projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bfd/
[deliverable/binutils-gdb.git] / binutils / od-macho.c
1 /* od-macho.c -- dump information about an Mach-O object file.
2 Copyright 2011, 2012 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 <stddef.h>
23 #include <time.h>
24 #include "sysdep.h"
25 #include "safe-ctype.h"
26 #include "bfd.h"
27 #include "objdump.h"
28 #include "bucomm.h"
29 #include "bfdlink.h"
30 #include "mach-o.h"
31 #include "mach-o/external.h"
32 #include "mach-o/codesign.h"
33
34 /* Index of the options in the options[] array. */
35 #define OPT_HEADER 0
36 #define OPT_SECTION 1
37 #define OPT_MAP 2
38 #define OPT_LOAD 3
39 #define OPT_DYSYMTAB 4
40 #define OPT_CODESIGN 5
41
42 /* List of actions. */
43 static struct objdump_private_option options[] =
44 {
45 { "header", 0 },
46 { "section", 0 },
47 { "map", 0 },
48 { "load", 0 },
49 { "dysymtab", 0 },
50 { "codesign", 0 },
51 { NULL, 0 }
52 };
53
54 /* Display help. */
55
56 static void
57 mach_o_help (FILE *stream)
58 {
59 fprintf (stream, _("\
60 For Mach-O files:\n\
61 header Display the file header\n\
62 section Display the segments and sections commands\n\
63 map Display the section map\n\
64 load Display the load commands\n\
65 dysymtab Display the dynamic symbol table\n\
66 codesign Display code signature section\n\
67 "));
68 }
69
70 /* Return TRUE if ABFD is handled. */
71
72 static int
73 mach_o_filter (bfd *abfd)
74 {
75 return bfd_get_flavour (abfd) == bfd_target_mach_o_flavour;
76 }
77 \f
78 static const bfd_mach_o_xlat_name bfd_mach_o_cpu_name[] =
79 {
80 { "vax", BFD_MACH_O_CPU_TYPE_VAX },
81 { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0 },
82 { "i386", BFD_MACH_O_CPU_TYPE_I386 },
83 { "mips", BFD_MACH_O_CPU_TYPE_MIPS },
84 { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000 },
85 { "hppa", BFD_MACH_O_CPU_TYPE_HPPA },
86 { "arm", BFD_MACH_O_CPU_TYPE_ARM },
87 { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000 },
88 { "sparc", BFD_MACH_O_CPU_TYPE_SPARC },
89 { "i860", BFD_MACH_O_CPU_TYPE_I860 },
90 { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA },
91 { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC },
92 { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64 },
93 { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64 },
94 { NULL, 0}
95 };
96
97 static const bfd_mach_o_xlat_name bfd_mach_o_filetype_name[] =
98 {
99 { "object", BFD_MACH_O_MH_OBJECT },
100 { "execute", BFD_MACH_O_MH_EXECUTE },
101 { "fvmlib", BFD_MACH_O_MH_FVMLIB },
102 { "core", BFD_MACH_O_MH_CORE },
103 { "preload", BFD_MACH_O_MH_PRELOAD },
104 { "dylib", BFD_MACH_O_MH_DYLIB },
105 { "dylinker", BFD_MACH_O_MH_DYLINKER },
106 { "bundle", BFD_MACH_O_MH_BUNDLE },
107 { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB },
108 { "dym", BFD_MACH_O_MH_DSYM },
109 { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE },
110 { NULL, 0}
111 };
112
113 static const bfd_mach_o_xlat_name bfd_mach_o_header_flags_name[] =
114 {
115 { "noundefs", BFD_MACH_O_MH_NOUNDEFS },
116 { "incrlink", BFD_MACH_O_MH_INCRLINK },
117 { "dyldlink", BFD_MACH_O_MH_DYLDLINK },
118 { "bindatload", BFD_MACH_O_MH_BINDATLOAD },
119 { "prebound", BFD_MACH_O_MH_PREBOUND },
120 { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS },
121 { "lazy_init", BFD_MACH_O_MH_LAZY_INIT },
122 { "twolevel", BFD_MACH_O_MH_TWOLEVEL },
123 { "force_flat", BFD_MACH_O_MH_FORCE_FLAT },
124 { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS },
125 { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING },
126 { "prebindable", BFD_MACH_O_MH_PREBINDABLE },
127 { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND },
128 { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS },
129 { "canonical", BFD_MACH_O_MH_CANONICAL },
130 { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES },
131 { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK },
132 { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION },
133 { "root_safe", BFD_MACH_O_MH_ROOT_SAFE },
134 { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE },
135 { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS },
136 { "pie", BFD_MACH_O_MH_PIE },
137 { NULL, 0}
138 };
139
140 static const bfd_mach_o_xlat_name bfd_mach_o_load_command_name[] =
141 {
142 { "segment", BFD_MACH_O_LC_SEGMENT},
143 { "symtab", BFD_MACH_O_LC_SYMTAB},
144 { "symseg", BFD_MACH_O_LC_SYMSEG},
145 { "thread", BFD_MACH_O_LC_THREAD},
146 { "unixthread", BFD_MACH_O_LC_UNIXTHREAD},
147 { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB},
148 { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB},
149 { "ident", BFD_MACH_O_LC_IDENT},
150 { "fvmfile", BFD_MACH_O_LC_FVMFILE},
151 { "prepage", BFD_MACH_O_LC_PREPAGE},
152 { "dysymtab", BFD_MACH_O_LC_DYSYMTAB},
153 { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB},
154 { "id_dylib", BFD_MACH_O_LC_ID_DYLIB},
155 { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER},
156 { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER},
157 { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB},
158 { "routines", BFD_MACH_O_LC_ROUTINES},
159 { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK},
160 { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA},
161 { "sub_client", BFD_MACH_O_LC_SUB_CLIENT},
162 { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY},
163 { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS},
164 { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM},
165 { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB},
166 { "segment_64", BFD_MACH_O_LC_SEGMENT_64},
167 { "routines_64", BFD_MACH_O_LC_ROUTINES_64},
168 { "uuid", BFD_MACH_O_LC_UUID},
169 { "rpath", BFD_MACH_O_LC_RPATH},
170 { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE},
171 { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO},
172 { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB},
173 { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB},
174 { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO},
175 { "dyld_info", BFD_MACH_O_LC_DYLD_INFO},
176 { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB},
177 { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX},
178 { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS},
179 { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS},
180 { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT},
181 { NULL, 0}
182 };
183
184 static const bfd_mach_o_xlat_name bfd_mach_o_thread_x86_name[] =
185 {
186 { "thread_state32", BFD_MACH_O_x86_THREAD_STATE32},
187 { "float_state32", BFD_MACH_O_x86_FLOAT_STATE32},
188 { "exception_state32", BFD_MACH_O_x86_EXCEPTION_STATE32},
189 { "thread_state64", BFD_MACH_O_x86_THREAD_STATE64},
190 { "float_state64", BFD_MACH_O_x86_FLOAT_STATE64},
191 { "exception_state64", BFD_MACH_O_x86_EXCEPTION_STATE64},
192 { "thread_state", BFD_MACH_O_x86_THREAD_STATE},
193 { "float_state", BFD_MACH_O_x86_FLOAT_STATE},
194 { "exception_state", BFD_MACH_O_x86_EXCEPTION_STATE},
195 { "debug_state32", BFD_MACH_O_x86_DEBUG_STATE32},
196 { "debug_state64", BFD_MACH_O_x86_DEBUG_STATE64},
197 { "debug_state", BFD_MACH_O_x86_DEBUG_STATE},
198 { "state_none", BFD_MACH_O_x86_THREAD_STATE_NONE},
199 { NULL, 0 }
200 };
201 \f
202 static void
203 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name *table,
204 unsigned long val)
205 {
206 int first = 1;
207
208 for (; table->name; table++)
209 {
210 if (table->val & val)
211 {
212 if (!first)
213 printf ("+");
214 printf ("%s", table->name);
215 val &= ~table->val;
216 first = 0;
217 }
218 }
219 if (val)
220 {
221 if (!first)
222 printf ("+");
223 printf ("0x%lx", val);
224 return;
225 }
226 if (first)
227 printf ("-");
228 }
229
230 static const char *
231 bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name *table,
232 unsigned long val)
233 {
234 for (; table->name; table++)
235 if (table->val == val)
236 return table->name;
237 return NULL;
238 }
239
240 static const char *
241 bfd_mach_o_get_name (const bfd_mach_o_xlat_name *table, unsigned long val)
242 {
243 const char *res = bfd_mach_o_get_name_or_null (table, val);
244
245 if (res == NULL)
246 return "*UNKNOWN*";
247 else
248 return res;
249 }
250
251 static void
252 dump_header (bfd *abfd)
253 {
254 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
255 bfd_mach_o_header *h = &mdata->header;
256
257 fputs (_("Mach-O header:\n"), stdout);
258 printf (_(" magic : %08lx\n"), h->magic);
259 printf (_(" cputype : %08lx (%s)\n"), h->cputype,
260 bfd_mach_o_get_name (bfd_mach_o_cpu_name, h->cputype));
261 printf (_(" cpusubtype: %08lx\n"), h->cpusubtype);
262 printf (_(" filetype : %08lx (%s)\n"),
263 h->filetype,
264 bfd_mach_o_get_name (bfd_mach_o_filetype_name, h->filetype));
265 printf (_(" ncmds : %08lx (%lu)\n"), h->ncmds, h->ncmds);
266 printf (_(" sizeofcmds: %08lx\n"), h->sizeofcmds);
267 printf (_(" flags : %08lx ("), h->flags);
268 bfd_mach_o_print_flags (bfd_mach_o_header_flags_name, h->flags);
269 fputs (_(")\n"), stdout);
270 printf (_(" reserved : %08x\n"), h->reserved);
271 }
272
273 static void
274 dump_section_map (bfd *abfd)
275 {
276 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
277 unsigned int i;
278 unsigned int sec_nbr = 0;
279
280 fputs (_("Segments and Sections:\n"), stdout);
281 fputs (_(" #: Segment name Section name Address\n"), stdout);
282
283 for (i = 0; i < mdata->header.ncmds; i++)
284 {
285 bfd_mach_o_segment_command *seg;
286 bfd_mach_o_section *sec;
287
288 if (mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT
289 && mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT_64)
290 continue;
291
292 seg = &mdata->commands[i].command.segment;
293
294 printf ("[Segment %-16s ", seg->segname);
295 printf_vma (seg->vmaddr);
296 putchar ('-');
297 printf_vma (seg->vmaddr + seg->vmsize - 1);
298 putchar (' ');
299 putchar (seg->initprot & BFD_MACH_O_PROT_READ ? 'r' : '-');
300 putchar (seg->initprot & BFD_MACH_O_PROT_WRITE ? 'w' : '-');
301 putchar (seg->initprot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-');
302 printf ("]\n");
303
304 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
305 {
306 printf ("%02u: %-16s %-16s ", ++sec_nbr,
307 sec->segname, sec->sectname);
308 printf_vma (sec->addr);
309 putchar (' ');
310 printf_vma (sec->size);
311 printf (" %08lx\n", sec->flags);
312 }
313 }
314 }
315
316 static void
317 dump_section (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_section *sec)
318 {
319 printf (" Section: %-16s %-16s (bfdname: %s)\n",
320 sec->sectname, sec->segname, sec->bfdsection->name);
321 printf (" addr: ");
322 printf_vma (sec->addr);
323 printf (" size: ");
324 printf_vma (sec->size);
325 printf (" offset: ");
326 printf_vma (sec->offset);
327 printf ("\n");
328 printf (" align: %ld", sec->align);
329 printf (" nreloc: %lu reloff: ", sec->nreloc);
330 printf_vma (sec->reloff);
331 printf ("\n");
332 printf (" flags: %08lx (type: %s", sec->flags,
333 bfd_mach_o_get_name (bfd_mach_o_section_type_name,
334 sec->flags & BFD_MACH_O_SECTION_TYPE_MASK));
335 printf (" attr: ");
336 bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name,
337 sec->flags & BFD_MACH_O_SECTION_ATTRIBUTES_MASK);
338 printf (")\n");
339 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
340 {
341 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
342 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
343 case BFD_MACH_O_S_SYMBOL_STUBS:
344 printf (" first indirect sym: %lu", sec->reserved1);
345 printf (" (%u entries)",
346 bfd_mach_o_section_get_nbr_indirect (abfd, sec));
347 break;
348 default:
349 printf (" reserved1: 0x%lx", sec->reserved1);
350 break;
351 }
352 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
353 {
354 case BFD_MACH_O_S_SYMBOL_STUBS:
355 printf (" stub size: %lu", sec->reserved2);
356 break;
357 default:
358 printf (" reserved2: 0x%lx", sec->reserved2);
359 break;
360 }
361 printf (" reserved3: 0x%lx\n", sec->reserved3);
362 }
363
364 static void
365 dump_segment (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd)
366 {
367 bfd_mach_o_segment_command *seg = &cmd->command.segment;
368 bfd_mach_o_section *sec;
369
370 printf (" name: %s\n", *seg->segname ? seg->segname : "*none*");
371 printf (" vmaddr: ");
372 printf_vma (seg->vmaddr);
373 printf (" vmsize: ");
374 printf_vma (seg->vmsize);
375 printf ("\n");
376 printf (" fileoff: ");
377 printf_vma (seg->fileoff);
378 printf (" filesize: ");
379 printf_vma ((bfd_vma)seg->filesize);
380 printf (" endoff: ");
381 printf_vma ((bfd_vma)(seg->fileoff + seg->filesize));
382 printf ("\n");
383 printf (" nsects: %lu ", seg->nsects);
384 printf (" flags: %lx\n", seg->flags);
385 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
386 dump_section (abfd, sec);
387 }
388
389 static void
390 dump_dysymtab (bfd *abfd, bfd_mach_o_load_command *cmd, bfd_boolean verbose)
391 {
392 bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab;
393 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
394 unsigned int i;
395
396 printf (" local symbols: idx: %10lu num: %-8lu",
397 dysymtab->ilocalsym, dysymtab->nlocalsym);
398 printf (" (nxtidx: %lu)\n",
399 dysymtab->ilocalsym + dysymtab->nlocalsym);
400 printf (" external symbols: idx: %10lu num: %-8lu",
401 dysymtab->iextdefsym, dysymtab->nextdefsym);
402 printf (" (nxtidx: %lu)\n",
403 dysymtab->iextdefsym + dysymtab->nextdefsym);
404 printf (" undefined symbols: idx: %10lu num: %-8lu",
405 dysymtab->iundefsym, dysymtab->nundefsym);
406 printf (" (nxtidx: %lu)\n",
407 dysymtab->iundefsym + dysymtab->nundefsym);
408 printf (" table of content: off: 0x%08lx num: %-8lu",
409 dysymtab->tocoff, dysymtab->ntoc);
410 printf (" (endoff: 0x%08lx)\n",
411 dysymtab->tocoff + dysymtab->ntoc * BFD_MACH_O_TABLE_OF_CONTENT_SIZE);
412 printf (" module table: off: 0x%08lx num: %-8lu",
413 dysymtab->modtaboff, dysymtab->nmodtab);
414 printf (" (endoff: 0x%08lx)\n",
415 dysymtab->modtaboff + dysymtab->nmodtab
416 * (mdata->header.version == 2 ?
417 BFD_MACH_O_DYLIB_MODULE_64_SIZE : BFD_MACH_O_DYLIB_MODULE_SIZE));
418 printf (" external reference table: off: 0x%08lx num: %-8lu",
419 dysymtab->extrefsymoff, dysymtab->nextrefsyms);
420 printf (" (endoff: 0x%08lx)\n",
421 dysymtab->extrefsymoff
422 + dysymtab->nextrefsyms * BFD_MACH_O_REFERENCE_SIZE);
423 printf (" indirect symbol table: off: 0x%08lx num: %-8lu",
424 dysymtab->indirectsymoff, dysymtab->nindirectsyms);
425 printf (" (endoff: 0x%08lx)\n",
426 dysymtab->indirectsymoff
427 + dysymtab->nindirectsyms * BFD_MACH_O_INDIRECT_SYMBOL_SIZE);
428 printf (" external relocation table: off: 0x%08lx num: %-8lu",
429 dysymtab->extreloff, dysymtab->nextrel);
430 printf (" (endoff: 0x%08lx)\n",
431 dysymtab->extreloff + dysymtab->nextrel * BFD_MACH_O_RELENT_SIZE);
432 printf (" local relocation table: off: 0x%08lx num: %-8lu",
433 dysymtab->locreloff, dysymtab->nlocrel);
434 printf (" (endoff: 0x%08lx)\n",
435 dysymtab->locreloff + dysymtab->nlocrel * BFD_MACH_O_RELENT_SIZE);
436
437 if (!verbose)
438 return;
439
440 if (dysymtab->ntoc > 0
441 || dysymtab->nindirectsyms > 0
442 || dysymtab->nextrefsyms > 0)
443 {
444 /* Try to read the symbols to display the toc or indirect symbols. */
445 bfd_mach_o_read_symtab_symbols (abfd);
446 }
447 else if (dysymtab->nmodtab > 0)
448 {
449 /* Try to read the strtab to display modules name. */
450 bfd_mach_o_read_symtab_strtab (abfd);
451 }
452
453 for (i = 0; i < dysymtab->nmodtab; i++)
454 {
455 bfd_mach_o_dylib_module *module = &dysymtab->dylib_module[i];
456 printf (" module %u:\n", i);
457 printf (" name: %lu", module->module_name_idx);
458 if (mdata->symtab && mdata->symtab->strtab)
459 printf (": %s",
460 mdata->symtab->strtab + module->module_name_idx);
461 printf ("\n");
462 printf (" extdefsym: idx: %8lu num: %lu\n",
463 module->iextdefsym, module->nextdefsym);
464 printf (" refsym: idx: %8lu num: %lu\n",
465 module->irefsym, module->nrefsym);
466 printf (" localsym: idx: %8lu num: %lu\n",
467 module->ilocalsym, module->nlocalsym);
468 printf (" extrel: idx: %8lu num: %lu\n",
469 module->iextrel, module->nextrel);
470 printf (" init: idx: %8u num: %u\n",
471 module->iinit, module->ninit);
472 printf (" term: idx: %8u num: %u\n",
473 module->iterm, module->nterm);
474 printf (" objc_module_info: addr: ");
475 printf_vma (module->objc_module_info_addr);
476 printf (" size: %lu\n", module->objc_module_info_size);
477 }
478
479 if (dysymtab->ntoc > 0)
480 {
481 bfd_mach_o_symtab_command *symtab = mdata->symtab;
482
483 printf (" table of content: (symbol/module)\n");
484 for (i = 0; i < dysymtab->ntoc; i++)
485 {
486 bfd_mach_o_dylib_table_of_content *toc = &dysymtab->dylib_toc[i];
487
488 printf (" %4u: ", i);
489 if (symtab && symtab->symbols && toc->symbol_index < symtab->nsyms)
490 {
491 const char *name = symtab->symbols[toc->symbol_index].symbol.name;
492 printf ("%s (%lu)", name ? name : "*invalid*",
493 toc->symbol_index);
494 }
495 else
496 printf ("%lu", toc->symbol_index);
497
498 printf (" / ");
499 if (symtab && symtab->strtab
500 && toc->module_index < dysymtab->nmodtab)
501 {
502 bfd_mach_o_dylib_module *mod;
503 mod = &dysymtab->dylib_module[toc->module_index];
504 printf ("%s (%lu)",
505 symtab->strtab + mod->module_name_idx,
506 toc->module_index);
507 }
508 else
509 printf ("%lu", toc->module_index);
510
511 printf ("\n");
512 }
513 }
514
515 if (dysymtab->nindirectsyms != 0)
516 {
517 printf (" indirect symbols:\n");
518
519 for (i = 0; i < mdata->nsects; i++)
520 {
521 bfd_mach_o_section *sec = mdata->sections[i];
522 unsigned int j, first, last;
523 bfd_mach_o_symtab_command *symtab = mdata->symtab;
524 bfd_vma addr;
525 bfd_vma entry_size;
526
527 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
528 {
529 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
530 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
531 case BFD_MACH_O_S_SYMBOL_STUBS:
532 first = sec->reserved1;
533 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
534 addr = sec->addr;
535 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
536 printf (" for section %s.%s:\n",
537 sec->segname, sec->sectname);
538 for (j = first; j < last; j++)
539 {
540 unsigned int isym = dysymtab->indirect_syms[j];
541
542 printf (" ");
543 printf_vma (addr);
544 printf (" %5u: 0x%08x", j, isym);
545 if (isym & BFD_MACH_O_INDIRECT_SYMBOL_LOCAL)
546 printf (" LOCAL");
547 if (isym & BFD_MACH_O_INDIRECT_SYMBOL_ABS)
548 printf (" ABSOLUTE");
549 if (symtab && symtab->symbols
550 && isym < symtab->nsyms
551 && symtab->symbols[isym].symbol.name)
552 printf (" %s", symtab->symbols[isym].symbol.name);
553 printf ("\n");
554 addr += entry_size;
555 }
556 break;
557 default:
558 break;
559 }
560 }
561 }
562 if (dysymtab->nextrefsyms > 0)
563 {
564 bfd_mach_o_symtab_command *symtab = mdata->symtab;
565
566 printf (" external reference table: (symbol flags)\n");
567 for (i = 0; i < dysymtab->nextrefsyms; i++)
568 {
569 bfd_mach_o_dylib_reference *ref = &dysymtab->ext_refs[i];
570
571 printf (" %4u: %5lu 0x%02lx", i, ref->isym, ref->flags);
572 if (symtab && symtab->symbols
573 && ref->isym < symtab->nsyms
574 && symtab->symbols[ref->isym].symbol.name)
575 printf (" %s", symtab->symbols[ref->isym].symbol.name);
576 printf ("\n");
577 }
578 }
579
580 }
581
582 static void
583 dump_dyld_info (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd)
584 {
585 bfd_mach_o_dyld_info_command *info = &cmd->command.dyld_info;
586
587 printf (" rebase: off: 0x%08x size: %-8u\n",
588 info->rebase_off, info->rebase_size);
589 printf (" bind: off: 0x%08x size: %-8u\n",
590 info->bind_off, info->bind_size);
591 printf (" weak bind: off: 0x%08x size: %-8u\n",
592 info->weak_bind_off, info->weak_bind_size);
593 printf (" lazy bind: off: 0x%08x size: %-8u\n",
594 info->lazy_bind_off, info->lazy_bind_size);
595 printf (" export: off: 0x%08x size: %-8u\n",
596 info->export_off, info->export_size);
597 }
598
599 static void
600 dump_thread (bfd *abfd, bfd_mach_o_load_command *cmd)
601 {
602 bfd_mach_o_thread_command *thread = &cmd->command.thread;
603 unsigned int j;
604 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
605 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
606
607 printf (" nflavours: %lu\n", thread->nflavours);
608 for (j = 0; j < thread->nflavours; j++)
609 {
610 bfd_mach_o_thread_flavour *flavour = &thread->flavours[j];
611 const bfd_mach_o_xlat_name *name_table;
612
613 printf (" %2u: flavour: 0x%08lx", j, flavour->flavour);
614 switch (mdata->header.cputype)
615 {
616 case BFD_MACH_O_CPU_TYPE_I386:
617 case BFD_MACH_O_CPU_TYPE_X86_64:
618 name_table = bfd_mach_o_thread_x86_name;
619 break;
620 default:
621 name_table = NULL;
622 break;
623 }
624 if (name_table != NULL)
625 printf (": %s", bfd_mach_o_get_name (name_table, flavour->flavour));
626 putchar ('\n');
627
628 printf (" offset: 0x%08lx size: 0x%08lx\n",
629 flavour->offset, flavour->size);
630 if (bed->_bfd_mach_o_print_thread)
631 {
632 char *buf = xmalloc (flavour->size);
633
634 if (bfd_seek (abfd, flavour->offset, SEEK_SET) == 0
635 && bfd_bread (buf, flavour->size, abfd) == flavour->size)
636 (*bed->_bfd_mach_o_print_thread)(abfd, flavour, stdout, buf);
637
638 free (buf);
639 }
640 }
641 }
642
643 static const bfd_mach_o_xlat_name bfd_mach_o_cs_magic[] =
644 {
645 { "embedded signature", BFD_MACH_O_CS_MAGIC_EMBEDDED_SIGNATURE },
646 { "requirement", BFD_MACH_O_CS_MAGIC_REQUIREMENT },
647 { "requirements", BFD_MACH_O_CS_MAGIC_REQUIREMENTS },
648 { "code directory", BFD_MACH_O_CS_MAGIC_CODEDIRECTORY },
649 { "embedded entitlements", BFD_MACH_O_CS_MAGIC_EMBEDDED_ENTITLEMENTS },
650 { "blob wrapper", BFD_MACH_O_CS_MAGIC_BLOB_WRAPPER },
651 { NULL, 0 }
652 };
653
654 static const bfd_mach_o_xlat_name bfd_mach_o_cs_hash_type[] =
655 {
656 { "no-hash", BFD_MACH_O_CS_NO_HASH },
657 { "sha1", BFD_MACH_O_CS_HASH_SHA1 },
658 { "sha256", BFD_MACH_O_CS_HASH_SHA256 },
659 { "skein 160", BFD_MACH_O_CS_HASH_PRESTANDARD_SKEIN_160x256 },
660 { "skein 256", BFD_MACH_O_CS_HASH_PRESTANDARD_SKEIN_256x512 },
661 { NULL, 0 }
662 };
663
664 static unsigned int
665 dump_code_signature_blob (bfd *abfd, const unsigned char *buf, unsigned int len);
666
667 static void
668 dump_code_signature_superblob (bfd *abfd ATTRIBUTE_UNUSED,
669 const unsigned char *buf, unsigned int len)
670 {
671 unsigned int count;
672 unsigned int i;
673
674 if (len < 12)
675 {
676 printf (_(" [bad block length]\n"));
677 return;
678 }
679 count = bfd_getb32 (buf + 8);
680 printf (_(" %u index entries:\n"), count);
681 if (len < 12 + 8 * count)
682 {
683 printf (_(" [bad block length]\n"));
684 return;
685 }
686 for (i = 0; i < count; i++)
687 {
688 unsigned int type;
689 unsigned int off;
690
691 type = bfd_getb32 (buf + 12 + 8 * i);
692 off = bfd_getb32 (buf + 12 + 8 * i + 4);
693 printf (_(" index entry %u: type: %08x, offset: %08x\n"),
694 i, type, off);
695
696 dump_code_signature_blob (abfd, buf + off, len - off);
697 }
698 }
699
700 static void
701 swap_code_codedirectory_v1_in
702 (const struct mach_o_codesign_codedirectory_external_v1 *src,
703 struct mach_o_codesign_codedirectory_v1 *dst)
704 {
705 dst->version = bfd_getb32 (src->version);
706 dst->flags = bfd_getb32 (src->flags);
707 dst->hash_offset = bfd_getb32 (src->hash_offset);
708 dst->ident_offset = bfd_getb32 (src->ident_offset);
709 dst->nbr_special_slots = bfd_getb32 (src->nbr_special_slots);
710 dst->nbr_code_slots = bfd_getb32 (src->nbr_code_slots);
711 dst->code_limit = bfd_getb32 (src->code_limit);
712 dst->hash_size = src->hash_size[0];
713 dst->hash_type = src->hash_type[0];
714 dst->spare1 = src->spare1[0];
715 dst->page_size = src->page_size[0];
716 dst->spare2 = bfd_getb32 (src->spare2);
717 }
718
719 static void
720 hexdump (unsigned int start, unsigned int len,
721 const unsigned char *buf)
722 {
723 unsigned int i, j;
724
725 for (i = 0; i < len; i += 16)
726 {
727 printf ("%08x:", start + i);
728 for (j = 0; j < 16; j++)
729 {
730 fputc (j == 8 ? '-' : ' ', stdout);
731 if (i + j < len)
732 printf ("%02x", buf[i + j]);
733 else
734 fputs (" ", stdout);
735 }
736 fputc (' ', stdout);
737 for (j = 0; j < 16; j++)
738 {
739 if (i + j < len)
740 fputc (ISPRINT (buf[i + j]) ? buf[i + j] : '.', stdout);
741 else
742 fputc (' ', stdout);
743 }
744 fputc ('\n', stdout);
745 }
746 }
747
748 static void
749 dump_code_signature_codedirectory (bfd *abfd ATTRIBUTE_UNUSED,
750 const unsigned char *buf, unsigned int len)
751 {
752 struct mach_o_codesign_codedirectory_v1 cd;
753 const char *id;
754
755 if (len < sizeof (struct mach_o_codesign_codedirectory_external_v1))
756 {
757 printf (_(" [bad block length]\n"));
758 return;
759 }
760
761 swap_code_codedirectory_v1_in
762 ((const struct mach_o_codesign_codedirectory_external_v1 *) (buf + 8), &cd);
763
764 printf (_(" version: %08x\n"), cd.version);
765 printf (_(" flags: %08x\n"), cd.flags);
766 printf (_(" hash offset: %08x\n"), cd.hash_offset);
767 id = (const char *) buf + cd.ident_offset;
768 printf (_(" ident offset: %08x (- %08x)\n"),
769 cd.ident_offset, cd.ident_offset + (unsigned) strlen (id) + 1);
770 printf (_(" identity: %s\n"), id);
771 printf (_(" nbr special slots: %08x (at offset %08x)\n"),
772 cd.nbr_special_slots,
773 cd.hash_offset - cd.nbr_special_slots * cd.hash_size);
774 printf (_(" nbr code slots: %08x\n"), cd.nbr_code_slots);
775 printf (_(" code limit: %08x\n"), cd.code_limit);
776 printf (_(" hash size: %02x\n"), cd.hash_size);
777 printf (_(" hash type: %02x (%s)\n"),
778 cd.hash_type,
779 bfd_mach_o_get_name (bfd_mach_o_cs_hash_type, cd.hash_type));
780 printf (_(" spare1: %02x\n"), cd.spare1);
781 printf (_(" page size: %02x\n"), cd.page_size);
782 printf (_(" spare2: %08x\n"), cd.spare2);
783 if (cd.version >= 0x20100)
784 printf (_(" scatter offset: %08x\n"),
785 (unsigned) bfd_getb32 (buf + 44));
786 }
787
788 static unsigned int
789 dump_code_signature_blob (bfd *abfd, const unsigned char *buf, unsigned int len)
790 {
791 unsigned int magic;
792 unsigned int length;
793
794 if (len < 8)
795 {
796 printf (_(" [truncated block]\n"));
797 return 0;
798 }
799 magic = bfd_getb32 (buf);
800 length = bfd_getb32 (buf + 4);
801 if (magic == 0 || length == 0)
802 return 0;
803
804 printf (_(" magic : %08x (%s)\n"), magic,
805 bfd_mach_o_get_name (bfd_mach_o_cs_magic, magic));
806 printf (_(" length: %08x\n"), length);
807 if (length > len)
808 {
809 printf (_(" [bad block length]\n"));
810 return 0;
811 }
812
813 switch (magic)
814 {
815 case BFD_MACH_O_CS_MAGIC_EMBEDDED_SIGNATURE:
816 dump_code_signature_superblob (abfd, buf, length);
817 break;
818 case BFD_MACH_O_CS_MAGIC_CODEDIRECTORY:
819 dump_code_signature_codedirectory (abfd, buf, length);
820 break;
821 default:
822 hexdump (0, length - 8, buf + 8);
823 break;
824 }
825 return length;
826 }
827
828 static void
829 dump_code_signature (bfd *abfd, bfd_mach_o_linkedit_command *cmd)
830 {
831 unsigned char *buf = xmalloc (cmd->datasize);
832 unsigned int off;
833
834 if (bfd_seek (abfd, cmd->dataoff, SEEK_SET) != 0
835 || bfd_bread (buf, cmd->datasize, abfd) != cmd->datasize)
836 {
837 non_fatal (_("cannot read code signature data"));
838 free (buf);
839 return;
840 }
841 for (off = 0; off < cmd->datasize;)
842 {
843 unsigned int len;
844
845 len = dump_code_signature_blob (abfd, buf + off, cmd->datasize - off);
846
847 if (len == 0)
848 break;
849 off += len;
850 }
851 free (buf);
852 }
853
854 static void
855 dump_load_command (bfd *abfd, bfd_mach_o_load_command *cmd,
856 bfd_boolean verbose)
857 {
858 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
859 const char *cmd_name;
860
861 cmd_name = bfd_mach_o_get_name_or_null
862 (bfd_mach_o_load_command_name, cmd->type);
863 printf ("Load command ");
864 if (cmd_name == NULL)
865 printf ("0x%02x:", cmd->type);
866 else
867 printf ("%s:", cmd_name);
868
869 switch (cmd->type)
870 {
871 case BFD_MACH_O_LC_SEGMENT:
872 case BFD_MACH_O_LC_SEGMENT_64:
873 dump_segment (abfd, cmd);
874 break;
875 case BFD_MACH_O_LC_UUID:
876 {
877 bfd_mach_o_uuid_command *uuid = &cmd->command.uuid;
878 unsigned int j;
879
880 for (j = 0; j < sizeof (uuid->uuid); j ++)
881 printf (" %02x", uuid->uuid[j]);
882 putchar ('\n');
883 }
884 break;
885 case BFD_MACH_O_LC_LOAD_DYLIB:
886 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
887 case BFD_MACH_O_LC_REEXPORT_DYLIB:
888 case BFD_MACH_O_LC_ID_DYLIB:
889 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
890 {
891 bfd_mach_o_dylib_command *dylib = &cmd->command.dylib;
892 printf (" %s\n", dylib->name_str);
893 printf (" time stamp: 0x%08lx\n",
894 dylib->timestamp);
895 printf (" current version: 0x%08lx\n",
896 dylib->current_version);
897 printf (" comptibility version: 0x%08lx\n",
898 dylib->compatibility_version);
899 break;
900 }
901 case BFD_MACH_O_LC_LOAD_DYLINKER:
902 case BFD_MACH_O_LC_ID_DYLINKER:
903 printf (" %s\n", cmd->command.dylinker.name_str);
904 break;
905 case BFD_MACH_O_LC_SYMTAB:
906 {
907 bfd_mach_o_symtab_command *symtab = &cmd->command.symtab;
908 printf ("\n"
909 " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n",
910 symtab->symoff, symtab->nsyms,
911 symtab->symoff + symtab->nsyms
912 * (mdata->header.version == 2
913 ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE));
914 printf (" stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n",
915 symtab->stroff, symtab->strsize,
916 symtab->stroff + symtab->strsize);
917 break;
918 }
919 case BFD_MACH_O_LC_DYSYMTAB:
920 putchar ('\n');
921 dump_dysymtab (abfd, cmd, verbose);
922 break;
923 case BFD_MACH_O_LC_CODE_SIGNATURE:
924 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
925 case BFD_MACH_O_LC_FUNCTION_STARTS:
926 {
927 bfd_mach_o_linkedit_command *linkedit = &cmd->command.linkedit;
928 printf
929 ("\n"
930 " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n",
931 linkedit->dataoff, linkedit->datasize,
932 linkedit->dataoff + linkedit->datasize);
933
934 if (verbose && cmd->type == BFD_MACH_O_LC_CODE_SIGNATURE)
935 dump_code_signature (abfd, linkedit);
936 break;
937 }
938 case BFD_MACH_O_LC_SUB_FRAMEWORK:
939 case BFD_MACH_O_LC_SUB_UMBRELLA:
940 case BFD_MACH_O_LC_SUB_LIBRARY:
941 case BFD_MACH_O_LC_SUB_CLIENT:
942 case BFD_MACH_O_LC_RPATH:
943 {
944 bfd_mach_o_str_command *str = &cmd->command.str;
945 printf (" %s\n", str->str);
946 break;
947 }
948 case BFD_MACH_O_LC_THREAD:
949 case BFD_MACH_O_LC_UNIXTHREAD:
950 dump_thread (abfd, cmd);
951 break;
952 case BFD_MACH_O_LC_ENCRYPTION_INFO:
953 {
954 bfd_mach_o_encryption_info_command *cryp =
955 &cmd->command.encryption_info;
956 printf
957 ("\n"
958 " cryptoff: 0x%08x cryptsize: 0x%08x (endoff 0x%08x)"
959 " cryptid: %u\n",
960 cryp->cryptoff, cryp->cryptsize,
961 cryp->cryptoff + cryp->cryptsize,
962 cryp->cryptid);
963 }
964 break;
965 case BFD_MACH_O_LC_DYLD_INFO:
966 putchar ('\n');
967 dump_dyld_info (abfd, cmd);
968 break;
969 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
970 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
971 {
972 bfd_mach_o_version_min_command *ver = &cmd->command.version_min;
973
974 printf (" %u.%u.%u\n", ver->rel, ver->maj, ver->min);
975 }
976 break;
977 default:
978 putchar ('\n');
979 printf (" offset: 0x%08lx\n", (unsigned long)cmd->offset);
980 printf (" size: 0x%08lx\n", (unsigned long)cmd->len);
981 break;
982 }
983 putchar ('\n');
984 }
985
986 static void
987 dump_load_commands (bfd *abfd, unsigned int cmd32, unsigned int cmd64)
988 {
989 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
990 unsigned int i;
991
992 for (i = 0; i < mdata->header.ncmds; i++)
993 {
994 bfd_mach_o_load_command *cmd = &mdata->commands[i];
995
996 if (cmd32 == 0)
997 dump_load_command (abfd, cmd, FALSE);
998 else if (cmd->type == cmd32 || cmd->type == cmd64)
999 dump_load_command (abfd, cmd, TRUE);
1000 }
1001 }
1002
1003 /* Dump ABFD (according to the options[] array). */
1004
1005 static void
1006 mach_o_dump (bfd *abfd)
1007 {
1008 if (options[OPT_HEADER].selected)
1009 dump_header (abfd);
1010 if (options[OPT_SECTION].selected)
1011 dump_load_commands (abfd, BFD_MACH_O_LC_SEGMENT, BFD_MACH_O_LC_SEGMENT_64);
1012 if (options[OPT_MAP].selected)
1013 dump_section_map (abfd);
1014 if (options[OPT_LOAD].selected)
1015 dump_load_commands (abfd, 0, 0);
1016 if (options[OPT_DYSYMTAB].selected)
1017 dump_load_commands (abfd, BFD_MACH_O_LC_DYSYMTAB, 0);
1018 if (options[OPT_CODESIGN].selected)
1019 dump_load_commands (abfd, BFD_MACH_O_LC_CODE_SIGNATURE, 0);
1020 }
1021
1022 /* Vector for Mach-O. */
1023
1024 const struct objdump_private_desc objdump_private_desc_mach_o =
1025 {
1026 mach_o_help,
1027 mach_o_filter,
1028 mach_o_dump,
1029 options
1030 };
GDB Binutils - Deliverables
This page took 0.086048 seconds and 5 git commands to generate.