]> git.saurik.com Git - apple/ld64.git/blob - src/other/ObjectDump.cpp
projects / apple / ld64.git / blob
? search:


e957e2b52b3342b100c1d8dae35cc5b89b19b892
[apple/ld64.git] / src / other / ObjectDump.cpp
1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
2 *
3 * Copyright (c) 2005-2010 Apple Inc. All rights reserved.
4 *
5 * @APPLE_LICENSE_HEADER_START@
6 *
7 * This file contains Original Code and/or Modifications of Original Code
8 * as defined in and that are subject to the Apple Public Source License
9 * Version 2.0 (the 'License'). You may not use this file except in
10 * compliance with the License. Please obtain a copy of the License at
11 * http://www.opensource.apple.com/apsl/ and read it before using this
12 * file.
13 *
14 * The Original Code and all software distributed under the License are
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
19 * Please see the License for the specific language governing rights and
20 * limitations under the License.
21 *
22 * @APPLE_LICENSE_HEADER_END@
23 */
24
25 #include <sys/types.h>
26 #include <sys/stat.h>
27 #include <sys/mman.h>
28 #include <fcntl.h>
29 #include <mach-o/nlist.h>
30 #include <mach-o/stab.h>
31 #include <mach-o/fat.h>
32 #include <mach-o/loader.h>
33
34 #include "MachOFileAbstraction.hpp"
35 #include "parsers/macho_relocatable_file.h"
36 #include "parsers/lto_file.h"
37
38 static bool sDumpContent= true;
39 static bool sDumpStabs = false;
40 static bool sSort = true;
41 static bool sNMmode = false;
42 static bool sShowSection = true;
43 static bool sShowDefinitionKind = true;
44 static bool sShowCombineKind = true;
45 static bool sShowLineInfo = true;
46
47 static cpu_type_t sPreferredArch = 0xFFFFFFFF;
48 static cpu_subtype_t sPreferredSubArch = 0xFFFFFFFF;
49 static const char* sMatchName = NULL;
50 static int sPrintRestrict;
51 static int sPrintAlign;
52 static int sPrintName;
53
54 __attribute__((noreturn))
55 void throwf(const char* format, ...)
56 {
57 va_list list;
58 char* p;
59 va_start(list, format);
60 vasprintf(&p, format, list);
61 va_end(list);
62
63 const char* t = p;
64 throw t;
65 }
66
67 void warning(const char* format, ...)
68 {
69 va_list list;
70 fprintf(stderr, "warning: ");
71 va_start(list, format);
72 vfprintf(stderr, format, list);
73 va_end(list);
74 fprintf(stderr, "\n");
75 }
76
77 static void dumpStabs(const std::vector<ld::relocatable::File::Stab>* stabs)
78 {
79 // debug info
80 printf("stabs: (%lu)\n", stabs->size());
81 for (std::vector<ld::relocatable::File::Stab>::const_iterator it = stabs->begin(); it != stabs->end(); ++it ) {
82 const ld::relocatable::File::Stab& stab = *it;
83 const char* code = "?????";
84 switch (stab.type) {
85 case N_GSYM:
86 code = " GSYM";
87 break;
88 case N_FNAME:
89 code = "FNAME";
90 break;
91 case N_FUN:
92 code = " FUN";
93 break;
94 case N_STSYM:
95 code = "STSYM";
96 break;
97 case N_LCSYM:
98 code = "LCSYM";
99 break;
100 case N_BNSYM:
101 code = "BNSYM";
102 break;
103 case N_OPT:
104 code = " OPT";
105 break;
106 case N_RSYM:
107 code = " RSYM";
108 break;
109 case N_SLINE:
110 code = "SLINE";
111 break;
112 case N_ENSYM:
113 code = "ENSYM";
114 break;
115 case N_SSYM:
116 code = " SSYM";
117 break;
118 case N_SO:
119 code = " SO";
120 break;
121 case N_OSO:
122 code = " OSO";
123 break;
124 case N_LSYM:
125 code = " LSYM";
126 break;
127 case N_BINCL:
128 code = "BINCL";
129 break;
130 case N_SOL:
131 code = " SOL";
132 break;
133 case N_PARAMS:
134 code = "PARMS";
135 break;
136 case N_VERSION:
137 code = " VERS";
138 break;
139 case N_OLEVEL:
140 code = "OLEVL";
141 break;
142 case N_PSYM:
143 code = " PSYM";
144 break;
145 case N_EINCL:
146 code = "EINCL";
147 break;
148 case N_ENTRY:
149 code = "ENTRY";
150 break;
151 case N_LBRAC:
152 code = "LBRAC";
153 break;
154 case N_EXCL:
155 code = " EXCL";
156 break;
157 case N_RBRAC:
158 code = "RBRAC";
159 break;
160 case N_BCOMM:
161 code = "BCOMM";
162 break;
163 case N_ECOMM:
164 code = "ECOMM";
165 break;
166 case N_LENG:
167 code = "LENG";
168 break;
169 }
170 printf(" [atom=%20s] %02X %04X %s %s\n", ((stab.atom != NULL) ? stab.atom->name() : ""), stab.other, stab.desc, code, stab.string);
171 }
172 }
173
174 #if 0
175 static void dumpAtomLikeNM(ld::Atom* atom)
176 {
177 uint32_t size = atom->size();
178
179 const char* visibility;
180 switch ( atom->scope() ) {
181 case ld::Atom::scopeTranslationUnit:
182 visibility = "internal";
183 break;
184 case ld::Atom::scopeLinkageUnit:
185 visibility = "hidden ";
186 break;
187 case ld::Atom::scopeGlobal:
188 visibility = "global ";
189 break;
190 default:
191 visibility = " ";
192 break;
193 }
194
195 const char* kind;
196 switch ( atom->definitionKind() ) {
197 case ld::Atom::kRegularDefinition:
198 kind = "regular ";
199 break;
200 case ld::Atom::kTentativeDefinition:
201 kind = "tentative";
202 break;
203 case ld::Atom::kWeakDefinition:
204 kind = "weak ";
205 break;
206 case ld::Atom::kAbsoluteSymbol:
207 kind = "absolute ";
208 break;
209 default:
210 kind = " ";
211 break;
212 }
213
214 printf("0x%08X %s %s %s\n", size, visibility, kind, atom->name());
215 }
216
217
218 static void dumpAtom(ld::Atom* atom)
219 {
220 if(sMatchName && strcmp(sMatchName, atom->name()))
221 return;
222
223 //printf("atom: %p\n", atom);
224
225 // name
226 if(!sPrintRestrict || sPrintName)
227 printf("name: %s\n", atom->name());
228
229 // scope
230 if(!sPrintRestrict)
231 switch ( atom->scope() ) {
232 case ld::Atom::scopeTranslationUnit:
233 printf("scope: translation unit\n");
234 break;
235 case ld::Atom::scopeLinkageUnit:
236 printf("scope: linkage unit\n");
237 break;
238 case ld::Atom::scopeGlobal:
239 printf("scope: global\n");
240 break;
241 default:
242 printf("scope: unknown\n");
243 }
244
245 // kind
246 if(!sPrintRestrict)
247 switch ( atom->definitionKind() ) {
248 case ld::Atom::kRegularDefinition:
249 printf("kind: regular\n");
250 break;
251 case ld::Atom::kWeakDefinition:
252 printf("kind: weak\n");
253 break;
254 case ld::Atom::kTentativeDefinition:
255 printf("kind: tentative\n");
256 break;
257 case ld::Atom::kExternalDefinition:
258 printf("kind: import\n");
259 break;
260 case ld::Atom::kExternalWeakDefinition:
261 printf("kind: weak import\n");
262 break;
263 case ld::Atom::kAbsoluteSymbol:
264 printf("kind: absolute symbol\n");
265 break;
266 default:
267 printf("kind: unknown\n");
268 }
269
270 // segment and section
271 if(!sPrintRestrict && (atom->section().sectionName() != NULL) )
272 printf("section: %s,%s\n", atom->section().segmentName(), atom->section().sectionName());
273
274 // attributes
275 if(!sPrintRestrict) {
276 printf("attrs: ");
277 if ( atom->dontDeadStrip() )
278 printf("dont-dead-strip ");
279 if ( atom->isThumb() )
280 printf("thumb ");
281 printf("\n");
282 }
283
284 // size
285 if(!sPrintRestrict)
286 printf("size: 0x%012llX\n", atom->size());
287
288 // alignment
289 if(!sPrintRestrict || sPrintAlign)
290 printf("align: %u mod %u\n", atom->alignment().modulus, (1 << atom->alignment().powerOf2) );
291
292 // content
293 if (!sPrintRestrict && sDumpContent ) {
294 uint64_t size = atom->size();
295 if ( size < 4096 ) {
296 uint8_t content[size];
297 atom->copyRawContent(content);
298 printf("content: ");
299 if ( atom->contentType() == ld::Atom::typeCString ) {
300 printf("\"");
301 for (unsigned int i=0; i < size; ++i) {
302 if(content[i]<'!' || content[i]>=127)
303 printf("\\%o", content[i]);
304 else
305 printf("%c", content[i]);
306 }
307 printf("\"");
308 }
309 else {
310 for (unsigned int i=0; i < size; ++i)
311 printf("%02X ", content[i]);
312 }
313 }
314 printf("\n");
315 }
316
317 // unwind info
318 if(!sPrintRestrict) {
319 if ( atom->beginUnwind() != atom->endUnwind() ) {
320 printf("unwind encodings:\n");
321 for (ld::Atom::UnwindInfo::iterator it = atom->beginUnwind(); it != atom->endUnwind(); ++it) {
322 printf("\t 0x%04X 0x%08X\n", it->startOffset, it->unwindInfo);
323 }
324 }
325 }
326 #if 0
327 // references
328 if(!sPrintRestrict) {
329 std::vector<ObjectFile::Reference*>& references = atom->getReferences();
330 const int refCount = references.size();
331 printf("references: (%u)\n", refCount);
332 for (int i=0; i < refCount; ++i) {
333 ObjectFile::Reference* ref = references[i];
334 printf(" %s\n", ref->getDescription());
335 }
336 }
337 #endif
338 // line info
339 if(!sPrintRestrict) {
340 if ( atom->beginLineInfo() != atom->endLineInfo() ) {
341 printf("line info:\n");
342 for (ld::Atom::LineInfo::iterator it = atom->beginLineInfo(); it != atom->endLineInfo(); ++it) {
343 printf(" offset 0x%04X, line %d, file %s\n", it->atomOffset, it->lineNumber, it->fileName);
344 }
345 }
346 }
347
348 if(!sPrintRestrict)
349 printf("\n");
350 }
351 #endif
352 struct AtomSorter
353 {
354 bool operator()(const ld::Atom* left, const ld::Atom* right)
355 {
356 if ( left == right )
357 return false;
358 // first sort by segment name
359 int diff = strcmp(left->section().segmentName(), right->section().segmentName());
360 if ( diff != 0 )
361 return (diff > 0);
362
363 // then sort by section name
364 diff = strcmp(left->section().sectionName(), right->section().sectionName());
365 if ( diff != 0 )
366 return (diff < 0);
367
368 // then sort by atom name
369 diff = strcmp(left->name(), right->name());
370 if ( diff != 0 )
371 return (diff < 0);
372
373 // if cstring, sort by content
374 if ( left->contentType() == ld::Atom::typeCString ) {
375 diff = strcmp((char*)left->rawContentPointer(), (char*)right->rawContentPointer());
376 if ( diff != 0 )
377 return (diff < 0);
378 }
379 else if ( left->section().type() == ld::Section::typeCStringPointer ) {
380 // if pointer to c-string sort by name
381 const char* leftString = NULL;
382 assert(left->fixupsBegin() != left->fixupsEnd());
383 for (ld::Fixup::iterator fit = left->fixupsBegin(); fit != left->fixupsEnd(); ++fit) {
384 if ( fit->binding == ld::Fixup::bindingByContentBound ) {
385 const ld::Atom* cstringAtom = fit->u.target;
386 assert(cstringAtom->contentType() == ld::Atom::typeCString);
387 leftString = (char*)cstringAtom->rawContentPointer();
388 }
389 }
390 const char* rightString = NULL;
391 assert(right->fixupsBegin() != right->fixupsEnd());
392 for (ld::Fixup::iterator fit = right->fixupsBegin(); fit != right->fixupsEnd(); ++fit) {
393 if ( fit->binding == ld::Fixup::bindingByContentBound ) {
394 const ld::Atom* cstringAtom = fit->u.target;
395 assert(cstringAtom->contentType() == ld::Atom::typeCString);
396 rightString = (char*)cstringAtom->rawContentPointer();
397 }
398 }
399 assert(leftString != NULL);
400 assert(rightString != NULL);
401 diff = strcmp(leftString, rightString);
402 if ( diff != 0 )
403 return (diff < 0);
404 }
405 else if ( left->section().type() == ld::Section::typeLiteral4 ) {
406 // if literal sort by content
407 uint32_t leftValue = *(uint32_t*)left->rawContentPointer();
408 uint32_t rightValue = *(uint32_t*)right->rawContentPointer();
409 diff = (leftValue - rightValue);
410 if ( diff != 0 )
411 return (diff < 0);
412 }
413 else if ( left->section().type() == ld::Section::typeCFI ) {
414 // if __he_frame sort by address
415 diff = (left->objectAddress() - right->objectAddress());
416 if ( diff != 0 )
417 return (diff < 0);
418 }
419 else if ( left->section().type() == ld::Section::typeNonLazyPointer ) {
420 // if non-lazy-pointer sort by name
421 const char* leftString = NULL;
422 assert(left->fixupsBegin() != left->fixupsEnd());
423 for (ld::Fixup::iterator fit = left->fixupsBegin(); fit != left->fixupsEnd(); ++fit) {
424 if ( fit->binding == ld::Fixup::bindingByNameUnbound ) {
425 leftString = fit->u.name;
426 }
427 else if ( fit->binding == ld::Fixup::bindingDirectlyBound ) {
428 leftString = fit->u.target->name();
429 }
430 }
431 const char* rightString = NULL;
432 assert(right->fixupsBegin() != right->fixupsEnd());
433 for (ld::Fixup::iterator fit = right->fixupsBegin(); fit != right->fixupsEnd(); ++fit) {
434 if ( fit->binding == ld::Fixup::bindingByNameUnbound ) {
435 rightString = fit->u.name;
436 }
437 else if ( fit->binding == ld::Fixup::bindingDirectlyBound ) {
438 rightString = fit->u.target->name();
439 }
440 }
441 assert(leftString != NULL);
442 assert(rightString != NULL);
443 diff = strcmp(leftString, rightString);
444 if ( diff != 0 )
445 return (diff < 0);
446 }
447
448 // else sort by size
449 return (left->size() < right->size());
450 }
451 };
452
453
454 class dumper : public ld::File::AtomHandler
455 {
456 public:
457 void dump();
458 virtual void doAtom(const ld::Atom&);
459 virtual void doFile(const ld::File&) {}
460 private:
461 void dumpAtom(const ld::Atom& atom);
462 const char* scopeString(const ld::Atom&);
463 const char* definitionString(const ld::Atom&);
464 const char* combineString(const ld::Atom&);
465 const char* inclusionString(const ld::Atom&);
466 const char* attributeString(const ld::Atom&);
467 const char* makeName(const ld::Atom& atom);
468 const char* referenceTargetAtomName(const ld::Fixup* ref);
469 void dumpFixup(const ld::Fixup* ref);
470
471 uint64_t addressOfFirstAtomInSection(const ld::Section&);
472
473 std::vector<const ld::Atom*> _atoms;
474 };
475
476 const char* dumper::scopeString(const ld::Atom& atom)
477 {
478 switch ( (ld::Atom::Scope)atom.scope() ) {
479 case ld::Atom::scopeTranslationUnit:
480 return "translation-unit";
481 case ld::Atom::scopeLinkageUnit:
482 return "hidden";
483 case ld::Atom::scopeGlobal:
484 if ( atom.autoHide() )
485 return "global but automatically hidden";
486 else
487 return "global";
488 }
489 return "UNKNOWN";
490 }
491
492 const char* dumper::definitionString(const ld::Atom& atom)
493 {
494 switch ( (ld::Atom::Definition)atom.definition() ) {
495 case ld::Atom::definitionRegular:
496 return "regular";
497 case ld::Atom::definitionTentative:
498 return "tentative";
499 case ld::Atom::definitionAbsolute:
500 return "absolute";
501 case ld::Atom::definitionProxy:
502 return "proxy";
503 }
504 return "UNKNOWN";
505 }
506
507 const char* dumper::combineString(const ld::Atom& atom)
508 {
509 switch ( (ld::Atom::Combine)atom.combine() ) {
510 case ld::Atom::combineNever:
511 return "never";
512 case ld::Atom::combineByName:
513 return "by-name";
514 case ld::Atom::combineByNameAndContent:
515 return "by-name-and-content";
516 case ld::Atom::combineByNameAndReferences:
517 return "by-name-and-references";
518 }
519 return "UNKNOWN";
520 }
521
522 const char* dumper::inclusionString(const ld::Atom& atom)
523 {
524 switch ( (ld::Atom::SymbolTableInclusion)atom.symbolTableInclusion() ) {
525 case ld::Atom::symbolTableNotIn:
526 return "not in";
527 case ld::Atom::symbolTableNotInFinalLinkedImages:
528 return "not in final linked images";
529 case ld::Atom::symbolTableIn:
530 return "in";
531 case ld::Atom::symbolTableInAndNeverStrip:
532 return "in and never strip";
533 case ld::Atom::symbolTableInAsAbsolute:
534 return "in as absolute";
535 case ld::Atom::symbolTableInWithRandomAutoStripLabel:
536 return "in as random auto-strip label";
537 }
538 return "UNKNOWN";
539 }
540
541
542
543 const char* dumper::attributeString(const ld::Atom& atom)
544 {
545 static char buffer[256];
546 buffer[0] = '\0';
547
548 if ( atom.dontDeadStrip() )
549 strcat(buffer, "dont-dead-strip ");
550
551 if ( atom.isThumb() )
552 strcat(buffer, "thumb ");
553
554 if ( atom.isAlias() )
555 strcat(buffer, "alias ");
556
557 if ( atom.contentType() == ld::Atom::typeResolver )
558 strcat(buffer, "resolver ");
559
560 return buffer;
561 }
562
563 const char* dumper::makeName(const ld::Atom& atom)
564 {
565 static char buffer[4096];
566 strcpy(buffer, "???");
567 switch ( atom.symbolTableInclusion() ) {
568 case ld::Atom::symbolTableNotIn:
569 if ( atom.contentType() == ld::Atom::typeCString ) {
570 strcpy(buffer, "cstring=");
571 strlcat(buffer, (char*)atom.rawContentPointer(), 4096);
572 }
573 else if ( atom.section().type() == ld::Section::typeLiteral4 ) {
574 char temp[16];
575 strcpy(buffer, "literal4=");
576 uint32_t value = *(uint32_t*)atom.rawContentPointer();
577 sprintf(temp, "0x%08X", value);
578 strcat(buffer, temp);
579 }
580 else if ( atom.section().type() == ld::Section::typeLiteral8 ) {
581 char temp[32];
582 strcpy(buffer, "literal8=");
583 uint32_t value1 = *(uint32_t*)atom.rawContentPointer();
584 uint32_t value2 = ((uint32_t*)atom.rawContentPointer())[1];
585 sprintf(temp, "0x%08X%08X", value1, value2);
586 strcat(buffer, temp);
587 }
588 else if ( atom.section().type() == ld::Section::typeLiteral16 ) {
589 char temp[64];
590 strcpy(buffer, "literal16=");
591 uint32_t value1 = *(uint32_t*)atom.rawContentPointer();
592 uint32_t value2 = ((uint32_t*)atom.rawContentPointer())[1];
593 uint32_t value3 = ((uint32_t*)atom.rawContentPointer())[2];
594 uint32_t value4 = ((uint32_t*)atom.rawContentPointer())[3];
595 sprintf(temp, "0x%08X%08X%08X%08X", value1, value2, value3, value4);
596 strcat(buffer, temp);
597 }
598 else if ( atom.section().type() == ld::Section::typeCStringPointer ) {
599 assert(atom.fixupsBegin() != atom.fixupsEnd());
600 for (ld::Fixup::iterator fit = atom.fixupsBegin(); fit != atom.fixupsEnd(); ++fit) {
601 if ( fit->binding == ld::Fixup::bindingByContentBound ) {
602 const ld::Atom* cstringAtom = fit->u.target;
603 if ( (cstringAtom != NULL) && (cstringAtom->contentType() == ld::Atom::typeCString) ) {
604 strlcpy(buffer, atom.name(), 4096);
605 strlcat(buffer, "=", 4096);
606 strlcat(buffer, (char*)cstringAtom->rawContentPointer(), 4096);
607 }
608 }
609 }
610 }
611 else if ( atom.section().type() == ld::Section::typeNonLazyPointer ) {
612 assert(atom.fixupsBegin() != atom.fixupsEnd());
613 for (ld::Fixup::iterator fit = atom.fixupsBegin(); fit != atom.fixupsEnd(); ++fit) {
614 if ( fit->binding == ld::Fixup::bindingByNameUnbound ) {
615 strcpy(buffer, "non-lazy-pointer-to:");
616 strlcat(buffer, fit->u.name, 4096);
617 return buffer;
618 }
619 else if ( fit->binding == ld::Fixup::bindingDirectlyBound ) {
620 strcpy(buffer, "non-lazy-pointer-to-local:");
621 strlcat(buffer, fit->u.target->name(), 4096);
622 return buffer;
623 }
624 }
625 strlcpy(buffer, atom.name(), 4096);
626 }
627 else {
628 uint64_t sectAddr = addressOfFirstAtomInSection(atom.section());
629 sprintf(buffer, "%s@%s+0x%08llX", atom.name(), atom.section().sectionName(), atom.objectAddress()-sectAddr);
630 }
631 break;
632 case ld::Atom::symbolTableNotInFinalLinkedImages:
633 case ld::Atom::symbolTableIn:
634 case ld::Atom::symbolTableInAndNeverStrip:
635 case ld::Atom::symbolTableInAsAbsolute:
636 case ld::Atom::symbolTableInWithRandomAutoStripLabel:
637 strlcpy(buffer, atom.name(), 4096);
638 break;
639 }
640 return buffer;
641 }
642
643 const char* dumper::referenceTargetAtomName(const ld::Fixup* ref)
644 {
645 static char buffer[4096];
646 switch ( ref->binding ) {
647 case ld::Fixup::bindingNone:
648 return "NO BINDING";
649 case ld::Fixup::bindingByNameUnbound:
650 strcpy(buffer, "by-name(");
651 strlcat(buffer, ref->u.name, 4096);
652 strlcat(buffer, ")", 4096);
653 return buffer;
654 //return ref->u.name;
655 case ld::Fixup::bindingByContentBound:
656 strcpy(buffer, "by-content(");
657 strlcat(buffer, makeName(*ref->u.target), 4096);
658 strlcat(buffer, ")", 4096);
659 return buffer;
660 case ld::Fixup::bindingDirectlyBound:
661 strcpy(buffer, "direct(");
662 strlcat(buffer, makeName(*ref->u.target), 4096);
663 strlcat(buffer, ")", 4096);
664 return buffer;
665 case ld::Fixup::bindingsIndirectlyBound:
666 return "BOUND INDIRECTLY";
667 }
668 return "BAD BINDING";
669 }
670
671
672 void dumper::dumpFixup(const ld::Fixup* ref)
673 {
674 if ( ref->weakImport ) {
675 printf("weak_import ");
676 }
677 switch ( (ld::Fixup::Kind)(ref->kind) ) {
678 case ld::Fixup::kindNone:
679 printf("none");
680 break;
681 case ld::Fixup::kindNoneFollowOn:
682 printf("followed by %s", referenceTargetAtomName(ref));
683 break;
684 case ld::Fixup::kindNoneGroupSubordinate:
685 printf("group subordinate %s", referenceTargetAtomName(ref));
686 break;
687 case ld::Fixup::kindNoneGroupSubordinateFDE:
688 printf("group subordinate FDE %s", referenceTargetAtomName(ref));
689 break;
690 case ld::Fixup::kindNoneGroupSubordinateLSDA:
691 printf("group subordinate LSDA %s", referenceTargetAtomName(ref));
692 break;
693 case ld::Fixup::kindNoneGroupSubordinatePersonality:
694 printf("group subordinate personality %s", referenceTargetAtomName(ref));
695 break;
696 case ld::Fixup::kindSetTargetAddress:
697 printf("%s", referenceTargetAtomName(ref));
698 break;
699 case ld::Fixup::kindSubtractTargetAddress:
700 printf(" - %s", referenceTargetAtomName(ref));
701 break;
702 case ld::Fixup::kindAddAddend:
703 printf(" + 0x%llX", ref->u.addend);
704 break;
705 case ld::Fixup::kindSubtractAddend:
706 printf(" - 0x%llX", ref->u.addend);
707 break;
708 case ld::Fixup::kindSetTargetImageOffset:
709 printf("imageOffset(%s)", referenceTargetAtomName(ref));
710 break;
711 case ld::Fixup::kindSetTargetSectionOffset:
712 printf("sectionOffset(%s)", referenceTargetAtomName(ref));
713 break;
714 case ld::Fixup::kindStore8:
715 printf(", then store byte");
716 break;
717 case ld::Fixup::kindStoreLittleEndian16:
718 printf(", then store 16-bit little endian");
719 break;
720 case ld::Fixup::kindStoreLittleEndianLow24of32:
721 printf(", then store low 24-bit little endian");
722 break;
723 case ld::Fixup::kindStoreLittleEndian32:
724 printf(", then store 32-bit little endian");
725 break;
726 case ld::Fixup::kindStoreLittleEndian64:
727 printf(", then store 64-bit little endian");
728 break;
729 case ld::Fixup::kindStoreBigEndian16:
730 printf(", then store 16-bit big endian");
731 break;
732 case ld::Fixup::kindStoreBigEndianLow24of32:
733 printf(", then store low 24-bit big endian");
734 break;
735 case ld::Fixup::kindStoreBigEndian32:
736 printf(", then store 32-bit big endian");
737 break;
738 case ld::Fixup::kindStoreBigEndian64:
739 printf(", then store 64-bit big endian");
740 break;
741 case ld::Fixup::kindStoreX86BranchPCRel8:
742 printf(", then store as x86 8-bit pcrel branch");
743 break;
744 case ld::Fixup::kindStoreX86BranchPCRel32:
745 printf(", then store as x86 32-bit pcrel branch");
746 break;
747 case ld::Fixup::kindStoreX86PCRel8:
748 printf(", then store as x86 8-bit pcrel");
749 break;
750 case ld::Fixup::kindStoreX86PCRel16:
751 printf(", then store as x86 16-bit pcrel");
752 break;
753 case ld::Fixup::kindStoreX86PCRel32:
754 printf(", then store as x86 32-bit pcrel");
755 break;
756 case ld::Fixup::kindStoreX86PCRel32_1:
757 printf(", then store as x86 32-bit pcrel from +1");
758 break;
759 case ld::Fixup::kindStoreX86PCRel32_2:
760 printf(", then store as x86 32-bit pcrel from +2");
761 break;
762 case ld::Fixup::kindStoreX86PCRel32_4:
763 printf(", then store as x86 32-bit pcrel from +4");
764 break;
765 case ld::Fixup::kindStoreX86PCRel32GOTLoad:
766 printf(", then store as x86 32-bit pcrel GOT load");
767 break;
768 case ld::Fixup::kindStoreX86PCRel32GOTLoadNowLEA:
769 printf(", then store as x86 32-bit pcrel GOT load -> LEA");
770 break;
771 case ld::Fixup::kindStoreX86PCRel32GOT:
772 printf(", then store as x86 32-bit pcrel GOT access");
773 break;
774 case ld::Fixup::kindStoreX86PCRel32TLVLoad:
775 printf(", then store as x86 32-bit pcrel TLV load");
776 break;
777 case ld::Fixup::kindStoreX86PCRel32TLVLoadNowLEA:
778 printf(", then store as x86 32-bit pcrel TLV load");
779 break;
780 case ld::Fixup::kindStoreX86Abs32TLVLoad:
781 printf(", then store as x86 32-bit absolute TLV load");
782 break;
783 case ld::Fixup::kindStoreX86Abs32TLVLoadNowLEA:
784 printf(", then store as x86 32-bit absolute TLV load -> LEA");
785 break;
786 case ld::Fixup::kindStoreARMBranch24:
787 printf(", then store as ARM 24-bit pcrel branch");
788 break;
789 case ld::Fixup::kindStoreThumbBranch22:
790 printf(", then store as Thumb 22-bit pcrel branch");
791 break;
792 case ld::Fixup::kindStoreARMLoad12:
793 printf(", then store as ARM 12-bit pcrel load");
794 break;
795 case ld::Fixup::kindStoreARMLow16:
796 printf(", then store low-16 in ARM movw");
797 break;
798 case ld::Fixup::kindStoreARMHigh16:
799 printf(", then store high-16 in ARM movt");
800 break;
801 case ld::Fixup::kindStoreThumbLow16:
802 printf(", then store low-16 in Thumb movw");
803 break;
804 case ld::Fixup::kindStoreThumbHigh16:
805 printf(", then store high-16 in Thumb movt");
806 break;
807 case ld::Fixup::kindStoreARM64Branch26:
808 printf(", then store as ARM64 26-bit pcrel branch");
809 break;
810 case ld::Fixup::kindStoreARM64Page21:
811 printf(", then store as ARM64 21-bit pcrel ADRP");
812 break;
813 case ld::Fixup::kindStoreARM64PageOff12:
814 printf(", then store as ARM64 12-bit offset");
815 break;
816 case ld::Fixup::kindStoreARM64GOTLoadPage21:
817 printf(", then store as ARM64 21-bit pcrel ADRP of GOT");
818 break;
819 case ld::Fixup::kindStoreARM64GOTLoadPageOff12:
820 printf(", then store as ARM64 12-bit page offset of GOT");
821 break;
822 case ld::Fixup::kindStoreARM64GOTLeaPage21:
823 printf(", then store as ARM64 21-bit pcrel ADRP of GOT lea");
824 break;
825 case ld::Fixup::kindStoreARM64GOTLeaPageOff12:
826 printf(", then store as ARM64 12-bit page offset of GOT lea");
827 break;
828 case ld::Fixup::kindStoreARM64TLVPLoadPage21:
829 printf(", then store as ARM64 21-bit pcrel ADRP of TLVP");
830 break;
831 case ld::Fixup::kindStoreARM64TLVPLoadPageOff12:
832 printf(", then store as ARM64 12-bit page offset of TLVP");
833 break;
834 case ld::Fixup::kindStoreARM64TLVPLoadNowLeaPage21:
835 printf(", then store as ARM64 21-bit pcrel ADRP of lea of TLVP");
836 break;
837 case ld::Fixup::kindStoreARM64TLVPLoadNowLeaPageOff12:
838 printf(", then store as ARM64 12-bit page offset of lea of TLVP");
839 break;
840 case ld::Fixup::kindStoreARM64PointerToGOT:
841 printf(", then store as 64-bit pointer to GOT entry");
842 break;
843 case ld::Fixup::kindStoreARM64PCRelToGOT:
844 printf(", then store as 32-bit delta to GOT entry");
845 break;
846 case ld::Fixup::kindDtraceExtra:
847 printf("dtrace static probe extra info");
848 break;
849 case ld::Fixup::kindStoreX86DtraceCallSiteNop:
850 printf("x86 dtrace static probe site");
851 break;
852 case ld::Fixup::kindStoreX86DtraceIsEnableSiteClear:
853 printf("x86 dtrace static is-enabled site");
854 break;
855 case ld::Fixup::kindStoreARMDtraceCallSiteNop:
856 printf("ARM dtrace static probe site");
857 break;
858 case ld::Fixup::kindStoreARMDtraceIsEnableSiteClear:
859 printf("ARM dtrace static is-enabled site");
860 break;
861 case ld::Fixup::kindStoreThumbDtraceCallSiteNop:
862 printf("Thumb dtrace static probe site");
863 break;
864 case ld::Fixup::kindStoreThumbDtraceIsEnableSiteClear:
865 printf("Thumb dtrace static is-enabled site");
866 break;
867 case ld::Fixup::kindStoreARM64DtraceCallSiteNop:
868 printf("ARM64 dtrace static probe site");
869 break;
870 case ld::Fixup::kindStoreARM64DtraceIsEnableSiteClear:
871 printf("ARM64 dtrace static is-enabled site");
872 break;
873 case ld::Fixup::kindLazyTarget:
874 printf("lazy reference to external symbol %s", referenceTargetAtomName(ref));
875 break;
876 case ld::Fixup::kindSetLazyOffset:
877 printf("offset of lazy binding info for %s", referenceTargetAtomName(ref));
878 break;
879 case ld::Fixup::kindIslandTarget:
880 printf("ultimate target of island %s", referenceTargetAtomName(ref));
881 break;
882 case ld::Fixup::kindDataInCodeStartData:
883 printf("start of data in code");
884 break;
885 case ld::Fixup::kindDataInCodeStartJT8:
886 printf("start of jump table 8 data in code");
887 break;
888 case ld::Fixup::kindDataInCodeStartJT16:
889 printf("start of jump table 16 data in code");
890 break;
891 case ld::Fixup::kindDataInCodeStartJT32:
892 printf("start of jump table 32 data in code");
893 break;
894 case ld::Fixup::kindDataInCodeStartJTA32:
895 printf("start of jump table absolute 32 data in code");
896 break;
897 case ld::Fixup::kindDataInCodeEnd:
898 printf("end of data in code");
899 break;
900 case ld::Fixup::kindLinkerOptimizationHint:
901 #if SUPPORT_ARCH_arm64
902 ld::Fixup::LOH_arm64 extra;
903 extra.addend = ref->u.addend;
904 printf("ARM64 hint: ");
905 switch(extra.info.kind) {
906 case LOH_ARM64_ADRP_ADRP:
907 printf("ADRP-ADRP");
908 break;
909 case LOH_ARM64_ADRP_LDR:
910 printf("ADRP-LDR");
911 break;
912 case LOH_ARM64_ADRP_ADD_LDR:
913 printf("ADRP-ADD-LDR");
914 break;
915 case LOH_ARM64_ADRP_LDR_GOT_LDR:
916 printf("ADRP-LDR-GOT-LDR");
917 break;
918 case LOH_ARM64_ADRP_ADD_STR:
919 printf("ADRP-ADD-STR");
920 break;
921 case LOH_ARM64_ADRP_LDR_GOT_STR:
922 printf("ADRP-LDR-GOT-STR");
923 break;
924 case LOH_ARM64_ADRP_ADD:
925 printf("ADRP-ADD");
926 break;
927 default:
928 printf("kind=%d", extra.info.kind);
929 break;
930 }
931 printf(", offset1=0x%X", (extra.info.delta1 << 2) + ref->offsetInAtom);
932 if ( extra.info.count > 0 )
933 printf(", offset2=0x%X", (extra.info.delta2 << 2) + ref->offsetInAtom);
934 if ( extra.info.count > 1 )
935 printf(", offset3=0x%X", (extra.info.delta3 << 2) + ref->offsetInAtom);
936 if ( extra.info.count > 2 )
937 printf(", offset4=0x%X", (extra.info.delta4 << 2) + ref->offsetInAtom);
938 #endif
939 break;
940 case ld::Fixup::kindStoreTargetAddressLittleEndian32:
941 printf("store 32-bit little endian address of %s", referenceTargetAtomName(ref));
942 break;
943 case ld::Fixup::kindStoreTargetAddressLittleEndian64:
944 printf("store 64-bit little endian address of %s", referenceTargetAtomName(ref));
945 break;
946 case ld::Fixup::kindStoreTargetAddressBigEndian32:
947 printf("store 32-bit big endian address of %s", referenceTargetAtomName(ref));
948 break;
949 case ld::Fixup::kindStoreTargetAddressBigEndian64:
950 printf("store 64-bit big endian address of %s", referenceTargetAtomName(ref));
951 break;
952 case ld::Fixup::kindStoreTargetAddressX86PCRel32:
953 printf("x86 store 32-bit pc-rel address of %s", referenceTargetAtomName(ref));
954 break;
955 case ld::Fixup::kindStoreTargetAddressX86BranchPCRel32:
956 printf("x86 store 32-bit pc-rel branch to %s", referenceTargetAtomName(ref));
957 break;
958 case ld::Fixup::kindStoreTargetAddressX86PCRel32GOTLoad:
959 printf("x86 store 32-bit pc-rel GOT load of %s", referenceTargetAtomName(ref));
960 break;
961 case ld::Fixup::kindStoreTargetAddressX86PCRel32GOTLoadNowLEA:
962 printf("x86 store 32-bit pc-rel lea of %s", referenceTargetAtomName(ref));
963 break;
964 case ld::Fixup::kindStoreTargetAddressX86PCRel32TLVLoad:
965 printf("x86 store 32-bit pc-rel TLV load of %s", referenceTargetAtomName(ref));
966 break;
967 case ld::Fixup::kindStoreTargetAddressX86PCRel32TLVLoadNowLEA:
968 printf("x86 store 32-bit pc-rel TLV lea of %s", referenceTargetAtomName(ref));
969 break;
970 case ld::Fixup::kindStoreTargetAddressX86Abs32TLVLoad:
971 printf("x86 store 32-bit absolute TLV load of %s", referenceTargetAtomName(ref));
972 break;
973 case ld::Fixup::kindStoreTargetAddressX86Abs32TLVLoadNowLEA:
974 printf("x86 store 32-bit absolute TLV lea of %s", referenceTargetAtomName(ref));
975 break;
976 case ld::Fixup::kindStoreTargetAddressARMBranch24:
977 printf("ARM store 24-bit pc-rel branch to %s", referenceTargetAtomName(ref));
978 break;
979 case ld::Fixup::kindStoreTargetAddressThumbBranch22:
980 printf("Thumb store 22-bit pc-rel branch to %s", referenceTargetAtomName(ref));
981 break;
982 case ld::Fixup::kindStoreTargetAddressARMLoad12:
983 printf("ARM store 12-bit pc-rel branch to %s", referenceTargetAtomName(ref));
984 break;
985 case ld::Fixup::kindSetTargetTLVTemplateOffset:
986 case ld::Fixup::kindSetTargetTLVTemplateOffsetLittleEndian32:
987 case ld::Fixup::kindSetTargetTLVTemplateOffsetLittleEndian64:
988 printf("tlv template offset of %s", referenceTargetAtomName(ref));
989 break;
990 case ld::Fixup::kindStoreTargetAddressARM64Branch26:
991 printf("ARM64 store 26-bit pcrel branch to %s", referenceTargetAtomName(ref));
992 break;
993 case ld::Fixup::kindStoreTargetAddressARM64Page21:
994 printf("ARM64 store 21-bit pcrel ADRP to %s", referenceTargetAtomName(ref));
995 break;
996 case ld::Fixup::kindStoreTargetAddressARM64PageOff12:
997 printf("ARM64 store 12-bit page offset of %s", referenceTargetAtomName(ref));
998 break;
999 case ld::Fixup::kindStoreTargetAddressARM64GOTLoadPage21:
1000 printf("ARM64 store 21-bit pcrel ADRP to GOT for %s", referenceTargetAtomName(ref));
1001 break;
1002 case ld::Fixup::kindStoreTargetAddressARM64GOTLoadPageOff12:
1003 printf("ARM64 store 12-bit page offset of GOT of %s", referenceTargetAtomName(ref));
1004 break;
1005 case ld::Fixup::kindStoreTargetAddressARM64GOTLeaPage21:
1006 printf("ARM64 store 21-bit pcrel ADRP to GOT lea for %s", referenceTargetAtomName(ref));
1007 break;
1008 case ld::Fixup::kindStoreTargetAddressARM64GOTLeaPageOff12:
1009 printf("ARM64 store 12-bit page offset of GOT lea of %s", referenceTargetAtomName(ref));
1010 break;
1011 case ld::Fixup::kindStoreTargetAddressARM64TLVPLoadPage21:
1012 printf("ARM64 store 21-bit pcrel ADRP to TLV for %s", referenceTargetAtomName(ref));
1013 break;
1014 case ld::Fixup::kindStoreTargetAddressARM64TLVPLoadPageOff12:
1015 printf("ARM64 store 12-bit page offset of TLV of %s", referenceTargetAtomName(ref));
1016 break;
1017 case ld::Fixup::kindStoreTargetAddressARM64TLVPLoadNowLeaPage21:
1018 printf("ARM64 store 21-bit pcrel ADRP to lea for TLV for %s", referenceTargetAtomName(ref));
1019 break;
1020 case ld::Fixup::kindStoreTargetAddressARM64TLVPLoadNowLeaPageOff12:
1021 printf("ARM64 store 12-bit page offset of lea for TLV of %s", referenceTargetAtomName(ref));
1022 break;
1023 //default:
1024 // printf("unknown fixup");
1025 // break;
1026 }
1027 }
1028
1029 uint64_t dumper::addressOfFirstAtomInSection(const ld::Section& sect)
1030 {
1031 uint64_t lowestAddr = (uint64_t)(-1);
1032 for (std::vector<const ld::Atom*>::iterator it=_atoms.begin(); it != _atoms.end(); ++it) {
1033 const ld::Atom* atom = *it;
1034 if ( &atom->section() == &sect ) {
1035 if ( atom->objectAddress() < lowestAddr )
1036 lowestAddr = atom->objectAddress();
1037 }
1038 }
1039 return lowestAddr;
1040 }
1041
1042 void dumper::doAtom(const ld::Atom& atom)
1043 {
1044 if ( (sMatchName != NULL) && (strcmp(sMatchName, atom.name()) != 0) )
1045 return;
1046 _atoms.push_back(&atom);
1047 }
1048
1049 void dumper::dump()
1050 {
1051 if ( sSort )
1052 std::sort(_atoms.begin(), _atoms.end(), AtomSorter());
1053
1054 for (std::vector<const ld::Atom*>::iterator it=_atoms.begin(); it != _atoms.end(); ++it) {
1055 this->dumpAtom(**it);
1056 }
1057 }
1058
1059 void dumper::dumpAtom(const ld::Atom& atom)
1060 {
1061 printf("name: %s\n", makeName(atom));
1062 printf("size: 0x%0llX\n", atom.size());
1063 printf("align: %u mod %u\n", atom.alignment().modulus, (1 << atom.alignment().powerOf2) );
1064 printf("scope: %s\n", scopeString(atom));
1065 if ( sShowDefinitionKind )
1066 printf("def: %s\n", definitionString(atom));
1067 if ( sShowCombineKind )
1068 printf("combine: %s\n", combineString(atom));
1069 printf("symbol: %s\n", inclusionString(atom));
1070 printf("attrs: %s\n", attributeString(atom));
1071 if ( sShowSection )
1072 printf("section: %s,%s\n", atom.section().segmentName(), atom.section().sectionName());
1073 if ( atom.beginUnwind() != atom.endUnwind() ) {
1074 uint32_t lastOffset = 0;
1075 uint32_t lastCUE = 0;
1076 bool first = true;
1077 const char* label = "unwind:";
1078 for (ld::Atom::UnwindInfo::iterator it=atom.beginUnwind(); it != atom.endUnwind(); ++it) {
1079 if ( !first ) {
1080 printf("%s 0x%08X -> 0x%08X: 0x%08X\n", label, lastOffset, it->startOffset, lastCUE);
1081 label = " ";
1082 }
1083 lastOffset = it->startOffset;
1084 lastCUE = it->unwindInfo;
1085 first = false;
1086 }
1087 printf("%s 0x%08X -> 0x%08X: 0x%08X\n", label, lastOffset, (uint32_t)atom.size(), lastCUE);
1088 }
1089 if ( atom.contentType() == ld::Atom::typeCString ) {
1090 uint8_t buffer[atom.size()+2];
1091 atom.copyRawContent(buffer);
1092 buffer[atom.size()] = '\0';
1093 printf("content: \"%s\"\n", buffer);
1094 }
1095 if ( atom.fixupsBegin() != atom.fixupsEnd() ) {
1096 printf("fixups:\n");
1097 for (unsigned int off=0; off < atom.size()+1; ++off) {
1098 for (ld::Fixup::iterator it = atom.fixupsBegin(); it != atom.fixupsEnd(); ++it) {
1099 if ( it->offsetInAtom == off ) {
1100 switch ( it->clusterSize ) {
1101 case ld::Fixup::k1of1:
1102 printf(" 0x%04X ", it->offsetInAtom);
1103 dumpFixup(it);
1104 break;
1105 case ld::Fixup::k1of2:
1106 printf(" 0x%04X ", it->offsetInAtom);
1107 dumpFixup(it);
1108 ++it;
1109 dumpFixup(it);
1110 break;
1111 case ld::Fixup::k1of3:
1112 printf(" 0x%04X ", it->offsetInAtom);
1113 dumpFixup(it);
1114 ++it;
1115 dumpFixup(it);
1116 ++it;
1117 dumpFixup(it);
1118 break;
1119 case ld::Fixup::k1of4:
1120 printf(" 0x%04X ", it->offsetInAtom);
1121 dumpFixup(it);
1122 ++it;
1123 dumpFixup(it);
1124 ++it;
1125 dumpFixup(it);
1126 ++it;
1127 dumpFixup(it);
1128 break;
1129 case ld::Fixup::k1of5:
1130 printf(" 0x%04X ", it->offsetInAtom);
1131 dumpFixup(it);
1132 ++it;
1133 dumpFixup(it);
1134 ++it;
1135 dumpFixup(it);
1136 ++it;
1137 dumpFixup(it);
1138 ++it;
1139 dumpFixup(it);
1140 break;
1141 default:
1142 printf(" BAD CLUSTER SIZE: cluster=%d\n", it->clusterSize);
1143 }
1144 printf("\n");
1145 }
1146 }
1147 }
1148 }
1149 if ( sShowLineInfo ) {
1150 if ( atom.beginLineInfo() != atom.endLineInfo() ) {
1151 printf("line info:\n");
1152 for (ld::Atom::LineInfo::iterator it = atom.beginLineInfo(); it != atom.endLineInfo(); ++it) {
1153 printf(" offset 0x%04X, line %d, file %s\n", it->atomOffset, it->lineNumber, it->fileName);
1154 }
1155 }
1156 }
1157
1158 printf("\n");
1159 }
1160
1161 static void dumpFile(ld::relocatable::File* file)
1162 {
1163 // stabs debug info
1164 if ( sDumpStabs && (file->debugInfo() == ld::relocatable::File::kDebugInfoStabs) ) {
1165 const std::vector<ld::relocatable::File::Stab>* stabs = file->stabs();
1166 if ( stabs != NULL )
1167 dumpStabs(stabs);
1168 }
1169 // dump atoms
1170 dumper d;
1171 file->forEachAtom(d);
1172 d.dump();
1173
1174 #if 0
1175 // get all atoms
1176 std::vector<ObjectFile::Atom*> atoms = reader->getAtoms();
1177
1178 // make copy of vector and sort (so output is canonical)
1179 std::vector<ObjectFile::Atom*> sortedAtoms(atoms);
1180 if ( sSort )
1181 std::sort(sortedAtoms.begin(), sortedAtoms.end(), AtomSorter());
1182
1183 for(std::vector<ObjectFile::Atom*>::iterator it=sortedAtoms.begin(); it != sortedAtoms.end(); ++it) {
1184 if ( sNMmode )
1185 dumpAtomLikeNM(*it);
1186 else
1187 dumpAtom(*it);
1188 }
1189 #endif
1190 }
1191
1192
1193 static ld::relocatable::File* createReader(const char* path)
1194 {
1195 struct stat stat_buf;
1196
1197 int fd = ::open(path, O_RDONLY, 0);
1198 if ( fd == -1 )
1199 throwf("cannot open file: %s", path);
1200 ::fstat(fd, &stat_buf);
1201 uint8_t* p = (uint8_t*)::mmap(NULL, stat_buf.st_size, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0);
1202 ::close(fd);
1203 if ( p == (uint8_t*)(-1) )
1204 throwf("cannot mmap file: %s", path);
1205 const mach_header* mh = (mach_header*)p;
1206 uint64_t fileLen = stat_buf.st_size;
1207 bool foundFatSlice = false;
1208 if ( mh->magic == OSSwapBigToHostInt32(FAT_MAGIC) ) {
1209 const struct fat_header* fh = (struct fat_header*)p;
1210 const struct fat_arch* archs = (struct fat_arch*)(p + sizeof(struct fat_header));
1211 if ( (uint32_t)sPreferredArch == 0xFFFFFFFF ) {
1212 // just dump first slice of fat .o file
1213 if ( OSSwapBigToHostInt32(fh->nfat_arch) > 0 ) {
1214 p = p + OSSwapBigToHostInt32(archs[0].offset);
1215 mh = (struct mach_header*)p;
1216 fileLen = OSSwapBigToHostInt32(archs[0].size);
1217 sPreferredArch = OSSwapBigToHostInt32(archs[0].cputype);
1218 sPreferredSubArch = OSSwapBigToHostInt32(archs[0].cpusubtype);
1219 foundFatSlice = true;
1220 }
1221 }
1222 else {
1223 for (unsigned long i=0; i < OSSwapBigToHostInt32(fh->nfat_arch); ++i) {
1224 if ( OSSwapBigToHostInt32(archs[i].cputype) == (uint32_t)sPreferredArch ) {
1225 if ( ((uint32_t)sPreferredSubArch == 0xFFFFFFFF) || ((uint32_t)sPreferredSubArch == OSSwapBigToHostInt32(archs[i].cpusubtype)) ) {
1226 p = p + OSSwapBigToHostInt32(archs[i].offset);
1227 mh = (struct mach_header*)p;
1228 fileLen = OSSwapBigToHostInt32(archs[i].size);
1229 foundFatSlice = true;
1230 break;
1231 }
1232 }
1233 }
1234 }
1235 }
1236
1237 mach_o::relocatable::ParserOptions objOpts;
1238 objOpts.architecture = sPreferredArch;
1239 objOpts.objSubtypeMustMatch = false;
1240 objOpts.logAllFiles = false;
1241 objOpts.warnUnwindConversionProblems = true;
1242 objOpts.keepDwarfUnwind = false;
1243 objOpts.forceDwarfConversion = false;
1244 objOpts.verboseOptimizationHints = true;
1245 objOpts.subType = sPreferredSubArch;
1246 #if 1
1247 if ( ! foundFatSlice ) {
1248 cpu_type_t archOfObj;
1249 cpu_subtype_t subArchOfObj;
1250 if ( mach_o::relocatable::isObjectFile(p, &archOfObj, &subArchOfObj) ) {
1251 objOpts.architecture = archOfObj;
1252 objOpts.subType = subArchOfObj;
1253 }
1254 }
1255
1256 ld::relocatable::File* objResult = mach_o::relocatable::parse(p, fileLen, path, stat_buf.st_mtime, ld::File::Ordinal::NullOrdinal(), objOpts);
1257 if ( objResult != NULL )
1258 return objResult;
1259
1260 // see if it is an llvm object file
1261 objResult = lto::parse(p, fileLen, path, stat_buf.st_mtime, ld::File::Ordinal::NullOrdinal(), sPreferredArch, sPreferredSubArch, false, true);
1262 if ( objResult != NULL )
1263 return objResult;
1264
1265 throwf("not a mach-o object file: %s", path);
1266 #else
1267 // for peformance testing
1268 for (int i=0; i < 500; ++i ) {
1269 ld::relocatable::File* objResult = mach_o::relocatable::parse(p, fileLen, path, stat_buf.st_mtime, 0, objOpts);
1270 delete objResult;
1271 }
1272 exit(0);
1273 #endif
1274 }
1275
1276 static
1277 void
1278 usage()
1279 {
1280 fprintf(stderr, "ObjectDump options:\n"
1281 "\t-no_content\tdon't dump contents\n"
1282 "\t-no_section\tdon't dump section name\n"
1283 "\t-no_defintion\tdon't dump definition kind\n"
1284 "\t-no_combine\tdon't dump combine mode\n"
1285 "\t-stabs\t\tdump stabs\n"
1286 "\t-arch aaa\tonly dump info about arch aaa\n"
1287 "\t-only sym\tonly dump info about sym\n"
1288 "\t-align\t\tonly print alignment info\n"
1289 "\t-name\t\tonly print symbol names\n"
1290 );
1291 }
1292
1293 int main(int argc, const char* argv[])
1294 {
1295 if(argc<2) {
1296 usage();
1297 return 0;
1298 }
1299
1300 try {
1301 for(int i=1; i < argc; ++i) {
1302 const char* arg = argv[i];
1303 if ( arg[0] == '-' ) {
1304 if ( strcmp(arg, "-no_content") == 0 ) {
1305 sDumpContent = false;
1306 }
1307 else if ( strcmp(arg, "-nm") == 0 ) {
1308 sNMmode = true;
1309 }
1310 else if ( strcmp(arg, "-stabs") == 0 ) {
1311 sDumpStabs = true;
1312 }
1313 else if ( strcmp(arg, "-no_sort") == 0 ) {
1314 sSort = false;
1315 }
1316 else if ( strcmp(arg, "-no_section") == 0 ) {
1317 sShowSection = false;
1318 }
1319 else if ( strcmp(arg, "-no_definition") == 0 ) {
1320 sShowDefinitionKind = false;
1321 }
1322 else if ( strcmp(arg, "-no_combine") == 0 ) {
1323 sShowCombineKind = false;
1324 }
1325 else if ( strcmp(arg, "-no_line_info") == 0 ) {
1326 sShowLineInfo = false;
1327 }
1328 else if ( strcmp(arg, "-arch") == 0 ) {
1329 const char* archName = argv[++i];
1330 if ( archName == NULL )
1331 throw "-arch missing architecture name";
1332 bool found = false;
1333 for (const ArchInfo* t=archInfoArray; t->archName != NULL; ++t) {
1334 if ( strcmp(t->archName,archName) == 0 ) {
1335 sPreferredArch = t->cpuType;
1336 if ( t->isSubType )
1337 sPreferredSubArch = t->cpuSubType;
1338 found = true;
1339 }
1340 }
1341 if ( !found )
1342 throwf("unknown architecture %s", archName);
1343 }
1344 else if ( strcmp(arg, "-only") == 0 ) {
1345 sMatchName = ++i<argc? argv[i]: NULL;
1346 }
1347 else if ( strcmp(arg, "-align") == 0 ) {
1348 sPrintRestrict = true;
1349 sPrintAlign = true;
1350 }
1351 else if ( strcmp(arg, "-name") == 0 ) {
1352 sPrintRestrict = true;
1353 sPrintName = true;
1354 }
1355 else {
1356 usage();
1357 throwf("unknown option: %s\n", arg);
1358 }
1359 }
1360 else {
1361 ld::relocatable::File* reader = createReader(arg);
1362 dumpFile(reader);
1363 }
1364 }
1365 }
1366 catch (const char* msg) {
1367 fprintf(stderr, "ObjDump failed: %s\n", msg);
1368 return 1;
1369 }
1370
1371 return 0;
1372 }
mirror of ld64