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


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