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