//===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This program is a utility that works like binutils "objdump", that is, it // dumps out a plethora of information about an object file depending on the // flags. // // The flags and output of this program should be near identical to those of // binutils objdump. // //===----------------------------------------------------------------------===// #include "llvm-objdump.h" #include "COFFDump.h" #include "ELFDump.h" #include "MachODump.h" #include "ObjdumpOptID.h" #include "OffloadDump.h" #include "SourcePrinter.h" #include "WasmDump.h" #include "XCOFFDump.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SetOperations.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSet.h" #include "llvm/ADT/Twine.h" #include "llvm/BinaryFormat/Wasm.h" #include "llvm/DebugInfo/BTF/BTFParser.h" #include "llvm/DebugInfo/DWARF/DWARFContext.h" #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h" #include "llvm/DebugInfo/Symbolize/Symbolize.h" #include "llvm/Debuginfod/BuildIDFetcher.h" #include "llvm/Debuginfod/Debuginfod.h" #include "llvm/Debuginfod/HTTPClient.h" #include "llvm/Demangle/Demangle.h" #include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/MCDisassembler/MCDisassembler.h" #include "llvm/MC/MCDisassembler/MCRelocationInfo.h" #include "llvm/MC/MCInst.h" #include "llvm/MC/MCInstPrinter.h" #include "llvm/MC/MCInstrAnalysis.h" #include "llvm/MC/MCInstrInfo.h" #include "llvm/MC/MCObjectFileInfo.h" #include "llvm/MC/MCRegisterInfo.h" #include "llvm/MC/MCTargetOptions.h" #include "llvm/MC/TargetRegistry.h" #include "llvm/Object/Archive.h" #include "llvm/Object/BuildID.h" #include "llvm/Object/COFF.h" #include "llvm/Object/COFFImportFile.h" #include "llvm/Object/ELFObjectFile.h" #include "llvm/Object/ELFTypes.h" #include "llvm/Object/FaultMapParser.h" #include "llvm/Object/MachO.h" #include "llvm/Object/MachOUniversal.h" #include "llvm/Object/ObjectFile.h" #include "llvm/Object/OffloadBinary.h" #include "llvm/Object/Wasm.h" #include "llvm/Option/Arg.h" #include "llvm/Option/ArgList.h" #include "llvm/Option/Option.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Debug.h" #include "llvm/Support/Errc.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Format.h" #include "llvm/Support/FormatVariadic.h" #include "llvm/Support/GraphWriter.h" #include "llvm/Support/LLVMDriver.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/SourceMgr.h" #include "llvm/Support/StringSaver.h" #include "llvm/Support/TargetSelect.h" #include "llvm/Support/WithColor.h" #include "llvm/Support/raw_ostream.h" #include "llvm/TargetParser/Host.h" #include "llvm/TargetParser/Triple.h" #include <algorithm> #include <cctype> #include <cstring> #include <optional> #include <set> #include <system_error> #include <unordered_map> #include <utility> usingnamespacellvm; usingnamespacellvm::object; usingnamespacellvm::objdump; usingnamespacellvm::opt; namespace { class CommonOptTable : public opt::GenericOptTable { … }; // ObjdumpOptID is in ObjdumpOptID.h namespace objdump_opt { #define PREFIX … #include "ObjdumpOpts.inc" #undef PREFIX static constexpr opt::OptTable::Info ObjdumpInfoTable[] = …; } // namespace objdump_opt class ObjdumpOptTable : public CommonOptTable { … }; enum OtoolOptID { … }; namespace otool { #define PREFIX … #include "OtoolOpts.inc" #undef PREFIX static constexpr opt::OptTable::Info OtoolInfoTable[] = …; } // namespace otool class OtoolOptTable : public CommonOptTable { … }; struct BBAddrMapLabel { … }; // This class represents the BBAddrMap and PGOMap associated with a single // function. class BBAddrMapFunctionEntry { … }; // This class represents the BBAddrMap and PGOMap of potentially multiple // functions in a section. class BBAddrMapInfo { … }; } // namespace #define DEBUG_TYPE … enum class ColorOutput { … }; static uint64_t AdjustVMA; static bool AllHeaders; static std::string ArchName; bool objdump::ArchiveHeaders; bool objdump::Demangle; bool objdump::Disassemble; bool objdump::DisassembleAll; bool objdump::SymbolDescription; bool objdump::TracebackTable; static std::vector<std::string> DisassembleSymbols; static bool DisassembleZeroes; static std::vector<std::string> DisassemblerOptions; static ColorOutput DisassemblyColor; DIDumpType objdump::DwarfDumpType; static bool DynamicRelocations; static bool FaultMapSection; static bool FileHeaders; bool objdump::SectionContents; static std::vector<std::string> InputFilenames; bool objdump::PrintLines; static bool MachOOpt; std::string objdump::MCPU; std::vector<std::string> objdump::MAttrs; bool objdump::ShowRawInsn; bool objdump::LeadingAddr; static bool Offloading; static bool RawClangAST; bool objdump::Relocations; bool objdump::PrintImmHex; bool objdump::PrivateHeaders; std::vector<std::string> objdump::FilterSections; bool objdump::SectionHeaders; static bool ShowAllSymbols; static bool ShowLMA; bool objdump::PrintSource; static uint64_t StartAddress; static bool HasStartAddressFlag; static uint64_t StopAddress = …; static bool HasStopAddressFlag; bool objdump::SymbolTable; static bool SymbolizeOperands; static bool PrettyPGOAnalysisMap; static bool DynamicSymbolTable; std::string objdump::TripleName; bool objdump::UnwindInfo; static bool Wide; std::string objdump::Prefix; uint32_t objdump::PrefixStrip; DebugVarsFormat objdump::DbgVariables = …; int objdump::DbgIndent = …; static StringSet<> DisasmSymbolSet; StringSet<> objdump::FoundSectionSet; static StringRef ToolName; std::unique_ptr<BuildIDFetcher> BIDFetcher; Dumper::Dumper(const object::ObjectFile &O) : … { … } void Dumper::reportUniqueWarning(Error Err) { … } void Dumper::reportUniqueWarning(const Twine &Msg) { … } static Expected<std::unique_ptr<Dumper>> createDumper(const ObjectFile &Obj) { … } namespace { struct FilterResult { … }; } // namespace static FilterResult checkSectionFilter(object::SectionRef S) { … } SectionFilter objdump::ToolSectionFilter(object::ObjectFile const &O, uint64_t *Idx) { … } std::string objdump::getFileNameForError(const object::Archive::Child &C, unsigned Index) { … } void objdump::reportWarning(const Twine &Message, StringRef File) { … } [[noreturn]] void objdump::reportError(StringRef File, const Twine &Message) { … } [[noreturn]] void objdump::reportError(Error E, StringRef FileName, StringRef ArchiveName, StringRef ArchitectureName) { … } static void reportCmdLineWarning(const Twine &Message) { … } [[noreturn]] static void reportCmdLineError(const Twine &Message) { … } static void warnOnNoMatchForSections() { … } static const Target *getTarget(const ObjectFile *Obj) { … } bool objdump::isRelocAddressLess(RelocationRef A, RelocationRef B) { … } static Error getRelocationValueString(const RelocationRef &Rel, bool SymbolDescription, SmallVectorImpl<char> &Result) { … } /// Indicates whether this relocation should hidden when listing /// relocations, usually because it is the trailing part of a multipart /// relocation that will be printed as part of the leading relocation. static bool getHidden(RelocationRef RelRef) { … } /// Get the column at which we want to start printing the instruction /// disassembly, taking into account anything which appears to the left of it. unsigned objdump::getInstStartColumn(const MCSubtargetInfo &STI) { … } static void AlignToInstStartColumn(size_t Start, const MCSubtargetInfo &STI, raw_ostream &OS) { … } void objdump::printRawData(ArrayRef<uint8_t> Bytes, uint64_t Address, formatted_raw_ostream &OS, MCSubtargetInfo const &STI) { … } namespace { static bool isAArch64Elf(const ObjectFile &Obj) { … } static bool isArmElf(const ObjectFile &Obj) { … } static bool isCSKYElf(const ObjectFile &Obj) { … } static bool hasMappingSymbols(const ObjectFile &Obj) { … } static void printRelocation(formatted_raw_ostream &OS, StringRef FileName, const RelocationRef &Rel, uint64_t Address, bool Is64Bits) { … } static void printBTFRelocation(formatted_raw_ostream &FOS, llvm::BTFParser &BTF, object::SectionedAddress Address, LiveVariablePrinter &LVP) { … } class PrettyPrinter { … }; PrettyPrinter PrettyPrinterInst; class HexagonPrettyPrinter : public PrettyPrinter { … }; HexagonPrettyPrinter HexagonPrettyPrinterInst; class AMDGCNPrettyPrinter : public PrettyPrinter { … }; AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst; class BPFPrettyPrinter : public PrettyPrinter { … }; BPFPrettyPrinter BPFPrettyPrinterInst; class ARMPrettyPrinter : public PrettyPrinter { … }; ARMPrettyPrinter ARMPrettyPrinterInst; class AArch64PrettyPrinter : public PrettyPrinter { … }; AArch64PrettyPrinter AArch64PrettyPrinterInst; class RISCVPrettyPrinter : public PrettyPrinter { … }; RISCVPrettyPrinter RISCVPrettyPrinterInst; PrettyPrinter &selectPrettyPrinter(Triple const &Triple) { … } class DisassemblerTarget { … }; DisassemblerTarget::DisassemblerTarget(const Target *TheTarget, ObjectFile &Obj, StringRef TripleName, StringRef MCPU, SubtargetFeatures &Features) : … { … } DisassemblerTarget::DisassemblerTarget(DisassemblerTarget &Other, SubtargetFeatures &Features) : … { … } } // namespace static uint8_t getElfSymbolType(const ObjectFile &Obj, const SymbolRef &Sym) { … } template <class ELFT> static void addDynamicElfSymbols(const ELFObjectFile<ELFT> &Obj, std::map<SectionRef, SectionSymbolsTy> &AllSymbols) { … } static void addDynamicElfSymbols(const ELFObjectFileBase &Obj, std::map<SectionRef, SectionSymbolsTy> &AllSymbols) { … } static std::optional<SectionRef> getWasmCodeSection(const WasmObjectFile &Obj) { … } static void addMissingWasmCodeSymbols(const WasmObjectFile &Obj, std::map<SectionRef, SectionSymbolsTy> &AllSymbols) { … } static void addPltEntries(const ObjectFile &Obj, std::map<SectionRef, SectionSymbolsTy> &AllSymbols, StringSaver &Saver) { … } // Normally the disassembly output will skip blocks of zeroes. This function // returns the number of zero bytes that can be skipped when dumping the // disassembly of the instructions in Buf. static size_t countSkippableZeroBytes(ArrayRef<uint8_t> Buf) { … } // Returns a map from sections to their relocations. static std::map<SectionRef, std::vector<RelocationRef>> getRelocsMap(object::ObjectFile const &Obj) { … } // Used for --adjust-vma to check if address should be adjusted by the // specified value for a given section. // For ELF we do not adjust non-allocatable sections like debug ones, // because they are not loadable. // TODO: implement for other file formats. static bool shouldAdjustVA(const SectionRef &Section) { … } MappingSymbolPair; static char getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols, uint64_t Address) { … } static uint64_t 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) { … } static void dumpELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End, ArrayRef<uint8_t> Bytes) { … } SymbolInfoTy objdump::createSymbolInfo(const ObjectFile &Obj, const SymbolRef &Symbol, bool IsMappingSymbol) { … } static SymbolInfoTy createDummySymbolInfo(const ObjectFile &Obj, const uint64_t Addr, StringRef &Name, uint8_t Type) { … } static void collectBBAddrMapLabels( const BBAddrMapInfo &FullAddrMap, uint64_t SectionAddr, uint64_t Start, uint64_t End, std::unordered_map<uint64_t, std::vector<BBAddrMapLabel>> &Labels) { … } 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) { … } // Create an MCSymbolizer for the target and add it to the MCDisassembler. // This is currently only used on AMDGPU, and assumes the format of the // void * argument passed to AMDGPU's createMCSymbolizer. static void 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) { … } static StringRef getSegmentName(const MachOObjectFile *MachO, const SectionRef &Section) { … } static void emitPostInstructionInfo(formatted_raw_ostream &FOS, const MCAsmInfo &MAI, const MCSubtargetInfo &STI, StringRef Comments, LiveVariablePrinter &LVP) { … } static void createFakeELFSections(ObjectFile &Obj) { … } // Tries to fetch a more complete version of the given object file using its // Build ID. Returns std::nullopt if nothing was found. static std::optional<OwningBinary<Binary>> fetchBinaryByBuildID(const ObjectFile &Obj) { … } static void disassembleObject(ObjectFile &Obj, const ObjectFile &DbgObj, DisassemblerTarget &PrimaryTarget, std::optional<DisassemblerTarget> &SecondaryTarget, SourcePrinter &SP, bool InlineRelocs) { … } static void disassembleObject(ObjectFile *Obj, bool InlineRelocs) { … } void Dumper::printRelocations() { … } // Returns true if we need to show LMA column when dumping section headers. We // show it only when the platform is ELF and either we have at least one section // whose VMA and LMA are different and/or when --show-lma flag is used. static bool shouldDisplayLMA(const ObjectFile &Obj) { … } static size_t getMaxSectionNameWidth(const ObjectFile &Obj) { … } void objdump::printSectionHeaders(ObjectFile &Obj) { … } void objdump::printSectionContents(const ObjectFile *Obj) { … } void Dumper::printSymbolTable(StringRef ArchiveName, StringRef ArchitectureName, bool DumpDynamic) { … } void Dumper::printSymbol(const SymbolRef &Symbol, ArrayRef<VersionEntry> SymbolVersions, StringRef FileName, StringRef ArchiveName, StringRef ArchitectureName, bool DumpDynamic) { … } static void printUnwindInfo(const ObjectFile *O) { … } /// Dump the raw contents of the __clangast section so the output can be piped /// into llvm-bcanalyzer. static void printRawClangAST(const ObjectFile *Obj) { … } static void printFaultMaps(const ObjectFile *Obj) { … } void Dumper::printPrivateHeaders() { … } static void printFileHeaders(const ObjectFile *O) { … } static void printArchiveChild(StringRef Filename, const Archive::Child &C) { … } // For ELF only now. static bool shouldWarnForInvalidStartStopAddress(ObjectFile *Obj) { … } static void checkForInvalidStartStopAddress(ObjectFile *Obj, uint64_t Start, uint64_t Stop) { … } static void dumpObject(ObjectFile *O, const Archive *A = nullptr, const Archive::Child *C = nullptr) { … } static void dumpObject(const COFFImportFile *I, const Archive *A, const Archive::Child *C = nullptr) { … } /// Dump each object file in \a a; static void dumpArchive(const Archive *A) { … } /// Open file and figure out how to dump it. static void dumpInput(StringRef file) { … } template <typename T> static void parseIntArg(const llvm::opt::InputArgList &InputArgs, int ID, T &Value) { … } static object::BuildID parseBuildIDArg(const opt::Arg *A) { … } void objdump::invalidArgValue(const opt::Arg *A) { … } static std::vector<std::string> commaSeparatedValues(const llvm::opt::InputArgList &InputArgs, int ID) { … } static void parseOtoolOptions(const llvm::opt::InputArgList &InputArgs) { … } static void parseObjdumpOptions(const llvm::opt::InputArgList &InputArgs) { … } int llvm_objdump_main(int argc, char **argv, const llvm::ToolContext &) { … }
Codebase Browser
llvm