1 //===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This program is a utility that works like binutils "objdump", that is, it
10 // dumps out a plethora of information about an object file depending on the
11 // flags.
12 //
13 // The flags and output of this program should be near identical to those of
14 // binutils objdump.
15 //
16 //===----------------------------------------------------------------------===//
17
18 #include "llvm-objdump.h"
19 #include "COFFDump.h"
20 #include "ELFDump.h"
21 #include "MachODump.h"
22 #include "ObjdumpOptID.h"
23 #include "OffloadDump.h"
24 #include "SourcePrinter.h"
25 #include "WasmDump.h"
26 #include "XCOFFDump.h"
27 #include "llvm/ADT/STLExtras.h"
28 #include "llvm/ADT/SetOperations.h"
29 #include "llvm/ADT/StringExtras.h"
30 #include "llvm/ADT/StringSet.h"
31 #include "llvm/ADT/Twine.h"
32 #include "llvm/DebugInfo/BTF/BTFParser.h"
33 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
34 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
35 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
36 #include "llvm/Debuginfod/BuildIDFetcher.h"
37 #include "llvm/Debuginfod/Debuginfod.h"
38 #include "llvm/Debuginfod/HTTPClient.h"
39 #include "llvm/Demangle/Demangle.h"
40 #include "llvm/MC/MCAsmInfo.h"
41 #include "llvm/MC/MCContext.h"
42 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
43 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
44 #include "llvm/MC/MCInst.h"
45 #include "llvm/MC/MCInstPrinter.h"
46 #include "llvm/MC/MCInstrAnalysis.h"
47 #include "llvm/MC/MCInstrInfo.h"
48 #include "llvm/MC/MCObjectFileInfo.h"
49 #include "llvm/MC/MCRegisterInfo.h"
50 #include "llvm/MC/MCTargetOptions.h"
51 #include "llvm/MC/TargetRegistry.h"
52 #include "llvm/Object/Archive.h"
53 #include "llvm/Object/BuildID.h"
54 #include "llvm/Object/COFF.h"
55 #include "llvm/Object/COFFImportFile.h"
56 #include "llvm/Object/ELFObjectFile.h"
57 #include "llvm/Object/ELFTypes.h"
58 #include "llvm/Object/FaultMapParser.h"
59 #include "llvm/Object/MachO.h"
60 #include "llvm/Object/MachOUniversal.h"
61 #include "llvm/Object/ObjectFile.h"
62 #include "llvm/Object/OffloadBinary.h"
63 #include "llvm/Object/Wasm.h"
64 #include "llvm/Option/Arg.h"
65 #include "llvm/Option/ArgList.h"
66 #include "llvm/Option/Option.h"
67 #include "llvm/Support/Casting.h"
68 #include "llvm/Support/Debug.h"
69 #include "llvm/Support/Errc.h"
70 #include "llvm/Support/FileSystem.h"
71 #include "llvm/Support/Format.h"
72 #include "llvm/Support/FormatVariadic.h"
73 #include "llvm/Support/GraphWriter.h"
74 #include "llvm/Support/LLVMDriver.h"
75 #include "llvm/Support/MemoryBuffer.h"
76 #include "llvm/Support/SourceMgr.h"
77 #include "llvm/Support/StringSaver.h"
78 #include "llvm/Support/TargetSelect.h"
79 #include "llvm/Support/WithColor.h"
80 #include "llvm/Support/raw_ostream.h"
81 #include "llvm/TargetParser/Host.h"
82 #include "llvm/TargetParser/Triple.h"
83 #include <algorithm>
84 #include <cctype>
85 #include <cstring>
86 #include <optional>
87 #include <set>
88 #include <system_error>
89 #include <unordered_map>
90 #include <utility>
91
92 using namespace llvm;
93 using namespace llvm::object;
94 using namespace llvm::objdump;
95 using namespace llvm::opt;
96
97 namespace {
98
99 class CommonOptTable : public opt::GenericOptTable {
100 public:
CommonOptTable(ArrayRef<Info> OptionInfos,const char * Usage,const char * Description)101 CommonOptTable(ArrayRef<Info> OptionInfos, const char *Usage,
102 const char *Description)
103 : opt::GenericOptTable(OptionInfos), Usage(Usage),
104 Description(Description) {
105 setGroupedShortOptions(true);
106 }
107
printHelp(StringRef Argv0,bool ShowHidden=false) const108 void printHelp(StringRef Argv0, bool ShowHidden = false) const {
109 Argv0 = sys::path::filename(Argv0);
110 opt::GenericOptTable::printHelp(outs(), (Argv0 + Usage).str().c_str(),
111 Description, ShowHidden, ShowHidden);
112 // TODO Replace this with OptTable API once it adds extrahelp support.
113 outs() << "\nPass @FILE as argument to read options from FILE.\n";
114 }
115
116 private:
117 const char *Usage;
118 const char *Description;
119 };
120
121 // ObjdumpOptID is in ObjdumpOptID.h
122 namespace objdump_opt {
123 #define PREFIX(NAME, VALUE) \
124 static constexpr StringLiteral NAME##_init[] = VALUE; \
125 static constexpr ArrayRef<StringLiteral> NAME(NAME##_init, \
126 std::size(NAME##_init) - 1);
127 #include "ObjdumpOpts.inc"
128 #undef PREFIX
129
130 static constexpr opt::OptTable::Info ObjdumpInfoTable[] = {
131 #define OPTION(...) \
132 LLVM_CONSTRUCT_OPT_INFO_WITH_ID_PREFIX(OBJDUMP_, __VA_ARGS__),
133 #include "ObjdumpOpts.inc"
134 #undef OPTION
135 };
136 } // namespace objdump_opt
137
138 class ObjdumpOptTable : public CommonOptTable {
139 public:
ObjdumpOptTable()140 ObjdumpOptTable()
141 : CommonOptTable(objdump_opt::ObjdumpInfoTable,
142 " [options] <input object files>",
143 "llvm object file dumper") {}
144 };
145
146 enum OtoolOptID {
147 OTOOL_INVALID = 0, // This is not an option ID.
148 #define OPTION(...) LLVM_MAKE_OPT_ID_WITH_ID_PREFIX(OTOOL_, __VA_ARGS__),
149 #include "OtoolOpts.inc"
150 #undef OPTION
151 };
152
153 namespace otool {
154 #define PREFIX(NAME, VALUE) \
155 static constexpr StringLiteral NAME##_init[] = VALUE; \
156 static constexpr ArrayRef<StringLiteral> NAME(NAME##_init, \
157 std::size(NAME##_init) - 1);
158 #include "OtoolOpts.inc"
159 #undef PREFIX
160
161 static constexpr opt::OptTable::Info OtoolInfoTable[] = {
162 #define OPTION(...) LLVM_CONSTRUCT_OPT_INFO_WITH_ID_PREFIX(OTOOL_, __VA_ARGS__),
163 #include "OtoolOpts.inc"
164 #undef OPTION
165 };
166 } // namespace otool
167
168 class OtoolOptTable : public CommonOptTable {
169 public:
OtoolOptTable()170 OtoolOptTable()
171 : CommonOptTable(otool::OtoolInfoTable, " [option...] [file...]",
172 "Mach-O object file displaying tool") {}
173 };
174
175 } // namespace
176
177 #define DEBUG_TYPE "objdump"
178
179 enum class ColorOutput {
180 Auto,
181 Enable,
182 Disable,
183 Invalid,
184 };
185
186 static uint64_t AdjustVMA;
187 static bool AllHeaders;
188 static std::string ArchName;
189 bool objdump::ArchiveHeaders;
190 bool objdump::Demangle;
191 bool objdump::Disassemble;
192 bool objdump::DisassembleAll;
193 bool objdump::SymbolDescription;
194 bool objdump::TracebackTable;
195 static std::vector<std::string> DisassembleSymbols;
196 static bool DisassembleZeroes;
197 static std::vector<std::string> DisassemblerOptions;
198 static ColorOutput DisassemblyColor;
199 DIDumpType objdump::DwarfDumpType;
200 static bool DynamicRelocations;
201 static bool FaultMapSection;
202 static bool FileHeaders;
203 bool objdump::SectionContents;
204 static std::vector<std::string> InputFilenames;
205 bool objdump::PrintLines;
206 static bool MachOOpt;
207 std::string objdump::MCPU;
208 std::vector<std::string> objdump::MAttrs;
209 bool objdump::ShowRawInsn;
210 bool objdump::LeadingAddr;
211 static bool Offloading;
212 static bool RawClangAST;
213 bool objdump::Relocations;
214 bool objdump::PrintImmHex;
215 bool objdump::PrivateHeaders;
216 std::vector<std::string> objdump::FilterSections;
217 bool objdump::SectionHeaders;
218 static bool ShowAllSymbols;
219 static bool ShowLMA;
220 bool objdump::PrintSource;
221
222 static uint64_t StartAddress;
223 static bool HasStartAddressFlag;
224 static uint64_t StopAddress = UINT64_MAX;
225 static bool HasStopAddressFlag;
226
227 bool objdump::SymbolTable;
228 static bool SymbolizeOperands;
229 static bool DynamicSymbolTable;
230 std::string objdump::TripleName;
231 bool objdump::UnwindInfo;
232 static bool Wide;
233 std::string objdump::Prefix;
234 uint32_t objdump::PrefixStrip;
235
236 DebugVarsFormat objdump::DbgVariables = DVDisabled;
237
238 int objdump::DbgIndent = 52;
239
240 static StringSet<> DisasmSymbolSet;
241 StringSet<> objdump::FoundSectionSet;
242 static StringRef ToolName;
243
244 std::unique_ptr<BuildIDFetcher> BIDFetcher;
245
Dumper(const object::ObjectFile & O)246 Dumper::Dumper(const object::ObjectFile &O) : O(O) {
247 WarningHandler = [this](const Twine &Msg) {
248 if (Warnings.insert(Msg.str()).second)
249 reportWarning(Msg, this->O.getFileName());
250 return Error::success();
251 };
252 }
253
reportUniqueWarning(Error Err)254 void Dumper::reportUniqueWarning(Error Err) {
255 reportUniqueWarning(toString(std::move(Err)));
256 }
257
reportUniqueWarning(const Twine & Msg)258 void Dumper::reportUniqueWarning(const Twine &Msg) {
259 cantFail(WarningHandler(Msg));
260 }
261
createDumper(const ObjectFile & Obj)262 static Expected<std::unique_ptr<Dumper>> createDumper(const ObjectFile &Obj) {
263 if (const auto *O = dyn_cast<COFFObjectFile>(&Obj))
264 return createCOFFDumper(*O);
265 if (const auto *O = dyn_cast<ELFObjectFileBase>(&Obj))
266 return createELFDumper(*O);
267 if (const auto *O = dyn_cast<MachOObjectFile>(&Obj))
268 return createMachODumper(*O);
269 if (const auto *O = dyn_cast<WasmObjectFile>(&Obj))
270 return createWasmDumper(*O);
271 if (const auto *O = dyn_cast<XCOFFObjectFile>(&Obj))
272 return createXCOFFDumper(*O);
273
274 return createStringError(errc::invalid_argument,
275 "unsupported object file format");
276 }
277
278 namespace {
279 struct FilterResult {
280 // True if the section should not be skipped.
281 bool Keep;
282
283 // True if the index counter should be incremented, even if the section should
284 // be skipped. For example, sections may be skipped if they are not included
285 // in the --section flag, but we still want those to count toward the section
286 // count.
287 bool IncrementIndex;
288 };
289 } // namespace
290
checkSectionFilter(object::SectionRef S)291 static FilterResult checkSectionFilter(object::SectionRef S) {
292 if (FilterSections.empty())
293 return {/*Keep=*/true, /*IncrementIndex=*/true};
294
295 Expected<StringRef> SecNameOrErr = S.getName();
296 if (!SecNameOrErr) {
297 consumeError(SecNameOrErr.takeError());
298 return {/*Keep=*/false, /*IncrementIndex=*/false};
299 }
300 StringRef SecName = *SecNameOrErr;
301
302 // StringSet does not allow empty key so avoid adding sections with
303 // no name (such as the section with index 0) here.
304 if (!SecName.empty())
305 FoundSectionSet.insert(SecName);
306
307 // Only show the section if it's in the FilterSections list, but always
308 // increment so the indexing is stable.
309 return {/*Keep=*/is_contained(FilterSections, SecName),
310 /*IncrementIndex=*/true};
311 }
312
ToolSectionFilter(object::ObjectFile const & O,uint64_t * Idx)313 SectionFilter objdump::ToolSectionFilter(object::ObjectFile const &O,
314 uint64_t *Idx) {
315 // Start at UINT64_MAX so that the first index returned after an increment is
316 // zero (after the unsigned wrap).
317 if (Idx)
318 *Idx = UINT64_MAX;
319 return SectionFilter(
320 [Idx](object::SectionRef S) {
321 FilterResult Result = checkSectionFilter(S);
322 if (Idx != nullptr && Result.IncrementIndex)
323 *Idx += 1;
324 return Result.Keep;
325 },
326 O);
327 }
328
getFileNameForError(const object::Archive::Child & C,unsigned Index)329 std::string objdump::getFileNameForError(const object::Archive::Child &C,
330 unsigned Index) {
331 Expected<StringRef> NameOrErr = C.getName();
332 if (NameOrErr)
333 return std::string(NameOrErr.get());
334 // If we have an error getting the name then we print the index of the archive
335 // member. Since we are already in an error state, we just ignore this error.
336 consumeError(NameOrErr.takeError());
337 return "<file index: " + std::to_string(Index) + ">";
338 }
339
reportWarning(const Twine & Message,StringRef File)340 void objdump::reportWarning(const Twine &Message, StringRef File) {
341 // Output order between errs() and outs() matters especially for archive
342 // files where the output is per member object.
343 outs().flush();
344 WithColor::warning(errs(), ToolName)
345 << "'" << File << "': " << Message << "\n";
346 }
347
reportError(StringRef File,const Twine & Message)348 [[noreturn]] void objdump::reportError(StringRef File, const Twine &Message) {
349 outs().flush();
350 WithColor::error(errs(), ToolName) << "'" << File << "': " << Message << "\n";
351 exit(1);
352 }
353
reportError(Error E,StringRef FileName,StringRef ArchiveName,StringRef ArchitectureName)354 [[noreturn]] void objdump::reportError(Error E, StringRef FileName,
355 StringRef ArchiveName,
356 StringRef ArchitectureName) {
357 assert(E);
358 outs().flush();
359 WithColor::error(errs(), ToolName);
360 if (ArchiveName != "")
361 errs() << ArchiveName << "(" << FileName << ")";
362 else
363 errs() << "'" << FileName << "'";
364 if (!ArchitectureName.empty())
365 errs() << " (for architecture " << ArchitectureName << ")";
366 errs() << ": ";
367 logAllUnhandledErrors(std::move(E), errs());
368 exit(1);
369 }
370
reportCmdLineWarning(const Twine & Message)371 static void reportCmdLineWarning(const Twine &Message) {
372 WithColor::warning(errs(), ToolName) << Message << "\n";
373 }
374
reportCmdLineError(const Twine & Message)375 [[noreturn]] static void reportCmdLineError(const Twine &Message) {
376 WithColor::error(errs(), ToolName) << Message << "\n";
377 exit(1);
378 }
379
warnOnNoMatchForSections()380 static void warnOnNoMatchForSections() {
381 SetVector<StringRef> MissingSections;
382 for (StringRef S : FilterSections) {
383 if (FoundSectionSet.count(S))
384 return;
385 // User may specify a unnamed section. Don't warn for it.
386 if (!S.empty())
387 MissingSections.insert(S);
388 }
389
390 // Warn only if no section in FilterSections is matched.
391 for (StringRef S : MissingSections)
392 reportCmdLineWarning("section '" + S +
393 "' mentioned in a -j/--section option, but not "
394 "found in any input file");
395 }
396
getTarget(const ObjectFile * Obj)397 static const Target *getTarget(const ObjectFile *Obj) {
398 // Figure out the target triple.
399 Triple TheTriple("unknown-unknown-unknown");
400 if (TripleName.empty()) {
401 TheTriple = Obj->makeTriple();
402 } else {
403 TheTriple.setTriple(Triple::normalize(TripleName));
404 auto Arch = Obj->getArch();
405 if (Arch == Triple::arm || Arch == Triple::armeb)
406 Obj->setARMSubArch(TheTriple);
407 }
408
409 // Get the target specific parser.
410 std::string Error;
411 const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple,
412 Error);
413 if (!TheTarget)
414 reportError(Obj->getFileName(), "can't find target: " + Error);
415
416 // Update the triple name and return the found target.
417 TripleName = TheTriple.getTriple();
418 return TheTarget;
419 }
420
isRelocAddressLess(RelocationRef A,RelocationRef B)421 bool objdump::isRelocAddressLess(RelocationRef A, RelocationRef B) {
422 return A.getOffset() < B.getOffset();
423 }
424
getRelocationValueString(const RelocationRef & Rel,bool SymbolDescription,SmallVectorImpl<char> & Result)425 static Error getRelocationValueString(const RelocationRef &Rel,
426 bool SymbolDescription,
427 SmallVectorImpl<char> &Result) {
428 const ObjectFile *Obj = Rel.getObject();
429 if (auto *ELF = dyn_cast<ELFObjectFileBase>(Obj))
430 return getELFRelocationValueString(ELF, Rel, Result);
431 if (auto *COFF = dyn_cast<COFFObjectFile>(Obj))
432 return getCOFFRelocationValueString(COFF, Rel, Result);
433 if (auto *Wasm = dyn_cast<WasmObjectFile>(Obj))
434 return getWasmRelocationValueString(Wasm, Rel, Result);
435 if (auto *MachO = dyn_cast<MachOObjectFile>(Obj))
436 return getMachORelocationValueString(MachO, Rel, Result);
437 if (auto *XCOFF = dyn_cast<XCOFFObjectFile>(Obj))
438 return getXCOFFRelocationValueString(*XCOFF, Rel, SymbolDescription,
439 Result);
440 llvm_unreachable("unknown object file format");
441 }
442
443 /// Indicates whether this relocation should hidden when listing
444 /// relocations, usually because it is the trailing part of a multipart
445 /// relocation that will be printed as part of the leading relocation.
getHidden(RelocationRef RelRef)446 static bool getHidden(RelocationRef RelRef) {
447 auto *MachO = dyn_cast<MachOObjectFile>(RelRef.getObject());
448 if (!MachO)
449 return false;
450
451 unsigned Arch = MachO->getArch();
452 DataRefImpl Rel = RelRef.getRawDataRefImpl();
453 uint64_t Type = MachO->getRelocationType(Rel);
454
455 // On arches that use the generic relocations, GENERIC_RELOC_PAIR
456 // is always hidden.
457 if (Arch == Triple::x86 || Arch == Triple::arm || Arch == Triple::ppc)
458 return Type == MachO::GENERIC_RELOC_PAIR;
459
460 if (Arch == Triple::x86_64) {
461 // On x86_64, X86_64_RELOC_UNSIGNED is hidden only when it follows
462 // an X86_64_RELOC_SUBTRACTOR.
463 if (Type == MachO::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) {
464 DataRefImpl RelPrev = Rel;
465 RelPrev.d.a--;
466 uint64_t PrevType = MachO->getRelocationType(RelPrev);
467 if (PrevType == MachO::X86_64_RELOC_SUBTRACTOR)
468 return true;
469 }
470 }
471
472 return false;
473 }
474
475 /// Get the column at which we want to start printing the instruction
476 /// disassembly, taking into account anything which appears to the left of it.
getInstStartColumn(const MCSubtargetInfo & STI)477 unsigned objdump::getInstStartColumn(const MCSubtargetInfo &STI) {
478 return !ShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24;
479 }
480
AlignToInstStartColumn(size_t Start,const MCSubtargetInfo & STI,raw_ostream & OS)481 static void AlignToInstStartColumn(size_t Start, const MCSubtargetInfo &STI,
482 raw_ostream &OS) {
483 // The output of printInst starts with a tab. Print some spaces so that
484 // the tab has 1 column and advances to the target tab stop.
485 unsigned TabStop = getInstStartColumn(STI);
486 unsigned Column = OS.tell() - Start;
487 OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8);
488 }
489
printRawData(ArrayRef<uint8_t> Bytes,uint64_t Address,formatted_raw_ostream & OS,MCSubtargetInfo const & STI)490 void objdump::printRawData(ArrayRef<uint8_t> Bytes, uint64_t Address,
491 formatted_raw_ostream &OS,
492 MCSubtargetInfo const &STI) {
493 size_t Start = OS.tell();
494 if (LeadingAddr)
495 OS << format("%8" PRIx64 ":", Address);
496 if (ShowRawInsn) {
497 OS << ' ';
498 dumpBytes(Bytes, OS);
499 }
500 AlignToInstStartColumn(Start, STI, OS);
501 }
502
503 namespace {
504
isAArch64Elf(const ObjectFile & Obj)505 static bool isAArch64Elf(const ObjectFile &Obj) {
506 const auto *Elf = dyn_cast<ELFObjectFileBase>(&Obj);
507 return Elf && Elf->getEMachine() == ELF::EM_AARCH64;
508 }
509
isArmElf(const ObjectFile & Obj)510 static bool isArmElf(const ObjectFile &Obj) {
511 const auto *Elf = dyn_cast<ELFObjectFileBase>(&Obj);
512 return Elf && Elf->getEMachine() == ELF::EM_ARM;
513 }
514
isCSKYElf(const ObjectFile & Obj)515 static bool isCSKYElf(const ObjectFile &Obj) {
516 const auto *Elf = dyn_cast<ELFObjectFileBase>(&Obj);
517 return Elf && Elf->getEMachine() == ELF::EM_CSKY;
518 }
519
hasMappingSymbols(const ObjectFile & Obj)520 static bool hasMappingSymbols(const ObjectFile &Obj) {
521 return isArmElf(Obj) || isAArch64Elf(Obj) || isCSKYElf(Obj) ;
522 }
523
printRelocation(formatted_raw_ostream & OS,StringRef FileName,const RelocationRef & Rel,uint64_t Address,bool Is64Bits)524 static void printRelocation(formatted_raw_ostream &OS, StringRef FileName,
525 const RelocationRef &Rel, uint64_t Address,
526 bool Is64Bits) {
527 StringRef Fmt = Is64Bits ? "%016" PRIx64 ": " : "%08" PRIx64 ": ";
528 SmallString<16> Name;
529 SmallString<32> Val;
530 Rel.getTypeName(Name);
531 if (Error E = getRelocationValueString(Rel, SymbolDescription, Val))
532 reportError(std::move(E), FileName);
533 OS << (Is64Bits || !LeadingAddr ? "\t\t" : "\t\t\t");
534 if (LeadingAddr)
535 OS << format(Fmt.data(), Address);
536 OS << Name << "\t" << Val;
537 }
538
printBTFRelocation(formatted_raw_ostream & FOS,llvm::BTFParser & BTF,object::SectionedAddress Address,LiveVariablePrinter & LVP)539 static void printBTFRelocation(formatted_raw_ostream &FOS, llvm::BTFParser &BTF,
540 object::SectionedAddress Address,
541 LiveVariablePrinter &LVP) {
542 const llvm::BTF::BPFFieldReloc *Reloc = BTF.findFieldReloc(Address);
543 if (!Reloc)
544 return;
545
546 SmallString<64> Val;
547 BTF.symbolize(Reloc, Val);
548 FOS << "\t\t";
549 if (LeadingAddr)
550 FOS << format("%016" PRIx64 ": ", Address.Address + AdjustVMA);
551 FOS << "CO-RE " << Val;
552 LVP.printAfterOtherLine(FOS, true);
553 }
554
555 class PrettyPrinter {
556 public:
557 virtual ~PrettyPrinter() = default;
558 virtual void
printInst(MCInstPrinter & IP,const MCInst * MI,ArrayRef<uint8_t> Bytes,object::SectionedAddress Address,formatted_raw_ostream & OS,StringRef Annot,MCSubtargetInfo const & STI,SourcePrinter * SP,StringRef ObjectFilename,std::vector<RelocationRef> * Rels,LiveVariablePrinter & LVP)559 printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
560 object::SectionedAddress Address, formatted_raw_ostream &OS,
561 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
562 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
563 LiveVariablePrinter &LVP) {
564 if (SP && (PrintSource || PrintLines))
565 SP->printSourceLine(OS, Address, ObjectFilename, LVP);
566 LVP.printBetweenInsts(OS, false);
567
568 printRawData(Bytes, Address.Address, OS, STI);
569
570 if (MI) {
571 // See MCInstPrinter::printInst. On targets where a PC relative immediate
572 // is relative to the next instruction and the length of a MCInst is
573 // difficult to measure (x86), this is the address of the next
574 // instruction.
575 uint64_t Addr =
576 Address.Address + (STI.getTargetTriple().isX86() ? Bytes.size() : 0);
577 IP.printInst(MI, Addr, "", STI, OS);
578 } else
579 OS << "\t<unknown>";
580 }
581 };
582 PrettyPrinter PrettyPrinterInst;
583
584 class HexagonPrettyPrinter : public PrettyPrinter {
585 public:
printLead(ArrayRef<uint8_t> Bytes,uint64_t Address,formatted_raw_ostream & OS)586 void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address,
587 formatted_raw_ostream &OS) {
588 uint32_t opcode =
589 (Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | Bytes[0];
590 if (LeadingAddr)
591 OS << format("%8" PRIx64 ":", Address);
592 if (ShowRawInsn) {
593 OS << "\t";
594 dumpBytes(Bytes.slice(0, 4), OS);
595 OS << format("\t%08" PRIx32, opcode);
596 }
597 }
printInst(MCInstPrinter & IP,const MCInst * MI,ArrayRef<uint8_t> Bytes,object::SectionedAddress Address,formatted_raw_ostream & OS,StringRef Annot,MCSubtargetInfo const & STI,SourcePrinter * SP,StringRef ObjectFilename,std::vector<RelocationRef> * Rels,LiveVariablePrinter & LVP)598 void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
599 object::SectionedAddress Address, formatted_raw_ostream &OS,
600 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
601 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
602 LiveVariablePrinter &LVP) override {
603 if (SP && (PrintSource || PrintLines))
604 SP->printSourceLine(OS, Address, ObjectFilename, LVP, "");
605 if (!MI) {
606 printLead(Bytes, Address.Address, OS);
607 OS << " <unknown>";
608 return;
609 }
610 std::string Buffer;
611 {
612 raw_string_ostream TempStream(Buffer);
613 IP.printInst(MI, Address.Address, "", STI, TempStream);
614 }
615 StringRef Contents(Buffer);
616 // Split off bundle attributes
617 auto PacketBundle = Contents.rsplit('\n');
618 // Split off first instruction from the rest
619 auto HeadTail = PacketBundle.first.split('\n');
620 auto Preamble = " { ";
621 auto Separator = "";
622
623 // Hexagon's packets require relocations to be inline rather than
624 // clustered at the end of the packet.
625 std::vector<RelocationRef>::const_iterator RelCur = Rels->begin();
626 std::vector<RelocationRef>::const_iterator RelEnd = Rels->end();
627 auto PrintReloc = [&]() -> void {
628 while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address.Address)) {
629 if (RelCur->getOffset() == Address.Address) {
630 printRelocation(OS, ObjectFilename, *RelCur, Address.Address, false);
631 return;
632 }
633 ++RelCur;
634 }
635 };
636
637 while (!HeadTail.first.empty()) {
638 OS << Separator;
639 Separator = "\n";
640 if (SP && (PrintSource || PrintLines))
641 SP->printSourceLine(OS, Address, ObjectFilename, LVP, "");
642 printLead(Bytes, Address.Address, OS);
643 OS << Preamble;
644 Preamble = " ";
645 StringRef Inst;
646 auto Duplex = HeadTail.first.split('\v');
647 if (!Duplex.second.empty()) {
648 OS << Duplex.first;
649 OS << "; ";
650 Inst = Duplex.second;
651 }
652 else
653 Inst = HeadTail.first;
654 OS << Inst;
655 HeadTail = HeadTail.second.split('\n');
656 if (HeadTail.first.empty())
657 OS << " } " << PacketBundle.second;
658 PrintReloc();
659 Bytes = Bytes.slice(4);
660 Address.Address += 4;
661 }
662 }
663 };
664 HexagonPrettyPrinter HexagonPrettyPrinterInst;
665
666 class AMDGCNPrettyPrinter : public PrettyPrinter {
667 public:
printInst(MCInstPrinter & IP,const MCInst * MI,ArrayRef<uint8_t> Bytes,object::SectionedAddress Address,formatted_raw_ostream & OS,StringRef Annot,MCSubtargetInfo const & STI,SourcePrinter * SP,StringRef ObjectFilename,std::vector<RelocationRef> * Rels,LiveVariablePrinter & LVP)668 void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
669 object::SectionedAddress Address, formatted_raw_ostream &OS,
670 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
671 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
672 LiveVariablePrinter &LVP) override {
673 if (SP && (PrintSource || PrintLines))
674 SP->printSourceLine(OS, Address, ObjectFilename, LVP);
675
676 if (MI) {
677 SmallString<40> InstStr;
678 raw_svector_ostream IS(InstStr);
679
680 IP.printInst(MI, Address.Address, "", STI, IS);
681
682 OS << left_justify(IS.str(), 60);
683 } else {
684 // an unrecognized encoding - this is probably data so represent it
685 // using the .long directive, or .byte directive if fewer than 4 bytes
686 // remaining
687 if (Bytes.size() >= 4) {
688 OS << format(
689 "\t.long 0x%08" PRIx32 " ",
690 support::endian::read32<llvm::endianness::little>(Bytes.data()));
691 OS.indent(42);
692 } else {
693 OS << format("\t.byte 0x%02" PRIx8, Bytes[0]);
694 for (unsigned int i = 1; i < Bytes.size(); i++)
695 OS << format(", 0x%02" PRIx8, Bytes[i]);
696 OS.indent(55 - (6 * Bytes.size()));
697 }
698 }
699
700 OS << format("// %012" PRIX64 ":", Address.Address);
701 if (Bytes.size() >= 4) {
702 // D should be casted to uint32_t here as it is passed by format to
703 // snprintf as vararg.
704 for (uint32_t D :
705 ArrayRef(reinterpret_cast<const support::little32_t *>(Bytes.data()),
706 Bytes.size() / 4))
707 OS << format(" %08" PRIX32, D);
708 } else {
709 for (unsigned char B : Bytes)
710 OS << format(" %02" PRIX8, B);
711 }
712
713 if (!Annot.empty())
714 OS << " // " << Annot;
715 }
716 };
717 AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst;
718
719 class BPFPrettyPrinter : public PrettyPrinter {
720 public:
printInst(MCInstPrinter & IP,const MCInst * MI,ArrayRef<uint8_t> Bytes,object::SectionedAddress Address,formatted_raw_ostream & OS,StringRef Annot,MCSubtargetInfo const & STI,SourcePrinter * SP,StringRef ObjectFilename,std::vector<RelocationRef> * Rels,LiveVariablePrinter & LVP)721 void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
722 object::SectionedAddress Address, formatted_raw_ostream &OS,
723 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
724 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
725 LiveVariablePrinter &LVP) override {
726 if (SP && (PrintSource || PrintLines))
727 SP->printSourceLine(OS, Address, ObjectFilename, LVP);
728 if (LeadingAddr)
729 OS << format("%8" PRId64 ":", Address.Address / 8);
730 if (ShowRawInsn) {
731 OS << "\t";
732 dumpBytes(Bytes, OS);
733 }
734 if (MI)
735 IP.printInst(MI, Address.Address, "", STI, OS);
736 else
737 OS << "\t<unknown>";
738 }
739 };
740 BPFPrettyPrinter BPFPrettyPrinterInst;
741
742 class ARMPrettyPrinter : public PrettyPrinter {
743 public:
printInst(MCInstPrinter & IP,const MCInst * MI,ArrayRef<uint8_t> Bytes,object::SectionedAddress Address,formatted_raw_ostream & OS,StringRef Annot,MCSubtargetInfo const & STI,SourcePrinter * SP,StringRef ObjectFilename,std::vector<RelocationRef> * Rels,LiveVariablePrinter & LVP)744 void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
745 object::SectionedAddress Address, formatted_raw_ostream &OS,
746 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
747 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
748 LiveVariablePrinter &LVP) override {
749 if (SP && (PrintSource || PrintLines))
750 SP->printSourceLine(OS, Address, ObjectFilename, LVP);
751 LVP.printBetweenInsts(OS, false);
752
753 size_t Start = OS.tell();
754 if (LeadingAddr)
755 OS << format("%8" PRIx64 ":", Address.Address);
756 if (ShowRawInsn) {
757 size_t Pos = 0, End = Bytes.size();
758 if (STI.checkFeatures("+thumb-mode")) {
759 for (; Pos + 2 <= End; Pos += 2)
760 OS << ' '
761 << format_hex_no_prefix(
762 llvm::support::endian::read<uint16_t>(
763 Bytes.data() + Pos, InstructionEndianness),
764 4);
765 } else {
766 for (; Pos + 4 <= End; Pos += 4)
767 OS << ' '
768 << format_hex_no_prefix(
769 llvm::support::endian::read<uint32_t>(
770 Bytes.data() + Pos, InstructionEndianness),
771 8);
772 }
773 if (Pos < End) {
774 OS << ' ';
775 dumpBytes(Bytes.slice(Pos), OS);
776 }
777 }
778
779 AlignToInstStartColumn(Start, STI, OS);
780
781 if (MI) {
782 IP.printInst(MI, Address.Address, "", STI, OS);
783 } else
784 OS << "\t<unknown>";
785 }
786
setInstructionEndianness(llvm::endianness Endianness)787 void setInstructionEndianness(llvm::endianness Endianness) {
788 InstructionEndianness = Endianness;
789 }
790
791 private:
792 llvm::endianness InstructionEndianness = llvm::endianness::little;
793 };
794 ARMPrettyPrinter ARMPrettyPrinterInst;
795
796 class AArch64PrettyPrinter : public PrettyPrinter {
797 public:
printInst(MCInstPrinter & IP,const MCInst * MI,ArrayRef<uint8_t> Bytes,object::SectionedAddress Address,formatted_raw_ostream & OS,StringRef Annot,MCSubtargetInfo const & STI,SourcePrinter * SP,StringRef ObjectFilename,std::vector<RelocationRef> * Rels,LiveVariablePrinter & LVP)798 void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
799 object::SectionedAddress Address, formatted_raw_ostream &OS,
800 StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
801 StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
802 LiveVariablePrinter &LVP) override {
803 if (SP && (PrintSource || PrintLines))
804 SP->printSourceLine(OS, Address, ObjectFilename, LVP);
805 LVP.printBetweenInsts(OS, false);
806
807 size_t Start = OS.tell();
808 if (LeadingAddr)
809 OS << format("%8" PRIx64 ":", Address.Address);
810 if (ShowRawInsn) {
811 size_t Pos = 0, End = Bytes.size();
812 for (; Pos + 4 <= End; Pos += 4)
813 OS << ' '
814 << format_hex_no_prefix(
815 llvm::support::endian::read<uint32_t>(
816 Bytes.data() + Pos, llvm::endianness::little),
817 8);
818 if (Pos < End) {
819 OS << ' ';
820 dumpBytes(Bytes.slice(Pos), OS);
821 }
822 }
823
824 AlignToInstStartColumn(Start, STI, OS);
825
826 if (MI) {
827 IP.printInst(MI, Address.Address, "", STI, OS);
828 } else
829 OS << "\t<unknown>";
830 }
831 };
832 AArch64PrettyPrinter AArch64PrettyPrinterInst;
833
selectPrettyPrinter(Triple const & Triple)834 PrettyPrinter &selectPrettyPrinter(Triple const &Triple) {
835 switch(Triple.getArch()) {
836 default:
837 return PrettyPrinterInst;
838 case Triple::hexagon:
839 return HexagonPrettyPrinterInst;
840 case Triple::amdgcn:
841 return AMDGCNPrettyPrinterInst;
842 case Triple::bpfel:
843 case Triple::bpfeb:
844 return BPFPrettyPrinterInst;
845 case Triple::arm:
846 case Triple::armeb:
847 case Triple::thumb:
848 case Triple::thumbeb:
849 return ARMPrettyPrinterInst;
850 case Triple::aarch64:
851 case Triple::aarch64_be:
852 case Triple::aarch64_32:
853 return AArch64PrettyPrinterInst;
854 }
855 }
856
857 class DisassemblerTarget {
858 public:
859 const Target *TheTarget;
860 std::unique_ptr<const MCSubtargetInfo> SubtargetInfo;
861 std::shared_ptr<MCContext> Context;
862 std::unique_ptr<MCDisassembler> DisAsm;
863 std::shared_ptr<MCInstrAnalysis> InstrAnalysis;
864 std::shared_ptr<MCInstPrinter> InstPrinter;
865 PrettyPrinter *Printer;
866
867 DisassemblerTarget(const Target *TheTarget, ObjectFile &Obj,
868 StringRef TripleName, StringRef MCPU,
869 SubtargetFeatures &Features);
870 DisassemblerTarget(DisassemblerTarget &Other, SubtargetFeatures &Features);
871
872 private:
873 MCTargetOptions Options;
874 std::shared_ptr<const MCRegisterInfo> RegisterInfo;
875 std::shared_ptr<const MCAsmInfo> AsmInfo;
876 std::shared_ptr<const MCInstrInfo> InstrInfo;
877 std::shared_ptr<MCObjectFileInfo> ObjectFileInfo;
878 };
879
DisassemblerTarget(const Target * TheTarget,ObjectFile & Obj,StringRef TripleName,StringRef MCPU,SubtargetFeatures & Features)880 DisassemblerTarget::DisassemblerTarget(const Target *TheTarget, ObjectFile &Obj,
881 StringRef TripleName, StringRef MCPU,
882 SubtargetFeatures &Features)
883 : TheTarget(TheTarget),
884 Printer(&selectPrettyPrinter(Triple(TripleName))),
885 RegisterInfo(TheTarget->createMCRegInfo(TripleName)) {
886 if (!RegisterInfo)
887 reportError(Obj.getFileName(), "no register info for target " + TripleName);
888
889 // Set up disassembler.
890 AsmInfo.reset(TheTarget->createMCAsmInfo(*RegisterInfo, TripleName, Options));
891 if (!AsmInfo)
892 reportError(Obj.getFileName(), "no assembly info for target " + TripleName);
893
894 SubtargetInfo.reset(
895 TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
896 if (!SubtargetInfo)
897 reportError(Obj.getFileName(),
898 "no subtarget info for target " + TripleName);
899 InstrInfo.reset(TheTarget->createMCInstrInfo());
900 if (!InstrInfo)
901 reportError(Obj.getFileName(),
902 "no instruction info for target " + TripleName);
903 Context =
904 std::make_shared<MCContext>(Triple(TripleName), AsmInfo.get(),
905 RegisterInfo.get(), SubtargetInfo.get());
906
907 // FIXME: for now initialize MCObjectFileInfo with default values
908 ObjectFileInfo.reset(
909 TheTarget->createMCObjectFileInfo(*Context, /*PIC=*/false));
910 Context->setObjectFileInfo(ObjectFileInfo.get());
911
912 DisAsm.reset(TheTarget->createMCDisassembler(*SubtargetInfo, *Context));
913 if (!DisAsm)
914 reportError(Obj.getFileName(), "no disassembler for target " + TripleName);
915
916 InstrAnalysis.reset(TheTarget->createMCInstrAnalysis(InstrInfo.get()));
917
918 int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
919 InstPrinter.reset(TheTarget->createMCInstPrinter(Triple(TripleName),
920 AsmPrinterVariant, *AsmInfo,
921 *InstrInfo, *RegisterInfo));
922 if (!InstPrinter)
923 reportError(Obj.getFileName(),
924 "no instruction printer for target " + TripleName);
925 InstPrinter->setPrintImmHex(PrintImmHex);
926 InstPrinter->setPrintBranchImmAsAddress(true);
927 InstPrinter->setSymbolizeOperands(SymbolizeOperands);
928 InstPrinter->setMCInstrAnalysis(InstrAnalysis.get());
929
930 switch (DisassemblyColor) {
931 case ColorOutput::Enable:
932 InstPrinter->setUseColor(true);
933 break;
934 case ColorOutput::Auto:
935 InstPrinter->setUseColor(outs().has_colors());
936 break;
937 case ColorOutput::Disable:
938 case ColorOutput::Invalid:
939 InstPrinter->setUseColor(false);
940 break;
941 };
942 }
943
DisassemblerTarget(DisassemblerTarget & Other,SubtargetFeatures & Features)944 DisassemblerTarget::DisassemblerTarget(DisassemblerTarget &Other,
945 SubtargetFeatures &Features)
946 : TheTarget(Other.TheTarget),
947 SubtargetInfo(TheTarget->createMCSubtargetInfo(TripleName, MCPU,
948 Features.getString())),
949 Context(Other.Context),
950 DisAsm(TheTarget->createMCDisassembler(*SubtargetInfo, *Context)),
951 InstrAnalysis(Other.InstrAnalysis), InstPrinter(Other.InstPrinter),
952 Printer(Other.Printer), RegisterInfo(Other.RegisterInfo),
953 AsmInfo(Other.AsmInfo), InstrInfo(Other.InstrInfo),
954 ObjectFileInfo(Other.ObjectFileInfo) {}
955 } // namespace
956
getElfSymbolType(const ObjectFile & Obj,const SymbolRef & Sym)957 static uint8_t getElfSymbolType(const ObjectFile &Obj, const SymbolRef &Sym) {
958 assert(Obj.isELF());
959 if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(&Obj))
960 return unwrapOrError(Elf32LEObj->getSymbol(Sym.getRawDataRefImpl()),
961 Obj.getFileName())
962 ->getType();
963 if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(&Obj))
964 return unwrapOrError(Elf64LEObj->getSymbol(Sym.getRawDataRefImpl()),
965 Obj.getFileName())
966 ->getType();
967 if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(&Obj))
968 return unwrapOrError(Elf32BEObj->getSymbol(Sym.getRawDataRefImpl()),
969 Obj.getFileName())
970 ->getType();
971 if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(&Obj))
972 return unwrapOrError(Elf64BEObj->getSymbol(Sym.getRawDataRefImpl()),
973 Obj.getFileName())
974 ->getType();
975 llvm_unreachable("Unsupported binary format");
976 }
977
978 template <class ELFT>
979 static void
addDynamicElfSymbols(const ELFObjectFile<ELFT> & Obj,std::map<SectionRef,SectionSymbolsTy> & AllSymbols)980 addDynamicElfSymbols(const ELFObjectFile<ELFT> &Obj,
981 std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
982 for (auto Symbol : Obj.getDynamicSymbolIterators()) {
983 uint8_t SymbolType = Symbol.getELFType();
984 if (SymbolType == ELF::STT_SECTION)
985 continue;
986
987 uint64_t Address = unwrapOrError(Symbol.getAddress(), Obj.getFileName());
988 // ELFSymbolRef::getAddress() returns size instead of value for common
989 // symbols which is not desirable for disassembly output. Overriding.
990 if (SymbolType == ELF::STT_COMMON)
991 Address = unwrapOrError(Obj.getSymbol(Symbol.getRawDataRefImpl()),
992 Obj.getFileName())
993 ->st_value;
994
995 StringRef Name = unwrapOrError(Symbol.getName(), Obj.getFileName());
996 if (Name.empty())
997 continue;
998
999 section_iterator SecI =
1000 unwrapOrError(Symbol.getSection(), Obj.getFileName());
1001 if (SecI == Obj.section_end())
1002 continue;
1003
1004 AllSymbols[*SecI].emplace_back(Address, Name, SymbolType);
1005 }
1006 }
1007
1008 static void
addDynamicElfSymbols(const ELFObjectFileBase & Obj,std::map<SectionRef,SectionSymbolsTy> & AllSymbols)1009 addDynamicElfSymbols(const ELFObjectFileBase &Obj,
1010 std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
1011 if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(&Obj))
1012 addDynamicElfSymbols(*Elf32LEObj, AllSymbols);
1013 else if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(&Obj))
1014 addDynamicElfSymbols(*Elf64LEObj, AllSymbols);
1015 else if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(&Obj))
1016 addDynamicElfSymbols(*Elf32BEObj, AllSymbols);
1017 else if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(&Obj))
1018 addDynamicElfSymbols(*Elf64BEObj, AllSymbols);
1019 else
1020 llvm_unreachable("Unsupported binary format");
1021 }
1022
getWasmCodeSection(const WasmObjectFile & Obj)1023 static std::optional<SectionRef> getWasmCodeSection(const WasmObjectFile &Obj) {
1024 for (auto SecI : Obj.sections()) {
1025 const WasmSection &Section = Obj.getWasmSection(SecI);
1026 if (Section.Type == wasm::WASM_SEC_CODE)
1027 return SecI;
1028 }
1029 return std::nullopt;
1030 }
1031
1032 static void
addMissingWasmCodeSymbols(const WasmObjectFile & Obj,std::map<SectionRef,SectionSymbolsTy> & AllSymbols)1033 addMissingWasmCodeSymbols(const WasmObjectFile &Obj,
1034 std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
1035 std::optional<SectionRef> Section = getWasmCodeSection(Obj);
1036 if (!Section)
1037 return;
1038 SectionSymbolsTy &Symbols = AllSymbols[*Section];
1039
1040 std::set<uint64_t> SymbolAddresses;
1041 for (const auto &Sym : Symbols)
1042 SymbolAddresses.insert(Sym.Addr);
1043
1044 for (const wasm::WasmFunction &Function : Obj.functions()) {
1045 uint64_t Address = Function.CodeSectionOffset;
1046 // Only add fallback symbols for functions not already present in the symbol
1047 // table.
1048 if (SymbolAddresses.count(Address))
1049 continue;
1050 // This function has no symbol, so it should have no SymbolName.
1051 assert(Function.SymbolName.empty());
1052 // We use DebugName for the name, though it may be empty if there is no
1053 // "name" custom section, or that section is missing a name for this
1054 // function.
1055 StringRef Name = Function.DebugName;
1056 Symbols.emplace_back(Address, Name, ELF::STT_NOTYPE);
1057 }
1058 }
1059
addPltEntries(const ObjectFile & Obj,std::map<SectionRef,SectionSymbolsTy> & AllSymbols,StringSaver & Saver)1060 static void addPltEntries(const ObjectFile &Obj,
1061 std::map<SectionRef, SectionSymbolsTy> &AllSymbols,
1062 StringSaver &Saver) {
1063 auto *ElfObj = dyn_cast<ELFObjectFileBase>(&Obj);
1064 if (!ElfObj)
1065 return;
1066 DenseMap<StringRef, SectionRef> Sections;
1067 for (SectionRef Section : Obj.sections()) {
1068 Expected<StringRef> SecNameOrErr = Section.getName();
1069 if (!SecNameOrErr) {
1070 consumeError(SecNameOrErr.takeError());
1071 continue;
1072 }
1073 Sections[*SecNameOrErr] = Section;
1074 }
1075 for (auto Plt : ElfObj->getPltEntries()) {
1076 if (Plt.Symbol) {
1077 SymbolRef Symbol(*Plt.Symbol, ElfObj);
1078 uint8_t SymbolType = getElfSymbolType(Obj, Symbol);
1079 if (Expected<StringRef> NameOrErr = Symbol.getName()) {
1080 if (!NameOrErr->empty())
1081 AllSymbols[Sections[Plt.Section]].emplace_back(
1082 Plt.Address, Saver.save((*NameOrErr + "@plt").str()), SymbolType);
1083 continue;
1084 } else {
1085 // The warning has been reported in disassembleObject().
1086 consumeError(NameOrErr.takeError());
1087 }
1088 }
1089 reportWarning("PLT entry at 0x" + Twine::utohexstr(Plt.Address) +
1090 " references an invalid symbol",
1091 Obj.getFileName());
1092 }
1093 }
1094
1095 // Normally the disassembly output will skip blocks of zeroes. This function
1096 // returns the number of zero bytes that can be skipped when dumping the
1097 // disassembly of the instructions in Buf.
countSkippableZeroBytes(ArrayRef<uint8_t> Buf)1098 static size_t countSkippableZeroBytes(ArrayRef<uint8_t> Buf) {
1099 // Find the number of leading zeroes.
1100 size_t N = 0;
1101 while (N < Buf.size() && !Buf[N])
1102 ++N;
1103
1104 // We may want to skip blocks of zero bytes, but unless we see
1105 // at least 8 of them in a row.
1106 if (N < 8)
1107 return 0;
1108
1109 // We skip zeroes in multiples of 4 because do not want to truncate an
1110 // instruction if it starts with a zero byte.
1111 return N & ~0x3;
1112 }
1113
1114 // Returns a map from sections to their relocations.
1115 static std::map<SectionRef, std::vector<RelocationRef>>
getRelocsMap(object::ObjectFile const & Obj)1116 getRelocsMap(object::ObjectFile const &Obj) {
1117 std::map<SectionRef, std::vector<RelocationRef>> Ret;
1118 uint64_t I = (uint64_t)-1;
1119 for (SectionRef Sec : Obj.sections()) {
1120 ++I;
1121 Expected<section_iterator> RelocatedOrErr = Sec.getRelocatedSection();
1122 if (!RelocatedOrErr)
1123 reportError(Obj.getFileName(),
1124 "section (" + Twine(I) +
1125 "): failed to get a relocated section: " +
1126 toString(RelocatedOrErr.takeError()));
1127
1128 section_iterator Relocated = *RelocatedOrErr;
1129 if (Relocated == Obj.section_end() || !checkSectionFilter(*Relocated).Keep)
1130 continue;
1131 std::vector<RelocationRef> &V = Ret[*Relocated];
1132 append_range(V, Sec.relocations());
1133 // Sort relocations by address.
1134 llvm::stable_sort(V, isRelocAddressLess);
1135 }
1136 return Ret;
1137 }
1138
1139 // Used for --adjust-vma to check if address should be adjusted by the
1140 // specified value for a given section.
1141 // For ELF we do not adjust non-allocatable sections like debug ones,
1142 // because they are not loadable.
1143 // TODO: implement for other file formats.
shouldAdjustVA(const SectionRef & Section)1144 static bool shouldAdjustVA(const SectionRef &Section) {
1145 const ObjectFile *Obj = Section.getObject();
1146 if (Obj->isELF())
1147 return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
1148 return false;
1149 }
1150
1151
1152 typedef std::pair<uint64_t, char> MappingSymbolPair;
getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols,uint64_t Address)1153 static char getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols,
1154 uint64_t Address) {
1155 auto It =
1156 partition_point(MappingSymbols, [Address](const MappingSymbolPair &Val) {
1157 return Val.first <= Address;
1158 });
1159 // Return zero for any address before the first mapping symbol; this means
1160 // we should use the default disassembly mode, depending on the target.
1161 if (It == MappingSymbols.begin())
1162 return '\x00';
1163 return (It - 1)->second;
1164 }
1165
dumpARMELFData(uint64_t SectionAddr,uint64_t Index,uint64_t End,const ObjectFile & Obj,ArrayRef<uint8_t> Bytes,ArrayRef<MappingSymbolPair> MappingSymbols,const MCSubtargetInfo & STI,raw_ostream & OS)1166 static uint64_t dumpARMELFData(uint64_t SectionAddr, uint64_t Index,
1167 uint64_t End, const ObjectFile &Obj,
1168 ArrayRef<uint8_t> Bytes,
1169 ArrayRef<MappingSymbolPair> MappingSymbols,
1170 const MCSubtargetInfo &STI, raw_ostream &OS) {
1171 llvm::endianness Endian =
1172 Obj.isLittleEndian() ? llvm::endianness::little : llvm::endianness::big;
1173 size_t Start = OS.tell();
1174 OS << format("%8" PRIx64 ": ", SectionAddr + Index);
1175 if (Index + 4 <= End) {
1176 dumpBytes(Bytes.slice(Index, 4), OS);
1177 AlignToInstStartColumn(Start, STI, OS);
1178 OS << "\t.word\t"
1179 << format_hex(support::endian::read32(Bytes.data() + Index, Endian),
1180 10);
1181 return 4;
1182 }
1183 if (Index + 2 <= End) {
1184 dumpBytes(Bytes.slice(Index, 2), OS);
1185 AlignToInstStartColumn(Start, STI, OS);
1186 OS << "\t.short\t"
1187 << format_hex(support::endian::read16(Bytes.data() + Index, Endian), 6);
1188 return 2;
1189 }
1190 dumpBytes(Bytes.slice(Index, 1), OS);
1191 AlignToInstStartColumn(Start, STI, OS);
1192 OS << "\t.byte\t" << format_hex(Bytes[Index], 4);
1193 return 1;
1194 }
1195
dumpELFData(uint64_t SectionAddr,uint64_t Index,uint64_t End,ArrayRef<uint8_t> Bytes)1196 static void dumpELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End,
1197 ArrayRef<uint8_t> Bytes) {
1198 // print out data up to 8 bytes at a time in hex and ascii
1199 uint8_t AsciiData[9] = {'\0'};
1200 uint8_t Byte;
1201 int NumBytes = 0;
1202
1203 for (; Index < End; ++Index) {
1204 if (NumBytes == 0)
1205 outs() << format("%8" PRIx64 ":", SectionAddr + Index);
1206 Byte = Bytes.slice(Index)[0];
1207 outs() << format(" %02x", Byte);
1208 AsciiData[NumBytes] = isPrint(Byte) ? Byte : '.';
1209
1210 uint8_t IndentOffset = 0;
1211 NumBytes++;
1212 if (Index == End - 1 || NumBytes > 8) {
1213 // Indent the space for less than 8 bytes data.
1214 // 2 spaces for byte and one for space between bytes
1215 IndentOffset = 3 * (8 - NumBytes);
1216 for (int Excess = NumBytes; Excess < 8; Excess++)
1217 AsciiData[Excess] = '\0';
1218 NumBytes = 8;
1219 }
1220 if (NumBytes == 8) {
1221 AsciiData[8] = '\0';
1222 outs() << std::string(IndentOffset, ' ') << " ";
1223 outs() << reinterpret_cast<char *>(AsciiData);
1224 outs() << '\n';
1225 NumBytes = 0;
1226 }
1227 }
1228 }
1229
createSymbolInfo(const ObjectFile & Obj,const SymbolRef & Symbol,bool IsMappingSymbol)1230 SymbolInfoTy objdump::createSymbolInfo(const ObjectFile &Obj,
1231 const SymbolRef &Symbol,
1232 bool IsMappingSymbol) {
1233 const StringRef FileName = Obj.getFileName();
1234 const uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName);
1235 const StringRef Name = unwrapOrError(Symbol.getName(), FileName);
1236
1237 if (Obj.isXCOFF() && (SymbolDescription || TracebackTable)) {
1238 const auto &XCOFFObj = cast<XCOFFObjectFile>(Obj);
1239 DataRefImpl SymbolDRI = Symbol.getRawDataRefImpl();
1240
1241 const uint32_t SymbolIndex = XCOFFObj.getSymbolIndex(SymbolDRI.p);
1242 std::optional<XCOFF::StorageMappingClass> Smc =
1243 getXCOFFSymbolCsectSMC(XCOFFObj, Symbol);
1244 return SymbolInfoTy(Smc, Addr, Name, SymbolIndex,
1245 isLabel(XCOFFObj, Symbol));
1246 } else if (Obj.isXCOFF()) {
1247 const SymbolRef::Type SymType = unwrapOrError(Symbol.getType(), FileName);
1248 return SymbolInfoTy(Addr, Name, SymType, /*IsMappingSymbol=*/false,
1249 /*IsXCOFF=*/true);
1250 } else {
1251 uint8_t Type =
1252 Obj.isELF() ? getElfSymbolType(Obj, Symbol) : (uint8_t)ELF::STT_NOTYPE;
1253 return SymbolInfoTy(Addr, Name, Type, IsMappingSymbol);
1254 }
1255 }
1256
createDummySymbolInfo(const ObjectFile & Obj,const uint64_t Addr,StringRef & Name,uint8_t Type)1257 static SymbolInfoTy createDummySymbolInfo(const ObjectFile &Obj,
1258 const uint64_t Addr, StringRef &Name,
1259 uint8_t Type) {
1260 if (Obj.isXCOFF() && (SymbolDescription || TracebackTable))
1261 return SymbolInfoTy(std::nullopt, Addr, Name, std::nullopt, false);
1262 else
1263 return SymbolInfoTy(Addr, Name, Type);
1264 }
1265
1266 struct BBAddrMapLabel {
1267 std::string BlockLabel;
1268 std::string PGOAnalysis;
1269 };
1270
constructPGOLabelString(const PGOAnalysisMap & PGOMap,size_t BBEntryIndex)1271 static std::string constructPGOLabelString(const PGOAnalysisMap &PGOMap,
1272 size_t BBEntryIndex) {
1273 std::string PGOString;
1274 raw_string_ostream PGOSS(PGOString);
1275
1276 PGOSS << " (";
1277 if (PGOMap.FeatEnable.FuncEntryCount && BBEntryIndex == 0) {
1278 PGOSS << "Entry count: " << Twine(PGOMap.FuncEntryCount);
1279 if (PGOMap.FeatEnable.BBFreq || PGOMap.FeatEnable.BrProb) {
1280 PGOSS << ", ";
1281 }
1282 }
1283
1284 if (PGOMap.FeatEnable.BBFreq || PGOMap.FeatEnable.BrProb) {
1285 assert(BBEntryIndex < PGOMap.BBEntries.size() &&
1286 "Expected PGOAnalysisMap and BBAddrMap to have the same entires");
1287 const PGOAnalysisMap::PGOBBEntry &PGOBBEntry =
1288 PGOMap.BBEntries[BBEntryIndex];
1289
1290 if (PGOMap.FeatEnable.BBFreq) {
1291 PGOSS << "Frequency: " << Twine(PGOBBEntry.BlockFreq.getFrequency());
1292 if (PGOMap.FeatEnable.BrProb && PGOBBEntry.Successors.size() > 0) {
1293 PGOSS << ", ";
1294 }
1295 }
1296 if (PGOMap.FeatEnable.BrProb && PGOBBEntry.Successors.size() > 0) {
1297 PGOSS << "Successors: ";
1298 interleaveComma(
1299 PGOBBEntry.Successors, PGOSS,
1300 [&PGOSS](const PGOAnalysisMap::PGOBBEntry::SuccessorEntry &SE) {
1301 PGOSS << "BB" << SE.ID << ":";
1302 PGOSS.write_hex(SE.Prob.getNumerator());
1303 });
1304 }
1305 }
1306 PGOSS << ")";
1307
1308 return PGOString;
1309 }
1310
collectBBAddrMapLabels(const std::unordered_map<uint64_t,BBAddrMap> & AddrToBBAddrMap,const std::unordered_map<uint64_t,PGOAnalysisMap> & AddrToPGOAnalysisMap,uint64_t SectionAddr,uint64_t Start,uint64_t End,std::unordered_map<uint64_t,std::vector<BBAddrMapLabel>> & Labels,const StringRef FileName)1311 static void collectBBAddrMapLabels(
1312 const std::unordered_map<uint64_t, BBAddrMap> &AddrToBBAddrMap,
1313 const std::unordered_map<uint64_t, PGOAnalysisMap> &AddrToPGOAnalysisMap,
1314 uint64_t SectionAddr, uint64_t Start, uint64_t End,
1315 std::unordered_map<uint64_t, std::vector<BBAddrMapLabel>> &Labels,
1316 const StringRef FileName) {
1317 if (AddrToBBAddrMap.empty())
1318 return;
1319 Labels.clear();
1320 uint64_t StartAddress = SectionAddr + Start;
1321 uint64_t EndAddress = SectionAddr + End;
1322 auto Iter = AddrToBBAddrMap.find(StartAddress);
1323 if (Iter == AddrToBBAddrMap.end())
1324 return;
1325 auto PGOIter = AddrToPGOAnalysisMap.find(StartAddress);
1326
1327 for (size_t I = 0; I < Iter->second.getBBEntries().size(); ++I) {
1328 const BBAddrMap::BBEntry &BBEntry = Iter->second.getBBEntries()[I];
1329 uint64_t BBAddress = BBEntry.Offset + Iter->second.getFunctionAddress();
1330 if (BBAddress >= EndAddress)
1331 continue;
1332
1333 std::string LabelString = ("BB" + Twine(BBEntry.ID)).str();
1334 std::string PGOString;
1335
1336 if (PGOIter != AddrToPGOAnalysisMap.end())
1337 PGOString = constructPGOLabelString(PGOIter->second, I);
1338
1339 Labels[BBAddress].push_back({LabelString, PGOString});
1340 }
1341 }
1342
1343 static void
collectLocalBranchTargets(ArrayRef<uint8_t> Bytes,MCInstrAnalysis * MIA,MCDisassembler * DisAsm,MCInstPrinter * IP,const MCSubtargetInfo * STI,uint64_t SectionAddr,uint64_t Start,uint64_t End,std::unordered_map<uint64_t,std::string> & Labels)1344 collectLocalBranchTargets(ArrayRef<uint8_t> Bytes, MCInstrAnalysis *MIA,
1345 MCDisassembler *DisAsm, MCInstPrinter *IP,
1346 const MCSubtargetInfo *STI, uint64_t SectionAddr,
1347 uint64_t Start, uint64_t End,
1348 std::unordered_map<uint64_t, std::string> &Labels) {
1349 // So far only supports PowerPC and X86.
1350 const bool isPPC = STI->getTargetTriple().isPPC();
1351 if (!isPPC && !STI->getTargetTriple().isX86())
1352 return;
1353
1354 if (MIA)
1355 MIA->resetState();
1356
1357 Labels.clear();
1358 unsigned LabelCount = 0;
1359 Start += SectionAddr;
1360 End += SectionAddr;
1361 const bool isXCOFF = STI->getTargetTriple().isOSBinFormatXCOFF();
1362 for (uint64_t Index = Start; Index < End;) {
1363 // Disassemble a real instruction and record function-local branch labels.
1364 MCInst Inst;
1365 uint64_t Size;
1366 ArrayRef<uint8_t> ThisBytes = Bytes.slice(Index - SectionAddr);
1367 bool Disassembled =
1368 DisAsm->getInstruction(Inst, Size, ThisBytes, Index, nulls());
1369 if (Size == 0)
1370 Size = std::min<uint64_t>(ThisBytes.size(),
1371 DisAsm->suggestBytesToSkip(ThisBytes, Index));
1372
1373 if (MIA) {
1374 if (Disassembled) {
1375 uint64_t Target;
1376 bool TargetKnown = MIA->evaluateBranch(Inst, Index, Size, Target);
1377 if (TargetKnown && (Target >= Start && Target < End) &&
1378 !Labels.count(Target)) {
1379 // On PowerPC and AIX, a function call is encoded as a branch to 0.
1380 // On other PowerPC platforms (ELF), a function call is encoded as
1381 // a branch to self. Do not add a label for these cases.
1382 if (!(isPPC &&
1383 ((Target == 0 && isXCOFF) || (Target == Index && !isXCOFF))))
1384 Labels[Target] = ("L" + Twine(LabelCount++)).str();
1385 }
1386 MIA->updateState(Inst, Index);
1387 } else
1388 MIA->resetState();
1389 }
1390 Index += Size;
1391 }
1392 }
1393
1394 // Create an MCSymbolizer for the target and add it to the MCDisassembler.
1395 // This is currently only used on AMDGPU, and assumes the format of the
1396 // void * argument passed to AMDGPU's createMCSymbolizer.
addSymbolizer(MCContext & Ctx,const Target * Target,StringRef TripleName,MCDisassembler * DisAsm,uint64_t SectionAddr,ArrayRef<uint8_t> Bytes,SectionSymbolsTy & Symbols,std::vector<std::unique_ptr<std::string>> & SynthesizedLabelNames)1397 static void addSymbolizer(
1398 MCContext &Ctx, const Target *Target, StringRef TripleName,
1399 MCDisassembler *DisAsm, uint64_t SectionAddr, ArrayRef<uint8_t> Bytes,
1400 SectionSymbolsTy &Symbols,
1401 std::vector<std::unique_ptr<std::string>> &SynthesizedLabelNames) {
1402
1403 std::unique_ptr<MCRelocationInfo> RelInfo(
1404 Target->createMCRelocationInfo(TripleName, Ctx));
1405 if (!RelInfo)
1406 return;
1407 std::unique_ptr<MCSymbolizer> Symbolizer(Target->createMCSymbolizer(
1408 TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
1409 MCSymbolizer *SymbolizerPtr = &*Symbolizer;
1410 DisAsm->setSymbolizer(std::move(Symbolizer));
1411
1412 if (!SymbolizeOperands)
1413 return;
1414
1415 // Synthesize labels referenced by branch instructions by
1416 // disassembling, discarding the output, and collecting the referenced
1417 // addresses from the symbolizer.
1418 for (size_t Index = 0; Index != Bytes.size();) {
1419 MCInst Inst;
1420 uint64_t Size;
1421 ArrayRef<uint8_t> ThisBytes = Bytes.slice(Index);
1422 const uint64_t ThisAddr = SectionAddr + Index;
1423 DisAsm->getInstruction(Inst, Size, ThisBytes, ThisAddr, nulls());
1424 if (Size == 0)
1425 Size = std::min<uint64_t>(ThisBytes.size(),
1426 DisAsm->suggestBytesToSkip(ThisBytes, Index));
1427 Index += Size;
1428 }
1429 ArrayRef<uint64_t> LabelAddrsRef = SymbolizerPtr->getReferencedAddresses();
1430 // Copy and sort to remove duplicates.
1431 std::vector<uint64_t> LabelAddrs;
1432 LabelAddrs.insert(LabelAddrs.end(), LabelAddrsRef.begin(),
1433 LabelAddrsRef.end());
1434 llvm::sort(LabelAddrs);
1435 LabelAddrs.resize(std::unique(LabelAddrs.begin(), LabelAddrs.end()) -
1436 LabelAddrs.begin());
1437 // Add the labels.
1438 for (unsigned LabelNum = 0; LabelNum != LabelAddrs.size(); ++LabelNum) {
1439 auto Name = std::make_unique<std::string>();
1440 *Name = (Twine("L") + Twine(LabelNum)).str();
1441 SynthesizedLabelNames.push_back(std::move(Name));
1442 Symbols.push_back(SymbolInfoTy(
1443 LabelAddrs[LabelNum], *SynthesizedLabelNames.back(), ELF::STT_NOTYPE));
1444 }
1445 llvm::stable_sort(Symbols);
1446 // Recreate the symbolizer with the new symbols list.
1447 RelInfo.reset(Target->createMCRelocationInfo(TripleName, Ctx));
1448 Symbolizer.reset(Target->createMCSymbolizer(
1449 TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
1450 DisAsm->setSymbolizer(std::move(Symbolizer));
1451 }
1452
getSegmentName(const MachOObjectFile * MachO,const SectionRef & Section)1453 static StringRef getSegmentName(const MachOObjectFile *MachO,
1454 const SectionRef &Section) {
1455 if (MachO) {
1456 DataRefImpl DR = Section.getRawDataRefImpl();
1457 StringRef SegmentName = MachO->getSectionFinalSegmentName(DR);
1458 return SegmentName;
1459 }
1460 return "";
1461 }
1462
emitPostInstructionInfo(formatted_raw_ostream & FOS,const MCAsmInfo & MAI,const MCSubtargetInfo & STI,StringRef Comments,LiveVariablePrinter & LVP)1463 static void emitPostInstructionInfo(formatted_raw_ostream &FOS,
1464 const MCAsmInfo &MAI,
1465 const MCSubtargetInfo &STI,
1466 StringRef Comments,
1467 LiveVariablePrinter &LVP) {
1468 do {
1469 if (!Comments.empty()) {
1470 // Emit a line of comments.
1471 StringRef Comment;
1472 std::tie(Comment, Comments) = Comments.split('\n');
1473 // MAI.getCommentColumn() assumes that instructions are printed at the
1474 // position of 8, while getInstStartColumn() returns the actual position.
1475 unsigned CommentColumn =
1476 MAI.getCommentColumn() - 8 + getInstStartColumn(STI);
1477 FOS.PadToColumn(CommentColumn);
1478 FOS << MAI.getCommentString() << ' ' << Comment;
1479 }
1480 LVP.printAfterInst(FOS);
1481 FOS << '\n';
1482 } while (!Comments.empty());
1483 FOS.flush();
1484 }
1485
createFakeELFSections(ObjectFile & Obj)1486 static void createFakeELFSections(ObjectFile &Obj) {
1487 assert(Obj.isELF());
1488 if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(&Obj))
1489 Elf32LEObj->createFakeSections();
1490 else if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(&Obj))
1491 Elf64LEObj->createFakeSections();
1492 else if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(&Obj))
1493 Elf32BEObj->createFakeSections();
1494 else if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(&Obj))
1495 Elf64BEObj->createFakeSections();
1496 else
1497 llvm_unreachable("Unsupported binary format");
1498 }
1499
1500 // Tries to fetch a more complete version of the given object file using its
1501 // Build ID. Returns std::nullopt if nothing was found.
1502 static std::optional<OwningBinary<Binary>>
fetchBinaryByBuildID(const ObjectFile & Obj)1503 fetchBinaryByBuildID(const ObjectFile &Obj) {
1504 object::BuildIDRef BuildID = getBuildID(&Obj);
1505 if (BuildID.empty())
1506 return std::nullopt;
1507 std::optional<std::string> Path = BIDFetcher->fetch(BuildID);
1508 if (!Path)
1509 return std::nullopt;
1510 Expected<OwningBinary<Binary>> DebugBinary = createBinary(*Path);
1511 if (!DebugBinary) {
1512 reportWarning(toString(DebugBinary.takeError()), *Path);
1513 return std::nullopt;
1514 }
1515 return std::move(*DebugBinary);
1516 }
1517
1518 static void
disassembleObject(ObjectFile & Obj,const ObjectFile & DbgObj,DisassemblerTarget & PrimaryTarget,std::optional<DisassemblerTarget> & SecondaryTarget,SourcePrinter & SP,bool InlineRelocs)1519 disassembleObject(ObjectFile &Obj, const ObjectFile &DbgObj,
1520 DisassemblerTarget &PrimaryTarget,
1521 std::optional<DisassemblerTarget> &SecondaryTarget,
1522 SourcePrinter &SP, bool InlineRelocs) {
1523 DisassemblerTarget *DT = &PrimaryTarget;
1524 bool PrimaryIsThumb = false;
1525 SmallVector<std::pair<uint64_t, uint64_t>, 0> CHPECodeMap;
1526
1527 if (SecondaryTarget) {
1528 if (isArmElf(Obj)) {
1529 PrimaryIsThumb =
1530 PrimaryTarget.SubtargetInfo->checkFeatures("+thumb-mode");
1531 } else if (const auto *COFFObj = dyn_cast<COFFObjectFile>(&Obj)) {
1532 const chpe_metadata *CHPEMetadata = COFFObj->getCHPEMetadata();
1533 if (CHPEMetadata && CHPEMetadata->CodeMapCount) {
1534 uintptr_t CodeMapInt;
1535 cantFail(COFFObj->getRvaPtr(CHPEMetadata->CodeMap, CodeMapInt));
1536 auto CodeMap = reinterpret_cast<const chpe_range_entry *>(CodeMapInt);
1537
1538 for (uint32_t i = 0; i < CHPEMetadata->CodeMapCount; ++i) {
1539 if (CodeMap[i].getType() == chpe_range_type::Amd64 &&
1540 CodeMap[i].Length) {
1541 // Store x86_64 CHPE code ranges.
1542 uint64_t Start = CodeMap[i].getStart() + COFFObj->getImageBase();
1543 CHPECodeMap.emplace_back(Start, Start + CodeMap[i].Length);
1544 }
1545 }
1546 llvm::sort(CHPECodeMap);
1547 }
1548 }
1549 }
1550
1551 std::map<SectionRef, std::vector<RelocationRef>> RelocMap;
1552 if (InlineRelocs || Obj.isXCOFF())
1553 RelocMap = getRelocsMap(Obj);
1554 bool Is64Bits = Obj.getBytesInAddress() > 4;
1555
1556 // Create a mapping from virtual address to symbol name. This is used to
1557 // pretty print the symbols while disassembling.
1558 std::map<SectionRef, SectionSymbolsTy> AllSymbols;
1559 std::map<SectionRef, SmallVector<MappingSymbolPair, 0>> AllMappingSymbols;
1560 SectionSymbolsTy AbsoluteSymbols;
1561 const StringRef FileName = Obj.getFileName();
1562 const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(&Obj);
1563 for (const SymbolRef &Symbol : Obj.symbols()) {
1564 Expected<StringRef> NameOrErr = Symbol.getName();
1565 if (!NameOrErr) {
1566 reportWarning(toString(NameOrErr.takeError()), FileName);
1567 continue;
1568 }
1569 if (NameOrErr->empty() && !(Obj.isXCOFF() && SymbolDescription))
1570 continue;
1571
1572 if (Obj.isELF() &&
1573 (cantFail(Symbol.getFlags()) & SymbolRef::SF_FormatSpecific)) {
1574 // Symbol is intended not to be displayed by default (STT_FILE,
1575 // STT_SECTION, or a mapping symbol). Ignore STT_SECTION symbols. We will
1576 // synthesize a section symbol if no symbol is defined at offset 0.
1577 //
1578 // For a mapping symbol, store it within both AllSymbols and
1579 // AllMappingSymbols. If --show-all-symbols is unspecified, its label will
1580 // not be printed in disassembly listing.
1581 if (getElfSymbolType(Obj, Symbol) != ELF::STT_SECTION &&
1582 hasMappingSymbols(Obj)) {
1583 section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName);
1584 if (SecI != Obj.section_end()) {
1585 uint64_t SectionAddr = SecI->getAddress();
1586 uint64_t Address = cantFail(Symbol.getAddress());
1587 StringRef Name = *NameOrErr;
1588 if (Name.consume_front("$") && Name.size() &&
1589 strchr("adtx", Name[0])) {
1590 AllMappingSymbols[*SecI].emplace_back(Address - SectionAddr,
1591 Name[0]);
1592 AllSymbols[*SecI].push_back(
1593 createSymbolInfo(Obj, Symbol, /*MappingSymbol=*/true));
1594 }
1595 }
1596 }
1597 continue;
1598 }
1599
1600 if (MachO) {
1601 // __mh_(execute|dylib|dylinker|bundle|preload|object)_header are special
1602 // symbols that support MachO header introspection. They do not bind to
1603 // code locations and are irrelevant for disassembly.
1604 if (NameOrErr->starts_with("__mh_") && NameOrErr->ends_with("_header"))
1605 continue;
1606 // Don't ask a Mach-O STAB symbol for its section unless you know that
1607 // STAB symbol's section field refers to a valid section index. Otherwise
1608 // the symbol may error trying to load a section that does not exist.
1609 DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
1610 uint8_t NType = (MachO->is64Bit() ?
1611 MachO->getSymbol64TableEntry(SymDRI).n_type:
1612 MachO->getSymbolTableEntry(SymDRI).n_type);
1613 if (NType & MachO::N_STAB)
1614 continue;
1615 }
1616
1617 section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName);
1618 if (SecI != Obj.section_end())
1619 AllSymbols[*SecI].push_back(createSymbolInfo(Obj, Symbol));
1620 else
1621 AbsoluteSymbols.push_back(createSymbolInfo(Obj, Symbol));
1622 }
1623
1624 if (AllSymbols.empty() && Obj.isELF())
1625 addDynamicElfSymbols(cast<ELFObjectFileBase>(Obj), AllSymbols);
1626
1627 if (Obj.isWasm())
1628 addMissingWasmCodeSymbols(cast<WasmObjectFile>(Obj), AllSymbols);
1629
1630 if (Obj.isELF() && Obj.sections().empty())
1631 createFakeELFSections(Obj);
1632
1633 BumpPtrAllocator A;
1634 StringSaver Saver(A);
1635 addPltEntries(Obj, AllSymbols, Saver);
1636
1637 // Create a mapping from virtual address to section. An empty section can
1638 // cause more than one section at the same address. Sort such sections to be
1639 // before same-addressed non-empty sections so that symbol lookups prefer the
1640 // non-empty section.
1641 std::vector<std::pair<uint64_t, SectionRef>> SectionAddresses;
1642 for (SectionRef Sec : Obj.sections())
1643 SectionAddresses.emplace_back(Sec.getAddress(), Sec);
1644 llvm::stable_sort(SectionAddresses, [](const auto &LHS, const auto &RHS) {
1645 if (LHS.first != RHS.first)
1646 return LHS.first < RHS.first;
1647 return LHS.second.getSize() < RHS.second.getSize();
1648 });
1649
1650 // Linked executables (.exe and .dll files) typically don't include a real
1651 // symbol table but they might contain an export table.
1652 if (const auto *COFFObj = dyn_cast<COFFObjectFile>(&Obj)) {
1653 for (const auto &ExportEntry : COFFObj->export_directories()) {
1654 StringRef Name;
1655 if (Error E = ExportEntry.getSymbolName(Name))
1656 reportError(std::move(E), Obj.getFileName());
1657 if (Name.empty())
1658 continue;
1659
1660 uint32_t RVA;
1661 if (Error E = ExportEntry.getExportRVA(RVA))
1662 reportError(std::move(E), Obj.getFileName());
1663
1664 uint64_t VA = COFFObj->getImageBase() + RVA;
1665 auto Sec = partition_point(
1666 SectionAddresses, [VA](const std::pair<uint64_t, SectionRef> &O) {
1667 return O.first <= VA;
1668 });
1669 if (Sec != SectionAddresses.begin()) {
1670 --Sec;
1671 AllSymbols[Sec->second].emplace_back(VA, Name, ELF::STT_NOTYPE);
1672 } else
1673 AbsoluteSymbols.emplace_back(VA, Name, ELF::STT_NOTYPE);
1674 }
1675 }
1676
1677 // Sort all the symbols, this allows us to use a simple binary search to find
1678 // Multiple symbols can have the same address. Use a stable sort to stabilize
1679 // the output.
1680 StringSet<> FoundDisasmSymbolSet;
1681 for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
1682 llvm::stable_sort(SecSyms.second);
1683 llvm::stable_sort(AbsoluteSymbols);
1684
1685 std::unique_ptr<DWARFContext> DICtx;
1686 LiveVariablePrinter LVP(*DT->Context->getRegisterInfo(), *DT->SubtargetInfo);
1687
1688 if (DbgVariables != DVDisabled) {
1689 DICtx = DWARFContext::create(DbgObj);
1690 for (const std::unique_ptr<DWARFUnit> &CU : DICtx->compile_units())
1691 LVP.addCompileUnit(CU->getUnitDIE(false));
1692 }
1693
1694 LLVM_DEBUG(LVP.dump());
1695
1696 std::unordered_map<uint64_t, BBAddrMap> AddrToBBAddrMap;
1697 std::unordered_map<uint64_t, PGOAnalysisMap> AddrToPGOAnalysisMap;
1698 auto ReadBBAddrMap = [&](std::optional<unsigned> SectionIndex =
1699 std::nullopt) {
1700 AddrToBBAddrMap.clear();
1701 if (const auto *Elf = dyn_cast<ELFObjectFileBase>(&Obj)) {
1702 std::vector<PGOAnalysisMap> PGOAnalyses;
1703 auto BBAddrMapsOrErr = Elf->readBBAddrMap(SectionIndex, &PGOAnalyses);
1704 if (!BBAddrMapsOrErr) {
1705 reportWarning(toString(BBAddrMapsOrErr.takeError()), Obj.getFileName());
1706 return;
1707 }
1708 for (const auto &[FunctionBBAddrMap, FunctionPGOAnalysis] :
1709 zip_equal(*std::move(BBAddrMapsOrErr), std::move(PGOAnalyses))) {
1710 uint64_t Addr = FunctionBBAddrMap.Addr;
1711 AddrToBBAddrMap.emplace(Addr, std::move(FunctionBBAddrMap));
1712 if (FunctionPGOAnalysis.FeatEnable.anyEnabled())
1713 AddrToPGOAnalysisMap.emplace(Addr, std::move(FunctionPGOAnalysis));
1714 }
1715 }
1716 };
1717
1718 // For non-relocatable objects, Read all LLVM_BB_ADDR_MAP sections into a
1719 // single mapping, since they don't have any conflicts.
1720 if (SymbolizeOperands && !Obj.isRelocatableObject())
1721 ReadBBAddrMap();
1722
1723 std::optional<llvm::BTFParser> BTF;
1724 if (InlineRelocs && BTFParser::hasBTFSections(Obj)) {
1725 BTF.emplace();
1726 BTFParser::ParseOptions Opts = {};
1727 Opts.LoadTypes = true;
1728 Opts.LoadRelocs = true;
1729 if (Error E = BTF->parse(Obj, Opts))
1730 WithColor::defaultErrorHandler(std::move(E));
1731 }
1732
1733 for (const SectionRef &Section : ToolSectionFilter(Obj)) {
1734 if (FilterSections.empty() && !DisassembleAll &&
1735 (!Section.isText() || Section.isVirtual()))
1736 continue;
1737
1738 uint64_t SectionAddr = Section.getAddress();
1739 uint64_t SectSize = Section.getSize();
1740 if (!SectSize)
1741 continue;
1742
1743 // For relocatable object files, read the LLVM_BB_ADDR_MAP section
1744 // corresponding to this section, if present.
1745 if (SymbolizeOperands && Obj.isRelocatableObject())
1746 ReadBBAddrMap(Section.getIndex());
1747
1748 // Get the list of all the symbols in this section.
1749 SectionSymbolsTy &Symbols = AllSymbols[Section];
1750 auto &MappingSymbols = AllMappingSymbols[Section];
1751 llvm::sort(MappingSymbols);
1752
1753 ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(
1754 unwrapOrError(Section.getContents(), Obj.getFileName()));
1755
1756 std::vector<std::unique_ptr<std::string>> SynthesizedLabelNames;
1757 if (Obj.isELF() && Obj.getArch() == Triple::amdgcn) {
1758 // AMDGPU disassembler uses symbolizer for printing labels
1759 addSymbolizer(*DT->Context, DT->TheTarget, TripleName, DT->DisAsm.get(),
1760 SectionAddr, Bytes, Symbols, SynthesizedLabelNames);
1761 }
1762
1763 StringRef SegmentName = getSegmentName(MachO, Section);
1764 StringRef SectionName = unwrapOrError(Section.getName(), Obj.getFileName());
1765 // If the section has no symbol at the start, just insert a dummy one.
1766 // Without --show-all-symbols, also insert one if all symbols at the start
1767 // are mapping symbols.
1768 bool CreateDummy = Symbols.empty();
1769 if (!CreateDummy) {
1770 CreateDummy = true;
1771 for (auto &Sym : Symbols) {
1772 if (Sym.Addr != SectionAddr)
1773 break;
1774 if (!Sym.IsMappingSymbol || ShowAllSymbols)
1775 CreateDummy = false;
1776 }
1777 }
1778 if (CreateDummy) {
1779 SymbolInfoTy Sym = createDummySymbolInfo(
1780 Obj, SectionAddr, SectionName,
1781 Section.isText() ? ELF::STT_FUNC : ELF::STT_OBJECT);
1782 if (Obj.isXCOFF())
1783 Symbols.insert(Symbols.begin(), Sym);
1784 else
1785 Symbols.insert(llvm::lower_bound(Symbols, Sym), Sym);
1786 }
1787
1788 SmallString<40> Comments;
1789 raw_svector_ostream CommentStream(Comments);
1790
1791 uint64_t VMAAdjustment = 0;
1792 if (shouldAdjustVA(Section))
1793 VMAAdjustment = AdjustVMA;
1794
1795 // In executable and shared objects, r_offset holds a virtual address.
1796 // Subtract SectionAddr from the r_offset field of a relocation to get
1797 // the section offset.
1798 uint64_t RelAdjustment = Obj.isRelocatableObject() ? 0 : SectionAddr;
1799 uint64_t Size;
1800 uint64_t Index;
1801 bool PrintedSection = false;
1802 std::vector<RelocationRef> Rels = RelocMap[Section];
1803 std::vector<RelocationRef>::const_iterator RelCur = Rels.begin();
1804 std::vector<RelocationRef>::const_iterator RelEnd = Rels.end();
1805
1806 // Loop over each chunk of code between two points where at least
1807 // one symbol is defined.
1808 for (size_t SI = 0, SE = Symbols.size(); SI != SE;) {
1809 // Advance SI past all the symbols starting at the same address,
1810 // and make an ArrayRef of them.
1811 unsigned FirstSI = SI;
1812 uint64_t Start = Symbols[SI].Addr;
1813 ArrayRef<SymbolInfoTy> SymbolsHere;
1814 while (SI != SE && Symbols[SI].Addr == Start)
1815 ++SI;
1816 SymbolsHere = ArrayRef<SymbolInfoTy>(&Symbols[FirstSI], SI - FirstSI);
1817
1818 // Get the demangled names of all those symbols. We end up with a vector
1819 // of StringRef that holds the names we're going to use, and a vector of
1820 // std::string that stores the new strings returned by demangle(), if
1821 // any. If we don't call demangle() then that vector can stay empty.
1822 std::vector<StringRef> SymNamesHere;
1823 std::vector<std::string> DemangledSymNamesHere;
1824 if (Demangle) {
1825 // Fetch the demangled names and store them locally.
1826 for (const SymbolInfoTy &Symbol : SymbolsHere)
1827 DemangledSymNamesHere.push_back(demangle(Symbol.Name));
1828 // Now we've finished modifying that vector, it's safe to make
1829 // a vector of StringRefs pointing into it.
1830 SymNamesHere.insert(SymNamesHere.begin(), DemangledSymNamesHere.begin(),
1831 DemangledSymNamesHere.end());
1832 } else {
1833 for (const SymbolInfoTy &Symbol : SymbolsHere)
1834 SymNamesHere.push_back(Symbol.Name);
1835 }
1836
1837 // Distinguish ELF data from code symbols, which will be used later on to
1838 // decide whether to 'disassemble' this chunk as a data declaration via
1839 // dumpELFData(), or whether to treat it as code.
1840 //
1841 // If data _and_ code symbols are defined at the same address, the code
1842 // takes priority, on the grounds that disassembling code is our main
1843 // purpose here, and it would be a worse failure to _not_ interpret
1844 // something that _was_ meaningful as code than vice versa.
1845 //
1846 // Any ELF symbol type that is not clearly data will be regarded as code.
1847 // In particular, one of the uses of STT_NOTYPE is for branch targets
1848 // inside functions, for which STT_FUNC would be inaccurate.
1849 //
1850 // So here, we spot whether there's any non-data symbol present at all,
1851 // and only set the DisassembleAsELFData flag if there isn't. Also, we use
1852 // this distinction to inform the decision of which symbol to print at
1853 // the head of the section, so that if we're printing code, we print a
1854 // code-related symbol name to go with it.
1855 bool DisassembleAsELFData = false;
1856 size_t DisplaySymIndex = SymbolsHere.size() - 1;
1857 if (Obj.isELF() && !DisassembleAll && Section.isText()) {
1858 DisassembleAsELFData = true; // unless we find a code symbol below
1859
1860 for (size_t i = 0; i < SymbolsHere.size(); ++i) {
1861 uint8_t SymTy = SymbolsHere[i].Type;
1862 if (SymTy != ELF::STT_OBJECT && SymTy != ELF::STT_COMMON) {
1863 DisassembleAsELFData = false;
1864 DisplaySymIndex = i;
1865 }
1866 }
1867 }
1868
1869 // Decide which symbol(s) from this collection we're going to print.
1870 std::vector<bool> SymsToPrint(SymbolsHere.size(), false);
1871 // If the user has given the --disassemble-symbols option, then we must
1872 // display every symbol in that set, and no others.
1873 if (!DisasmSymbolSet.empty()) {
1874 bool FoundAny = false;
1875 for (size_t i = 0; i < SymbolsHere.size(); ++i) {
1876 if (DisasmSymbolSet.count(SymNamesHere[i])) {
1877 SymsToPrint[i] = true;
1878 FoundAny = true;
1879 }
1880 }
1881
1882 // And if none of the symbols here is one that the user asked for, skip
1883 // disassembling this entire chunk of code.
1884 if (!FoundAny)
1885 continue;
1886 } else if (!SymbolsHere[DisplaySymIndex].IsMappingSymbol) {
1887 // Otherwise, print whichever symbol at this location is last in the
1888 // Symbols array, because that array is pre-sorted in a way intended to
1889 // correlate with priority of which symbol to display.
1890 SymsToPrint[DisplaySymIndex] = true;
1891 }
1892
1893 // Now that we know we're disassembling this section, override the choice
1894 // of which symbols to display by printing _all_ of them at this address
1895 // if the user asked for all symbols.
1896 //
1897 // That way, '--show-all-symbols --disassemble-symbol=foo' will print
1898 // only the chunk of code headed by 'foo', but also show any other
1899 // symbols defined at that address, such as aliases for 'foo', or the ARM
1900 // mapping symbol preceding its code.
1901 if (ShowAllSymbols) {
1902 for (size_t i = 0; i < SymbolsHere.size(); ++i)
1903 SymsToPrint[i] = true;
1904 }
1905
1906 if (Start < SectionAddr || StopAddress <= Start)
1907 continue;
1908
1909 for (size_t i = 0; i < SymbolsHere.size(); ++i)
1910 FoundDisasmSymbolSet.insert(SymNamesHere[i]);
1911
1912 // The end is the section end, the beginning of the next symbol, or
1913 // --stop-address.
1914 uint64_t End = std::min<uint64_t>(SectionAddr + SectSize, StopAddress);
1915 if (SI < SE)
1916 End = std::min(End, Symbols[SI].Addr);
1917 if (Start >= End || End <= StartAddress)
1918 continue;
1919 Start -= SectionAddr;
1920 End -= SectionAddr;
1921
1922 if (!PrintedSection) {
1923 PrintedSection = true;
1924 outs() << "\nDisassembly of section ";
1925 if (!SegmentName.empty())
1926 outs() << SegmentName << ",";
1927 outs() << SectionName << ":\n";
1928 }
1929
1930 bool PrintedLabel = false;
1931 for (size_t i = 0; i < SymbolsHere.size(); ++i) {
1932 if (!SymsToPrint[i])
1933 continue;
1934
1935 const SymbolInfoTy &Symbol = SymbolsHere[i];
1936 const StringRef SymbolName = SymNamesHere[i];
1937
1938 if (!PrintedLabel) {
1939 outs() << '\n';
1940 PrintedLabel = true;
1941 }
1942 if (LeadingAddr)
1943 outs() << format(Is64Bits ? "%016" PRIx64 " " : "%08" PRIx64 " ",
1944 SectionAddr + Start + VMAAdjustment);
1945 if (Obj.isXCOFF() && SymbolDescription) {
1946 outs() << getXCOFFSymbolDescription(Symbol, SymbolName) << ":\n";
1947 } else
1948 outs() << '<' << SymbolName << ">:\n";
1949 }
1950
1951 // Don't print raw contents of a virtual section. A virtual section
1952 // doesn't have any contents in the file.
1953 if (Section.isVirtual()) {
1954 outs() << "...\n";
1955 continue;
1956 }
1957
1958 // See if any of the symbols defined at this location triggers target-
1959 // specific disassembly behavior, e.g. of special descriptors or function
1960 // prelude information.
1961 //
1962 // We stop this loop at the first symbol that triggers some kind of
1963 // interesting behavior (if any), on the assumption that if two symbols
1964 // defined at the same address trigger two conflicting symbol handlers,
1965 // the object file is probably confused anyway, and it would make even
1966 // less sense to present the output of _both_ handlers, because that
1967 // would describe the same data twice.
1968 for (size_t SHI = 0; SHI < SymbolsHere.size(); ++SHI) {
1969 SymbolInfoTy Symbol = SymbolsHere[SHI];
1970
1971 auto Status = DT->DisAsm->onSymbolStart(
1972 Symbol, Size, Bytes.slice(Start, End - Start), SectionAddr + Start,
1973 CommentStream);
1974
1975 if (!Status) {
1976 // If onSymbolStart returns std::nullopt, that means it didn't trigger
1977 // any interesting handling for this symbol. Try the other symbols
1978 // defined at this address.
1979 continue;
1980 }
1981
1982 if (*Status == MCDisassembler::Fail) {
1983 // If onSymbolStart returns Fail, that means it identified some kind
1984 // of special data at this address, but wasn't able to disassemble it
1985 // meaningfully. So we fall back to disassembling the failed region
1986 // as bytes, assuming that the target detected the failure before
1987 // printing anything.
1988 //
1989 // Return values Success or SoftFail (i.e no 'real' failure) are
1990 // expected to mean that the target has emitted its own output.
1991 //
1992 // Either way, 'Size' will have been set to the amount of data
1993 // covered by whatever prologue the target identified. So we advance
1994 // our own position to beyond that. Sometimes that will be the entire
1995 // distance to the next symbol, and sometimes it will be just a
1996 // prologue and we should start disassembling instructions from where
1997 // it left off.
1998 outs() << DT->Context->getAsmInfo()->getCommentString()
1999 << " error in decoding " << SymNamesHere[SHI]
2000 << " : decoding failed region as bytes.\n";
2001 for (uint64_t I = 0; I < Size; ++I) {
2002 outs() << "\t.byte\t " << format_hex(Bytes[I], 1, /*Upper=*/true)
2003 << "\n";
2004 }
2005 }
2006 Start += Size;
2007 break;
2008 }
2009
2010 Index = Start;
2011 if (SectionAddr < StartAddress)
2012 Index = std::max<uint64_t>(Index, StartAddress - SectionAddr);
2013
2014 if (DisassembleAsELFData) {
2015 dumpELFData(SectionAddr, Index, End, Bytes);
2016 Index = End;
2017 continue;
2018 }
2019
2020 // Skip relocations from symbols that are not dumped.
2021 for (; RelCur != RelEnd; ++RelCur) {
2022 uint64_t Offset = RelCur->getOffset() - RelAdjustment;
2023 if (Index <= Offset)
2024 break;
2025 }
2026
2027 bool DumpARMELFData = false;
2028 bool DumpTracebackTableForXCOFFFunction =
2029 Obj.isXCOFF() && Section.isText() && TracebackTable &&
2030 Symbols[SI - 1].XCOFFSymInfo.StorageMappingClass &&
2031 (*Symbols[SI - 1].XCOFFSymInfo.StorageMappingClass == XCOFF::XMC_PR);
2032
2033 formatted_raw_ostream FOS(outs());
2034
2035 std::unordered_map<uint64_t, std::string> AllLabels;
2036 std::unordered_map<uint64_t, std::vector<BBAddrMapLabel>> BBAddrMapLabels;
2037 if (SymbolizeOperands) {
2038 collectLocalBranchTargets(Bytes, DT->InstrAnalysis.get(),
2039 DT->DisAsm.get(), DT->InstPrinter.get(),
2040 PrimaryTarget.SubtargetInfo.get(),
2041 SectionAddr, Index, End, AllLabels);
2042 collectBBAddrMapLabels(AddrToBBAddrMap, AddrToPGOAnalysisMap,
2043 SectionAddr, Index, End, BBAddrMapLabels,
2044 FileName);
2045 }
2046
2047 if (DT->InstrAnalysis)
2048 DT->InstrAnalysis->resetState();
2049
2050 while (Index < End) {
2051 uint64_t RelOffset;
2052
2053 // ARM and AArch64 ELF binaries can interleave data and text in the
2054 // same section. We rely on the markers introduced to understand what
2055 // we need to dump. If the data marker is within a function, it is
2056 // denoted as a word/short etc.
2057 if (!MappingSymbols.empty()) {
2058 char Kind = getMappingSymbolKind(MappingSymbols, Index);
2059 DumpARMELFData = Kind == 'd';
2060 if (SecondaryTarget) {
2061 if (Kind == 'a') {
2062 DT = PrimaryIsThumb ? &*SecondaryTarget : &PrimaryTarget;
2063 } else if (Kind == 't') {
2064 DT = PrimaryIsThumb ? &PrimaryTarget : &*SecondaryTarget;
2065 }
2066 }
2067 } else if (!CHPECodeMap.empty()) {
2068 uint64_t Address = SectionAddr + Index;
2069 auto It = partition_point(
2070 CHPECodeMap,
2071 [Address](const std::pair<uint64_t, uint64_t> &Entry) {
2072 return Entry.first <= Address;
2073 });
2074 if (It != CHPECodeMap.begin() && Address < (It - 1)->second) {
2075 DT = &*SecondaryTarget;
2076 } else {
2077 DT = &PrimaryTarget;
2078 // X64 disassembler range may have left Index unaligned, so
2079 // make sure that it's aligned when we switch back to ARM64
2080 // code.
2081 Index = llvm::alignTo(Index, 4);
2082 if (Index >= End)
2083 break;
2084 }
2085 }
2086
2087 auto findRel = [&]() {
2088 while (RelCur != RelEnd) {
2089 RelOffset = RelCur->getOffset() - RelAdjustment;
2090 // If this relocation is hidden, skip it.
2091 if (getHidden(*RelCur) || SectionAddr + RelOffset < StartAddress) {
2092 ++RelCur;
2093 continue;
2094 }
2095
2096 // Stop when RelCur's offset is past the disassembled
2097 // instruction/data.
2098 if (RelOffset >= Index + Size)
2099 return false;
2100 if (RelOffset >= Index)
2101 return true;
2102 ++RelCur;
2103 }
2104 return false;
2105 };
2106
2107 if (DumpARMELFData) {
2108 Size = dumpARMELFData(SectionAddr, Index, End, Obj, Bytes,
2109 MappingSymbols, *DT->SubtargetInfo, FOS);
2110 } else {
2111 // When -z or --disassemble-zeroes are given we always dissasemble
2112 // them. Otherwise we might want to skip zero bytes we see.
2113 if (!DisassembleZeroes) {
2114 uint64_t MaxOffset = End - Index;
2115 // For --reloc: print zero blocks patched by relocations, so that
2116 // relocations can be shown in the dump.
2117 if (InlineRelocs && RelCur != RelEnd)
2118 MaxOffset = std::min(RelCur->getOffset() - RelAdjustment - Index,
2119 MaxOffset);
2120
2121 if (size_t N =
2122 countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) {
2123 FOS << "\t\t..." << '\n';
2124 Index += N;
2125 continue;
2126 }
2127 }
2128
2129 if (DumpTracebackTableForXCOFFFunction &&
2130 doesXCOFFTracebackTableBegin(Bytes.slice(Index, 4))) {
2131 dumpTracebackTable(Bytes.slice(Index),
2132 SectionAddr + Index + VMAAdjustment, FOS,
2133 SectionAddr + End + VMAAdjustment,
2134 *DT->SubtargetInfo, cast<XCOFFObjectFile>(&Obj));
2135 Index = End;
2136 continue;
2137 }
2138
2139 // Print local label if there's any.
2140 auto Iter1 = BBAddrMapLabels.find(SectionAddr + Index);
2141 if (Iter1 != BBAddrMapLabels.end()) {
2142 for (const auto &BBLabel : Iter1->second)
2143 FOS << "<" << BBLabel.BlockLabel << ">" << BBLabel.PGOAnalysis
2144 << ":\n";
2145 } else {
2146 auto Iter2 = AllLabels.find(SectionAddr + Index);
2147 if (Iter2 != AllLabels.end())
2148 FOS << "<" << Iter2->second << ">:\n";
2149 }
2150
2151 // Disassemble a real instruction or a data when disassemble all is
2152 // provided
2153 MCInst Inst;
2154 ArrayRef<uint8_t> ThisBytes = Bytes.slice(Index);
2155 uint64_t ThisAddr = SectionAddr + Index;
2156 bool Disassembled = DT->DisAsm->getInstruction(
2157 Inst, Size, ThisBytes, ThisAddr, CommentStream);
2158 if (Size == 0)
2159 Size = std::min<uint64_t>(
2160 ThisBytes.size(),
2161 DT->DisAsm->suggestBytesToSkip(ThisBytes, ThisAddr));
2162
2163 LVP.update({Index, Section.getIndex()},
2164 {Index + Size, Section.getIndex()}, Index + Size != End);
2165
2166 DT->InstPrinter->setCommentStream(CommentStream);
2167
2168 DT->Printer->printInst(
2169 *DT->InstPrinter, Disassembled ? &Inst : nullptr,
2170 Bytes.slice(Index, Size),
2171 {SectionAddr + Index + VMAAdjustment, Section.getIndex()}, FOS,
2172 "", *DT->SubtargetInfo, &SP, Obj.getFileName(), &Rels, LVP);
2173
2174 DT->InstPrinter->setCommentStream(llvm::nulls());
2175
2176 // If disassembly succeeds, we try to resolve the target address
2177 // (jump target or memory operand address) and print it to the
2178 // right of the instruction.
2179 //
2180 // Otherwise, we don't print anything else so that we avoid
2181 // analyzing invalid or incomplete instruction information.
2182 if (Disassembled && DT->InstrAnalysis) {
2183 llvm::raw_ostream *TargetOS = &FOS;
2184 uint64_t Target;
2185 bool PrintTarget = DT->InstrAnalysis->evaluateBranch(
2186 Inst, SectionAddr + Index, Size, Target);
2187
2188 if (!PrintTarget) {
2189 if (std::optional<uint64_t> MaybeTarget =
2190 DT->InstrAnalysis->evaluateMemoryOperandAddress(
2191 Inst, DT->SubtargetInfo.get(), SectionAddr + Index,
2192 Size)) {
2193 Target = *MaybeTarget;
2194 PrintTarget = true;
2195 // Do not print real address when symbolizing.
2196 if (!SymbolizeOperands) {
2197 // Memory operand addresses are printed as comments.
2198 TargetOS = &CommentStream;
2199 *TargetOS << "0x" << Twine::utohexstr(Target);
2200 }
2201 }
2202 }
2203
2204 if (PrintTarget) {
2205 // In a relocatable object, the target's section must reside in
2206 // the same section as the call instruction or it is accessed
2207 // through a relocation.
2208 //
2209 // In a non-relocatable object, the target may be in any section.
2210 // In that case, locate the section(s) containing the target
2211 // address and find the symbol in one of those, if possible.
2212 //
2213 // N.B. Except for XCOFF, we don't walk the relocations in the
2214 // relocatable case yet.
2215 std::vector<const SectionSymbolsTy *> TargetSectionSymbols;
2216 if (!Obj.isRelocatableObject()) {
2217 auto It = llvm::partition_point(
2218 SectionAddresses,
2219 [=](const std::pair<uint64_t, SectionRef> &O) {
2220 return O.first <= Target;
2221 });
2222 uint64_t TargetSecAddr = 0;
2223 while (It != SectionAddresses.begin()) {
2224 --It;
2225 if (TargetSecAddr == 0)
2226 TargetSecAddr = It->first;
2227 if (It->first != TargetSecAddr)
2228 break;
2229 TargetSectionSymbols.push_back(&AllSymbols[It->second]);
2230 }
2231 } else {
2232 TargetSectionSymbols.push_back(&Symbols);
2233 }
2234 TargetSectionSymbols.push_back(&AbsoluteSymbols);
2235
2236 // Find the last symbol in the first candidate section whose
2237 // offset is less than or equal to the target. If there are no
2238 // such symbols, try in the next section and so on, before finally
2239 // using the nearest preceding absolute symbol (if any), if there
2240 // are no other valid symbols.
2241 const SymbolInfoTy *TargetSym = nullptr;
2242 for (const SectionSymbolsTy *TargetSymbols :
2243 TargetSectionSymbols) {
2244 auto It = llvm::partition_point(
2245 *TargetSymbols,
2246 [=](const SymbolInfoTy &O) { return O.Addr <= Target; });
2247 while (It != TargetSymbols->begin()) {
2248 --It;
2249 // Skip mapping symbols to avoid possible ambiguity as they
2250 // do not allow uniquely identifying the target address.
2251 if (!It->IsMappingSymbol) {
2252 TargetSym = &*It;
2253 break;
2254 }
2255 }
2256 if (TargetSym)
2257 break;
2258 }
2259
2260 // Branch targets are printed just after the instructions.
2261 // Print the labels corresponding to the target if there's any.
2262 bool BBAddrMapLabelAvailable = BBAddrMapLabels.count(Target);
2263 bool LabelAvailable = AllLabels.count(Target);
2264
2265 if (TargetSym != nullptr) {
2266 uint64_t TargetAddress = TargetSym->Addr;
2267 uint64_t Disp = Target - TargetAddress;
2268 std::string TargetName = Demangle ? demangle(TargetSym->Name)
2269 : TargetSym->Name.str();
2270 bool RelFixedUp = false;
2271 SmallString<32> Val;
2272
2273 *TargetOS << " <";
2274 // On XCOFF, we use relocations, even without -r, so we
2275 // can print the correct name for an extern function call.
2276 if (Obj.isXCOFF() && findRel()) {
2277 // Check for possible branch relocations and
2278 // branches to fixup code.
2279 bool BranchRelocationType = true;
2280 XCOFF::RelocationType RelocType;
2281 if (Obj.is64Bit()) {
2282 const XCOFFRelocation64 *Reloc =
2283 reinterpret_cast<XCOFFRelocation64 *>(
2284 RelCur->getRawDataRefImpl().p);
2285 RelFixedUp = Reloc->isFixupIndicated();
2286 RelocType = Reloc->Type;
2287 } else {
2288 const XCOFFRelocation32 *Reloc =
2289 reinterpret_cast<XCOFFRelocation32 *>(
2290 RelCur->getRawDataRefImpl().p);
2291 RelFixedUp = Reloc->isFixupIndicated();
2292 RelocType = Reloc->Type;
2293 }
2294 BranchRelocationType =
2295 RelocType == XCOFF::R_BA || RelocType == XCOFF::R_BR ||
2296 RelocType == XCOFF::R_RBA || RelocType == XCOFF::R_RBR;
2297
2298 // If we have a valid relocation, try to print its
2299 // corresponding symbol name. Multiple relocations on the
2300 // same instruction are not handled.
2301 // Branches to fixup code will have the RelFixedUp flag set in
2302 // the RLD. For these instructions, we print the correct
2303 // branch target, but print the referenced symbol as a
2304 // comment.
2305 if (Error E = getRelocationValueString(*RelCur, false, Val)) {
2306 // If -r was used, this error will be printed later.
2307 // Otherwise, we ignore the error and print what
2308 // would have been printed without using relocations.
2309 consumeError(std::move(E));
2310 *TargetOS << TargetName;
2311 RelFixedUp = false; // Suppress comment for RLD sym name
2312 } else if (BranchRelocationType && !RelFixedUp)
2313 *TargetOS << Val;
2314 else
2315 *TargetOS << TargetName;
2316 if (Disp)
2317 *TargetOS << "+0x" << Twine::utohexstr(Disp);
2318 } else if (!Disp) {
2319 *TargetOS << TargetName;
2320 } else if (BBAddrMapLabelAvailable) {
2321 *TargetOS << BBAddrMapLabels[Target].front().BlockLabel;
2322 } else if (LabelAvailable) {
2323 *TargetOS << AllLabels[Target];
2324 } else {
2325 // Always Print the binary symbol plus an offset if there's no
2326 // local label corresponding to the target address.
2327 *TargetOS << TargetName << "+0x" << Twine::utohexstr(Disp);
2328 }
2329 *TargetOS << ">";
2330 if (RelFixedUp && !InlineRelocs) {
2331 // We have fixup code for a relocation. We print the
2332 // referenced symbol as a comment.
2333 *TargetOS << "\t# " << Val;
2334 }
2335
2336 } else if (BBAddrMapLabelAvailable) {
2337 *TargetOS << " <" << BBAddrMapLabels[Target].front().BlockLabel
2338 << ">";
2339 } else if (LabelAvailable) {
2340 *TargetOS << " <" << AllLabels[Target] << ">";
2341 }
2342 // By convention, each record in the comment stream should be
2343 // terminated.
2344 if (TargetOS == &CommentStream)
2345 *TargetOS << "\n";
2346 }
2347
2348 DT->InstrAnalysis->updateState(Inst, SectionAddr + Index);
2349 } else if (!Disassembled && DT->InstrAnalysis) {
2350 DT->InstrAnalysis->resetState();
2351 }
2352 }
2353
2354 assert(DT->Context->getAsmInfo());
2355 emitPostInstructionInfo(FOS, *DT->Context->getAsmInfo(),
2356 *DT->SubtargetInfo, CommentStream.str(), LVP);
2357 Comments.clear();
2358
2359 if (BTF)
2360 printBTFRelocation(FOS, *BTF, {Index, Section.getIndex()}, LVP);
2361
2362 // Hexagon handles relocs in pretty printer
2363 if (InlineRelocs && Obj.getArch() != Triple::hexagon) {
2364 while (findRel()) {
2365 // When --adjust-vma is used, update the address printed.
2366 if (RelCur->getSymbol() != Obj.symbol_end()) {
2367 Expected<section_iterator> SymSI =
2368 RelCur->getSymbol()->getSection();
2369 if (SymSI && *SymSI != Obj.section_end() &&
2370 shouldAdjustVA(**SymSI))
2371 RelOffset += AdjustVMA;
2372 }
2373
2374 printRelocation(FOS, Obj.getFileName(), *RelCur,
2375 SectionAddr + RelOffset, Is64Bits);
2376 LVP.printAfterOtherLine(FOS, true);
2377 ++RelCur;
2378 }
2379 }
2380
2381 Index += Size;
2382 }
2383 }
2384 }
2385 StringSet<> MissingDisasmSymbolSet =
2386 set_difference(DisasmSymbolSet, FoundDisasmSymbolSet);
2387 for (StringRef Sym : MissingDisasmSymbolSet.keys())
2388 reportWarning("failed to disassemble missing symbol " + Sym, FileName);
2389 }
2390
disassembleObject(ObjectFile * Obj,bool InlineRelocs)2391 static void disassembleObject(ObjectFile *Obj, bool InlineRelocs) {
2392 // If information useful for showing the disassembly is missing, try to find a
2393 // more complete binary and disassemble that instead.
2394 OwningBinary<Binary> FetchedBinary;
2395 if (Obj->symbols().empty()) {
2396 if (std::optional<OwningBinary<Binary>> FetchedBinaryOpt =
2397 fetchBinaryByBuildID(*Obj)) {
2398 if (auto *O = dyn_cast<ObjectFile>(FetchedBinaryOpt->getBinary())) {
2399 if (!O->symbols().empty() ||
2400 (!O->sections().empty() && Obj->sections().empty())) {
2401 FetchedBinary = std::move(*FetchedBinaryOpt);
2402 Obj = O;
2403 }
2404 }
2405 }
2406 }
2407
2408 const Target *TheTarget = getTarget(Obj);
2409
2410 // Package up features to be passed to target/subtarget
2411 Expected<SubtargetFeatures> FeaturesValue = Obj->getFeatures();
2412 if (!FeaturesValue)
2413 reportError(FeaturesValue.takeError(), Obj->getFileName());
2414 SubtargetFeatures Features = *FeaturesValue;
2415 if (!MAttrs.empty()) {
2416 for (unsigned I = 0; I != MAttrs.size(); ++I)
2417 Features.AddFeature(MAttrs[I]);
2418 } else if (MCPU.empty() && Obj->getArch() == llvm::Triple::aarch64) {
2419 Features.AddFeature("+all");
2420 }
2421
2422 if (MCPU.empty())
2423 MCPU = Obj->tryGetCPUName().value_or("").str();
2424
2425 if (isArmElf(*Obj)) {
2426 // When disassembling big-endian Arm ELF, the instruction endianness is
2427 // determined in a complex way. In relocatable objects, AAELF32 mandates
2428 // that instruction endianness matches the ELF file endianness; in
2429 // executable images, that's true unless the file header has the EF_ARM_BE8
2430 // flag, in which case instructions are little-endian regardless of data
2431 // endianness.
2432 //
2433 // We must set the big-endian-instructions SubtargetFeature to make the
2434 // disassembler read the instructions the right way round, and also tell
2435 // our own prettyprinter to retrieve the encodings the same way to print in
2436 // hex.
2437 const auto *Elf32BE = dyn_cast<ELF32BEObjectFile>(Obj);
2438
2439 if (Elf32BE && (Elf32BE->isRelocatableObject() ||
2440 !(Elf32BE->getPlatformFlags() & ELF::EF_ARM_BE8))) {
2441 Features.AddFeature("+big-endian-instructions");
2442 ARMPrettyPrinterInst.setInstructionEndianness(llvm::endianness::big);
2443 } else {
2444 ARMPrettyPrinterInst.setInstructionEndianness(llvm::endianness::little);
2445 }
2446 }
2447
2448 DisassemblerTarget PrimaryTarget(TheTarget, *Obj, TripleName, MCPU, Features);
2449
2450 // If we have an ARM object file, we need a second disassembler, because
2451 // ARM CPUs have two different instruction sets: ARM mode, and Thumb mode.
2452 // We use mapping symbols to switch between the two assemblers, where
2453 // appropriate.
2454 std::optional<DisassemblerTarget> SecondaryTarget;
2455
2456 if (isArmElf(*Obj)) {
2457 if (!PrimaryTarget.SubtargetInfo->checkFeatures("+mclass")) {
2458 if (PrimaryTarget.SubtargetInfo->checkFeatures("+thumb-mode"))
2459 Features.AddFeature("-thumb-mode");
2460 else
2461 Features.AddFeature("+thumb-mode");
2462 SecondaryTarget.emplace(PrimaryTarget, Features);
2463 }
2464 } else if (const auto *COFFObj = dyn_cast<COFFObjectFile>(Obj)) {
2465 const chpe_metadata *CHPEMetadata = COFFObj->getCHPEMetadata();
2466 if (CHPEMetadata && CHPEMetadata->CodeMapCount) {
2467 // Set up x86_64 disassembler for ARM64EC binaries.
2468 Triple X64Triple(TripleName);
2469 X64Triple.setArch(Triple::ArchType::x86_64);
2470
2471 std::string Error;
2472 const Target *X64Target =
2473 TargetRegistry::lookupTarget("", X64Triple, Error);
2474 if (X64Target) {
2475 SubtargetFeatures X64Features;
2476 SecondaryTarget.emplace(X64Target, *Obj, X64Triple.getTriple(), "",
2477 X64Features);
2478 } else {
2479 reportWarning(Error, Obj->getFileName());
2480 }
2481 }
2482 }
2483
2484 const ObjectFile *DbgObj = Obj;
2485 if (!FetchedBinary.getBinary() && !Obj->hasDebugInfo()) {
2486 if (std::optional<OwningBinary<Binary>> DebugBinaryOpt =
2487 fetchBinaryByBuildID(*Obj)) {
2488 if (auto *FetchedObj =
2489 dyn_cast<const ObjectFile>(DebugBinaryOpt->getBinary())) {
2490 if (FetchedObj->hasDebugInfo()) {
2491 FetchedBinary = std::move(*DebugBinaryOpt);
2492 DbgObj = FetchedObj;
2493 }
2494 }
2495 }
2496 }
2497
2498 std::unique_ptr<object::Binary> DSYMBinary;
2499 std::unique_ptr<MemoryBuffer> DSYMBuf;
2500 if (!DbgObj->hasDebugInfo()) {
2501 if (const MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&*Obj)) {
2502 DbgObj = objdump::getMachODSymObject(MachOOF, Obj->getFileName(),
2503 DSYMBinary, DSYMBuf);
2504 if (!DbgObj)
2505 return;
2506 }
2507 }
2508
2509 SourcePrinter SP(DbgObj, TheTarget->getName());
2510
2511 for (StringRef Opt : DisassemblerOptions)
2512 if (!PrimaryTarget.InstPrinter->applyTargetSpecificCLOption(Opt))
2513 reportError(Obj->getFileName(),
2514 "Unrecognized disassembler option: " + Opt);
2515
2516 disassembleObject(*Obj, *DbgObj, PrimaryTarget, SecondaryTarget, SP,
2517 InlineRelocs);
2518 }
2519
printRelocations()2520 void Dumper::printRelocations() {
2521 StringRef Fmt = O.getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64;
2522
2523 // Build a mapping from relocation target to a vector of relocation
2524 // sections. Usually, there is an only one relocation section for
2525 // each relocated section.
2526 MapVector<SectionRef, std::vector<SectionRef>> SecToRelSec;
2527 uint64_t Ndx;
2528 for (const SectionRef &Section : ToolSectionFilter(O, &Ndx)) {
2529 if (O.isELF() && (ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC))
2530 continue;
2531 if (Section.relocation_begin() == Section.relocation_end())
2532 continue;
2533 Expected<section_iterator> SecOrErr = Section.getRelocatedSection();
2534 if (!SecOrErr)
2535 reportError(O.getFileName(),
2536 "section (" + Twine(Ndx) +
2537 "): unable to get a relocation target: " +
2538 toString(SecOrErr.takeError()));
2539 SecToRelSec[**SecOrErr].push_back(Section);
2540 }
2541
2542 for (std::pair<SectionRef, std::vector<SectionRef>> &P : SecToRelSec) {
2543 StringRef SecName = unwrapOrError(P.first.getName(), O.getFileName());
2544 outs() << "\nRELOCATION RECORDS FOR [" << SecName << "]:\n";
2545 uint32_t OffsetPadding = (O.getBytesInAddress() > 4 ? 16 : 8);
2546 uint32_t TypePadding = 24;
2547 outs() << left_justify("OFFSET", OffsetPadding) << " "
2548 << left_justify("TYPE", TypePadding) << " "
2549 << "VALUE\n";
2550
2551 for (SectionRef Section : P.second) {
2552 for (const RelocationRef &Reloc : Section.relocations()) {
2553 uint64_t Address = Reloc.getOffset();
2554 SmallString<32> RelocName;
2555 SmallString<32> ValueStr;
2556 if (Address < StartAddress || Address > StopAddress || getHidden(Reloc))
2557 continue;
2558 Reloc.getTypeName(RelocName);
2559 if (Error E =
2560 getRelocationValueString(Reloc, SymbolDescription, ValueStr))
2561 reportUniqueWarning(std::move(E));
2562
2563 outs() << format(Fmt.data(), Address) << " "
2564 << left_justify(RelocName, TypePadding) << " " << ValueStr
2565 << "\n";
2566 }
2567 }
2568 }
2569 }
2570
2571 // Returns true if we need to show LMA column when dumping section headers. We
2572 // show it only when the platform is ELF and either we have at least one section
2573 // whose VMA and LMA are different and/or when --show-lma flag is used.
shouldDisplayLMA(const ObjectFile & Obj)2574 static bool shouldDisplayLMA(const ObjectFile &Obj) {
2575 if (!Obj.isELF())
2576 return false;
2577 for (const SectionRef &S : ToolSectionFilter(Obj))
2578 if (S.getAddress() != getELFSectionLMA(S))
2579 return true;
2580 return ShowLMA;
2581 }
2582
getMaxSectionNameWidth(const ObjectFile & Obj)2583 static size_t getMaxSectionNameWidth(const ObjectFile &Obj) {
2584 // Default column width for names is 13 even if no names are that long.
2585 size_t MaxWidth = 13;
2586 for (const SectionRef &Section : ToolSectionFilter(Obj)) {
2587 StringRef Name = unwrapOrError(Section.getName(), Obj.getFileName());
2588 MaxWidth = std::max(MaxWidth, Name.size());
2589 }
2590 return MaxWidth;
2591 }
2592
printSectionHeaders(ObjectFile & Obj)2593 void objdump::printSectionHeaders(ObjectFile &Obj) {
2594 if (Obj.isELF() && Obj.sections().empty())
2595 createFakeELFSections(Obj);
2596
2597 size_t NameWidth = getMaxSectionNameWidth(Obj);
2598 size_t AddressWidth = 2 * Obj.getBytesInAddress();
2599 bool HasLMAColumn = shouldDisplayLMA(Obj);
2600 outs() << "\nSections:\n";
2601 if (HasLMAColumn)
2602 outs() << "Idx " << left_justify("Name", NameWidth) << " Size "
2603 << left_justify("VMA", AddressWidth) << " "
2604 << left_justify("LMA", AddressWidth) << " Type\n";
2605 else
2606 outs() << "Idx " << left_justify("Name", NameWidth) << " Size "
2607 << left_justify("VMA", AddressWidth) << " Type\n";
2608
2609 uint64_t Idx;
2610 for (const SectionRef &Section : ToolSectionFilter(Obj, &Idx)) {
2611 StringRef Name = unwrapOrError(Section.getName(), Obj.getFileName());
2612 uint64_t VMA = Section.getAddress();
2613 if (shouldAdjustVA(Section))
2614 VMA += AdjustVMA;
2615
2616 uint64_t Size = Section.getSize();
2617
2618 std::string Type = Section.isText() ? "TEXT" : "";
2619 if (Section.isData())
2620 Type += Type.empty() ? "DATA" : ", DATA";
2621 if (Section.isBSS())
2622 Type += Type.empty() ? "BSS" : ", BSS";
2623 if (Section.isDebugSection())
2624 Type += Type.empty() ? "DEBUG" : ", DEBUG";
2625
2626 if (HasLMAColumn)
2627 outs() << format("%3" PRIu64 " %-*s %08" PRIx64 " ", Idx, NameWidth,
2628 Name.str().c_str(), Size)
2629 << format_hex_no_prefix(VMA, AddressWidth) << " "
2630 << format_hex_no_prefix(getELFSectionLMA(Section), AddressWidth)
2631 << " " << Type << "\n";
2632 else
2633 outs() << format("%3" PRIu64 " %-*s %08" PRIx64 " ", Idx, NameWidth,
2634 Name.str().c_str(), Size)
2635 << format_hex_no_prefix(VMA, AddressWidth) << " " << Type << "\n";
2636 }
2637 }
2638
printSectionContents(const ObjectFile * Obj)2639 void objdump::printSectionContents(const ObjectFile *Obj) {
2640 const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj);
2641
2642 for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
2643 StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName());
2644 uint64_t BaseAddr = Section.getAddress();
2645 uint64_t Size = Section.getSize();
2646 if (!Size)
2647 continue;
2648
2649 outs() << "Contents of section ";
2650 StringRef SegmentName = getSegmentName(MachO, Section);
2651 if (!SegmentName.empty())
2652 outs() << SegmentName << ",";
2653 outs() << Name << ":\n";
2654 if (Section.isBSS()) {
2655 outs() << format("<skipping contents of bss section at [%04" PRIx64
2656 ", %04" PRIx64 ")>\n",
2657 BaseAddr, BaseAddr + Size);
2658 continue;
2659 }
2660
2661 StringRef Contents = unwrapOrError(Section.getContents(), Obj->getFileName());
2662
2663 // Dump out the content as hex and printable ascii characters.
2664 for (std::size_t Addr = 0, End = Contents.size(); Addr < End; Addr += 16) {
2665 outs() << format(" %04" PRIx64 " ", BaseAddr + Addr);
2666 // Dump line of hex.
2667 for (std::size_t I = 0; I < 16; ++I) {
2668 if (I != 0 && I % 4 == 0)
2669 outs() << ' ';
2670 if (Addr + I < End)
2671 outs() << hexdigit((Contents[Addr + I] >> 4) & 0xF, true)
2672 << hexdigit(Contents[Addr + I] & 0xF, true);
2673 else
2674 outs() << " ";
2675 }
2676 // Print ascii.
2677 outs() << " ";
2678 for (std::size_t I = 0; I < 16 && Addr + I < End; ++I) {
2679 if (isPrint(static_cast<unsigned char>(Contents[Addr + I]) & 0xFF))
2680 outs() << Contents[Addr + I];
2681 else
2682 outs() << ".";
2683 }
2684 outs() << "\n";
2685 }
2686 }
2687 }
2688
printSymbolTable(StringRef ArchiveName,StringRef ArchitectureName,bool DumpDynamic)2689 void Dumper::printSymbolTable(StringRef ArchiveName, StringRef ArchitectureName,
2690 bool DumpDynamic) {
2691 if (O.isCOFF() && !DumpDynamic) {
2692 outs() << "\nSYMBOL TABLE:\n";
2693 printCOFFSymbolTable(cast<const COFFObjectFile>(O));
2694 return;
2695 }
2696
2697 const StringRef FileName = O.getFileName();
2698
2699 if (!DumpDynamic) {
2700 outs() << "\nSYMBOL TABLE:\n";
2701 for (auto I = O.symbol_begin(); I != O.symbol_end(); ++I)
2702 printSymbol(*I, {}, FileName, ArchiveName, ArchitectureName, DumpDynamic);
2703 return;
2704 }
2705
2706 outs() << "\nDYNAMIC SYMBOL TABLE:\n";
2707 if (!O.isELF()) {
2708 reportWarning(
2709 "this operation is not currently supported for this file format",
2710 FileName);
2711 return;
2712 }
2713
2714 const ELFObjectFileBase *ELF = cast<const ELFObjectFileBase>(&O);
2715 auto Symbols = ELF->getDynamicSymbolIterators();
2716 Expected<std::vector<VersionEntry>> SymbolVersionsOrErr =
2717 ELF->readDynsymVersions();
2718 if (!SymbolVersionsOrErr) {
2719 reportWarning(toString(SymbolVersionsOrErr.takeError()), FileName);
2720 SymbolVersionsOrErr = std::vector<VersionEntry>();
2721 (void)!SymbolVersionsOrErr;
2722 }
2723 for (auto &Sym : Symbols)
2724 printSymbol(Sym, *SymbolVersionsOrErr, FileName, ArchiveName,
2725 ArchitectureName, DumpDynamic);
2726 }
2727
printSymbol(const SymbolRef & Symbol,ArrayRef<VersionEntry> SymbolVersions,StringRef FileName,StringRef ArchiveName,StringRef ArchitectureName,bool DumpDynamic)2728 void Dumper::printSymbol(const SymbolRef &Symbol,
2729 ArrayRef<VersionEntry> SymbolVersions,
2730 StringRef FileName, StringRef ArchiveName,
2731 StringRef ArchitectureName, bool DumpDynamic) {
2732 const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(&O);
2733 Expected<uint64_t> AddrOrErr = Symbol.getAddress();
2734 if (!AddrOrErr) {
2735 reportUniqueWarning(AddrOrErr.takeError());
2736 return;
2737 }
2738 uint64_t Address = *AddrOrErr;
2739 section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName);
2740 if (SecI != O.section_end() && shouldAdjustVA(*SecI))
2741 Address += AdjustVMA;
2742 if ((Address < StartAddress) || (Address > StopAddress))
2743 return;
2744 SymbolRef::Type Type =
2745 unwrapOrError(Symbol.getType(), FileName, ArchiveName, ArchitectureName);
2746 uint32_t Flags =
2747 unwrapOrError(Symbol.getFlags(), FileName, ArchiveName, ArchitectureName);
2748
2749 // Don't ask a Mach-O STAB symbol for its section unless you know that
2750 // STAB symbol's section field refers to a valid section index. Otherwise
2751 // the symbol may error trying to load a section that does not exist.
2752 bool IsSTAB = false;
2753 if (MachO) {
2754 DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
2755 uint8_t NType =
2756 (MachO->is64Bit() ? MachO->getSymbol64TableEntry(SymDRI).n_type
2757 : MachO->getSymbolTableEntry(SymDRI).n_type);
2758 if (NType & MachO::N_STAB)
2759 IsSTAB = true;
2760 }
2761 section_iterator Section = IsSTAB
2762 ? O.section_end()
2763 : unwrapOrError(Symbol.getSection(), FileName,
2764 ArchiveName, ArchitectureName);
2765
2766 StringRef Name;
2767 if (Type == SymbolRef::ST_Debug && Section != O.section_end()) {
2768 if (Expected<StringRef> NameOrErr = Section->getName())
2769 Name = *NameOrErr;
2770 else
2771 consumeError(NameOrErr.takeError());
2772
2773 } else {
2774 Name = unwrapOrError(Symbol.getName(), FileName, ArchiveName,
2775 ArchitectureName);
2776 }
2777
2778 bool Global = Flags & SymbolRef::SF_Global;
2779 bool Weak = Flags & SymbolRef::SF_Weak;
2780 bool Absolute = Flags & SymbolRef::SF_Absolute;
2781 bool Common = Flags & SymbolRef::SF_Common;
2782 bool Hidden = Flags & SymbolRef::SF_Hidden;
2783
2784 char GlobLoc = ' ';
2785 if ((Section != O.section_end() || Absolute) && !Weak)
2786 GlobLoc = Global ? 'g' : 'l';
2787 char IFunc = ' ';
2788 if (O.isELF()) {
2789 if (ELFSymbolRef(Symbol).getELFType() == ELF::STT_GNU_IFUNC)
2790 IFunc = 'i';
2791 if (ELFSymbolRef(Symbol).getBinding() == ELF::STB_GNU_UNIQUE)
2792 GlobLoc = 'u';
2793 }
2794
2795 char Debug = ' ';
2796 if (DumpDynamic)
2797 Debug = 'D';
2798 else if (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
2799 Debug = 'd';
2800
2801 char FileFunc = ' ';
2802 if (Type == SymbolRef::ST_File)
2803 FileFunc = 'f';
2804 else if (Type == SymbolRef::ST_Function)
2805 FileFunc = 'F';
2806 else if (Type == SymbolRef::ST_Data)
2807 FileFunc = 'O';
2808
2809 const char *Fmt = O.getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64;
2810
2811 outs() << format(Fmt, Address) << " "
2812 << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' '
2813 << (Weak ? 'w' : ' ') // Weak?
2814 << ' ' // Constructor. Not supported yet.
2815 << ' ' // Warning. Not supported yet.
2816 << IFunc // Indirect reference to another symbol.
2817 << Debug // Debugging (d) or dynamic (D) symbol.
2818 << FileFunc // Name of function (F), file (f) or object (O).
2819 << ' ';
2820 if (Absolute) {
2821 outs() << "*ABS*";
2822 } else if (Common) {
2823 outs() << "*COM*";
2824 } else if (Section == O.section_end()) {
2825 if (O.isXCOFF()) {
2826 XCOFFSymbolRef XCOFFSym = cast<const XCOFFObjectFile>(O).toSymbolRef(
2827 Symbol.getRawDataRefImpl());
2828 if (XCOFF::N_DEBUG == XCOFFSym.getSectionNumber())
2829 outs() << "*DEBUG*";
2830 else
2831 outs() << "*UND*";
2832 } else
2833 outs() << "*UND*";
2834 } else {
2835 StringRef SegmentName = getSegmentName(MachO, *Section);
2836 if (!SegmentName.empty())
2837 outs() << SegmentName << ",";
2838 StringRef SectionName = unwrapOrError(Section->getName(), FileName);
2839 outs() << SectionName;
2840 if (O.isXCOFF()) {
2841 std::optional<SymbolRef> SymRef =
2842 getXCOFFSymbolContainingSymbolRef(cast<XCOFFObjectFile>(O), Symbol);
2843 if (SymRef) {
2844
2845 Expected<StringRef> NameOrErr = SymRef->getName();
2846
2847 if (NameOrErr) {
2848 outs() << " (csect:";
2849 std::string SymName =
2850 Demangle ? demangle(*NameOrErr) : NameOrErr->str();
2851
2852 if (SymbolDescription)
2853 SymName = getXCOFFSymbolDescription(createSymbolInfo(O, *SymRef),
2854 SymName);
2855
2856 outs() << ' ' << SymName;
2857 outs() << ") ";
2858 } else
2859 reportWarning(toString(NameOrErr.takeError()), FileName);
2860 }
2861 }
2862 }
2863
2864 if (Common)
2865 outs() << '\t' << format(Fmt, static_cast<uint64_t>(Symbol.getAlignment()));
2866 else if (O.isXCOFF())
2867 outs() << '\t'
2868 << format(Fmt, cast<XCOFFObjectFile>(O).getSymbolSize(
2869 Symbol.getRawDataRefImpl()));
2870 else if (O.isELF())
2871 outs() << '\t' << format(Fmt, ELFSymbolRef(Symbol).getSize());
2872
2873 if (O.isELF()) {
2874 if (!SymbolVersions.empty()) {
2875 const VersionEntry &Ver =
2876 SymbolVersions[Symbol.getRawDataRefImpl().d.b - 1];
2877 std::string Str;
2878 if (!Ver.Name.empty())
2879 Str = Ver.IsVerDef ? ' ' + Ver.Name : '(' + Ver.Name + ')';
2880 outs() << ' ' << left_justify(Str, 12);
2881 }
2882
2883 uint8_t Other = ELFSymbolRef(Symbol).getOther();
2884 switch (Other) {
2885 case ELF::STV_DEFAULT:
2886 break;
2887 case ELF::STV_INTERNAL:
2888 outs() << " .internal";
2889 break;
2890 case ELF::STV_HIDDEN:
2891 outs() << " .hidden";
2892 break;
2893 case ELF::STV_PROTECTED:
2894 outs() << " .protected";
2895 break;
2896 default:
2897 outs() << format(" 0x%02x", Other);
2898 break;
2899 }
2900 } else if (Hidden) {
2901 outs() << " .hidden";
2902 }
2903
2904 std::string SymName = Demangle ? demangle(Name) : Name.str();
2905 if (O.isXCOFF() && SymbolDescription)
2906 SymName = getXCOFFSymbolDescription(createSymbolInfo(O, Symbol), SymName);
2907
2908 outs() << ' ' << SymName << '\n';
2909 }
2910
printUnwindInfo(const ObjectFile * O)2911 static void printUnwindInfo(const ObjectFile *O) {
2912 outs() << "Unwind info:\n\n";
2913
2914 if (const COFFObjectFile *Coff = dyn_cast<COFFObjectFile>(O))
2915 printCOFFUnwindInfo(Coff);
2916 else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O))
2917 printMachOUnwindInfo(MachO);
2918 else
2919 // TODO: Extract DWARF dump tool to objdump.
2920 WithColor::error(errs(), ToolName)
2921 << "This operation is only currently supported "
2922 "for COFF and MachO object files.\n";
2923 }
2924
2925 /// Dump the raw contents of the __clangast section so the output can be piped
2926 /// into llvm-bcanalyzer.
printRawClangAST(const ObjectFile * Obj)2927 static void printRawClangAST(const ObjectFile *Obj) {
2928 if (outs().is_displayed()) {
2929 WithColor::error(errs(), ToolName)
2930 << "The -raw-clang-ast option will dump the raw binary contents of "
2931 "the clang ast section.\n"
2932 "Please redirect the output to a file or another program such as "
2933 "llvm-bcanalyzer.\n";
2934 return;
2935 }
2936
2937 StringRef ClangASTSectionName("__clangast");
2938 if (Obj->isCOFF()) {
2939 ClangASTSectionName = "clangast";
2940 }
2941
2942 std::optional<object::SectionRef> ClangASTSection;
2943 for (auto Sec : ToolSectionFilter(*Obj)) {
2944 StringRef Name;
2945 if (Expected<StringRef> NameOrErr = Sec.getName())
2946 Name = *NameOrErr;
2947 else
2948 consumeError(NameOrErr.takeError());
2949
2950 if (Name == ClangASTSectionName) {
2951 ClangASTSection = Sec;
2952 break;
2953 }
2954 }
2955 if (!ClangASTSection)
2956 return;
2957
2958 StringRef ClangASTContents =
2959 unwrapOrError(ClangASTSection->getContents(), Obj->getFileName());
2960 outs().write(ClangASTContents.data(), ClangASTContents.size());
2961 }
2962
printFaultMaps(const ObjectFile * Obj)2963 static void printFaultMaps(const ObjectFile *Obj) {
2964 StringRef FaultMapSectionName;
2965
2966 if (Obj->isELF()) {
2967 FaultMapSectionName = ".llvm_faultmaps";
2968 } else if (Obj->isMachO()) {
2969 FaultMapSectionName = "__llvm_faultmaps";
2970 } else {
2971 WithColor::error(errs(), ToolName)
2972 << "This operation is only currently supported "
2973 "for ELF and Mach-O executable files.\n";
2974 return;
2975 }
2976
2977 std::optional<object::SectionRef> FaultMapSection;
2978
2979 for (auto Sec : ToolSectionFilter(*Obj)) {
2980 StringRef Name;
2981 if (Expected<StringRef> NameOrErr = Sec.getName())
2982 Name = *NameOrErr;
2983 else
2984 consumeError(NameOrErr.takeError());
2985
2986 if (Name == FaultMapSectionName) {
2987 FaultMapSection = Sec;
2988 break;
2989 }
2990 }
2991
2992 outs() << "FaultMap table:\n";
2993
2994 if (!FaultMapSection) {
2995 outs() << "<not found>\n";
2996 return;
2997 }
2998
2999 StringRef FaultMapContents =
3000 unwrapOrError(FaultMapSection->getContents(), Obj->getFileName());
3001 FaultMapParser FMP(FaultMapContents.bytes_begin(),
3002 FaultMapContents.bytes_end());
3003
3004 outs() << FMP;
3005 }
3006
printPrivateHeaders()3007 void Dumper::printPrivateHeaders() {
3008 reportError(O.getFileName(), "Invalid/Unsupported object file format");
3009 }
3010
printFileHeaders(const ObjectFile * O)3011 static void printFileHeaders(const ObjectFile *O) {
3012 if (!O->isELF() && !O->isCOFF())
3013 reportError(O->getFileName(), "Invalid/Unsupported object file format");
3014
3015 Triple::ArchType AT = O->getArch();
3016 outs() << "architecture: " << Triple::getArchTypeName(AT) << "\n";
3017 uint64_t Address = unwrapOrError(O->getStartAddress(), O->getFileName());
3018
3019 StringRef Fmt = O->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64;
3020 outs() << "start address: "
3021 << "0x" << format(Fmt.data(), Address) << "\n";
3022 }
3023
printArchiveChild(StringRef Filename,const Archive::Child & C)3024 static void printArchiveChild(StringRef Filename, const Archive::Child &C) {
3025 Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();
3026 if (!ModeOrErr) {
3027 WithColor::error(errs(), ToolName) << "ill-formed archive entry.\n";
3028 consumeError(ModeOrErr.takeError());
3029 return;
3030 }
3031 sys::fs::perms Mode = ModeOrErr.get();
3032 outs() << ((Mode & sys::fs::owner_read) ? "r" : "-");
3033 outs() << ((Mode & sys::fs::owner_write) ? "w" : "-");
3034 outs() << ((Mode & sys::fs::owner_exe) ? "x" : "-");
3035 outs() << ((Mode & sys::fs::group_read) ? "r" : "-");
3036 outs() << ((Mode & sys::fs::group_write) ? "w" : "-");
3037 outs() << ((Mode & sys::fs::group_exe) ? "x" : "-");
3038 outs() << ((Mode & sys::fs::others_read) ? "r" : "-");
3039 outs() << ((Mode & sys::fs::others_write) ? "w" : "-");
3040 outs() << ((Mode & sys::fs::others_exe) ? "x" : "-");
3041
3042 outs() << " ";
3043
3044 outs() << format("%d/%d %6" PRId64 " ", unwrapOrError(C.getUID(), Filename),
3045 unwrapOrError(C.getGID(), Filename),
3046 unwrapOrError(C.getRawSize(), Filename));
3047
3048 StringRef RawLastModified = C.getRawLastModified();
3049 unsigned Seconds;
3050 if (RawLastModified.getAsInteger(10, Seconds))
3051 outs() << "(date: \"" << RawLastModified
3052 << "\" contains non-decimal chars) ";
3053 else {
3054 // Since ctime(3) returns a 26 character string of the form:
3055 // "Sun Sep 16 01:03:52 1973\n\0"
3056 // just print 24 characters.
3057 time_t t = Seconds;
3058 outs() << format("%.24s ", ctime(&t));
3059 }
3060
3061 StringRef Name = "";
3062 Expected<StringRef> NameOrErr = C.getName();
3063 if (!NameOrErr) {
3064 consumeError(NameOrErr.takeError());
3065 Name = unwrapOrError(C.getRawName(), Filename);
3066 } else {
3067 Name = NameOrErr.get();
3068 }
3069 outs() << Name << "\n";
3070 }
3071
3072 // For ELF only now.
shouldWarnForInvalidStartStopAddress(ObjectFile * Obj)3073 static bool shouldWarnForInvalidStartStopAddress(ObjectFile *Obj) {
3074 if (const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj)) {
3075 if (Elf->getEType() != ELF::ET_REL)
3076 return true;
3077 }
3078 return false;
3079 }
3080
checkForInvalidStartStopAddress(ObjectFile * Obj,uint64_t Start,uint64_t Stop)3081 static void checkForInvalidStartStopAddress(ObjectFile *Obj,
3082 uint64_t Start, uint64_t Stop) {
3083 if (!shouldWarnForInvalidStartStopAddress(Obj))
3084 return;
3085
3086 for (const SectionRef &Section : Obj->sections())
3087 if (ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC) {
3088 uint64_t BaseAddr = Section.getAddress();
3089 uint64_t Size = Section.getSize();
3090 if ((Start < BaseAddr + Size) && Stop > BaseAddr)
3091 return;
3092 }
3093
3094 if (!HasStartAddressFlag)
3095 reportWarning("no section has address less than 0x" +
3096 Twine::utohexstr(Stop) + " specified by --stop-address",
3097 Obj->getFileName());
3098 else if (!HasStopAddressFlag)
3099 reportWarning("no section has address greater than or equal to 0x" +
3100 Twine::utohexstr(Start) + " specified by --start-address",
3101 Obj->getFileName());
3102 else
3103 reportWarning("no section overlaps the range [0x" +
3104 Twine::utohexstr(Start) + ",0x" + Twine::utohexstr(Stop) +
3105 ") specified by --start-address/--stop-address",
3106 Obj->getFileName());
3107 }
3108
dumpObject(ObjectFile * O,const Archive * A=nullptr,const Archive::Child * C=nullptr)3109 static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
3110 const Archive::Child *C = nullptr) {
3111 Expected<std::unique_ptr<Dumper>> DumperOrErr = createDumper(*O);
3112 if (!DumperOrErr) {
3113 reportError(DumperOrErr.takeError(), O->getFileName(),
3114 A ? A->getFileName() : "");
3115 return;
3116 }
3117 Dumper &D = **DumperOrErr;
3118
3119 // Avoid other output when using a raw option.
3120 if (!RawClangAST) {
3121 outs() << '\n';
3122 if (A)
3123 outs() << A->getFileName() << "(" << O->getFileName() << ")";
3124 else
3125 outs() << O->getFileName();
3126 outs() << ":\tfile format " << O->getFileFormatName().lower() << "\n";
3127 }
3128
3129 if (HasStartAddressFlag || HasStopAddressFlag)
3130 checkForInvalidStartStopAddress(O, StartAddress, StopAddress);
3131
3132 // TODO: Change print* free functions to Dumper member functions to utilitize
3133 // stateful functions like reportUniqueWarning.
3134
3135 // Note: the order here matches GNU objdump for compatability.
3136 StringRef ArchiveName = A ? A->getFileName() : "";
3137 if (ArchiveHeaders && !MachOOpt && C)
3138 printArchiveChild(ArchiveName, *C);
3139 if (FileHeaders)
3140 printFileHeaders(O);
3141 if (PrivateHeaders || FirstPrivateHeader)
3142 D.printPrivateHeaders();
3143 if (SectionHeaders)
3144 printSectionHeaders(*O);
3145 if (SymbolTable)
3146 D.printSymbolTable(ArchiveName);
3147 if (DynamicSymbolTable)
3148 D.printSymbolTable(ArchiveName, /*ArchitectureName=*/"",
3149 /*DumpDynamic=*/true);
3150 if (DwarfDumpType != DIDT_Null) {
3151 std::unique_ptr<DIContext> DICtx = DWARFContext::create(*O);
3152 // Dump the complete DWARF structure.
3153 DIDumpOptions DumpOpts;
3154 DumpOpts.DumpType = DwarfDumpType;
3155 DICtx->dump(outs(), DumpOpts);
3156 }
3157 if (Relocations && !Disassemble)
3158 D.printRelocations();
3159 if (DynamicRelocations)
3160 D.printDynamicRelocations();
3161 if (SectionContents)
3162 printSectionContents(O);
3163 if (Disassemble)
3164 disassembleObject(O, Relocations);
3165 if (UnwindInfo)
3166 printUnwindInfo(O);
3167
3168 // Mach-O specific options:
3169 if (ExportsTrie)
3170 printExportsTrie(O);
3171 if (Rebase)
3172 printRebaseTable(O);
3173 if (Bind)
3174 printBindTable(O);
3175 if (LazyBind)
3176 printLazyBindTable(O);
3177 if (WeakBind)
3178 printWeakBindTable(O);
3179
3180 // Other special sections:
3181 if (RawClangAST)
3182 printRawClangAST(O);
3183 if (FaultMapSection)
3184 printFaultMaps(O);
3185 if (Offloading)
3186 dumpOffloadBinary(*O);
3187 }
3188
dumpObject(const COFFImportFile * I,const Archive * A,const Archive::Child * C=nullptr)3189 static void dumpObject(const COFFImportFile *I, const Archive *A,
3190 const Archive::Child *C = nullptr) {
3191 StringRef ArchiveName = A ? A->getFileName() : "";
3192
3193 // Avoid other output when using a raw option.
3194 if (!RawClangAST)
3195 outs() << '\n'
3196 << ArchiveName << "(" << I->getFileName() << ")"
3197 << ":\tfile format COFF-import-file"
3198 << "\n\n";
3199
3200 if (ArchiveHeaders && !MachOOpt && C)
3201 printArchiveChild(ArchiveName, *C);
3202 if (SymbolTable)
3203 printCOFFSymbolTable(*I);
3204 }
3205
3206 /// Dump each object file in \a a;
dumpArchive(const Archive * A)3207 static void dumpArchive(const Archive *A) {
3208 Error Err = Error::success();
3209 unsigned I = -1;
3210 for (auto &C : A->children(Err)) {
3211 ++I;
3212 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
3213 if (!ChildOrErr) {
3214 if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
3215 reportError(std::move(E), getFileNameForError(C, I), A->getFileName());
3216 continue;
3217 }
3218 if (ObjectFile *O = dyn_cast<ObjectFile>(&*ChildOrErr.get()))
3219 dumpObject(O, A, &C);
3220 else if (COFFImportFile *I = dyn_cast<COFFImportFile>(&*ChildOrErr.get()))
3221 dumpObject(I, A, &C);
3222 else
3223 reportError(errorCodeToError(object_error::invalid_file_type),
3224 A->getFileName());
3225 }
3226 if (Err)
3227 reportError(std::move(Err), A->getFileName());
3228 }
3229
3230 /// Open file and figure out how to dump it.
dumpInput(StringRef file)3231 static void dumpInput(StringRef file) {
3232 // If we are using the Mach-O specific object file parser, then let it parse
3233 // the file and process the command line options. So the -arch flags can
3234 // be used to select specific slices, etc.
3235 if (MachOOpt) {
3236 parseInputMachO(file);
3237 return;
3238 }
3239
3240 // Attempt to open the binary.
3241 OwningBinary<Binary> OBinary = unwrapOrError(createBinary(file), file);
3242 Binary &Binary = *OBinary.getBinary();
3243
3244 if (Archive *A = dyn_cast<Archive>(&Binary))
3245 dumpArchive(A);
3246 else if (ObjectFile *O = dyn_cast<ObjectFile>(&Binary))
3247 dumpObject(O);
3248 else if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Binary))
3249 parseInputMachO(UB);
3250 else if (OffloadBinary *OB = dyn_cast<OffloadBinary>(&Binary))
3251 dumpOffloadSections(*OB);
3252 else
3253 reportError(errorCodeToError(object_error::invalid_file_type), file);
3254 }
3255
3256 template <typename T>
parseIntArg(const llvm::opt::InputArgList & InputArgs,int ID,T & Value)3257 static void parseIntArg(const llvm::opt::InputArgList &InputArgs, int ID,
3258 T &Value) {
3259 if (const opt::Arg *A = InputArgs.getLastArg(ID)) {
3260 StringRef V(A->getValue());
3261 if (!llvm::to_integer(V, Value, 0)) {
3262 reportCmdLineError(A->getSpelling() +
3263 ": expected a non-negative integer, but got '" + V +
3264 "'");
3265 }
3266 }
3267 }
3268
parseBuildIDArg(const opt::Arg * A)3269 static object::BuildID parseBuildIDArg(const opt::Arg *A) {
3270 StringRef V(A->getValue());
3271 object::BuildID BID = parseBuildID(V);
3272 if (BID.empty())
3273 reportCmdLineError(A->getSpelling() + ": expected a build ID, but got '" +
3274 V + "'");
3275 return BID;
3276 }
3277
invalidArgValue(const opt::Arg * A)3278 void objdump::invalidArgValue(const opt::Arg *A) {
3279 reportCmdLineError("'" + StringRef(A->getValue()) +
3280 "' is not a valid value for '" + A->getSpelling() + "'");
3281 }
3282
3283 static std::vector<std::string>
commaSeparatedValues(const llvm::opt::InputArgList & InputArgs,int ID)3284 commaSeparatedValues(const llvm::opt::InputArgList &InputArgs, int ID) {
3285 std::vector<std::string> Values;
3286 for (StringRef Value : InputArgs.getAllArgValues(ID)) {
3287 llvm::SmallVector<StringRef, 2> SplitValues;
3288 llvm::SplitString(Value, SplitValues, ",");
3289 for (StringRef SplitValue : SplitValues)
3290 Values.push_back(SplitValue.str());
3291 }
3292 return Values;
3293 }
3294
parseOtoolOptions(const llvm::opt::InputArgList & InputArgs)3295 static void parseOtoolOptions(const llvm::opt::InputArgList &InputArgs) {
3296 MachOOpt = true;
3297 FullLeadingAddr = true;
3298 PrintImmHex = true;
3299
3300 ArchName = InputArgs.getLastArgValue(OTOOL_arch).str();
3301 LinkOptHints = InputArgs.hasArg(OTOOL_C);
3302 if (InputArgs.hasArg(OTOOL_d))
3303 FilterSections.push_back("__DATA,__data");
3304 DylibId = InputArgs.hasArg(OTOOL_D);
3305 UniversalHeaders = InputArgs.hasArg(OTOOL_f);
3306 DataInCode = InputArgs.hasArg(OTOOL_G);
3307 FirstPrivateHeader = InputArgs.hasArg(OTOOL_h);
3308 IndirectSymbols = InputArgs.hasArg(OTOOL_I);
3309 ShowRawInsn = InputArgs.hasArg(OTOOL_j);
3310 PrivateHeaders = InputArgs.hasArg(OTOOL_l);
3311 DylibsUsed = InputArgs.hasArg(OTOOL_L);
3312 MCPU = InputArgs.getLastArgValue(OTOOL_mcpu_EQ).str();
3313 ObjcMetaData = InputArgs.hasArg(OTOOL_o);
3314 DisSymName = InputArgs.getLastArgValue(OTOOL_p).str();
3315 InfoPlist = InputArgs.hasArg(OTOOL_P);
3316 Relocations = InputArgs.hasArg(OTOOL_r);
3317 if (const Arg *A = InputArgs.getLastArg(OTOOL_s)) {
3318 auto Filter = (A->getValue(0) + StringRef(",") + A->getValue(1)).str();
3319 FilterSections.push_back(Filter);
3320 }
3321 if (InputArgs.hasArg(OTOOL_t))
3322 FilterSections.push_back("__TEXT,__text");
3323 Verbose = InputArgs.hasArg(OTOOL_v) || InputArgs.hasArg(OTOOL_V) ||
3324 InputArgs.hasArg(OTOOL_o);
3325 SymbolicOperands = InputArgs.hasArg(OTOOL_V);
3326 if (InputArgs.hasArg(OTOOL_x))
3327 FilterSections.push_back(",__text");
3328 LeadingAddr = LeadingHeaders = !InputArgs.hasArg(OTOOL_X);
3329
3330 ChainedFixups = InputArgs.hasArg(OTOOL_chained_fixups);
3331 DyldInfo = InputArgs.hasArg(OTOOL_dyld_info);
3332
3333 InputFilenames = InputArgs.getAllArgValues(OTOOL_INPUT);
3334 if (InputFilenames.empty())
3335 reportCmdLineError("no input file");
3336
3337 for (const Arg *A : InputArgs) {
3338 const Option &O = A->getOption();
3339 if (O.getGroup().isValid() && O.getGroup().getID() == OTOOL_grp_obsolete) {
3340 reportCmdLineWarning(O.getPrefixedName() +
3341 " is obsolete and not implemented");
3342 }
3343 }
3344 }
3345
parseObjdumpOptions(const llvm::opt::InputArgList & InputArgs)3346 static void parseObjdumpOptions(const llvm::opt::InputArgList &InputArgs) {
3347 parseIntArg(InputArgs, OBJDUMP_adjust_vma_EQ, AdjustVMA);
3348 AllHeaders = InputArgs.hasArg(OBJDUMP_all_headers);
3349 ArchName = InputArgs.getLastArgValue(OBJDUMP_arch_name_EQ).str();
3350 ArchiveHeaders = InputArgs.hasArg(OBJDUMP_archive_headers);
3351 Demangle = InputArgs.hasArg(OBJDUMP_demangle);
3352 Disassemble = InputArgs.hasArg(OBJDUMP_disassemble);
3353 DisassembleAll = InputArgs.hasArg(OBJDUMP_disassemble_all);
3354 SymbolDescription = InputArgs.hasArg(OBJDUMP_symbol_description);
3355 TracebackTable = InputArgs.hasArg(OBJDUMP_traceback_table);
3356 DisassembleSymbols =
3357 commaSeparatedValues(InputArgs, OBJDUMP_disassemble_symbols_EQ);
3358 DisassembleZeroes = InputArgs.hasArg(OBJDUMP_disassemble_zeroes);
3359 if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_dwarf_EQ)) {
3360 DwarfDumpType = StringSwitch<DIDumpType>(A->getValue())
3361 .Case("frames", DIDT_DebugFrame)
3362 .Default(DIDT_Null);
3363 if (DwarfDumpType == DIDT_Null)
3364 invalidArgValue(A);
3365 }
3366 DynamicRelocations = InputArgs.hasArg(OBJDUMP_dynamic_reloc);
3367 FaultMapSection = InputArgs.hasArg(OBJDUMP_fault_map_section);
3368 Offloading = InputArgs.hasArg(OBJDUMP_offloading);
3369 FileHeaders = InputArgs.hasArg(OBJDUMP_file_headers);
3370 SectionContents = InputArgs.hasArg(OBJDUMP_full_contents);
3371 PrintLines = InputArgs.hasArg(OBJDUMP_line_numbers);
3372 InputFilenames = InputArgs.getAllArgValues(OBJDUMP_INPUT);
3373 MachOOpt = InputArgs.hasArg(OBJDUMP_macho);
3374 MCPU = InputArgs.getLastArgValue(OBJDUMP_mcpu_EQ).str();
3375 MAttrs = commaSeparatedValues(InputArgs, OBJDUMP_mattr_EQ);
3376 ShowRawInsn = !InputArgs.hasArg(OBJDUMP_no_show_raw_insn);
3377 LeadingAddr = !InputArgs.hasArg(OBJDUMP_no_leading_addr);
3378 RawClangAST = InputArgs.hasArg(OBJDUMP_raw_clang_ast);
3379 Relocations = InputArgs.hasArg(OBJDUMP_reloc);
3380 PrintImmHex =
3381 InputArgs.hasFlag(OBJDUMP_print_imm_hex, OBJDUMP_no_print_imm_hex, true);
3382 PrivateHeaders = InputArgs.hasArg(OBJDUMP_private_headers);
3383 FilterSections = InputArgs.getAllArgValues(OBJDUMP_section_EQ);
3384 SectionHeaders = InputArgs.hasArg(OBJDUMP_section_headers);
3385 ShowAllSymbols = InputArgs.hasArg(OBJDUMP_show_all_symbols);
3386 ShowLMA = InputArgs.hasArg(OBJDUMP_show_lma);
3387 PrintSource = InputArgs.hasArg(OBJDUMP_source);
3388 parseIntArg(InputArgs, OBJDUMP_start_address_EQ, StartAddress);
3389 HasStartAddressFlag = InputArgs.hasArg(OBJDUMP_start_address_EQ);
3390 parseIntArg(InputArgs, OBJDUMP_stop_address_EQ, StopAddress);
3391 HasStopAddressFlag = InputArgs.hasArg(OBJDUMP_stop_address_EQ);
3392 SymbolTable = InputArgs.hasArg(OBJDUMP_syms);
3393 SymbolizeOperands = InputArgs.hasArg(OBJDUMP_symbolize_operands);
3394 DynamicSymbolTable = InputArgs.hasArg(OBJDUMP_dynamic_syms);
3395 TripleName = InputArgs.getLastArgValue(OBJDUMP_triple_EQ).str();
3396 UnwindInfo = InputArgs.hasArg(OBJDUMP_unwind_info);
3397 Wide = InputArgs.hasArg(OBJDUMP_wide);
3398 Prefix = InputArgs.getLastArgValue(OBJDUMP_prefix).str();
3399 parseIntArg(InputArgs, OBJDUMP_prefix_strip, PrefixStrip);
3400 if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_debug_vars_EQ)) {
3401 DbgVariables = StringSwitch<DebugVarsFormat>(A->getValue())
3402 .Case("ascii", DVASCII)
3403 .Case("unicode", DVUnicode)
3404 .Default(DVInvalid);
3405 if (DbgVariables == DVInvalid)
3406 invalidArgValue(A);
3407 }
3408 if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_disassembler_color_EQ)) {
3409 DisassemblyColor = StringSwitch<ColorOutput>(A->getValue())
3410 .Case("on", ColorOutput::Enable)
3411 .Case("off", ColorOutput::Disable)
3412 .Case("terminal", ColorOutput::Auto)
3413 .Default(ColorOutput::Invalid);
3414 if (DisassemblyColor == ColorOutput::Invalid)
3415 invalidArgValue(A);
3416 }
3417
3418 parseIntArg(InputArgs, OBJDUMP_debug_vars_indent_EQ, DbgIndent);
3419
3420 parseMachOOptions(InputArgs);
3421
3422 // Parse -M (--disassembler-options) and deprecated
3423 // --x86-asm-syntax={att,intel}.
3424 //
3425 // Note, for x86, the asm dialect (AssemblerDialect) is initialized when the
3426 // MCAsmInfo is constructed. MCInstPrinter::applyTargetSpecificCLOption is
3427 // called too late. For now we have to use the internal cl::opt option.
3428 const char *AsmSyntax = nullptr;
3429 for (const auto *A : InputArgs.filtered(OBJDUMP_disassembler_options_EQ,
3430 OBJDUMP_x86_asm_syntax_att,
3431 OBJDUMP_x86_asm_syntax_intel)) {
3432 switch (A->getOption().getID()) {
3433 case OBJDUMP_x86_asm_syntax_att:
3434 AsmSyntax = "--x86-asm-syntax=att";
3435 continue;
3436 case OBJDUMP_x86_asm_syntax_intel:
3437 AsmSyntax = "--x86-asm-syntax=intel";
3438 continue;
3439 }
3440
3441 SmallVector<StringRef, 2> Values;
3442 llvm::SplitString(A->getValue(), Values, ",");
3443 for (StringRef V : Values) {
3444 if (V == "att")
3445 AsmSyntax = "--x86-asm-syntax=att";
3446 else if (V == "intel")
3447 AsmSyntax = "--x86-asm-syntax=intel";
3448 else
3449 DisassemblerOptions.push_back(V.str());
3450 }
3451 }
3452 SmallVector<const char *> Args = {"llvm-objdump"};
3453 for (const opt::Arg *A : InputArgs.filtered(OBJDUMP_mllvm))
3454 Args.push_back(A->getValue());
3455 if (AsmSyntax)
3456 Args.push_back(AsmSyntax);
3457 if (Args.size() > 1)
3458 llvm::cl::ParseCommandLineOptions(Args.size(), Args.data());
3459
3460 // Look up any provided build IDs, then append them to the input filenames.
3461 for (const opt::Arg *A : InputArgs.filtered(OBJDUMP_build_id)) {
3462 object::BuildID BuildID = parseBuildIDArg(A);
3463 std::optional<std::string> Path = BIDFetcher->fetch(BuildID);
3464 if (!Path) {
3465 reportCmdLineError(A->getSpelling() + ": could not find build ID '" +
3466 A->getValue() + "'");
3467 }
3468 InputFilenames.push_back(std::move(*Path));
3469 }
3470
3471 // objdump defaults to a.out if no filenames specified.
3472 if (InputFilenames.empty())
3473 InputFilenames.push_back("a.out");
3474 }
3475
llvm_objdump_main(int argc,char ** argv,const llvm::ToolContext &)3476 int llvm_objdump_main(int argc, char **argv, const llvm::ToolContext &) {
3477 using namespace llvm;
3478
3479 ToolName = argv[0];
3480 std::unique_ptr<CommonOptTable> T;
3481 OptSpecifier Unknown, HelpFlag, HelpHiddenFlag, VersionFlag;
3482
3483 StringRef Stem = sys::path::stem(ToolName);
3484 auto Is = [=](StringRef Tool) {
3485 // We need to recognize the following filenames:
3486 //
3487 // llvm-objdump -> objdump
3488 // llvm-otool-10.exe -> otool
3489 // powerpc64-unknown-freebsd13-objdump -> objdump
3490 auto I = Stem.rfind_insensitive(Tool);
3491 return I != StringRef::npos &&
3492 (I + Tool.size() == Stem.size() || !isAlnum(Stem[I + Tool.size()]));
3493 };
3494 if (Is("otool")) {
3495 T = std::make_unique<OtoolOptTable>();
3496 Unknown = OTOOL_UNKNOWN;
3497 HelpFlag = OTOOL_help;
3498 HelpHiddenFlag = OTOOL_help_hidden;
3499 VersionFlag = OTOOL_version;
3500 } else {
3501 T = std::make_unique<ObjdumpOptTable>();
3502 Unknown = OBJDUMP_UNKNOWN;
3503 HelpFlag = OBJDUMP_help;
3504 HelpHiddenFlag = OBJDUMP_help_hidden;
3505 VersionFlag = OBJDUMP_version;
3506 }
3507
3508 BumpPtrAllocator A;
3509 StringSaver Saver(A);
3510 opt::InputArgList InputArgs =
3511 T->parseArgs(argc, argv, Unknown, Saver,
3512 [&](StringRef Msg) { reportCmdLineError(Msg); });
3513
3514 if (InputArgs.size() == 0 || InputArgs.hasArg(HelpFlag)) {
3515 T->printHelp(ToolName);
3516 return 0;
3517 }
3518 if (InputArgs.hasArg(HelpHiddenFlag)) {
3519 T->printHelp(ToolName, /*ShowHidden=*/true);
3520 return 0;
3521 }
3522
3523 // Initialize targets and assembly printers/parsers.
3524 InitializeAllTargetInfos();
3525 InitializeAllTargetMCs();
3526 InitializeAllDisassemblers();
3527
3528 if (InputArgs.hasArg(VersionFlag)) {
3529 cl::PrintVersionMessage();
3530 if (!Is("otool")) {
3531 outs() << '\n';
3532 TargetRegistry::printRegisteredTargetsForVersion(outs());
3533 }
3534 return 0;
3535 }
3536
3537 // Initialize debuginfod.
3538 const bool ShouldUseDebuginfodByDefault =
3539 InputArgs.hasArg(OBJDUMP_build_id) || canUseDebuginfod();
3540 std::vector<std::string> DebugFileDirectories =
3541 InputArgs.getAllArgValues(OBJDUMP_debug_file_directory);
3542 if (InputArgs.hasFlag(OBJDUMP_debuginfod, OBJDUMP_no_debuginfod,
3543 ShouldUseDebuginfodByDefault)) {
3544 HTTPClient::initialize();
3545 BIDFetcher =
3546 std::make_unique<DebuginfodFetcher>(std::move(DebugFileDirectories));
3547 } else {
3548 BIDFetcher =
3549 std::make_unique<BuildIDFetcher>(std::move(DebugFileDirectories));
3550 }
3551
3552 if (Is("otool"))
3553 parseOtoolOptions(InputArgs);
3554 else
3555 parseObjdumpOptions(InputArgs);
3556
3557 if (StartAddress >= StopAddress)
3558 reportCmdLineError("start address should be less than stop address");
3559
3560 // Removes trailing separators from prefix.
3561 while (!Prefix.empty() && sys::path::is_separator(Prefix.back()))
3562 Prefix.pop_back();
3563
3564 if (AllHeaders)
3565 ArchiveHeaders = FileHeaders = PrivateHeaders = Relocations =
3566 SectionHeaders = SymbolTable = true;
3567
3568 if (DisassembleAll || PrintSource || PrintLines || TracebackTable ||
3569 !DisassembleSymbols.empty())
3570 Disassemble = true;
3571
3572 if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null &&
3573 !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST &&
3574 !Relocations && !SectionHeaders && !SectionContents && !SymbolTable &&
3575 !DynamicSymbolTable && !UnwindInfo && !FaultMapSection && !Offloading &&
3576 !(MachOOpt &&
3577 (Bind || DataInCode || ChainedFixups || DyldInfo || DylibId ||
3578 DylibsUsed || ExportsTrie || FirstPrivateHeader ||
3579 FunctionStartsType != FunctionStartsMode::None || IndirectSymbols ||
3580 InfoPlist || LazyBind || LinkOptHints || ObjcMetaData || Rebase ||
3581 Rpaths || UniversalHeaders || WeakBind || !FilterSections.empty()))) {
3582 T->printHelp(ToolName);
3583 return 2;
3584 }
3585
3586 DisasmSymbolSet.insert(DisassembleSymbols.begin(), DisassembleSymbols.end());
3587
3588 llvm::for_each(InputFilenames, dumpInput);
3589
3590 warnOnNoMatchForSections();
3591
3592 return EXIT_SUCCESS;
3593 }
3594