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