aboutsummaryrefslogtreecommitdiff
path: root/tools/llvm-objdump
diff options
context:
space:
mode:
Diffstat (limited to 'tools/llvm-objdump')
-rw-r--r--tools/llvm-objdump/COFFDump.cpp82
-rw-r--r--tools/llvm-objdump/ELFDump.cpp252
-rw-r--r--tools/llvm-objdump/MachODump.cpp978
-rw-r--r--tools/llvm-objdump/WasmDump.cpp40
-rw-r--r--tools/llvm-objdump/llvm-objdump.cpp2215
-rw-r--r--tools/llvm-objdump/llvm-objdump.h153
6 files changed, 1989 insertions, 1731 deletions
diff --git a/tools/llvm-objdump/COFFDump.cpp b/tools/llvm-objdump/COFFDump.cpp
index 55607ec299be..1ba0a68902c9 100644
--- a/tools/llvm-objdump/COFFDump.cpp
+++ b/tools/llvm-objdump/COFFDump.cpp
@@ -1,9 +1,8 @@
//===-- COFFDump.cpp - COFF-specific dumper ---------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
///
@@ -25,10 +24,10 @@
#include "llvm/Support/WithColor.h"
#include "llvm/Support/raw_ostream.h"
-using namespace llvm;
-using namespace object;
+using namespace llvm::object;
using namespace llvm::Win64EH;
+namespace llvm {
// Returns the name of the unwind code.
static StringRef getUnwindCodeTypeName(uint8_t Code) {
switch(Code) {
@@ -156,70 +155,68 @@ static void printAllUnwindCodes(ArrayRef<UnwindCode> UCs) {
}
// Given a symbol sym this functions returns the address and section of it.
-static std::error_code
-resolveSectionAndAddress(const COFFObjectFile *Obj, const SymbolRef &Sym,
- const coff_section *&ResolvedSection,
- uint64_t &ResolvedAddr) {
+static Error resolveSectionAndAddress(const COFFObjectFile *Obj,
+ const SymbolRef &Sym,
+ const coff_section *&ResolvedSection,
+ uint64_t &ResolvedAddr) {
Expected<uint64_t> ResolvedAddrOrErr = Sym.getAddress();
if (!ResolvedAddrOrErr)
- return errorToErrorCode(ResolvedAddrOrErr.takeError());
+ return ResolvedAddrOrErr.takeError();
ResolvedAddr = *ResolvedAddrOrErr;
Expected<section_iterator> Iter = Sym.getSection();
if (!Iter)
- return errorToErrorCode(Iter.takeError());
+ return Iter.takeError();
ResolvedSection = Obj->getCOFFSection(**Iter);
- return std::error_code();
+ return Error::success();
}
// Given a vector of relocations for a section and an offset into this section
// the function returns the symbol used for the relocation at the offset.
-static std::error_code resolveSymbol(const std::vector<RelocationRef> &Rels,
+static Error resolveSymbol(const std::vector<RelocationRef> &Rels,
uint64_t Offset, SymbolRef &Sym) {
for (auto &R : Rels) {
uint64_t Ofs = R.getOffset();
if (Ofs == Offset) {
Sym = *R.getSymbol();
- return std::error_code();
+ return Error::success();
}
}
- return object_error::parse_failed;
+ return make_error<BinaryError>();
}
// Given a vector of relocations for a section and an offset into this section
// the function resolves the symbol used for the relocation at the offset and
// returns the section content and the address inside the content pointed to
// by the symbol.
-static std::error_code
+static Error
getSectionContents(const COFFObjectFile *Obj,
const std::vector<RelocationRef> &Rels, uint64_t Offset,
ArrayRef<uint8_t> &Contents, uint64_t &Addr) {
SymbolRef Sym;
- if (std::error_code EC = resolveSymbol(Rels, Offset, Sym))
- return EC;
+ if (Error E = resolveSymbol(Rels, Offset, Sym))
+ return E;
const coff_section *Section;
- if (std::error_code EC = resolveSectionAndAddress(Obj, Sym, Section, Addr))
- return EC;
- if (std::error_code EC = Obj->getSectionContents(Section, Contents))
- return EC;
- return std::error_code();
+ if (Error E = resolveSectionAndAddress(Obj, Sym, Section, Addr))
+ return E;
+ return Obj->getSectionContents(Section, Contents);
}
// Given a vector of relocations for a section and an offset into this section
// the function returns the name of the symbol used for the relocation at the
// offset.
-static std::error_code resolveSymbolName(const std::vector<RelocationRef> &Rels,
- uint64_t Offset, StringRef &Name) {
+static Error resolveSymbolName(const std::vector<RelocationRef> &Rels,
+ uint64_t Offset, StringRef &Name) {
SymbolRef Sym;
- if (std::error_code EC = resolveSymbol(Rels, Offset, Sym))
+ if (Error EC = resolveSymbol(Rels, Offset, Sym))
return EC;
Expected<StringRef> NameOrErr = Sym.getName();
if (!NameOrErr)
- return errorToErrorCode(NameOrErr.takeError());
+ return NameOrErr.takeError();
Name = *NameOrErr;
- return std::error_code();
+ return Error::success();
}
-static void printCOFFSymbolAddress(llvm::raw_ostream &Out,
+static void printCOFFSymbolAddress(raw_ostream &Out,
const std::vector<RelocationRef> &Rels,
uint64_t Offset, uint32_t Disp) {
StringRef Sym;
@@ -469,6 +466,18 @@ static bool getPDataSection(const COFFObjectFile *Obj,
return false;
}
+Error getCOFFRelocationValueString(const COFFObjectFile *Obj,
+ const RelocationRef &Rel,
+ SmallVectorImpl<char> &Result) {
+ symbol_iterator SymI = Rel.getSymbol();
+ Expected<StringRef> SymNameOrErr = SymI->getName();
+ if (!SymNameOrErr)
+ return SymNameOrErr.takeError();
+ StringRef SymName = *SymNameOrErr;
+ Result.append(SymName.begin(), SymName.end());
+ return Error::success();
+}
+
static void printWin64EHUnwindInfo(const Win64EH::UnwindInfo *UI) {
// The casts to int are required in order to output the value as number.
// Without the casts the value would be interpreted as char data (which
@@ -578,7 +587,7 @@ static void printRuntimeFunctionRels(const COFFObjectFile *Obj,
printWin64EHUnwindInfo(UI);
}
-void llvm::printCOFFUnwindInfo(const COFFObjectFile *Obj) {
+void printCOFFUnwindInfo(const COFFObjectFile *Obj) {
if (Obj->getMachine() != COFF::IMAGE_FILE_MACHINE_AMD64) {
WithColor::error(errs(), "llvm-objdump")
<< "unsupported image machine type "
@@ -607,7 +616,7 @@ void llvm::printCOFFUnwindInfo(const COFFObjectFile *Obj) {
}
}
-void llvm::printCOFFFileHeader(const object::ObjectFile *Obj) {
+void printCOFFFileHeader(const object::ObjectFile *Obj) {
const COFFObjectFile *file = dyn_cast<const COFFObjectFile>(Obj);
printTLSDirectory(file);
printLoadConfiguration(file);
@@ -615,7 +624,7 @@ void llvm::printCOFFFileHeader(const object::ObjectFile *Obj) {
printExportTable(file);
}
-void llvm::printCOFFSymbolTable(const object::COFFImportFile *i) {
+void printCOFFSymbolTable(const object::COFFImportFile *i) {
unsigned Index = 0;
bool IsCode = i->getCOFFImportHeader()->getType() == COFF::IMPORT_CODE;
@@ -623,7 +632,7 @@ void llvm::printCOFFSymbolTable(const object::COFFImportFile *i) {
std::string Name;
raw_string_ostream NS(Name);
- Sym.printName(NS);
+ cantFail(Sym.printName(NS));
NS.flush();
outs() << "[" << format("%2d", Index) << "]"
@@ -638,11 +647,11 @@ void llvm::printCOFFSymbolTable(const object::COFFImportFile *i) {
}
}
-void llvm::printCOFFSymbolTable(const COFFObjectFile *coff) {
+void printCOFFSymbolTable(const COFFObjectFile *coff) {
for (unsigned SI = 0, SE = coff->getNumberOfSymbols(); SI != SE; ++SI) {
Expected<COFFSymbolRef> Symbol = coff->getSymbol(SI);
StringRef Name;
- error(errorToErrorCode(Symbol.takeError()));
+ error(Symbol.takeError());
error(coff->getSymbolName(*Symbol, Name));
outs() << "[" << format("%2d", SI) << "]"
@@ -709,3 +718,4 @@ void llvm::printCOFFSymbolTable(const COFFObjectFile *coff) {
}
}
}
+} // namespace llvm
diff --git a/tools/llvm-objdump/ELFDump.cpp b/tools/llvm-objdump/ELFDump.cpp
index b17a15a0d8fc..9c4d67d0f1bd 100644
--- a/tools/llvm-objdump/ELFDump.cpp
+++ b/tools/llvm-objdump/ELFDump.cpp
@@ -1,9 +1,8 @@
//===-- ELFDump.cpp - ELF-specific dumper -----------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
///
@@ -13,23 +12,22 @@
//===----------------------------------------------------------------------===//
#include "llvm-objdump.h"
+#include "llvm/Demangle/Demangle.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
-using namespace llvm;
using namespace llvm::object;
+namespace llvm {
template <class ELFT>
-Expected<StringRef> getDynamicStrTab(const ELFFile<ELFT> *Elf) {
- typedef ELFFile<ELFT> ELFO;
-
+static Expected<StringRef> getDynamicStrTab(const ELFFile<ELFT> *Elf) {
auto DynamicEntriesOrError = Elf->dynamicEntries();
if (!DynamicEntriesOrError)
return DynamicEntriesOrError.takeError();
- for (const typename ELFO::Elf_Dyn &Dyn : *DynamicEntriesOrError) {
+ for (const typename ELFT::Dyn &Dyn : *DynamicEntriesOrError) {
if (Dyn.d_tag == ELF::DT_STRTAB) {
auto MappedAddrOrError = Elf->toMappedAddr(Dyn.getPtr());
if (!MappedAddrOrError)
@@ -43,7 +41,7 @@ Expected<StringRef> getDynamicStrTab(const ELFFile<ELFT> *Elf) {
if (!SectionsOrError)
return SectionsOrError.takeError();
- for (const typename ELFO::Elf_Shdr &Sec : *SectionsOrError) {
+ for (const typename ELFT::Shdr &Sec : *SectionsOrError) {
if (Sec.sh_type == ELF::SHT_DYNSYM)
return Elf->getStringTableForSymtab(Sec);
}
@@ -52,40 +50,135 @@ Expected<StringRef> getDynamicStrTab(const ELFFile<ELFT> *Elf) {
}
template <class ELFT>
-void printDynamicSection(const ELFFile<ELFT> *Elf, StringRef Filename) {
- auto ProgramHeaderOrError = Elf->program_headers();
- if (!ProgramHeaderOrError)
- report_error(Filename, ProgramHeaderOrError.takeError());
+static Error getRelocationValueString(const ELFObjectFile<ELFT> *Obj,
+ const RelocationRef &RelRef,
+ SmallVectorImpl<char> &Result) {
+ const ELFFile<ELFT> &EF = *Obj->getELFFile();
+ DataRefImpl Rel = RelRef.getRawDataRefImpl();
+ auto SecOrErr = EF.getSection(Rel.d.a);
+ if (!SecOrErr)
+ return SecOrErr.takeError();
- auto DynamicEntriesOrError = Elf->dynamicEntries();
- if (!DynamicEntriesOrError)
- report_error(Filename, DynamicEntriesOrError.takeError());
+ int64_t Addend = 0;
+ // If there is no Symbol associated with the relocation, we set the undef
+ // boolean value to 'true'. This will prevent us from calling functions that
+ // requires the relocation to be associated with a symbol.
+ //
+ // In SHT_REL case we would need to read the addend from section data.
+ // GNU objdump does not do that and we just follow for simplicity atm.
+ bool Undef = false;
+ if ((*SecOrErr)->sh_type == ELF::SHT_RELA) {
+ const typename ELFT::Rela *ERela = Obj->getRela(Rel);
+ Addend = ERela->r_addend;
+ Undef = ERela->getSymbol(false) == 0;
+ } else if ((*SecOrErr)->sh_type != ELF::SHT_REL) {
+ return make_error<BinaryError>();
+ }
+
+ // Default scheme is to print Target, as well as "+ <addend>" for nonzero
+ // addend. Should be acceptable for all normal purposes.
+ std::string FmtBuf;
+ raw_string_ostream Fmt(FmtBuf);
+
+ if (!Undef) {
+ symbol_iterator SI = RelRef.getSymbol();
+ const typename ELFT::Sym *Sym = Obj->getSymbol(SI->getRawDataRefImpl());
+ if (Sym->getType() == ELF::STT_SECTION) {
+ Expected<section_iterator> SymSI = SI->getSection();
+ if (!SymSI)
+ return SymSI.takeError();
+ const typename ELFT::Shdr *SymSec =
+ Obj->getSection((*SymSI)->getRawDataRefImpl());
+ auto SecName = EF.getSectionName(SymSec);
+ if (!SecName)
+ return SecName.takeError();
+ Fmt << *SecName;
+ } else {
+ Expected<StringRef> SymName = SI->getName();
+ if (!SymName)
+ return SymName.takeError();
+ if (Demangle)
+ Fmt << demangle(*SymName);
+ else
+ Fmt << *SymName;
+ }
+ } else {
+ Fmt << "*ABS*";
+ }
+
+ if (Addend != 0)
+ Fmt << (Addend < 0 ? "" : "+") << Addend;
+ Fmt.flush();
+ Result.append(FmtBuf.begin(), FmtBuf.end());
+ return Error::success();
+}
+Error getELFRelocationValueString(const ELFObjectFileBase *Obj,
+ const RelocationRef &Rel,
+ SmallVectorImpl<char> &Result) {
+ if (auto *ELF32LE = dyn_cast<ELF32LEObjectFile>(Obj))
+ return getRelocationValueString(ELF32LE, Rel, Result);
+ if (auto *ELF64LE = dyn_cast<ELF64LEObjectFile>(Obj))
+ return getRelocationValueString(ELF64LE, Rel, Result);
+ if (auto *ELF32BE = dyn_cast<ELF32BEObjectFile>(Obj))
+ return getRelocationValueString(ELF32BE, Rel, Result);
+ auto *ELF64BE = cast<ELF64BEObjectFile>(Obj);
+ return getRelocationValueString(ELF64BE, Rel, Result);
+}
+
+template <class ELFT>
+static uint64_t getSectionLMA(const ELFFile<ELFT> *Obj,
+ const object::ELFSectionRef &Sec) {
+ auto PhdrRangeOrErr = Obj->program_headers();
+ if (!PhdrRangeOrErr)
+ report_fatal_error(toString(PhdrRangeOrErr.takeError()));
+
+ // Search for a PT_LOAD segment containing the requested section. Use this
+ // segment's p_addr to calculate the section's LMA.
+ for (const typename ELFT::Phdr &Phdr : *PhdrRangeOrErr)
+ if ((Phdr.p_type == ELF::PT_LOAD) && (Phdr.p_vaddr <= Sec.getAddress()) &&
+ (Phdr.p_vaddr + Phdr.p_memsz > Sec.getAddress()))
+ return Sec.getAddress() - Phdr.p_vaddr + Phdr.p_paddr;
+
+ // Return section's VMA if it isn't in a PT_LOAD segment.
+ return Sec.getAddress();
+}
+
+uint64_t getELFSectionLMA(const object::ELFSectionRef &Sec) {
+ if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Sec.getObject()))
+ return getSectionLMA(ELFObj->getELFFile(), Sec);
+ else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Sec.getObject()))
+ return getSectionLMA(ELFObj->getELFFile(), Sec);
+ else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Sec.getObject()))
+ return getSectionLMA(ELFObj->getELFFile(), Sec);
+ const auto *ELFObj = cast<ELF64BEObjectFile>(Sec.getObject());
+ return getSectionLMA(ELFObj->getELFFile(), Sec);
+}
+
+template <class ELFT>
+void printDynamicSection(const ELFFile<ELFT> *Elf, StringRef Filename) {
+ ArrayRef<typename ELFT::Dyn> DynamicEntries =
+ unwrapOrError(Elf->dynamicEntries(), Filename);
outs() << "Dynamic Section:\n";
- for (const auto &Dyn : *DynamicEntriesOrError) {
+ for (const typename ELFT::Dyn &Dyn : DynamicEntries) {
if (Dyn.d_tag == ELF::DT_NULL)
continue;
- StringRef Str = StringRef(Elf->getDynamicTagAsString(Dyn.d_tag));
-
- if (Str.empty()) {
- std::string HexStr = utohexstr(static_cast<uint64_t>(Dyn.d_tag), true);
- outs() << format(" 0x%-19s", HexStr.c_str());
- } else {
- // We use "-21" in order to match GNU objdump's output.
- outs() << format(" %-21s", Str.data());
- }
+ std::string Str = Elf->getDynamicTagAsString(Dyn.d_tag);
+ outs() << format(" %-21s", Str.c_str());
const char *Fmt =
ELFT::Is64Bits ? "0x%016" PRIx64 "\n" : "0x%08" PRIx64 "\n";
- if (Dyn.d_tag == ELF::DT_NEEDED) {
+ if (Dyn.d_tag == ELF::DT_NEEDED || Dyn.d_tag == ELF::DT_RPATH ||
+ Dyn.d_tag == ELF::DT_RUNPATH || Dyn.d_tag == ELF::DT_SONAME ||
+ Dyn.d_tag == ELF::DT_AUXILIARY || Dyn.d_tag == ELF::DT_FILTER) {
Expected<StringRef> StrTabOrErr = getDynamicStrTab(Elf);
if (StrTabOrErr) {
const char *Data = StrTabOrErr.get().data();
outs() << (Data + Dyn.d_un.d_val) << "\n";
continue;
}
- warn(errorToErrorCode(StrTabOrErr.takeError()).message());
+ warn(toString(StrTabOrErr.takeError()));
consumeError(StrTabOrErr.takeError());
}
outs() << format(Fmt, (uint64_t)Dyn.d_un.d_val);
@@ -93,13 +186,11 @@ void printDynamicSection(const ELFFile<ELFT> *Elf, StringRef Filename) {
}
template <class ELFT> void printProgramHeaders(const ELFFile<ELFT> *o) {
- typedef ELFFile<ELFT> ELFO;
outs() << "Program Header:\n";
auto ProgramHeaderOrError = o->program_headers();
if (!ProgramHeaderOrError)
- report_fatal_error(
- errorToErrorCode(ProgramHeaderOrError.takeError()).message());
- for (const typename ELFO::Elf_Phdr &Phdr : *ProgramHeaderOrError) {
+ report_fatal_error(toString(ProgramHeaderOrError.takeError()));
+ for (const typename ELFT::Phdr &Phdr : *ProgramHeaderOrError) {
switch (Phdr.p_type) {
case ELF::PT_DYNAMIC:
outs() << " DYNAMIC ";
@@ -157,7 +248,86 @@ template <class ELFT> void printProgramHeaders(const ELFFile<ELFT> *o) {
outs() << "\n";
}
-void llvm::printELFFileHeader(const object::ObjectFile *Obj) {
+template <class ELFT>
+void printSymbolVersionDependency(ArrayRef<uint8_t> Contents,
+ StringRef StrTab) {
+ outs() << "Version References:\n";
+
+ const uint8_t *Buf = Contents.data();
+ while (Buf) {
+ auto *Verneed = reinterpret_cast<const typename ELFT::Verneed *>(Buf);
+ outs() << " required from "
+ << StringRef(StrTab.drop_front(Verneed->vn_file).data()) << ":\n";
+
+ const uint8_t *BufAux = Buf + Verneed->vn_aux;
+ while (BufAux) {
+ auto *Vernaux = reinterpret_cast<const typename ELFT::Vernaux *>(BufAux);
+ outs() << " "
+ << format("0x%08" PRIx32 " ", (uint32_t)Vernaux->vna_hash)
+ << format("0x%02" PRIx16 " ", (uint16_t)Vernaux->vna_flags)
+ << format("%02" PRIu16 " ", (uint16_t)Vernaux->vna_other)
+ << StringRef(StrTab.drop_front(Vernaux->vna_name).data()) << '\n';
+ BufAux = Vernaux->vna_next ? BufAux + Vernaux->vna_next : nullptr;
+ }
+ Buf = Verneed->vn_next ? Buf + Verneed->vn_next : nullptr;
+ }
+}
+
+template <class ELFT>
+void printSymbolVersionDefinition(const typename ELFT::Shdr &Shdr,
+ ArrayRef<uint8_t> Contents,
+ StringRef StrTab) {
+ outs() << "Version definitions:\n";
+
+ const uint8_t *Buf = Contents.data();
+ uint32_t VerdefIndex = 1;
+ // sh_info contains the number of entries in the SHT_GNU_verdef section. To
+ // make the index column have consistent width, we should insert blank spaces
+ // according to sh_info.
+ uint16_t VerdefIndexWidth = std::to_string(Shdr.sh_info).size();
+ while (Buf) {
+ auto *Verdef = reinterpret_cast<const typename ELFT::Verdef *>(Buf);
+ outs() << format_decimal(VerdefIndex++, VerdefIndexWidth) << " "
+ << format("0x%02" PRIx16 " ", (uint16_t)Verdef->vd_flags)
+ << format("0x%08" PRIx32 " ", (uint32_t)Verdef->vd_hash);
+
+ const uint8_t *BufAux = Buf + Verdef->vd_aux;
+ uint16_t VerdauxIndex = 0;
+ while (BufAux) {
+ auto *Verdaux = reinterpret_cast<const typename ELFT::Verdaux *>(BufAux);
+ if (VerdauxIndex)
+ outs() << std::string(VerdefIndexWidth + 17, ' ');
+ outs() << StringRef(StrTab.drop_front(Verdaux->vda_name).data()) << '\n';
+ BufAux = Verdaux->vda_next ? BufAux + Verdaux->vda_next : nullptr;
+ ++VerdauxIndex;
+ }
+ Buf = Verdef->vd_next ? Buf + Verdef->vd_next : nullptr;
+ }
+}
+
+template <class ELFT>
+void printSymbolVersionInfo(const ELFFile<ELFT> *Elf, StringRef FileName) {
+ ArrayRef<typename ELFT::Shdr> Sections =
+ unwrapOrError(Elf->sections(), FileName);
+ for (const typename ELFT::Shdr &Shdr : Sections) {
+ if (Shdr.sh_type != ELF::SHT_GNU_verneed &&
+ Shdr.sh_type != ELF::SHT_GNU_verdef)
+ continue;
+
+ ArrayRef<uint8_t> Contents =
+ unwrapOrError(Elf->getSectionContents(&Shdr), FileName);
+ const typename ELFT::Shdr *StrTabSec =
+ unwrapOrError(Elf->getSection(Shdr.sh_link), FileName);
+ StringRef StrTab = unwrapOrError(Elf->getStringTable(StrTabSec), FileName);
+
+ if (Shdr.sh_type == ELF::SHT_GNU_verneed)
+ printSymbolVersionDependency<ELFT>(Contents, StrTab);
+ else
+ printSymbolVersionDefinition<ELFT>(Shdr, Contents, StrTab);
+ }
+}
+
+void printELFFileHeader(const object::ObjectFile *Obj) {
if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
printProgramHeaders(ELFObj->getELFFile());
else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
@@ -168,7 +338,7 @@ void llvm::printELFFileHeader(const object::ObjectFile *Obj) {
printProgramHeaders(ELFObj->getELFFile());
}
-void llvm::printELFDynamicSection(const object::ObjectFile *Obj) {
+void printELFDynamicSection(const object::ObjectFile *Obj) {
if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
@@ -178,3 +348,15 @@ void llvm::printELFDynamicSection(const object::ObjectFile *Obj) {
else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
}
+
+void printELFSymbolVersionInfo(const object::ObjectFile *Obj) {
+ if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
+ printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+ else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
+ printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+ else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
+ printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+ else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
+ printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+}
+} // namespace llvm
diff --git a/tools/llvm-objdump/MachODump.cpp b/tools/llvm-objdump/MachODump.cpp
index 5ef7058ec9da..58ff7be4543c 100644
--- a/tools/llvm-objdump/MachODump.cpp
+++ b/tools/llvm-objdump/MachODump.cpp
@@ -1,9 +1,8 @@
//===-- MachODump.cpp - Object file dumping utility for llvm --------------===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
//
@@ -56,83 +55,140 @@ extern "C" {
}
#endif
-using namespace llvm;
-using namespace object;
+using namespace llvm::object;
+
+namespace llvm {
+
+cl::OptionCategory MachOCat("llvm-objdump MachO Specific Options");
+
+extern cl::opt<bool> ArchiveHeaders;
+extern cl::opt<bool> Disassemble;
+extern cl::opt<bool> DisassembleAll;
+extern cl::opt<DIDumpType> DwarfDumpType;
+extern cl::list<std::string> FilterSections;
+extern cl::list<std::string> MAttrs;
+extern cl::opt<std::string> MCPU;
+extern cl::opt<bool> NoShowRawInsn;
+extern cl::opt<bool> NoLeadingAddr;
+extern cl::opt<bool> PrintImmHex;
+extern cl::opt<bool> PrivateHeaders;
+extern cl::opt<bool> Relocations;
+extern cl::opt<bool> SectionHeaders;
+extern cl::opt<bool> SectionContents;
+extern cl::opt<bool> SymbolTable;
+extern cl::opt<std::string> TripleName;
+extern cl::opt<bool> UnwindInfo;
+
+cl::opt<bool>
+ FirstPrivateHeader("private-header",
+ cl::desc("Display only the first format specific file "
+ "header"),
+ cl::cat(MachOCat));
+
+cl::opt<bool> ExportsTrie("exports-trie",
+ cl::desc("Display mach-o exported symbols"),
+ cl::cat(MachOCat));
+
+cl::opt<bool> Rebase("rebase", cl::desc("Display mach-o rebasing info"),
+ cl::cat(MachOCat));
+
+cl::opt<bool> Bind("bind", cl::desc("Display mach-o binding info"),
+ cl::cat(MachOCat));
+
+cl::opt<bool> LazyBind("lazy-bind",
+ cl::desc("Display mach-o lazy binding info"),
+ cl::cat(MachOCat));
+
+cl::opt<bool> WeakBind("weak-bind",
+ cl::desc("Display mach-o weak binding info"),
+ cl::cat(MachOCat));
static cl::opt<bool>
- UseDbg("g",
- cl::desc("Print line information from debug info if available"));
+ UseDbg("g", cl::Grouping,
+ cl::desc("Print line information from debug info if available"),
+ cl::cat(MachOCat));
static cl::opt<std::string> DSYMFile("dsym",
- cl::desc("Use .dSYM file for debug info"));
+ cl::desc("Use .dSYM file for debug info"),
+ cl::cat(MachOCat));
static cl::opt<bool> FullLeadingAddr("full-leading-addr",
- cl::desc("Print full leading address"));
+ cl::desc("Print full leading address"),
+ cl::cat(MachOCat));
static cl::opt<bool> NoLeadingHeaders("no-leading-headers",
- cl::desc("Print no leading headers"));
+ cl::desc("Print no leading headers"),
+ cl::cat(MachOCat));
-cl::opt<bool> llvm::UniversalHeaders("universal-headers",
- cl::desc("Print Mach-O universal headers "
- "(requires -macho)"));
+cl::opt<bool> UniversalHeaders("universal-headers",
+ cl::desc("Print Mach-O universal headers "
+ "(requires -macho)"),
+ cl::cat(MachOCat));
cl::opt<bool>
ArchiveMemberOffsets("archive-member-offsets",
cl::desc("Print the offset to each archive member for "
"Mach-O archives (requires -macho and "
- "-archive-headers)"));
-
-cl::opt<bool>
- llvm::IndirectSymbols("indirect-symbols",
- cl::desc("Print indirect symbol table for Mach-O "
- "objects (requires -macho)"));
+ "-archive-headers)"),
+ cl::cat(MachOCat));
-cl::opt<bool>
- llvm::DataInCode("data-in-code",
- cl::desc("Print the data in code table for Mach-O objects "
- "(requires -macho)"));
-
-cl::opt<bool>
- llvm::LinkOptHints("link-opt-hints",
- cl::desc("Print the linker optimization hints for "
- "Mach-O objects (requires -macho)"));
-
-cl::opt<bool>
- llvm::InfoPlist("info-plist",
- cl::desc("Print the info plist section as strings for "
- "Mach-O objects (requires -macho)"));
+cl::opt<bool> IndirectSymbols("indirect-symbols",
+ cl::desc("Print indirect symbol table for Mach-O "
+ "objects (requires -macho)"),
+ cl::cat(MachOCat));
cl::opt<bool>
- llvm::DylibsUsed("dylibs-used",
- cl::desc("Print the shared libraries used for linked "
- "Mach-O files (requires -macho)"));
+ DataInCode("data-in-code",
+ cl::desc("Print the data in code table for Mach-O objects "
+ "(requires -macho)"),
+ cl::cat(MachOCat));
+
+cl::opt<bool> LinkOptHints("link-opt-hints",
+ cl::desc("Print the linker optimization hints for "
+ "Mach-O objects (requires -macho)"),
+ cl::cat(MachOCat));
+
+cl::opt<bool> InfoPlist("info-plist",
+ cl::desc("Print the info plist section as strings for "
+ "Mach-O objects (requires -macho)"),
+ cl::cat(MachOCat));
+
+cl::opt<bool> DylibsUsed("dylibs-used",
+ cl::desc("Print the shared libraries used for linked "
+ "Mach-O files (requires -macho)"),
+ cl::cat(MachOCat));
cl::opt<bool>
- llvm::DylibId("dylib-id",
- cl::desc("Print the shared library's id for the dylib Mach-O "
- "file (requires -macho)"));
+ DylibId("dylib-id",
+ cl::desc("Print the shared library's id for the dylib Mach-O "
+ "file (requires -macho)"),
+ cl::cat(MachOCat));
cl::opt<bool>
- llvm::NonVerbose("non-verbose",
- cl::desc("Print the info for Mach-O objects in "
- "non-verbose or numeric form (requires -macho)"));
+ NonVerbose("non-verbose",
+ cl::desc("Print the info for Mach-O objects in "
+ "non-verbose or numeric form (requires -macho)"),
+ cl::cat(MachOCat));
cl::opt<bool>
- llvm::ObjcMetaData("objc-meta-data",
- cl::desc("Print the Objective-C runtime meta data for "
- "Mach-O files (requires -macho)"));
+ ObjcMetaData("objc-meta-data",
+ cl::desc("Print the Objective-C runtime meta data for "
+ "Mach-O files (requires -macho)"),
+ cl::cat(MachOCat));
-cl::opt<std::string> llvm::DisSymName(
+cl::opt<std::string> DisSymName(
"dis-symname",
- cl::desc("disassemble just this symbol's instructions (requires -macho)"));
+ cl::desc("disassemble just this symbol's instructions (requires -macho)"),
+ cl::cat(MachOCat));
static cl::opt<bool> NoSymbolicOperands(
"no-symbolic-operands",
- cl::desc("do not symbolic operands when disassembling (requires -macho)"));
+ cl::desc("do not symbolic operands when disassembling (requires -macho)"),
+ cl::cat(MachOCat));
static cl::list<std::string>
ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
- cl::ZeroOrMore);
+ cl::ZeroOrMore, cl::cat(MachOCat));
bool ArchAll = false;
@@ -142,7 +198,7 @@ static const Target *GetTarget(const MachOObjectFile *MachOObj,
const char **McpuDefault,
const Target **ThumbTarget) {
// Figure out the target triple.
- llvm::Triple TT(TripleName);
+ Triple TT(TripleName);
if (TripleName.empty()) {
TT = MachOObj->getArchTriple(McpuDefault);
TripleName = TT.str();
@@ -151,7 +207,7 @@ static const Target *GetTarget(const MachOObjectFile *MachOObj,
if (TT.getArch() == Triple::arm) {
// We've inferred a 32-bit ARM target from the object file. All MachO CPUs
// that support ARM are also capable of Thumb mode.
- llvm::Triple ThumbTriple = TT;
+ Triple ThumbTriple = TT;
std::string ThumbName = (Twine("thumb") + TT.getArchName().substr(3)).str();
ThumbTriple.setArchName(ThumbName);
ThumbTripleName = ThumbTriple.str();
@@ -180,11 +236,11 @@ struct SymbolSorter {
bool operator()(const SymbolRef &A, const SymbolRef &B) {
Expected<SymbolRef::Type> ATypeOrErr = A.getType();
if (!ATypeOrErr)
- report_error(A.getObject()->getFileName(), ATypeOrErr.takeError());
+ report_error(ATypeOrErr.takeError(), A.getObject()->getFileName());
SymbolRef::Type AType = *ATypeOrErr;
Expected<SymbolRef::Type> BTypeOrErr = B.getType();
if (!BTypeOrErr)
- report_error(B.getObject()->getFileName(), BTypeOrErr.takeError());
+ report_error(BTypeOrErr.takeError(), B.getObject()->getFileName());
SymbolRef::Type BType = *BTypeOrErr;
uint64_t AAddr = (AType != SymbolRef::ST_Function) ? 0 : A.getValue();
uint64_t BAddr = (BType != SymbolRef::ST_Function) ? 0 : B.getValue();
@@ -308,11 +364,10 @@ static void getSectionsAndSymbols(MachOObjectFile *MachOObj,
std::vector<SymbolRef> &Symbols,
SmallVectorImpl<uint64_t> &FoundFns,
uint64_t &BaseSegmentAddress) {
+ const StringRef FileName = MachOObj->getFileName();
for (const SymbolRef &Symbol : MachOObj->symbols()) {
- Expected<StringRef> SymName = Symbol.getName();
- if (!SymName)
- report_error(MachOObj->getFileName(), SymName.takeError());
- if (!SymName->startswith("ltmp"))
+ StringRef SymName = unwrapOrError(Symbol.getName(), FileName);
+ if (!SymName.startswith("ltmp"))
Symbols.push_back(Symbol);
}
@@ -342,6 +397,254 @@ static void getSectionsAndSymbols(MachOObjectFile *MachOObj,
}
}
+static void printRelocationTargetName(const MachOObjectFile *O,
+ const MachO::any_relocation_info &RE,
+ raw_string_ostream &Fmt) {
+ // Target of a scattered relocation is an address. In the interest of
+ // generating pretty output, scan through the symbol table looking for a
+ // symbol that aligns with that address. If we find one, print it.
+ // Otherwise, we just print the hex address of the target.
+ const StringRef FileName = O->getFileName();
+ if (O->isRelocationScattered(RE)) {
+ uint32_t Val = O->getPlainRelocationSymbolNum(RE);
+
+ for (const SymbolRef &Symbol : O->symbols()) {
+ uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName);
+ if (Addr != Val)
+ continue;
+ Fmt << unwrapOrError(Symbol.getName(), FileName);
+ return;
+ }
+
+ // If we couldn't find a symbol that this relocation refers to, try
+ // to find a section beginning instead.
+ for (const SectionRef &Section : ToolSectionFilter(*O)) {
+ StringRef Name;
+ uint64_t Addr = Section.getAddress();
+ if (Addr != Val)
+ continue;
+ if (std::error_code EC = Section.getName(Name))
+ report_error(errorCodeToError(EC), O->getFileName());
+ Fmt << Name;
+ return;
+ }
+
+ Fmt << format("0x%x", Val);
+ return;
+ }
+
+ StringRef S;
+ bool isExtern = O->getPlainRelocationExternal(RE);
+ uint64_t Val = O->getPlainRelocationSymbolNum(RE);
+
+ if (O->getAnyRelocationType(RE) == MachO::ARM64_RELOC_ADDEND) {
+ Fmt << format("0x%0" PRIx64, Val);
+ return;
+ }
+
+ if (isExtern) {
+ symbol_iterator SI = O->symbol_begin();
+ advance(SI, Val);
+ S = unwrapOrError(SI->getName(), FileName);
+ } else {
+ section_iterator SI = O->section_begin();
+ // Adjust for the fact that sections are 1-indexed.
+ if (Val == 0) {
+ Fmt << "0 (?,?)";
+ return;
+ }
+ uint32_t I = Val - 1;
+ while (I != 0 && SI != O->section_end()) {
+ --I;
+ advance(SI, 1);
+ }
+ if (SI == O->section_end())
+ Fmt << Val << " (?,?)";
+ else
+ SI->getName(S);
+ }
+
+ Fmt << S;
+}
+
+Error getMachORelocationValueString(const MachOObjectFile *Obj,
+ const RelocationRef &RelRef,
+ SmallVectorImpl<char> &Result) {
+ DataRefImpl Rel = RelRef.getRawDataRefImpl();
+ MachO::any_relocation_info RE = Obj->getRelocation(Rel);
+
+ unsigned Arch = Obj->getArch();
+
+ std::string FmtBuf;
+ raw_string_ostream Fmt(FmtBuf);
+ unsigned Type = Obj->getAnyRelocationType(RE);
+ bool IsPCRel = Obj->getAnyRelocationPCRel(RE);
+
+ // Determine any addends that should be displayed with the relocation.
+ // These require decoding the relocation type, which is triple-specific.
+
+ // X86_64 has entirely custom relocation types.
+ if (Arch == Triple::x86_64) {
+ switch (Type) {
+ case MachO::X86_64_RELOC_GOT_LOAD:
+ case MachO::X86_64_RELOC_GOT: {
+ printRelocationTargetName(Obj, RE, Fmt);
+ Fmt << "@GOT";
+ if (IsPCRel)
+ Fmt << "PCREL";
+ break;
+ }
+ case MachO::X86_64_RELOC_SUBTRACTOR: {
+ DataRefImpl RelNext = Rel;
+ Obj->moveRelocationNext(RelNext);
+ MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
+
+ // X86_64_RELOC_SUBTRACTOR must be followed by a relocation of type
+ // X86_64_RELOC_UNSIGNED.
+ // NOTE: Scattered relocations don't exist on x86_64.
+ unsigned RType = Obj->getAnyRelocationType(RENext);
+ if (RType != MachO::X86_64_RELOC_UNSIGNED)
+ report_error(Obj->getFileName(), "Expected X86_64_RELOC_UNSIGNED after "
+ "X86_64_RELOC_SUBTRACTOR.");
+
+ // The X86_64_RELOC_UNSIGNED contains the minuend symbol;
+ // X86_64_RELOC_SUBTRACTOR contains the subtrahend.
+ printRelocationTargetName(Obj, RENext, Fmt);
+ Fmt << "-";
+ printRelocationTargetName(Obj, RE, Fmt);
+ break;
+ }
+ case MachO::X86_64_RELOC_TLV:
+ printRelocationTargetName(Obj, RE, Fmt);
+ Fmt << "@TLV";
+ if (IsPCRel)
+ Fmt << "P";
+ break;
+ case MachO::X86_64_RELOC_SIGNED_1:
+ printRelocationTargetName(Obj, RE, Fmt);
+ Fmt << "-1";
+ break;
+ case MachO::X86_64_RELOC_SIGNED_2:
+ printRelocationTargetName(Obj, RE, Fmt);
+ Fmt << "-2";
+ break;
+ case MachO::X86_64_RELOC_SIGNED_4:
+ printRelocationTargetName(Obj, RE, Fmt);
+ Fmt << "-4";
+ break;
+ default:
+ printRelocationTargetName(Obj, RE, Fmt);
+ break;
+ }
+ // X86 and ARM share some relocation types in common.
+ } else if (Arch == Triple::x86 || Arch == Triple::arm ||
+ Arch == Triple::ppc) {
+ // Generic relocation types...
+ switch (Type) {
+ case MachO::GENERIC_RELOC_PAIR: // prints no info
+ return Error::success();
+ case MachO::GENERIC_RELOC_SECTDIFF: {
+ DataRefImpl RelNext = Rel;
+ Obj->moveRelocationNext(RelNext);
+ MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
+
+ // X86 sect diff's must be followed by a relocation of type
+ // GENERIC_RELOC_PAIR.
+ unsigned RType = Obj->getAnyRelocationType(RENext);
+
+ if (RType != MachO::GENERIC_RELOC_PAIR)
+ report_error(Obj->getFileName(), "Expected GENERIC_RELOC_PAIR after "
+ "GENERIC_RELOC_SECTDIFF.");
+
+ printRelocationTargetName(Obj, RE, Fmt);
+ Fmt << "-";
+ printRelocationTargetName(Obj, RENext, Fmt);
+ break;
+ }
+ }
+
+ if (Arch == Triple::x86 || Arch == Triple::ppc) {
+ switch (Type) {
+ case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
+ DataRefImpl RelNext = Rel;
+ Obj->moveRelocationNext(RelNext);
+ MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
+
+ // X86 sect diff's must be followed by a relocation of type
+ // GENERIC_RELOC_PAIR.
+ unsigned RType = Obj->getAnyRelocationType(RENext);
+ if (RType != MachO::GENERIC_RELOC_PAIR)
+ report_error(Obj->getFileName(), "Expected GENERIC_RELOC_PAIR after "
+ "GENERIC_RELOC_LOCAL_SECTDIFF.");
+
+ printRelocationTargetName(Obj, RE, Fmt);
+ Fmt << "-";
+ printRelocationTargetName(Obj, RENext, Fmt);
+ break;
+ }
+ case MachO::GENERIC_RELOC_TLV: {
+ printRelocationTargetName(Obj, RE, Fmt);
+ Fmt << "@TLV";
+ if (IsPCRel)
+ Fmt << "P";
+ break;
+ }
+ default:
+ printRelocationTargetName(Obj, RE, Fmt);
+ }
+ } else { // ARM-specific relocations
+ switch (Type) {
+ case MachO::ARM_RELOC_HALF:
+ case MachO::ARM_RELOC_HALF_SECTDIFF: {
+ // Half relocations steal a bit from the length field to encode
+ // whether this is an upper16 or a lower16 relocation.
+ bool isUpper = (Obj->getAnyRelocationLength(RE) & 0x1) == 1;
+
+ if (isUpper)
+ Fmt << ":upper16:(";
+ else
+ Fmt << ":lower16:(";
+ printRelocationTargetName(Obj, RE, Fmt);
+
+ DataRefImpl RelNext = Rel;
+ Obj->moveRelocationNext(RelNext);
+ MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
+
+ // ARM half relocs must be followed by a relocation of type
+ // ARM_RELOC_PAIR.
+ unsigned RType = Obj->getAnyRelocationType(RENext);
+ if (RType != MachO::ARM_RELOC_PAIR)
+ report_error(Obj->getFileName(), "Expected ARM_RELOC_PAIR after "
+ "ARM_RELOC_HALF");
+
+ // NOTE: The half of the target virtual address is stashed in the
+ // address field of the secondary relocation, but we can't reverse
+ // engineer the constant offset from it without decoding the movw/movt
+ // instruction to find the other half in its immediate field.
+
+ // ARM_RELOC_HALF_SECTDIFF encodes the second section in the
+ // symbol/section pointer of the follow-on relocation.
+ if (Type == MachO::ARM_RELOC_HALF_SECTDIFF) {
+ Fmt << "-";
+ printRelocationTargetName(Obj, RENext, Fmt);
+ }
+
+ Fmt << ")";
+ break;
+ }
+ default: {
+ printRelocationTargetName(Obj, RE, Fmt);
+ }
+ }
+ }
+ } else
+ printRelocationTargetName(Obj, RE, Fmt);
+
+ Fmt.flush();
+ Result.append(FmtBuf.begin(), FmtBuf.end());
+ return Error::success();
+}
+
static void PrintIndirectSymbolTable(MachOObjectFile *O, bool verbose,
uint32_t n, uint32_t count,
uint32_t stride, uint64_t addr) {
@@ -389,10 +692,7 @@ static void PrintIndirectSymbolTable(MachOObjectFile *O, bool verbose,
if (indirect_symbol < Symtab.nsyms) {
symbol_iterator Sym = O->getSymbolByIndex(indirect_symbol);
SymbolRef Symbol = *Sym;
- Expected<StringRef> SymName = Symbol.getName();
- if (!SymName)
- report_error(O->getFileName(), SymName.takeError());
- outs() << *SymName;
+ outs() << unwrapOrError(Symbol.getName(), O->getFileName());
} else {
outs() << "?";
}
@@ -500,6 +800,7 @@ static void PrintRType(const uint64_t cputype, const unsigned r_type) {
outs() << arm_r_types[r_type];
break;
case MachO::CPU_TYPE_ARM64:
+ case MachO::CPU_TYPE_ARM64_32:
outs() << arm64_r_types[r_type];
break;
default:
@@ -510,9 +811,8 @@ static void PrintRType(const uint64_t cputype, const unsigned r_type) {
static void PrintRLength(const uint64_t cputype, const unsigned r_type,
const unsigned r_length, const bool previous_arm_half){
if (cputype == MachO::CPU_TYPE_ARM &&
- (r_type == llvm::MachO::ARM_RELOC_HALF ||
- r_type == llvm::MachO::ARM_RELOC_HALF_SECTDIFF ||
- previous_arm_half == true)) {
+ (r_type == MachO::ARM_RELOC_HALF ||
+ r_type == MachO::ARM_RELOC_HALF_SECTDIFF || previous_arm_half == true)) {
if ((r_length & 0x1) == 0)
outs() << "lo/";
else
@@ -573,9 +873,8 @@ static void PrintRelocationEntries(const MachOObjectFile *O,
if (verbose) {
// scattered: address
if ((cputype == MachO::CPU_TYPE_I386 &&
- r_type == llvm::MachO::GENERIC_RELOC_PAIR) ||
- (cputype == MachO::CPU_TYPE_ARM &&
- r_type == llvm::MachO::ARM_RELOC_PAIR))
+ r_type == MachO::GENERIC_RELOC_PAIR) ||
+ (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR))
outs() << " ";
else
outs() << format("%08x ", (unsigned int)r_address);
@@ -597,29 +896,27 @@ static void PrintRelocationEntries(const MachOObjectFile *O,
outs() << format("True 0x%08x", (unsigned int)r_value);
if (previous_sectdiff == false) {
if ((cputype == MachO::CPU_TYPE_ARM &&
- r_type == llvm::MachO::ARM_RELOC_PAIR))
+ r_type == MachO::ARM_RELOC_PAIR))
outs() << format(" half = 0x%04x ", (unsigned int)r_address);
- }
- else if (cputype == MachO::CPU_TYPE_ARM &&
- sectdiff_r_type == llvm::MachO::ARM_RELOC_HALF_SECTDIFF)
+ } else if (cputype == MachO::CPU_TYPE_ARM &&
+ sectdiff_r_type == MachO::ARM_RELOC_HALF_SECTDIFF)
outs() << format(" other_half = 0x%04x ", (unsigned int)r_address);
if ((cputype == MachO::CPU_TYPE_I386 &&
- (r_type == llvm::MachO::GENERIC_RELOC_SECTDIFF ||
- r_type == llvm::MachO::GENERIC_RELOC_LOCAL_SECTDIFF)) ||
+ (r_type == MachO::GENERIC_RELOC_SECTDIFF ||
+ r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)) ||
(cputype == MachO::CPU_TYPE_ARM &&
- (sectdiff_r_type == llvm::MachO::ARM_RELOC_SECTDIFF ||
- sectdiff_r_type == llvm::MachO::ARM_RELOC_LOCAL_SECTDIFF ||
- sectdiff_r_type == llvm::MachO::ARM_RELOC_HALF_SECTDIFF))) {
- previous_sectdiff = true;
- sectdiff_r_type = r_type;
- }
- else {
+ (sectdiff_r_type == MachO::ARM_RELOC_SECTDIFF ||
+ sectdiff_r_type == MachO::ARM_RELOC_LOCAL_SECTDIFF ||
+ sectdiff_r_type == MachO::ARM_RELOC_HALF_SECTDIFF))) {
+ previous_sectdiff = true;
+ sectdiff_r_type = r_type;
+ } else {
previous_sectdiff = false;
sectdiff_r_type = 0;
}
if (cputype == MachO::CPU_TYPE_ARM &&
- (r_type == llvm::MachO::ARM_RELOC_HALF ||
- r_type == llvm::MachO::ARM_RELOC_HALF_SECTDIFF))
+ (r_type == MachO::ARM_RELOC_HALF ||
+ r_type == MachO::ARM_RELOC_HALF_SECTDIFF))
previous_arm_half = true;
else
previous_arm_half = false;
@@ -635,8 +932,7 @@ static void PrintRelocationEntries(const MachOObjectFile *O,
else {
if (verbose) {
// plain: address
- if (cputype == MachO::CPU_TYPE_ARM &&
- r_type == llvm::MachO::ARM_RELOC_PAIR)
+ if (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR)
outs() << " ";
else
outs() << format("%08x ", (unsigned int)r_address);
@@ -678,28 +974,27 @@ static void PrintRelocationEntries(const MachOObjectFile *O,
outs() << "False ";
// plain: symbolnum/value
- if (cputype == MachO::CPU_TYPE_ARM &&
- r_type == llvm::MachO::ARM_RELOC_PAIR)
+ if (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR)
outs() << format("other_half = 0x%04x\n", (unsigned int)r_address);
- else if (cputype == MachO::CPU_TYPE_ARM64 &&
- r_type == llvm::MachO::ARM64_RELOC_ADDEND)
+ else if ((cputype == MachO::CPU_TYPE_ARM64 ||
+ cputype == MachO::CPU_TYPE_ARM64_32) &&
+ r_type == MachO::ARM64_RELOC_ADDEND)
outs() << format("addend = 0x%06x\n", (unsigned int)r_symbolnum);
else {
outs() << format("%d ", r_symbolnum);
- if (r_symbolnum == llvm::MachO::R_ABS)
+ if (r_symbolnum == MachO::R_ABS)
outs() << "R_ABS\n";
else {
// in this case, r_symbolnum is actually a 1-based section number
uint32_t nsects = O->section_end()->getRawDataRefImpl().d.a;
if (r_symbolnum > 0 && r_symbolnum <= nsects) {
- llvm::object::DataRefImpl DRI;
+ object::DataRefImpl DRI;
DRI.d.a = r_symbolnum-1;
StringRef SegName = O->getSectionFinalSegmentName(DRI);
- StringRef SectName;
- if (O->getSectionName(DRI, SectName))
- outs() << "(?,?)\n";
+ if (Expected<StringRef> NameOrErr = O->getSectionName(DRI))
+ outs() << "(" << SegName << "," << *NameOrErr << ")\n";
else
- outs() << "(" << SegName << "," << SectName << ")\n";
+ outs() << "(?,?)\n";
}
else {
outs() << "(?,?)\n";
@@ -708,8 +1003,8 @@ static void PrintRelocationEntries(const MachOObjectFile *O,
}
}
if (cputype == MachO::CPU_TYPE_ARM &&
- (r_type == llvm::MachO::ARM_RELOC_HALF ||
- r_type == llvm::MachO::ARM_RELOC_HALF_SECTDIFF))
+ (r_type == MachO::ARM_RELOC_HALF ||
+ r_type == MachO::ARM_RELOC_HALF_SECTDIFF))
previous_arm_half = true;
else
previous_arm_half = false;
@@ -752,13 +1047,12 @@ static void PrintRelocations(const MachOObjectFile *O, const bool verbose) {
DataRefImpl DRI;
DRI.d.a = J;
const StringRef SegName = O->getSectionFinalSegmentName(DRI);
- StringRef SectName;
- if (O->getSectionName(DRI, SectName))
+ if (Expected<StringRef> NameOrErr = O->getSectionName(DRI))
+ outs() << "Relocation information (" << SegName << "," << *NameOrErr
+ << format(") %u entries", Sec.nreloc);
+ else
outs() << "Relocation information (" << SegName << ",?) "
<< format("%u entries", Sec.nreloc);
- else
- outs() << "Relocation information (" << SegName << ","
- << SectName << format(") %u entries", Sec.nreloc);
outs() << "\naddress pcrel length extern type scattered "
"symbolnum/value\n";
PrintRelocationEntries(O, O->section_rel_begin(DRI),
@@ -773,13 +1067,12 @@ static void PrintRelocations(const MachOObjectFile *O, const bool verbose) {
DataRefImpl DRI;
DRI.d.a = J;
const StringRef SegName = O->getSectionFinalSegmentName(DRI);
- StringRef SectName;
- if (O->getSectionName(DRI, SectName))
+ if (Expected<StringRef> NameOrErr = O->getSectionName(DRI))
+ outs() << "Relocation information (" << SegName << "," << *NameOrErr
+ << format(") %u entries", Sec.nreloc);
+ else
outs() << "Relocation information (" << SegName << ",?) "
<< format("%u entries", Sec.nreloc);
- else
- outs() << "Relocation information (" << SegName << ","
- << SectName << format(") %u entries", Sec.nreloc);
outs() << "\naddress pcrel length extern type scattered "
"symbolnum/value\n";
PrintRelocationEntries(O, O->section_rel_begin(DRI),
@@ -913,7 +1206,16 @@ static void PrintDylibs(MachOObjectFile *O, bool JustId) {
outs() << " current version "
<< ((dl.dylib.current_version >> 16) & 0xffff) << "."
<< ((dl.dylib.current_version >> 8) & 0xff) << "."
- << (dl.dylib.current_version & 0xff) << ")\n";
+ << (dl.dylib.current_version & 0xff);
+ if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB)
+ outs() << ", weak";
+ if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB)
+ outs() << ", reexport";
+ if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB)
+ outs() << ", upward";
+ if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB)
+ outs() << ", lazy";
+ outs() << ")\n";
}
} else {
outs() << "\tBad offset (" << dl.dylib.name << ") for name of ";
@@ -942,18 +1244,13 @@ typedef DenseMap<uint64_t, StringRef> SymbolAddressMap;
static void CreateSymbolAddressMap(MachOObjectFile *O,
SymbolAddressMap *AddrMap) {
// Create a map of symbol addresses to symbol names.
+ const StringRef FileName = O->getFileName();
for (const SymbolRef &Symbol : O->symbols()) {
- Expected<SymbolRef::Type> STOrErr = Symbol.getType();
- if (!STOrErr)
- report_error(O->getFileName(), STOrErr.takeError());
- SymbolRef::Type ST = *STOrErr;
+ SymbolRef::Type ST = unwrapOrError(Symbol.getType(), FileName);
if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
ST == SymbolRef::ST_Other) {
uint64_t Address = Symbol.getValue();
- Expected<StringRef> SymNameOrErr = Symbol.getName();
- if (!SymNameOrErr)
- report_error(O->getFileName(), SymNameOrErr.takeError());
- StringRef SymName = *SymNameOrErr;
+ StringRef SymName = unwrapOrError(Symbol.getName(), FileName);
if (!SymName.startswith(".objc"))
(*AddrMap)[Address] = SymName;
}
@@ -1186,10 +1483,8 @@ static void DumpLiteralPointerSection(MachOObjectFile *O,
});
if (Reloc != Relocs.end()) {
symbol_iterator RelocSym = Reloc->second;
- Expected<StringRef> SymName = RelocSym->getName();
- if (!SymName)
- report_error(O->getFileName(), SymName.takeError());
- outs() << "external relocation entry for symbol:" << *SymName << "\n";
+ StringRef SymName = unwrapOrError(RelocSym->getName(), O->getFileName());
+ outs() << "external relocation entry for symbol:" << SymName << "\n";
continue;
}
@@ -1220,8 +1515,8 @@ static void DumpLiteralPointerSection(MachOObjectFile *O,
section_type = Sec.flags & MachO::SECTION_TYPE;
}
- StringRef BytesStr;
- Sect->getContents(BytesStr);
+ StringRef BytesStr = unwrapOrError(Sect->getContents(), O->getFileName());
+
const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
switch (section_type) {
@@ -1333,10 +1628,7 @@ static void DumpInitTermPointerSection(MachOObjectFile *O,
});
if (Reloc != Relocs.end()) {
symbol_iterator RelocSym = Reloc->second;
- Expected<StringRef> SymName = RelocSym->getName();
- if (!SymName)
- report_error(O->getFileName(), SymName.takeError());
- outs() << " " << *SymName;
+ outs() << " " << unwrapOrError(RelocSym->getName(), O->getFileName());
} else {
SymbolName = GuessSymbolName(p, AddrMap);
if (SymbolName)
@@ -1438,8 +1730,8 @@ static void DumpSectionContents(StringRef Filename, MachOObjectFile *O,
}
uint32_t section_type = section_flags & MachO::SECTION_TYPE;
- StringRef BytesStr;
- Section.getContents(BytesStr);
+ StringRef BytesStr =
+ unwrapOrError(Section.getContents(), O->getFileName());
const char *sect = reinterpret_cast<const char *>(BytesStr.data());
uint32_t sect_size = BytesStr.size();
uint64_t sect_addr = Section.getAddress();
@@ -1523,8 +1815,8 @@ static void DumpInfoPlistSectionContents(StringRef Filename,
if (SegName == "__TEXT" && SectName == "__info_plist") {
if (!NoLeadingHeaders)
outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
- StringRef BytesStr;
- Section.getContents(BytesStr);
+ StringRef BytesStr =
+ unwrapOrError(Section.getContents(), O->getFileName());
const char *sect = reinterpret_cast<const char *>(BytesStr.data());
outs() << format("%.*s", BytesStr.size(), sect) << "\n";
return;
@@ -1609,8 +1901,8 @@ static void ProcessMachO(StringRef Name, MachOObjectFile *MachOOF,
// the error message.
if (Disassemble || IndirectSymbols || !FilterSections.empty() || UnwindInfo)
if (Error Err = MachOOF->checkSymbolTable())
- report_error(ArchiveName, FileName, std::move(Err), ArchitectureName);
-
+ report_error(std::move(Err), ArchiveName, FileName, ArchitectureName);
+
if (DisassembleAll) {
for (const SectionRef &Section : MachOOF->sections()) {
StringRef SectName;
@@ -1774,6 +2066,21 @@ static void printCPUType(uint32_t cputype, uint32_t cpusubtype) {
outs() << " cputype CPU_TYPE_ARM64\n";
outs() << " cpusubtype CPU_SUBTYPE_ARM64_ALL\n";
break;
+ case MachO::CPU_SUBTYPE_ARM64E:
+ outs() << " cputype CPU_TYPE_ARM64\n";
+ outs() << " cpusubtype CPU_SUBTYPE_ARM64E\n";
+ break;
+ default:
+ printUnknownCPUType(cputype, cpusubtype);
+ break;
+ }
+ break;
+ case MachO::CPU_TYPE_ARM64_32:
+ switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
+ case MachO::CPU_SUBTYPE_ARM64_32_V8:
+ outs() << " cputype CPU_TYPE_ARM64_32\n";
+ outs() << " cpusubtype CPU_SUBTYPE_ARM64_32_V8\n";
+ break;
default:
printUnknownCPUType(cputype, cpusubtype);
break;
@@ -1862,10 +2169,8 @@ static void printArchiveChild(StringRef Filename, const Archive::Child &C,
StringRef ArchitectureName = StringRef()) {
if (print_offset)
outs() << C.getChildOffset() << "\t";
- Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();
- if (!ModeOrErr)
- report_error(Filename, C, ModeOrErr.takeError(), ArchitectureName);
- sys::fs::perms Mode = ModeOrErr.get();
+ sys::fs::perms Mode =
+ unwrapOrError(C.getAccessMode(), Filename, C, ArchitectureName);
if (verbose) {
// FIXME: this first dash, "-", is for (Mode & S_IFMT) == S_IFREG.
// But there is nothing in sys::fs::perms for S_IFMT or S_IFREG.
@@ -1883,20 +2188,11 @@ static void printArchiveChild(StringRef Filename, const Archive::Child &C,
outs() << format("0%o ", Mode);
}
- Expected<unsigned> UIDOrErr = C.getUID();
- if (!UIDOrErr)
- report_error(Filename, C, UIDOrErr.takeError(), ArchitectureName);
- unsigned UID = UIDOrErr.get();
- outs() << format("%3d/", UID);
- Expected<unsigned> GIDOrErr = C.getGID();
- if (!GIDOrErr)
- report_error(Filename, C, GIDOrErr.takeError(), ArchitectureName);
- unsigned GID = GIDOrErr.get();
- outs() << format("%-3d ", GID);
- Expected<uint64_t> Size = C.getRawSize();
- if (!Size)
- report_error(Filename, C, Size.takeError(), ArchitectureName);
- outs() << format("%5" PRId64, Size.get()) << " ";
+ outs() << format(
+ "%3d/%-3d %5" PRId64 " ",
+ unwrapOrError(C.getUID(), Filename, C, ArchitectureName),
+ unwrapOrError(C.getGID(), Filename, C, ArchitectureName),
+ unwrapOrError(C.getRawSize(), Filename, C, ArchitectureName));
StringRef RawLastModified = C.getRawLastModified();
if (verbose) {
@@ -1919,21 +2215,15 @@ static void printArchiveChild(StringRef Filename, const Archive::Child &C,
Expected<StringRef> NameOrErr = C.getName();
if (!NameOrErr) {
consumeError(NameOrErr.takeError());
- Expected<StringRef> NameOrErr = C.getRawName();
- if (!NameOrErr)
- report_error(Filename, C, NameOrErr.takeError(), ArchitectureName);
- StringRef RawName = NameOrErr.get();
- outs() << RawName << "\n";
+ outs() << unwrapOrError(C.getRawName(), Filename, C, ArchitectureName)
+ << "\n";
} else {
StringRef Name = NameOrErr.get();
outs() << Name << "\n";
}
} else {
- Expected<StringRef> NameOrErr = C.getRawName();
- if (!NameOrErr)
- report_error(Filename, C, NameOrErr.takeError(), ArchitectureName);
- StringRef RawName = NameOrErr.get();
- outs() << RawName << "\n";
+ outs() << unwrapOrError(C.getRawName(), Filename, C, ArchitectureName)
+ << "\n";
}
}
@@ -1941,12 +2231,11 @@ static void printArchiveHeaders(StringRef Filename, Archive *A, bool verbose,
bool print_offset,
StringRef ArchitectureName = StringRef()) {
Error Err = Error::success();
- ;
for (const auto &C : A->children(Err, false))
printArchiveChild(Filename, C, verbose, print_offset, ArchitectureName);
if (Err)
- report_error(StringRef(), Filename, std::move(Err), ArchitectureName);
+ report_error(std::move(Err), StringRef(), Filename, ArchitectureName);
}
static bool ValidateArchFlags() {
@@ -1970,15 +2259,15 @@ static bool ValidateArchFlags() {
// -arch flags selecting just those slices as specified by them and also parses
// archive files. Then for each individual Mach-O file ProcessMachO() is
// called to process the file based on the command line options.
-void llvm::parseInputMachO(StringRef Filename) {
+void parseInputMachO(StringRef Filename) {
if (!ValidateArchFlags())
return;
// Attempt to open the binary.
Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(Filename);
if (!BinaryOrErr) {
- if (auto E = isNotObjectErrorInvalidFileType(BinaryOrErr.takeError()))
- report_error(Filename, std::move(E));
+ if (Error E = isNotObjectErrorInvalidFileType(BinaryOrErr.takeError()))
+ report_error(std::move(E), Filename);
else
outs() << Filename << ": is not an object file\n";
return;
@@ -1994,8 +2283,8 @@ void llvm::parseInputMachO(StringRef Filename) {
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
- if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
- report_error(Filename, C, std::move(E));
+ if (Error E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
+ report_error(std::move(E), Filename, C);
continue;
}
if (MachOObjectFile *O = dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) {
@@ -2005,7 +2294,7 @@ void llvm::parseInputMachO(StringRef Filename) {
}
}
if (Err)
- report_error(Filename, std::move(Err));
+ report_error(std::move(Err), Filename);
return;
}
if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) {
@@ -2026,7 +2315,7 @@ void llvm::parseInputMachO(StringRef Filename) {
llvm_unreachable("Input object can't be invalid at this point");
}
-void llvm::parseInputMachO(MachOUniversalBinary *UB) {
+void parseInputMachO(MachOUniversalBinary *UB) {
if (!ValidateArchFlags())
return;
@@ -2055,13 +2344,12 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
ObjectFile &O = *ObjOrErr.get();
if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O))
ProcessMachO(Filename, MachOOF, "", ArchitectureName);
- } else if (auto E = isNotObjectErrorInvalidFileType(
- ObjOrErr.takeError())) {
- report_error(Filename, StringRef(), std::move(E),
- ArchitectureName);
+ } else if (Error E = isNotObjectErrorInvalidFileType(
+ ObjOrErr.takeError())) {
+ report_error(std::move(E), Filename, StringRef(), ArchitectureName);
continue;
} else if (Expected<std::unique_ptr<Archive>> AOrErr =
- I->getAsArchive()) {
+ I->getAsArchive()) {
std::unique_ptr<Archive> &A = *AOrErr;
outs() << "Archive : " << Filename;
if (!ArchitectureName.empty())
@@ -2074,8 +2362,8 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
- if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
- report_error(Filename, C, std::move(E), ArchitectureName);
+ if (Error E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
+ report_error(std::move(E), Filename, C, ArchitectureName);
continue;
}
if (MachOObjectFile *O =
@@ -2083,7 +2371,7 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
ProcessMachO(Filename, O, O->getFileName(), ArchitectureName);
}
if (Err)
- report_error(Filename, std::move(Err));
+ report_error(std::move(Err), Filename);
} else {
consumeError(AOrErr.takeError());
error("Mach-O universal file: " + Filename + " for " +
@@ -2116,11 +2404,11 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
ObjectFile &O = *ObjOrErr.get();
if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O))
ProcessMachO(Filename, MachOOF);
- } else if (auto E = isNotObjectErrorInvalidFileType(
- ObjOrErr.takeError())) {
- report_error(Filename, std::move(E));
+ } else if (Error E =
+ isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) {
+ report_error(std::move(E), Filename);
} else if (Expected<std::unique_ptr<Archive>> AOrErr =
- I->getAsArchive()) {
+ I->getAsArchive()) {
std::unique_ptr<Archive> &A = *AOrErr;
outs() << "Archive : " << Filename << "\n";
if (ArchiveHeaders)
@@ -2130,8 +2418,9 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
- if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
- report_error(Filename, C, std::move(E));
+ if (Error E =
+ isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
+ report_error(std::move(E), Filename, C);
continue;
}
if (MachOObjectFile *O =
@@ -2139,7 +2428,7 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
ProcessMachO(Filename, O, O->getFileName());
}
if (Err)
- report_error(Filename, std::move(Err));
+ report_error(std::move(Err), Filename);
} else {
consumeError(AOrErr.takeError());
error("Mach-O universal file: " + Filename + " for architecture " +
@@ -2164,11 +2453,10 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
ObjectFile &Obj = *ObjOrErr.get();
if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&Obj))
ProcessMachO(Filename, MachOOF, "", ArchitectureName);
- } else if (auto E = isNotObjectErrorInvalidFileType(
- ObjOrErr.takeError())) {
- report_error(StringRef(), Filename, std::move(E), ArchitectureName);
- } else if (Expected<std::unique_ptr<Archive>> AOrErr =
- I->getAsArchive()) {
+ } else if (Error E =
+ isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) {
+ report_error(std::move(E), StringRef(), Filename, ArchitectureName);
+ } else if (Expected<std::unique_ptr<Archive>> AOrErr = I->getAsArchive()) {
std::unique_ptr<Archive> &A = *AOrErr;
outs() << "Archive : " << Filename;
if (!ArchitectureName.empty())
@@ -2181,8 +2469,8 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
- if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
- report_error(Filename, C, std::move(E), ArchitectureName);
+ if (Error E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
+ report_error(std::move(E), Filename, C, ArchitectureName);
continue;
}
if (MachOObjectFile *O =
@@ -2193,7 +2481,7 @@ void llvm::parseInputMachO(MachOUniversalBinary *UB) {
}
}
if (Err)
- report_error(Filename, std::move(Err));
+ report_error(std::move(Err), Filename);
} else {
consumeError(AOrErr.takeError());
error("Mach-O universal file: " + Filename + " for architecture " +
@@ -2308,12 +2596,9 @@ static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
}
}
if (reloc_found && isExtern) {
- Expected<StringRef> SymName = Symbol.getName();
- if (!SymName)
- report_error(info->O->getFileName(), SymName.takeError());
- const char *name = SymName->data();
op_info->AddSymbol.Present = 1;
- op_info->AddSymbol.Name = name;
+ op_info->AddSymbol.Name =
+ unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
// For i386 extern relocation entries the value in the instruction is
// the offset from the symbol, and value is already set in op_info->Value.
return 1;
@@ -2372,10 +2657,8 @@ static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
// is the offset from the external symbol.
if (info->O->getAnyRelocationPCRel(RE))
op_info->Value -= Pc + Offset + Size;
- Expected<StringRef> SymName = Symbol.getName();
- if (!SymName)
- report_error(info->O->getFileName(), SymName.takeError());
- const char *name = SymName->data();
+ const char *name =
+ unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
op_info->AddSymbol.Present = 1;
op_info->AddSymbol.Name = name;
return 1;
@@ -2412,10 +2695,8 @@ static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
// is the offset from the external symbol.
if (info->O->getAnyRelocationPCRel(RE))
op_info->Value -= Pc + Offset + Size;
- Expected<StringRef> SymName = Symbol.getName();
- if (!SymName)
- report_error(info->O->getFileName(), SymName.takeError());
- const char *name = SymName->data();
+ const char *name =
+ unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
unsigned Type = info->O->getAnyRelocationType(RE);
if (Type == MachO::X86_64_RELOC_SUBTRACTOR) {
DataRefImpl RelNext = Rel;
@@ -2429,10 +2710,7 @@ static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
op_info->SubtractSymbol.Name = name;
symbol_iterator RelocSymNext = info->O->getSymbolByIndex(SymbolNum);
Symbol = *RelocSymNext;
- Expected<StringRef> SymNameNext = Symbol.getName();
- if (!SymNameNext)
- report_error(info->O->getFileName(), SymNameNext.takeError());
- name = SymNameNext->data();
+ name = unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
}
}
// TODO: add the VariantKinds to op_info->VariantKind for relocation types
@@ -2501,10 +2779,8 @@ static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
}
if (isExtern) {
- Expected<StringRef> SymName = Symbol.getName();
- if (!SymName)
- report_error(info->O->getFileName(), SymName.takeError());
- const char *name = SymName->data();
+ const char *name =
+ unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
op_info->AddSymbol.Present = 1;
op_info->AddSymbol.Name = name;
switch (r_type) {
@@ -2620,10 +2896,9 @@ static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
// NOTE: Scattered relocations don't exist on arm64.
if (!info->O->getPlainRelocationExternal(RE))
return 0;
- Expected<StringRef> SymName = Reloc->getSymbol()->getName();
- if (!SymName)
- report_error(info->O->getFileName(), SymName.takeError());
- const char *name = SymName->data();
+ const char *name =
+ unwrapOrError(Reloc->getSymbol()->getName(), info->O->getFileName())
+ .data();
op_info->AddSymbol.Present = 1;
op_info->AddSymbol.Name = name;
@@ -2749,12 +3024,8 @@ static const char *GuessIndirectSymbol(uint64_t ReferenceValue,
info->O->getIndirectSymbolTableEntry(Dysymtab, index);
if (indirect_symbol < Symtab.nsyms) {
symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol);
- SymbolRef Symbol = *Sym;
- Expected<StringRef> SymName = Symbol.getName();
- if (!SymName)
- report_error(info->O->getFileName(), SymName.takeError());
- const char *name = SymName->data();
- return name;
+ return unwrapOrError(Sym->getName(), info->O->getFileName())
+ .data();
}
}
}
@@ -2784,12 +3055,8 @@ static const char *GuessIndirectSymbol(uint64_t ReferenceValue,
info->O->getIndirectSymbolTableEntry(Dysymtab, index);
if (indirect_symbol < Symtab.nsyms) {
symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol);
- SymbolRef Symbol = *Sym;
- Expected<StringRef> SymName = Symbol.getName();
- if (!SymName)
- report_error(info->O->getFileName(), SymName.takeError());
- const char *name = SymName->data();
- return name;
+ return unwrapOrError(Sym->getName(), info->O->getFileName())
+ .data();
}
}
}
@@ -2960,8 +3227,8 @@ static const char *get_pointer_64(uint64_t Address, uint32_t &offset,
S = (*(info->Sections))[SectIdx];
offset = Address - SectAddress;
left = SectSize - offset;
- StringRef SectContents;
- ((*(info->Sections))[SectIdx]).getContents(SectContents);
+ StringRef SectContents = unwrapOrError(
+ ((*(info->Sections))[SectIdx]).getContents(), info->O->getFileName());
return SectContents.data() + offset;
}
}
@@ -3015,10 +3282,7 @@ static const char *get_symbol_64(uint32_t sect_offset, SectionRef S,
const char *SymbolName = nullptr;
if (reloc_found && isExtern) {
n_value = Symbol.getValue();
- Expected<StringRef> NameOrError = Symbol.getName();
- if (!NameOrError)
- report_error(info->O->getFileName(), NameOrError.takeError());
- StringRef Name = *NameOrError;
+ StringRef Name = unwrapOrError(Symbol.getName(), info->O->getFileName());
if (!Name.empty()) {
SymbolName = Name.data();
return SymbolName;
@@ -3767,8 +4031,7 @@ walk_pointer_list_64(const char *listname, const SectionRef S,
StringRef SegName = O->getSectionFinalSegmentName(Ref);
outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
- StringRef BytesStr;
- S.getContents(BytesStr);
+ StringRef BytesStr = unwrapOrError(S.getContents(), O->getFileName());
const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint64_t)) {
@@ -3818,8 +4081,7 @@ walk_pointer_list_32(const char *listname, const SectionRef S,
StringRef SegName = O->getSectionFinalSegmentName(Ref);
outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
- StringRef BytesStr;
- S.getContents(BytesStr);
+ StringRef BytesStr = unwrapOrError(S.getContents(), O->getFileName());
const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint32_t)) {
@@ -6970,32 +7232,78 @@ static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
raw_ostream &DebugOut = nulls();
#endif
+ // Try to find debug info and set up the DIContext for it.
std::unique_ptr<DIContext> diContext;
- ObjectFile *DbgObj = MachOOF;
+ std::unique_ptr<Binary> DSYMBinary;
std::unique_ptr<MemoryBuffer> DSYMBuf;
- // Try to find debug info and set up the DIContext for it.
if (UseDbg) {
+ ObjectFile *DbgObj = MachOOF;
+
// A separate DSym file path was specified, parse it as a macho file,
// get the sections and supply it to the section name parsing machinery.
if (!DSYMFile.empty()) {
ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
MemoryBuffer::getFileOrSTDIN(DSYMFile);
if (std::error_code EC = BufOrErr.getError()) {
- report_error(DSYMFile, errorCodeToError(EC));
+ report_error(errorCodeToError(EC), DSYMFile);
return;
}
- Expected<std::unique_ptr<MachOObjectFile>> DbgObjCheck =
- ObjectFile::createMachOObjectFile(BufOrErr.get()->getMemBufferRef());
+ // We need to keep the file alive, because we're replacing DbgObj with it.
+ DSYMBuf = std::move(BufOrErr.get());
- if (Error E = DbgObjCheck.takeError()) {
- report_error(DSYMFile, std::move(E));
+ Expected<std::unique_ptr<Binary>> BinaryOrErr =
+ createBinary(DSYMBuf.get()->getMemBufferRef());
+ if (!BinaryOrErr) {
+ report_error(BinaryOrErr.takeError(), DSYMFile);
return;
}
- DbgObj = DbgObjCheck.get().release();
- // We need to keep the file alive, because we're replacing DbgObj with it.
- DSYMBuf = std::move(BufOrErr.get());
+ // We need to keep the Binary elive with the buffer
+ DSYMBinary = std::move(BinaryOrErr.get());
+
+ if (ObjectFile *O = dyn_cast<ObjectFile>(DSYMBinary.get())) {
+ // this is a Mach-O object file, use it
+ if (MachOObjectFile *MachDSYM = dyn_cast<MachOObjectFile>(&*O)) {
+ DbgObj = MachDSYM;
+ }
+ else {
+ WithColor::error(errs(), "llvm-objdump")
+ << DSYMFile << " is not a Mach-O file type.\n";
+ return;
+ }
+ }
+ else if (auto UB = dyn_cast<MachOUniversalBinary>(DSYMBinary.get())){
+ // this is a Universal Binary, find a Mach-O for this architecture
+ uint32_t CPUType, CPUSubType;
+ const char *ArchFlag;
+ if (MachOOF->is64Bit()) {
+ const MachO::mach_header_64 H_64 = MachOOF->getHeader64();
+ CPUType = H_64.cputype;
+ CPUSubType = H_64.cpusubtype;
+ } else {
+ const MachO::mach_header H = MachOOF->getHeader();
+ CPUType = H.cputype;
+ CPUSubType = H.cpusubtype;
+ }
+ Triple T = MachOObjectFile::getArchTriple(CPUType, CPUSubType, nullptr,
+ &ArchFlag);
+ Expected<std::unique_ptr<MachOObjectFile>> MachDSYM =
+ UB->getObjectForArch(ArchFlag);
+ if (!MachDSYM) {
+ report_error(MachDSYM.takeError(), DSYMFile);
+ return;
+ }
+
+ // We need to keep the Binary elive with the buffer
+ DbgObj = &*MachDSYM.get();
+ DSYMBinary = std::move(*MachDSYM);
+ }
+ else {
+ WithColor::error(errs(), "llvm-objdump")
+ << DSYMFile << " is not a Mach-O or Universal file type.\n";
+ return;
+ }
}
// Setup the DIContext
@@ -7016,10 +7324,9 @@ static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
if (SegmentName != DisSegName)
continue;
- StringRef BytesStr;
- Sections[SectIdx].getContents(BytesStr);
- ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
- BytesStr.size());
+ StringRef BytesStr =
+ unwrapOrError(Sections[SectIdx].getContents(), Filename);
+ ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(BytesStr);
uint64_t SectAddress = Sections[SectIdx].getAddress();
bool symbolTableWorked = false;
@@ -7029,17 +7336,13 @@ static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
SymbolAddressMap AddrMap;
bool DisSymNameFound = false;
for (const SymbolRef &Symbol : MachOOF->symbols()) {
- Expected<SymbolRef::Type> STOrErr = Symbol.getType();
- if (!STOrErr)
- report_error(MachOOF->getFileName(), STOrErr.takeError());
- SymbolRef::Type ST = *STOrErr;
+ SymbolRef::Type ST =
+ unwrapOrError(Symbol.getType(), MachOOF->getFileName());
if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
ST == SymbolRef::ST_Other) {
uint64_t Address = Symbol.getValue();
- Expected<StringRef> SymNameOrErr = Symbol.getName();
- if (!SymNameOrErr)
- report_error(MachOOF->getFileName(), SymNameOrErr.takeError());
- StringRef SymName = *SymNameOrErr;
+ StringRef SymName =
+ unwrapOrError(Symbol.getName(), MachOOF->getFileName());
AddrMap[Address] = SymName;
if (!DisSymName.empty() && DisSymName == SymName)
DisSymNameFound = true;
@@ -7076,15 +7379,10 @@ static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
// Disassemble symbol by symbol.
for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
- Expected<StringRef> SymNameOrErr = Symbols[SymIdx].getName();
- if (!SymNameOrErr)
- report_error(MachOOF->getFileName(), SymNameOrErr.takeError());
- StringRef SymName = *SymNameOrErr;
-
- Expected<SymbolRef::Type> STOrErr = Symbols[SymIdx].getType();
- if (!STOrErr)
- report_error(MachOOF->getFileName(), STOrErr.takeError());
- SymbolRef::Type ST = *STOrErr;
+ StringRef SymName =
+ unwrapOrError(Symbols[SymIdx].getName(), MachOOF->getFileName());
+ SymbolRef::Type ST =
+ unwrapOrError(Symbols[SymIdx].getType(), MachOOF->getFileName());
if (ST != SymbolRef::ST_Function && ST != SymbolRef::ST_Data)
continue;
@@ -7137,10 +7435,8 @@ static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
uint64_t NextSym = 0;
uint64_t NextSymIdx = SymIdx + 1;
while (Symbols.size() > NextSymIdx) {
- Expected<SymbolRef::Type> STOrErr = Symbols[NextSymIdx].getType();
- if (!STOrErr)
- report_error(MachOOF->getFileName(), STOrErr.takeError());
- SymbolRef::Type NextSymType = *STOrErr;
+ SymbolRef::Type NextSymType = unwrapOrError(
+ Symbols[NextSymIdx].getType(), MachOOF->getFileName());
if (NextSymType == SymbolRef::ST_Function) {
containsNextSym =
Sections[SectIdx].containsSymbol(Symbols[NextSymIdx]);
@@ -7243,7 +7539,7 @@ static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
// Print debug info.
if (diContext) {
- DILineInfo dli = diContext->getLineInfoForAddress(PC);
+ DILineInfo dli = diContext->getLineInfoForAddress({PC, SectIdx});
// Print valid line info if it changed.
if (dli != lastLine && dli.Line != 0)
outs() << "\t## " << dli.FileName << ':' << dli.Line << ':'
@@ -7415,10 +7711,7 @@ static void findUnwindRelocNameAddend(const MachOObjectFile *Obj,
const RelocationRef &Reloc, uint64_t Addr,
StringRef &Name, uint64_t &Addend) {
if (Reloc.getSymbol() != Obj->symbol_end()) {
- Expected<StringRef> NameOrErr = Reloc.getSymbol()->getName();
- if (!NameOrErr)
- report_error(Obj->getFileName(), NameOrErr.takeError());
- Name = *NameOrErr;
+ Name = unwrapOrError(Reloc.getSymbol()->getName(), Obj->getFileName());
Addend = Addr;
return;
}
@@ -7440,16 +7733,11 @@ static void findUnwindRelocNameAddend(const MachOObjectFile *Obj,
// Go back one so that SymbolAddress <= Addr.
--Sym;
- auto SectOrErr = Sym->second.getSection();
- if (!SectOrErr)
- report_error(Obj->getFileName(), SectOrErr.takeError());
- section_iterator SymSection = *SectOrErr;
+ section_iterator SymSection =
+ unwrapOrError(Sym->second.getSection(), Obj->getFileName());
if (RelocSection == *SymSection) {
// There's a valid symbol in the same section before this reference.
- Expected<StringRef> NameOrErr = Sym->second.getName();
- if (!NameOrErr)
- report_error(Obj->getFileName(), NameOrErr.takeError());
- Name = *NameOrErr;
+ Name = unwrapOrError(Sym->second.getName(), Obj->getFileName());
Addend = Addr - Sym->first;
return;
}
@@ -7490,9 +7778,8 @@ printMachOCompactUnwindSection(const MachOObjectFile *Obj,
uint32_t PointerSize = Is64 ? sizeof(uint64_t) : sizeof(uint32_t);
uint32_t EntrySize = 3 * PointerSize + 2 * sizeof(uint32_t);
- StringRef Contents;
- CompactUnwind.getContents(Contents);
-
+ StringRef Contents =
+ unwrapOrError(CompactUnwind.getContents(), Obj->getFileName());
SmallVector<CompactUnwindEntry, 4> CompactUnwinds;
// First populate the initial raw offsets, encodings and so on from the entry.
@@ -7633,8 +7920,8 @@ static void printMachOUnwindInfoSection(const MachOObjectFile *Obj,
outs() << "Contents of __unwind_info section:\n";
- StringRef Contents;
- UnwindInfo.getContents(Contents);
+ StringRef Contents =
+ unwrapOrError(UnwindInfo.getContents(), Obj->getFileName());
ptrdiff_t Pos = 0;
//===----------------------------------
@@ -7801,7 +8088,7 @@ static void printMachOUnwindInfoSection(const MachOObjectFile *Obj,
}
}
-void llvm::printMachOUnwindInfo(const MachOObjectFile *Obj) {
+void printMachOUnwindInfo(const MachOObjectFile *Obj) {
std::map<uint64_t, SymbolRef> Symbols;
for (const SymbolRef &SymRef : Obj->symbols()) {
// Discard any undefined or absolute symbols. They're not going to take part
@@ -7917,6 +8204,20 @@ static void PrintMachHeader(uint32_t magic, uint32_t cputype,
case MachO::CPU_SUBTYPE_ARM64_ALL:
outs() << " ALL";
break;
+ case MachO::CPU_SUBTYPE_ARM64E:
+ outs() << " E";
+ break;
+ default:
+ outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
+ break;
+ }
+ break;
+ case MachO::CPU_TYPE_ARM64_32:
+ outs() << " ARM64_32";
+ switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
+ case MachO::CPU_SUBTYPE_ARM64_32_V8:
+ outs() << " V8";
+ break;
default:
outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
break;
@@ -9485,7 +9786,8 @@ static void PrintThreadCommand(MachO::thread_command t, const char *Ptr,
begin += count * sizeof(uint32_t);
}
}
- } else if (cputype == MachO::CPU_TYPE_ARM64) {
+ } else if (cputype == MachO::CPU_TYPE_ARM64 ||
+ cputype == MachO::CPU_TYPE_ARM64_32) {
while (begin < end) {
if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
memcpy((char *)&flavor, begin, sizeof(uint32_t));
@@ -9790,12 +10092,12 @@ static void PrintMachHeader(const MachOObjectFile *Obj, bool verbose) {
}
}
-void llvm::printMachOFileHeader(const object::ObjectFile *Obj) {
+void printMachOFileHeader(const object::ObjectFile *Obj) {
const MachOObjectFile *file = dyn_cast<const MachOObjectFile>(Obj);
PrintMachHeader(file, !NonVerbose);
}
-void llvm::printMachOLoadCommands(const object::ObjectFile *Obj) {
+void printMachOLoadCommands(const object::ObjectFile *Obj) {
const MachOObjectFile *file = dyn_cast<const MachOObjectFile>(Obj);
uint32_t filetype = 0;
uint32_t cputype = 0;
@@ -9817,7 +10119,7 @@ void llvm::printMachOLoadCommands(const object::ObjectFile *Obj) {
// export trie dumping
//===----------------------------------------------------------------------===//
-void llvm::printMachOExportsTrie(const object::MachOObjectFile *Obj) {
+void printMachOExportsTrie(const object::MachOObjectFile *Obj) {
uint64_t BaseSegmentAddress = 0;
for (const auto &Command : Obj->load_commands()) {
if (Command.C.cmd == MachO::LC_SEGMENT) {
@@ -9835,7 +10137,7 @@ void llvm::printMachOExportsTrie(const object::MachOObjectFile *Obj) {
}
}
Error Err = Error::success();
- for (const llvm::object::ExportEntry &Entry : Obj->exports(Err)) {
+ for (const object::ExportEntry &Entry : Obj->exports(Err)) {
uint64_t Flags = Entry.flags();
bool ReExport = (Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT);
bool WeakDef = (Flags & MachO::EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION);
@@ -9889,17 +10191,17 @@ void llvm::printMachOExportsTrie(const object::MachOObjectFile *Obj) {
outs() << "\n";
}
if (Err)
- report_error(Obj->getFileName(), std::move(Err));
+ report_error(std::move(Err), Obj->getFileName());
}
//===----------------------------------------------------------------------===//
// rebase table dumping
//===----------------------------------------------------------------------===//
-void llvm::printMachORebaseTable(object::MachOObjectFile *Obj) {
+void printMachORebaseTable(object::MachOObjectFile *Obj) {
outs() << "segment section address type\n";
Error Err = Error::success();
- for (const llvm::object::MachORebaseEntry &Entry : Obj->rebaseTable(Err)) {
+ for (const object::MachORebaseEntry &Entry : Obj->rebaseTable(Err)) {
StringRef SegmentName = Entry.segmentName();
StringRef SectionName = Entry.sectionName();
uint64_t Address = Entry.address();
@@ -9910,7 +10212,7 @@ void llvm::printMachORebaseTable(object::MachOObjectFile *Obj) {
Address, Entry.typeName().str().c_str());
}
if (Err)
- report_error(Obj->getFileName(), std::move(Err));
+ report_error(std::move(Err), Obj->getFileName());
}
static StringRef ordinalName(const object::MachOObjectFile *Obj, int Ordinal) {
@@ -9938,12 +10240,12 @@ static StringRef ordinalName(const object::MachOObjectFile *Obj, int Ordinal) {
// bind table dumping
//===----------------------------------------------------------------------===//
-void llvm::printMachOBindTable(object::MachOObjectFile *Obj) {
+void printMachOBindTable(object::MachOObjectFile *Obj) {
// Build table of sections so names can used in final output.
outs() << "segment section address type "
"addend dylib symbol\n";
Error Err = Error::success();
- for (const llvm::object::MachOBindEntry &Entry : Obj->bindTable(Err)) {
+ for (const object::MachOBindEntry &Entry : Obj->bindTable(Err)) {
StringRef SegmentName = Entry.segmentName();
StringRef SectionName = Entry.sectionName();
uint64_t Address = Entry.address();
@@ -9962,18 +10264,18 @@ void llvm::printMachOBindTable(object::MachOObjectFile *Obj) {
<< Entry.symbolName() << Attr << "\n";
}
if (Err)
- report_error(Obj->getFileName(), std::move(Err));
+ report_error(std::move(Err), Obj->getFileName());
}
//===----------------------------------------------------------------------===//
// lazy bind table dumping
//===----------------------------------------------------------------------===//
-void llvm::printMachOLazyBindTable(object::MachOObjectFile *Obj) {
+void printMachOLazyBindTable(object::MachOObjectFile *Obj) {
outs() << "segment section address "
"dylib symbol\n";
Error Err = Error::success();
- for (const llvm::object::MachOBindEntry &Entry : Obj->lazyBindTable(Err)) {
+ for (const object::MachOBindEntry &Entry : Obj->lazyBindTable(Err)) {
StringRef SegmentName = Entry.segmentName();
StringRef SectionName = Entry.sectionName();
uint64_t Address = Entry.address();
@@ -9987,18 +10289,18 @@ void llvm::printMachOLazyBindTable(object::MachOObjectFile *Obj) {
<< Entry.symbolName() << "\n";
}
if (Err)
- report_error(Obj->getFileName(), std::move(Err));
+ report_error(std::move(Err), Obj->getFileName());
}
//===----------------------------------------------------------------------===//
// weak bind table dumping
//===----------------------------------------------------------------------===//
-void llvm::printMachOWeakBindTable(object::MachOObjectFile *Obj) {
+void printMachOWeakBindTable(object::MachOObjectFile *Obj) {
outs() << "segment section address "
"type addend symbol\n";
Error Err = Error::success();
- for (const llvm::object::MachOBindEntry &Entry : Obj->weakBindTable(Err)) {
+ for (const object::MachOBindEntry &Entry : Obj->weakBindTable(Err)) {
// Strong symbols don't have a location to update.
if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION) {
outs() << " strong "
@@ -10019,7 +10321,7 @@ void llvm::printMachOWeakBindTable(object::MachOObjectFile *Obj) {
<< "\n";
}
if (Err)
- report_error(Obj->getFileName(), std::move(Err));
+ report_error(std::move(Err), Obj->getFileName());
}
// get_dyld_bind_info_symbolname() is used for disassembly and passed an
@@ -10031,16 +10333,66 @@ static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue,
if (info->bindtable == nullptr) {
info->bindtable = llvm::make_unique<SymbolAddressMap>();
Error Err = Error::success();
- for (const llvm::object::MachOBindEntry &Entry : info->O->bindTable(Err)) {
+ for (const object::MachOBindEntry &Entry : info->O->bindTable(Err)) {
uint64_t Address = Entry.address();
StringRef name = Entry.symbolName();
if (!name.empty())
(*info->bindtable)[Address] = name;
}
if (Err)
- report_error(info->O->getFileName(), std::move(Err));
+ report_error(std::move(Err), info->O->getFileName());
}
auto name = info->bindtable->lookup(ReferenceValue);
return !name.empty() ? name.data() : nullptr;
}
+void printLazyBindTable(ObjectFile *o) {
+ outs() << "Lazy bind table:\n";
+ if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
+ printMachOLazyBindTable(MachO);
+ else
+ WithColor::error()
+ << "This operation is only currently supported "
+ "for Mach-O executable files.\n";
+}
+
+void printWeakBindTable(ObjectFile *o) {
+ outs() << "Weak bind table:\n";
+ if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
+ printMachOWeakBindTable(MachO);
+ else
+ WithColor::error()
+ << "This operation is only currently supported "
+ "for Mach-O executable files.\n";
+}
+
+void printExportsTrie(const ObjectFile *o) {
+ outs() << "Exports trie:\n";
+ if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
+ printMachOExportsTrie(MachO);
+ else
+ WithColor::error()
+ << "This operation is only currently supported "
+ "for Mach-O executable files.\n";
+}
+
+void printRebaseTable(ObjectFile *o) {
+ outs() << "Rebase table:\n";
+ if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
+ printMachORebaseTable(MachO);
+ else
+ WithColor::error()
+ << "This operation is only currently supported "
+ "for Mach-O executable files.\n";
+}
+
+void printBindTable(ObjectFile *o) {
+ outs() << "Bind table:\n";
+ if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
+ printMachOBindTable(MachO);
+ else
+ WithColor::error()
+ << "This operation is only currently supported "
+ "for Mach-O executable files.\n";
+}
+} // namespace llvm
diff --git a/tools/llvm-objdump/WasmDump.cpp b/tools/llvm-objdump/WasmDump.cpp
index 045002cd4b34..da27a4acbb5f 100644
--- a/tools/llvm-objdump/WasmDump.cpp
+++ b/tools/llvm-objdump/WasmDump.cpp
@@ -1,9 +1,8 @@
//===-- WasmDump.cpp - wasm-specific dumper ---------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
///
@@ -15,14 +14,39 @@
#include "llvm-objdump.h"
#include "llvm/Object/Wasm.h"
-using namespace llvm;
-using namespace object;
+using namespace llvm::object;
-void llvm::printWasmFileHeader(const object::ObjectFile *Obj) {
- const WasmObjectFile *File = dyn_cast<const WasmObjectFile>(Obj);
+namespace llvm {
+void printWasmFileHeader(const object::ObjectFile *Obj) {
+ const auto *File = dyn_cast<const WasmObjectFile>(Obj);
outs() << "Program Header:\n";
outs() << "Version: 0x";
outs().write_hex(File->getHeader().Version);
outs() << "\n";
}
+
+Error getWasmRelocationValueString(const WasmObjectFile *Obj,
+ const RelocationRef &RelRef,
+ SmallVectorImpl<char> &Result) {
+ const wasm::WasmRelocation &Rel = Obj->getWasmRelocation(RelRef);
+ symbol_iterator SI = RelRef.getSymbol();
+ std::string FmtBuf;
+ raw_string_ostream Fmt(FmtBuf);
+ if (SI == Obj->symbol_end()) {
+ // Not all wasm relocations have symbols associated with them.
+ // In particular R_WASM_TYPE_INDEX_LEB.
+ Fmt << Rel.Index;
+ } else {
+ Expected<StringRef> SymNameOrErr = SI->getName();
+ if (!SymNameOrErr)
+ return SymNameOrErr.takeError();
+ StringRef SymName = *SymNameOrErr;
+ Result.append(SymName.begin(), SymName.end());
+ }
+ Fmt << (Rel.Addend < 0 ? "" : "+") << Rel.Addend;
+ Fmt.flush();
+ Result.append(FmtBuf.begin(), FmtBuf.end());
+ return Error::success();
+}
+} // namespace llvm
diff --git a/tools/llvm-objdump/llvm-objdump.cpp b/tools/llvm-objdump/llvm-objdump.cpp
index ba8d3c5b8d5c..58981203c59e 100644
--- a/tools/llvm-objdump/llvm-objdump.cpp
+++ b/tools/llvm-objdump/llvm-objdump.cpp
@@ -1,9 +1,8 @@
//===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
//
@@ -19,6 +18,7 @@
#include "llvm-objdump.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetOperations.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/ADT/Triple.h"
@@ -68,283 +68,298 @@
#include <unordered_map>
#include <utility>
-using namespace llvm;
-using namespace object;
+using namespace llvm::object;
+
+namespace llvm {
+
+cl::OptionCategory ObjdumpCat("llvm-objdump Options");
+
+// MachO specific
+extern cl::OptionCategory MachOCat;
+extern cl::opt<bool> Bind;
+extern cl::opt<bool> DataInCode;
+extern cl::opt<bool> DylibsUsed;
+extern cl::opt<bool> DylibId;
+extern cl::opt<bool> ExportsTrie;
+extern cl::opt<bool> FirstPrivateHeader;
+extern cl::opt<bool> IndirectSymbols;
+extern cl::opt<bool> InfoPlist;
+extern cl::opt<bool> LazyBind;
+extern cl::opt<bool> LinkOptHints;
+extern cl::opt<bool> ObjcMetaData;
+extern cl::opt<bool> Rebase;
+extern cl::opt<bool> UniversalHeaders;
+extern cl::opt<bool> WeakBind;
+
+static cl::opt<uint64_t> AdjustVMA(
+ "adjust-vma",
+ cl::desc("Increase the displayed address by the specified offset"),
+ cl::value_desc("offset"), cl::init(0), cl::cat(ObjdumpCat));
-cl::opt<bool>
- llvm::AllHeaders("all-headers",
- cl::desc("Display all available header information"));
+static cl::opt<bool>
+ AllHeaders("all-headers",
+ cl::desc("Display all available header information"),
+ cl::cat(ObjdumpCat));
static cl::alias AllHeadersShort("x", cl::desc("Alias for --all-headers"),
+ cl::NotHidden, cl::Grouping,
cl::aliasopt(AllHeaders));
-static cl::list<std::string>
-InputFilenames(cl::Positional, cl::desc("<input object files>"),cl::ZeroOrMore);
+static cl::opt<std::string>
+ ArchName("arch-name",
+ cl::desc("Target arch to disassemble for, "
+ "see -version for available targets"),
+ cl::cat(ObjdumpCat));
+
+cl::opt<bool> ArchiveHeaders("archive-headers",
+ cl::desc("Display archive header information"),
+ cl::cat(ObjdumpCat));
+static cl::alias ArchiveHeadersShort("a",
+ cl::desc("Alias for --archive-headers"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(ArchiveHeaders));
+
+cl::opt<bool> Demangle("demangle", cl::desc("Demangle symbols names"),
+ cl::init(false), cl::cat(ObjdumpCat));
+static cl::alias DemangleShort("C", cl::desc("Alias for --demangle"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(Demangle));
+
+cl::opt<bool> Disassemble(
+ "disassemble",
+ cl::desc("Display assembler mnemonics for the machine instructions"),
+ cl::cat(ObjdumpCat));
+static cl::alias DisassembleShort("d", cl::desc("Alias for --disassemble"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(Disassemble));
+
+cl::opt<bool> DisassembleAll(
+ "disassemble-all",
+ cl::desc("Display assembler mnemonics for the machine instructions"),
+ cl::cat(ObjdumpCat));
+static cl::alias DisassembleAllShort("D",
+ cl::desc("Alias for --disassemble-all"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(DisassembleAll));
-cl::opt<bool>
-llvm::Disassemble("disassemble",
- cl::desc("Display assembler mnemonics for the machine instructions"));
+static cl::list<std::string>
+ DisassembleFunctions("disassemble-functions", cl::CommaSeparated,
+ cl::desc("List of functions to disassemble. "
+ "Accept demangled names when --demangle is "
+ "specified, otherwise accept mangled names"),
+ cl::cat(ObjdumpCat));
+
+static cl::opt<bool> DisassembleZeroes(
+ "disassemble-zeroes",
+ cl::desc("Do not skip blocks of zeroes when disassembling"),
+ cl::cat(ObjdumpCat));
static cl::alias
-Disassembled("d", cl::desc("Alias for --disassemble"),
- cl::aliasopt(Disassemble));
+ DisassembleZeroesShort("z", cl::desc("Alias for --disassemble-zeroes"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(DisassembleZeroes));
-cl::opt<bool>
-llvm::DisassembleAll("disassemble-all",
- cl::desc("Display assembler mnemonics for the machine instructions"));
+static cl::list<std::string>
+ DisassemblerOptions("disassembler-options",
+ cl::desc("Pass target specific disassembler options"),
+ cl::value_desc("options"), cl::CommaSeparated,
+ cl::cat(ObjdumpCat));
static cl::alias
-DisassembleAlld("D", cl::desc("Alias for --disassemble-all"),
- cl::aliasopt(DisassembleAll));
-
-cl::opt<bool> llvm::Demangle("demangle", cl::desc("Demangle symbols names"),
- cl::init(false));
-
-static cl::alias DemangleShort("C", cl::desc("Alias for --demangle"),
- cl::aliasopt(llvm::Demangle));
+ DisassemblerOptionsShort("M", cl::desc("Alias for --disassembler-options"),
+ cl::NotHidden, cl::Grouping, cl::Prefix,
+ cl::CommaSeparated,
+ cl::aliasopt(DisassemblerOptions));
-static cl::list<std::string>
-DisassembleFunctions("df",
- cl::CommaSeparated,
- cl::desc("List of functions to disassemble"));
-static StringSet<> DisasmFuncsSet;
+cl::opt<DIDumpType> DwarfDumpType(
+ "dwarf", cl::init(DIDT_Null), cl::desc("Dump of dwarf debug sections:"),
+ cl::values(clEnumValN(DIDT_DebugFrame, "frames", ".debug_frame")),
+ cl::cat(ObjdumpCat));
+
+static cl::opt<bool> DynamicRelocations(
+ "dynamic-reloc",
+ cl::desc("Display the dynamic relocation entries in the file"),
+ cl::cat(ObjdumpCat));
+static cl::alias DynamicRelocationShort("R",
+ cl::desc("Alias for --dynamic-reloc"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(DynamicRelocations));
-cl::opt<bool>
-llvm::Relocations("reloc",
- cl::desc("Display the relocation entries in the file"));
-static cl::alias RelocationsShort("r", cl::desc("Alias for --reloc"),
- cl::NotHidden,
- cl::aliasopt(llvm::Relocations));
+static cl::opt<bool>
+ FaultMapSection("fault-map-section",
+ cl::desc("Display contents of faultmap section"),
+ cl::cat(ObjdumpCat));
-cl::opt<bool>
-llvm::DynamicRelocations("dynamic-reloc",
- cl::desc("Display the dynamic relocation entries in the file"));
-static cl::alias
-DynamicRelocationsd("R", cl::desc("Alias for --dynamic-reloc"),
- cl::aliasopt(DynamicRelocations));
+static cl::opt<bool>
+ FileHeaders("file-headers",
+ cl::desc("Display the contents of the overall file header"),
+ cl::cat(ObjdumpCat));
+static cl::alias FileHeadersShort("f", cl::desc("Alias for --file-headers"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(FileHeaders));
-cl::opt<bool>
- llvm::SectionContents("full-contents",
- cl::desc("Display the content of each section"));
+cl::opt<bool> SectionContents("full-contents",
+ cl::desc("Display the content of each section"),
+ cl::cat(ObjdumpCat));
static cl::alias SectionContentsShort("s",
cl::desc("Alias for --full-contents"),
+ cl::NotHidden, cl::Grouping,
cl::aliasopt(SectionContents));
-cl::opt<bool> llvm::SymbolTable("syms", cl::desc("Display the symbol table"));
-static cl::alias SymbolTableShort("t", cl::desc("Alias for --syms"),
- cl::NotHidden,
- cl::aliasopt(llvm::SymbolTable));
-
-cl::opt<bool>
-llvm::ExportsTrie("exports-trie", cl::desc("Display mach-o exported symbols"));
-
-cl::opt<bool>
-llvm::Rebase("rebase", cl::desc("Display mach-o rebasing info"));
-
-cl::opt<bool>
-llvm::Bind("bind", cl::desc("Display mach-o binding info"));
-
-cl::opt<bool>
-llvm::LazyBind("lazy-bind", cl::desc("Display mach-o lazy binding info"));
-
-cl::opt<bool>
-llvm::WeakBind("weak-bind", cl::desc("Display mach-o weak binding info"));
-
-cl::opt<bool>
-llvm::RawClangAST("raw-clang-ast",
- cl::desc("Dump the raw binary contents of the clang AST section"));
+static cl::list<std::string> InputFilenames(cl::Positional,
+ cl::desc("<input object files>"),
+ cl::ZeroOrMore,
+ cl::cat(ObjdumpCat));
static cl::opt<bool>
-MachOOpt("macho", cl::desc("Use MachO specific object file parser"));
-static cl::alias
-MachOm("m", cl::desc("Alias for --macho"), cl::aliasopt(MachOOpt));
-
-cl::opt<std::string>
-llvm::TripleName("triple", cl::desc("Target triple to disassemble for, "
- "see -version for available targets"));
+ PrintLines("line-numbers",
+ cl::desc("Display source line numbers with "
+ "disassembly. Implies disassemble object"),
+ cl::cat(ObjdumpCat));
+static cl::alias PrintLinesShort("l", cl::desc("Alias for --line-numbers"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(PrintLines));
+
+static cl::opt<bool> MachOOpt("macho",
+ cl::desc("Use MachO specific object file parser"),
+ cl::cat(ObjdumpCat));
+static cl::alias MachOm("m", cl::desc("Alias for --macho"), cl::NotHidden,
+ cl::Grouping, cl::aliasopt(MachOOpt));
cl::opt<std::string>
-llvm::MCPU("mcpu",
- cl::desc("Target a specific cpu type (-mcpu=help for details)"),
- cl::value_desc("cpu-name"),
- cl::init(""));
-
-cl::opt<std::string>
-llvm::ArchName("arch-name", cl::desc("Target arch to disassemble for, "
- "see -version for available targets"));
+ MCPU("mcpu",
+ cl::desc("Target a specific cpu type (-mcpu=help for details)"),
+ cl::value_desc("cpu-name"), cl::init(""), cl::cat(ObjdumpCat));
+
+cl::list<std::string> MAttrs("mattr", cl::CommaSeparated,
+ cl::desc("Target specific attributes"),
+ cl::value_desc("a1,+a2,-a3,..."),
+ cl::cat(ObjdumpCat));
+
+cl::opt<bool> NoShowRawInsn("no-show-raw-insn",
+ cl::desc("When disassembling "
+ "instructions, do not print "
+ "the instruction bytes."),
+ cl::cat(ObjdumpCat));
+cl::opt<bool> NoLeadingAddr("no-leading-addr",
+ cl::desc("Print no leading address"),
+ cl::cat(ObjdumpCat));
+
+static cl::opt<bool> RawClangAST(
+ "raw-clang-ast",
+ cl::desc("Dump the raw binary contents of the clang AST section"),
+ cl::cat(ObjdumpCat));
cl::opt<bool>
-llvm::SectionHeaders("section-headers", cl::desc("Display summaries of the "
- "headers for each section."));
-static cl::alias
-SectionHeadersShort("headers", cl::desc("Alias for --section-headers"),
- cl::aliasopt(SectionHeaders));
-static cl::alias
-SectionHeadersShorter("h", cl::desc("Alias for --section-headers"),
- cl::aliasopt(SectionHeaders));
-
-cl::list<std::string>
-llvm::FilterSections("section", cl::desc("Operate on the specified sections only. "
- "With -macho dump segment,section"));
-cl::alias
-static FilterSectionsj("j", cl::desc("Alias for --section"),
- cl::aliasopt(llvm::FilterSections));
-
-cl::list<std::string>
-llvm::MAttrs("mattr",
- cl::CommaSeparated,
- cl::desc("Target specific attributes"),
- cl::value_desc("a1,+a2,-a3,..."));
-
-cl::opt<bool>
-llvm::NoShowRawInsn("no-show-raw-insn", cl::desc("When disassembling "
- "instructions, do not print "
- "the instruction bytes."));
-cl::opt<bool>
-llvm::NoLeadingAddr("no-leading-addr", cl::desc("Print no leading address"));
-
-cl::opt<bool>
-llvm::UnwindInfo("unwind-info", cl::desc("Display unwind information"));
-
-static cl::alias
-UnwindInfoShort("u", cl::desc("Alias for --unwind-info"),
- cl::aliasopt(UnwindInfo));
-
-cl::opt<bool>
-llvm::PrivateHeaders("private-headers",
- cl::desc("Display format specific file headers"));
-
-cl::opt<bool>
-llvm::FirstPrivateHeader("private-header",
- cl::desc("Display only the first format specific file "
- "header"));
-
-static cl::alias
-PrivateHeadersShort("p", cl::desc("Alias for --private-headers"),
- cl::aliasopt(PrivateHeaders));
-
-cl::opt<bool> llvm::FileHeaders(
- "file-headers",
- cl::desc("Display the contents of the overall file header"));
-
-static cl::alias FileHeadersShort("f", cl::desc("Alias for --file-headers"),
- cl::aliasopt(FileHeaders));
-
-cl::opt<bool>
- llvm::ArchiveHeaders("archive-headers",
- cl::desc("Display archive header information"));
+ Relocations("reloc", cl::desc("Display the relocation entries in the file"),
+ cl::cat(ObjdumpCat));
+static cl::alias RelocationsShort("r", cl::desc("Alias for --reloc"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(Relocations));
-cl::alias
-ArchiveHeadersShort("a", cl::desc("Alias for --archive-headers"),
- cl::aliasopt(ArchiveHeaders));
+cl::opt<bool> PrintImmHex("print-imm-hex",
+ cl::desc("Use hex format for immediate values"),
+ cl::cat(ObjdumpCat));
-cl::opt<bool>
- llvm::PrintImmHex("print-imm-hex",
- cl::desc("Use hex format for immediate values"));
+cl::opt<bool> PrivateHeaders("private-headers",
+ cl::desc("Display format specific file headers"),
+ cl::cat(ObjdumpCat));
+static cl::alias PrivateHeadersShort("p",
+ cl::desc("Alias for --private-headers"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(PrivateHeaders));
-cl::opt<bool> PrintFaultMaps("fault-map-section",
- cl::desc("Display contents of faultmap section"));
+cl::list<std::string>
+ FilterSections("section",
+ cl::desc("Operate on the specified sections only. "
+ "With -macho dump segment,section"),
+ cl::cat(ObjdumpCat));
+static cl::alias FilterSectionsj("j", cl::desc("Alias for --section"),
+ cl::NotHidden, cl::Grouping, cl::Prefix,
+ cl::aliasopt(FilterSections));
+
+cl::opt<bool> SectionHeaders("section-headers",
+ cl::desc("Display summaries of the "
+ "headers for each section."),
+ cl::cat(ObjdumpCat));
+static cl::alias SectionHeadersShort("headers",
+ cl::desc("Alias for --section-headers"),
+ cl::NotHidden,
+ cl::aliasopt(SectionHeaders));
+static cl::alias SectionHeadersShorter("h",
+ cl::desc("Alias for --section-headers"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(SectionHeaders));
-cl::opt<DIDumpType> llvm::DwarfDumpType(
- "dwarf", cl::init(DIDT_Null), cl::desc("Dump of dwarf debug sections:"),
- cl::values(clEnumValN(DIDT_DebugFrame, "frames", ".debug_frame")));
+static cl::opt<bool>
+ ShowLMA("show-lma",
+ cl::desc("Display LMA column when dumping ELF section headers"),
+ cl::cat(ObjdumpCat));
-cl::opt<bool> PrintSource(
+static cl::opt<bool> PrintSource(
"source",
cl::desc(
- "Display source inlined with disassembly. Implies disassemble object"));
-
-cl::alias PrintSourceShort("S", cl::desc("Alias for -source"),
- cl::aliasopt(PrintSource));
+ "Display source inlined with disassembly. Implies disassemble object"),
+ cl::cat(ObjdumpCat));
+static cl::alias PrintSourceShort("S", cl::desc("Alias for -source"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(PrintSource));
-cl::opt<bool> PrintLines("line-numbers",
- cl::desc("Display source line numbers with "
- "disassembly. Implies disassemble object"));
-
-cl::alias PrintLinesShort("l", cl::desc("Alias for -line-numbers"),
- cl::aliasopt(PrintLines));
-
-cl::opt<unsigned long long>
+static cl::opt<uint64_t>
StartAddress("start-address", cl::desc("Disassemble beginning at address"),
- cl::value_desc("address"), cl::init(0));
-cl::opt<unsigned long long>
- StopAddress("stop-address",
- cl::desc("Stop disassembly at address"),
- cl::value_desc("address"), cl::init(UINT64_MAX));
-
-cl::opt<bool> DisassembleZeroes(
- "disassemble-zeroes",
- cl::desc("Do not skip blocks of zeroes when disassembling"));
-cl::alias DisassembleZeroesShort("z",
- cl::desc("Alias for --disassemble-zeroes"),
- cl::aliasopt(DisassembleZeroes));
+ cl::value_desc("address"), cl::init(0), cl::cat(ObjdumpCat));
+static cl::opt<uint64_t> StopAddress("stop-address",
+ cl::desc("Stop disassembly at address"),
+ cl::value_desc("address"),
+ cl::init(UINT64_MAX), cl::cat(ObjdumpCat));
+
+cl::opt<bool> SymbolTable("syms", cl::desc("Display the symbol table"),
+ cl::cat(ObjdumpCat));
+static cl::alias SymbolTableShort("t", cl::desc("Alias for --syms"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(SymbolTable));
-static StringRef ToolName;
+cl::opt<std::string> TripleName("triple",
+ cl::desc("Target triple to disassemble for, "
+ "see -version for available targets"),
+ cl::cat(ObjdumpCat));
-typedef std::vector<std::tuple<uint64_t, StringRef, uint8_t>> SectionSymbolsTy;
+cl::opt<bool> UnwindInfo("unwind-info", cl::desc("Display unwind information"),
+ cl::cat(ObjdumpCat));
+static cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind-info"),
+ cl::NotHidden, cl::Grouping,
+ cl::aliasopt(UnwindInfo));
-namespace {
-typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;
+static cl::opt<bool>
+ Wide("wide", cl::desc("Ignored for compatibility with GNU objdump"),
+ cl::cat(ObjdumpCat));
+static cl::alias WideShort("w", cl::Grouping, cl::aliasopt(Wide));
-class SectionFilterIterator {
-public:
- SectionFilterIterator(FilterPredicate P,
- llvm::object::section_iterator const &I,
- llvm::object::section_iterator const &E)
- : Predicate(std::move(P)), Iterator(I), End(E) {
- ScanPredicate();
- }
- const llvm::object::SectionRef &operator*() const { return *Iterator; }
- SectionFilterIterator &operator++() {
- ++Iterator;
- ScanPredicate();
- return *this;
- }
- bool operator!=(SectionFilterIterator const &Other) const {
- return Iterator != Other.Iterator;
- }
+static cl::extrahelp
+ HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
-private:
- void ScanPredicate() {
- while (Iterator != End && !Predicate(*Iterator)) {
- ++Iterator;
- }
- }
- FilterPredicate Predicate;
- llvm::object::section_iterator Iterator;
- llvm::object::section_iterator End;
-};
+static StringSet<> DisasmFuncsSet;
+static StringSet<> FoundSectionSet;
+static StringRef ToolName;
-class SectionFilter {
-public:
- SectionFilter(FilterPredicate P, llvm::object::ObjectFile const &O)
- : Predicate(std::move(P)), Object(O) {}
- SectionFilterIterator begin() {
- return SectionFilterIterator(Predicate, Object.section_begin(),
- Object.section_end());
- }
- SectionFilterIterator end() {
- return SectionFilterIterator(Predicate, Object.section_end(),
- Object.section_end());
- }
+typedef std::vector<std::tuple<uint64_t, StringRef, uint8_t>> SectionSymbolsTy;
-private:
- FilterPredicate Predicate;
- llvm::object::ObjectFile const &Object;
-};
-SectionFilter ToolSectionFilter(llvm::object::ObjectFile const &O) {
- return SectionFilter(
- [](llvm::object::SectionRef const &S) {
- if (FilterSections.empty())
- return true;
- llvm::StringRef String;
- std::error_code error = S.getName(String);
- if (error)
- return false;
- return is_contained(FilterSections, String);
- },
- O);
+static bool shouldKeep(object::SectionRef S) {
+ if (FilterSections.empty())
+ return true;
+ StringRef SecName;
+ std::error_code error = S.getName(SecName);
+ if (error)
+ return false;
+ // StringSet does not allow empty key so avoid adding sections with
+ // no name (such as the section with index 0) here.
+ if (!SecName.empty())
+ FoundSectionSet.insert(SecName);
+ return is_contained(FilterSections, SecName);
}
+
+SectionFilter ToolSectionFilter(object::ObjectFile const &O) {
+ return SectionFilter([](object::SectionRef S) { return shouldKeep(S); }, O);
}
-void llvm::error(std::error_code EC) {
+void error(std::error_code EC) {
if (!EC)
return;
WithColor::error(errs(), ToolName)
@@ -353,34 +368,39 @@ void llvm::error(std::error_code EC) {
exit(1);
}
-LLVM_ATTRIBUTE_NORETURN void llvm::error(Twine Message) {
+void error(Error E) {
+ if (!E)
+ return;
+ WithColor::error(errs(), ToolName) << toString(std::move(E));
+ exit(1);
+}
+
+LLVM_ATTRIBUTE_NORETURN void error(Twine Message) {
WithColor::error(errs(), ToolName) << Message << ".\n";
errs().flush();
exit(1);
}
-void llvm::warn(StringRef Message) {
+void warn(StringRef Message) {
WithColor::warning(errs(), ToolName) << Message << ".\n";
errs().flush();
}
-LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File,
- Twine Message) {
- WithColor::error(errs(), ToolName)
- << "'" << File << "': " << Message << ".\n";
- exit(1);
+static void warn(Twine Message) {
+ // Output order between errs() and outs() matters especially for archive
+ // files where the output is per member object.
+ outs().flush();
+ WithColor::warning(errs(), ToolName) << Message << "\n";
+ errs().flush();
}
-LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File,
- std::error_code EC) {
- assert(EC);
+LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, Twine Message) {
WithColor::error(errs(), ToolName)
- << "'" << File << "': " << EC.message() << ".\n";
+ << "'" << File << "': " << Message << ".\n";
exit(1);
}
-LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File,
- llvm::Error E) {
+LLVM_ATTRIBUTE_NORETURN void report_error(Error E, StringRef File) {
assert(E);
std::string Buf;
raw_string_ostream OS(Buf);
@@ -390,10 +410,9 @@ LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File,
exit(1);
}
-LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName,
- StringRef FileName,
- llvm::Error E,
- StringRef ArchitectureName) {
+LLVM_ATTRIBUTE_NORETURN void report_error(Error E, StringRef ArchiveName,
+ StringRef FileName,
+ StringRef ArchitectureName) {
assert(E);
WithColor::error(errs(), ToolName);
if (ArchiveName != "")
@@ -410,25 +429,39 @@ LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName,
exit(1);
}
-LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName,
- const object::Archive::Child &C,
- llvm::Error E,
- StringRef ArchitectureName) {
+LLVM_ATTRIBUTE_NORETURN void report_error(Error E, StringRef ArchiveName,
+ const object::Archive::Child &C,
+ StringRef ArchitectureName) {
Expected<StringRef> NameOrErr = C.getName();
// TODO: if we have a error getting the name then it would be nice to print
// the index of which archive member this is and or its offset in the
// archive instead of "???" as the name.
if (!NameOrErr) {
consumeError(NameOrErr.takeError());
- llvm::report_error(ArchiveName, "???", std::move(E), ArchitectureName);
+ report_error(std::move(E), ArchiveName, "???", ArchitectureName);
} else
- llvm::report_error(ArchiveName, NameOrErr.get(), std::move(E),
- ArchitectureName);
+ report_error(std::move(E), ArchiveName, NameOrErr.get(), ArchitectureName);
+}
+
+static void warnOnNoMatchForSections() {
+ SetVector<StringRef> MissingSections;
+ for (StringRef S : FilterSections) {
+ if (FoundSectionSet.count(S))
+ return;
+ // User may specify a unnamed section. Don't warn for it.
+ if (!S.empty())
+ MissingSections.insert(S);
+ }
+
+ // Warn only if no section in FilterSections is matched.
+ for (StringRef S : MissingSections)
+ warn("section '" + S + "' mentioned in a -j/--section option, but not "
+ "found in any input file");
}
static const Target *getTarget(const ObjectFile *Obj = nullptr) {
// Figure out the target triple.
- llvm::Triple TheTriple("unknown-unknown-unknown");
+ Triple TheTriple("unknown-unknown-unknown");
if (TripleName.empty()) {
if (Obj)
TheTriple = Obj->makeTriple();
@@ -459,423 +492,21 @@ static const Target *getTarget(const ObjectFile *Obj = nullptr) {
return TheTarget;
}
-bool llvm::isRelocAddressLess(RelocationRef A, RelocationRef B) {
+bool isRelocAddressLess(RelocationRef A, RelocationRef B) {
return A.getOffset() < B.getOffset();
}
-static std::string demangle(StringRef Name) {
- char *Demangled = nullptr;
- if (Name.startswith("_Z"))
- Demangled = itaniumDemangle(Name.data(), Demangled, nullptr, nullptr);
- else if (Name.startswith("?"))
- Demangled = microsoftDemangle(Name.data(), Demangled, nullptr, nullptr);
-
- if (!Demangled)
- return Name;
-
- std::string Ret = Demangled;
- free(Demangled);
- return Ret;
-}
-
-template <class ELFT>
-static std::error_code getRelocationValueString(const ELFObjectFile<ELFT> *Obj,
- const RelocationRef &RelRef,
- SmallVectorImpl<char> &Result) {
- typedef typename ELFObjectFile<ELFT>::Elf_Sym Elf_Sym;
- typedef typename ELFObjectFile<ELFT>::Elf_Shdr Elf_Shdr;
- typedef typename ELFObjectFile<ELFT>::Elf_Rela Elf_Rela;
-
- const ELFFile<ELFT> &EF = *Obj->getELFFile();
- DataRefImpl Rel = RelRef.getRawDataRefImpl();
- auto SecOrErr = EF.getSection(Rel.d.a);
- if (!SecOrErr)
- return errorToErrorCode(SecOrErr.takeError());
- const Elf_Shdr *Sec = *SecOrErr;
- auto SymTabOrErr = EF.getSection(Sec->sh_link);
- if (!SymTabOrErr)
- return errorToErrorCode(SymTabOrErr.takeError());
- const Elf_Shdr *SymTab = *SymTabOrErr;
- assert(SymTab->sh_type == ELF::SHT_SYMTAB ||
- SymTab->sh_type == ELF::SHT_DYNSYM);
- auto StrTabSec = EF.getSection(SymTab->sh_link);
- if (!StrTabSec)
- return errorToErrorCode(StrTabSec.takeError());
- auto StrTabOrErr = EF.getStringTable(*StrTabSec);
- if (!StrTabOrErr)
- return errorToErrorCode(StrTabOrErr.takeError());
- StringRef StrTab = *StrTabOrErr;
- int64_t Addend = 0;
- // If there is no Symbol associated with the relocation, we set the undef
- // boolean value to 'true'. This will prevent us from calling functions that
- // requires the relocation to be associated with a symbol.
- bool Undef = false;
- switch (Sec->sh_type) {
- default:
- return object_error::parse_failed;
- case ELF::SHT_REL: {
- // TODO: Read implicit addend from section data.
- break;
- }
- case ELF::SHT_RELA: {
- const Elf_Rela *ERela = Obj->getRela(Rel);
- Addend = ERela->r_addend;
- Undef = ERela->getSymbol(false) == 0;
- break;
- }
- }
- std::string Target;
- if (!Undef) {
- symbol_iterator SI = RelRef.getSymbol();
- const Elf_Sym *symb = Obj->getSymbol(SI->getRawDataRefImpl());
- if (symb->getType() == ELF::STT_SECTION) {
- Expected<section_iterator> SymSI = SI->getSection();
- if (!SymSI)
- return errorToErrorCode(SymSI.takeError());
- const Elf_Shdr *SymSec = Obj->getSection((*SymSI)->getRawDataRefImpl());
- auto SecName = EF.getSectionName(SymSec);
- if (!SecName)
- return errorToErrorCode(SecName.takeError());
- Target = *SecName;
- } else {
- Expected<StringRef> SymName = symb->getName(StrTab);
- if (!SymName)
- return errorToErrorCode(SymName.takeError());
- if (Demangle)
- Target = demangle(*SymName);
- else
- Target = *SymName;
- }
- } else
- Target = "*ABS*";
-
- // Default scheme is to print Target, as well as "+ <addend>" for nonzero
- // addend. Should be acceptable for all normal purposes.
- std::string FmtBuf;
- raw_string_ostream Fmt(FmtBuf);
- Fmt << Target;
- if (Addend != 0)
- Fmt << (Addend < 0 ? "" : "+") << Addend;
- Fmt.flush();
- Result.append(FmtBuf.begin(), FmtBuf.end());
- return std::error_code();
-}
-
-static std::error_code getRelocationValueString(const ELFObjectFileBase *Obj,
- const RelocationRef &Rel,
- SmallVectorImpl<char> &Result) {
- if (auto *ELF32LE = dyn_cast<ELF32LEObjectFile>(Obj))
- return getRelocationValueString(ELF32LE, Rel, Result);
- if (auto *ELF64LE = dyn_cast<ELF64LEObjectFile>(Obj))
- return getRelocationValueString(ELF64LE, Rel, Result);
- if (auto *ELF32BE = dyn_cast<ELF32BEObjectFile>(Obj))
- return getRelocationValueString(ELF32BE, Rel, Result);
- auto *ELF64BE = cast<ELF64BEObjectFile>(Obj);
- return getRelocationValueString(ELF64BE, Rel, Result);
-}
-
-static std::error_code getRelocationValueString(const COFFObjectFile *Obj,
- const RelocationRef &Rel,
- SmallVectorImpl<char> &Result) {
- symbol_iterator SymI = Rel.getSymbol();
- Expected<StringRef> SymNameOrErr = SymI->getName();
- if (!SymNameOrErr)
- return errorToErrorCode(SymNameOrErr.takeError());
- StringRef SymName = *SymNameOrErr;
- Result.append(SymName.begin(), SymName.end());
- return std::error_code();
-}
-
-static void printRelocationTargetName(const MachOObjectFile *O,
- const MachO::any_relocation_info &RE,
- raw_string_ostream &Fmt) {
- // Target of a scattered relocation is an address. In the interest of
- // generating pretty output, scan through the symbol table looking for a
- // symbol that aligns with that address. If we find one, print it.
- // Otherwise, we just print the hex address of the target.
- if (O->isRelocationScattered(RE)) {
- uint32_t Val = O->getPlainRelocationSymbolNum(RE);
-
- for (const SymbolRef &Symbol : O->symbols()) {
- Expected<uint64_t> Addr = Symbol.getAddress();
- if (!Addr)
- report_error(O->getFileName(), Addr.takeError());
- if (*Addr != Val)
- continue;
- Expected<StringRef> Name = Symbol.getName();
- if (!Name)
- report_error(O->getFileName(), Name.takeError());
- Fmt << *Name;
- return;
- }
-
- // If we couldn't find a symbol that this relocation refers to, try
- // to find a section beginning instead.
- for (const SectionRef &Section : ToolSectionFilter(*O)) {
- std::error_code ec;
-
- StringRef Name;
- uint64_t Addr = Section.getAddress();
- if (Addr != Val)
- continue;
- if ((ec = Section.getName(Name)))
- report_error(O->getFileName(), ec);
- Fmt << Name;
- return;
- }
-
- Fmt << format("0x%x", Val);
- return;
- }
-
- StringRef S;
- bool isExtern = O->getPlainRelocationExternal(RE);
- uint64_t Val = O->getPlainRelocationSymbolNum(RE);
-
- if (O->getAnyRelocationType(RE) == MachO::ARM64_RELOC_ADDEND) {
- Fmt << format("0x%0" PRIx64, Val);
- return;
- }
-
- if (isExtern) {
- symbol_iterator SI = O->symbol_begin();
- advance(SI, Val);
- Expected<StringRef> SOrErr = SI->getName();
- if (!SOrErr)
- report_error(O->getFileName(), SOrErr.takeError());
- S = *SOrErr;
- } else {
- section_iterator SI = O->section_begin();
- // Adjust for the fact that sections are 1-indexed.
- if (Val == 0) {
- Fmt << "0 (?,?)";
- return;
- }
- uint32_t I = Val - 1;
- while (I != 0 && SI != O->section_end()) {
- --I;
- advance(SI, 1);
- }
- if (SI == O->section_end())
- Fmt << Val << " (?,?)";
- else
- SI->getName(S);
- }
-
- Fmt << S;
-}
-
-static std::error_code getRelocationValueString(const WasmObjectFile *Obj,
- const RelocationRef &RelRef,
- SmallVectorImpl<char> &Result) {
- const wasm::WasmRelocation& Rel = Obj->getWasmRelocation(RelRef);
- symbol_iterator SI = RelRef.getSymbol();
- std::string FmtBuf;
- raw_string_ostream Fmt(FmtBuf);
- if (SI == Obj->symbol_end()) {
- // Not all wasm relocations have symbols associated with them.
- // In particular R_WEBASSEMBLY_TYPE_INDEX_LEB.
- Fmt << Rel.Index;
- } else {
- Expected<StringRef> SymNameOrErr = SI->getName();
- if (!SymNameOrErr)
- return errorToErrorCode(SymNameOrErr.takeError());
- StringRef SymName = *SymNameOrErr;
- Result.append(SymName.begin(), SymName.end());
- }
- Fmt << (Rel.Addend < 0 ? "" : "+") << Rel.Addend;
- Fmt.flush();
- Result.append(FmtBuf.begin(), FmtBuf.end());
- return std::error_code();
-}
-
-static std::error_code getRelocationValueString(const MachOObjectFile *Obj,
- const RelocationRef &RelRef,
- SmallVectorImpl<char> &Result) {
- DataRefImpl Rel = RelRef.getRawDataRefImpl();
- MachO::any_relocation_info RE = Obj->getRelocation(Rel);
-
- unsigned Arch = Obj->getArch();
-
- std::string FmtBuf;
- raw_string_ostream Fmt(FmtBuf);
- unsigned Type = Obj->getAnyRelocationType(RE);
- bool IsPCRel = Obj->getAnyRelocationPCRel(RE);
-
- // Determine any addends that should be displayed with the relocation.
- // These require decoding the relocation type, which is triple-specific.
-
- // X86_64 has entirely custom relocation types.
- if (Arch == Triple::x86_64) {
- switch (Type) {
- case MachO::X86_64_RELOC_GOT_LOAD:
- case MachO::X86_64_RELOC_GOT: {
- printRelocationTargetName(Obj, RE, Fmt);
- Fmt << "@GOT";
- if (IsPCRel)
- Fmt << "PCREL";
- break;
- }
- case MachO::X86_64_RELOC_SUBTRACTOR: {
- DataRefImpl RelNext = Rel;
- Obj->moveRelocationNext(RelNext);
- MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
-
- // X86_64_RELOC_SUBTRACTOR must be followed by a relocation of type
- // X86_64_RELOC_UNSIGNED.
- // NOTE: Scattered relocations don't exist on x86_64.
- unsigned RType = Obj->getAnyRelocationType(RENext);
- if (RType != MachO::X86_64_RELOC_UNSIGNED)
- report_error(Obj->getFileName(), "Expected X86_64_RELOC_UNSIGNED after "
- "X86_64_RELOC_SUBTRACTOR.");
-
- // The X86_64_RELOC_UNSIGNED contains the minuend symbol;
- // X86_64_RELOC_SUBTRACTOR contains the subtrahend.
- printRelocationTargetName(Obj, RENext, Fmt);
- Fmt << "-";
- printRelocationTargetName(Obj, RE, Fmt);
- break;
- }
- case MachO::X86_64_RELOC_TLV:
- printRelocationTargetName(Obj, RE, Fmt);
- Fmt << "@TLV";
- if (IsPCRel)
- Fmt << "P";
- break;
- case MachO::X86_64_RELOC_SIGNED_1:
- printRelocationTargetName(Obj, RE, Fmt);
- Fmt << "-1";
- break;
- case MachO::X86_64_RELOC_SIGNED_2:
- printRelocationTargetName(Obj, RE, Fmt);
- Fmt << "-2";
- break;
- case MachO::X86_64_RELOC_SIGNED_4:
- printRelocationTargetName(Obj, RE, Fmt);
- Fmt << "-4";
- break;
- default:
- printRelocationTargetName(Obj, RE, Fmt);
- break;
- }
- // X86 and ARM share some relocation types in common.
- } else if (Arch == Triple::x86 || Arch == Triple::arm ||
- Arch == Triple::ppc) {
- // Generic relocation types...
- switch (Type) {
- case MachO::GENERIC_RELOC_PAIR: // prints no info
- return std::error_code();
- case MachO::GENERIC_RELOC_SECTDIFF: {
- DataRefImpl RelNext = Rel;
- Obj->moveRelocationNext(RelNext);
- MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
-
- // X86 sect diff's must be followed by a relocation of type
- // GENERIC_RELOC_PAIR.
- unsigned RType = Obj->getAnyRelocationType(RENext);
-
- if (RType != MachO::GENERIC_RELOC_PAIR)
- report_error(Obj->getFileName(), "Expected GENERIC_RELOC_PAIR after "
- "GENERIC_RELOC_SECTDIFF.");
-
- printRelocationTargetName(Obj, RE, Fmt);
- Fmt << "-";
- printRelocationTargetName(Obj, RENext, Fmt);
- break;
- }
- }
-
- if (Arch == Triple::x86 || Arch == Triple::ppc) {
- switch (Type) {
- case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
- DataRefImpl RelNext = Rel;
- Obj->moveRelocationNext(RelNext);
- MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
-
- // X86 sect diff's must be followed by a relocation of type
- // GENERIC_RELOC_PAIR.
- unsigned RType = Obj->getAnyRelocationType(RENext);
- if (RType != MachO::GENERIC_RELOC_PAIR)
- report_error(Obj->getFileName(), "Expected GENERIC_RELOC_PAIR after "
- "GENERIC_RELOC_LOCAL_SECTDIFF.");
-
- printRelocationTargetName(Obj, RE, Fmt);
- Fmt << "-";
- printRelocationTargetName(Obj, RENext, Fmt);
- break;
- }
- case MachO::GENERIC_RELOC_TLV: {
- printRelocationTargetName(Obj, RE, Fmt);
- Fmt << "@TLV";
- if (IsPCRel)
- Fmt << "P";
- break;
- }
- default:
- printRelocationTargetName(Obj, RE, Fmt);
- }
- } else { // ARM-specific relocations
- switch (Type) {
- case MachO::ARM_RELOC_HALF:
- case MachO::ARM_RELOC_HALF_SECTDIFF: {
- // Half relocations steal a bit from the length field to encode
- // whether this is an upper16 or a lower16 relocation.
- bool isUpper = (Obj->getAnyRelocationLength(RE) & 0x1) == 1;
-
- if (isUpper)
- Fmt << ":upper16:(";
- else
- Fmt << ":lower16:(";
- printRelocationTargetName(Obj, RE, Fmt);
-
- DataRefImpl RelNext = Rel;
- Obj->moveRelocationNext(RelNext);
- MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
-
- // ARM half relocs must be followed by a relocation of type
- // ARM_RELOC_PAIR.
- unsigned RType = Obj->getAnyRelocationType(RENext);
- if (RType != MachO::ARM_RELOC_PAIR)
- report_error(Obj->getFileName(), "Expected ARM_RELOC_PAIR after "
- "ARM_RELOC_HALF");
-
- // NOTE: The half of the target virtual address is stashed in the
- // address field of the secondary relocation, but we can't reverse
- // engineer the constant offset from it without decoding the movw/movt
- // instruction to find the other half in its immediate field.
-
- // ARM_RELOC_HALF_SECTDIFF encodes the second section in the
- // symbol/section pointer of the follow-on relocation.
- if (Type == MachO::ARM_RELOC_HALF_SECTDIFF) {
- Fmt << "-";
- printRelocationTargetName(Obj, RENext, Fmt);
- }
-
- Fmt << ")";
- break;
- }
- default: { printRelocationTargetName(Obj, RE, Fmt); }
- }
- }
- } else
- printRelocationTargetName(Obj, RE, Fmt);
-
- Fmt.flush();
- Result.append(FmtBuf.begin(), FmtBuf.end());
- return std::error_code();
-}
-
-static std::error_code getRelocationValueString(const RelocationRef &Rel,
- SmallVectorImpl<char> &Result) {
+static Error getRelocationValueString(const RelocationRef &Rel,
+ SmallVectorImpl<char> &Result) {
const ObjectFile *Obj = Rel.getObject();
if (auto *ELF = dyn_cast<ELFObjectFileBase>(Obj))
- return getRelocationValueString(ELF, Rel, Result);
+ return getELFRelocationValueString(ELF, Rel, Result);
if (auto *COFF = dyn_cast<COFFObjectFile>(Obj))
- return getRelocationValueString(COFF, Rel, Result);
+ return getCOFFRelocationValueString(COFF, Rel, Result);
if (auto *Wasm = dyn_cast<WasmObjectFile>(Obj))
- return getRelocationValueString(Wasm, Rel, Result);
+ return getWasmRelocationValueString(Wasm, Rel, Result);
if (auto *MachO = dyn_cast<MachOObjectFile>(Obj))
- return getRelocationValueString(MachO, Rel, Result);
+ return getMachORelocationValueString(MachO, Rel, Result);
llvm_unreachable("unknown object file format");
}
@@ -928,13 +559,15 @@ private:
public:
SourcePrinter() = default;
SourcePrinter(const ObjectFile *Obj, StringRef DefaultArch) : Obj(Obj) {
- symbolize::LLVMSymbolizer::Options SymbolizerOpts(
- DILineInfoSpecifier::FunctionNameKind::None, true, false, false,
- DefaultArch);
+ symbolize::LLVMSymbolizer::Options SymbolizerOpts;
+ SymbolizerOpts.PrintFunctions = DILineInfoSpecifier::FunctionNameKind::None;
+ SymbolizerOpts.Demangle = false;
+ SymbolizerOpts.DefaultArch = DefaultArch;
Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts));
}
virtual ~SourcePrinter() = default;
- virtual void printSourceLine(raw_ostream &OS, uint64_t Address,
+ virtual void printSourceLine(raw_ostream &OS,
+ object::SectionedAddress Address,
StringRef Delimiter = "; ");
};
@@ -949,35 +582,37 @@ bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
Buffer = std::move(*BufferOrError);
}
// Chomp the file to get lines
- size_t BufferSize = Buffer->getBufferSize();
- const char *BufferStart = Buffer->getBufferStart();
- for (const char *Start = BufferStart, *End = BufferStart;
- End < BufferStart + BufferSize; End++)
- if (*End == '\n' || End == BufferStart + BufferSize - 1 ||
- (*End == '\r' && *(End + 1) == '\n')) {
- LineCache[LineInfo.FileName].push_back(StringRef(Start, End - Start));
- if (*End == '\r')
- End++;
- Start = End + 1;
+ const char *BufferStart = Buffer->getBufferStart(),
+ *BufferEnd = Buffer->getBufferEnd();
+ std::vector<StringRef> &Lines = LineCache[LineInfo.FileName];
+ const char *Start = BufferStart;
+ for (const char *I = BufferStart; I != BufferEnd; ++I)
+ if (*I == '\n') {
+ Lines.emplace_back(Start, I - Start - (BufferStart < I && I[-1] == '\r'));
+ Start = I + 1;
}
+ if (Start < BufferEnd)
+ Lines.emplace_back(Start, BufferEnd - Start);
SourceCache[LineInfo.FileName] = std::move(Buffer);
return true;
}
-void SourcePrinter::printSourceLine(raw_ostream &OS, uint64_t Address,
+void SourcePrinter::printSourceLine(raw_ostream &OS,
+ object::SectionedAddress Address,
StringRef Delimiter) {
if (!Symbolizer)
return;
+
DILineInfo LineInfo = DILineInfo();
- auto ExpectecLineInfo =
- Symbolizer->symbolizeCode(Obj->getFileName(), Address);
- if (!ExpectecLineInfo)
- consumeError(ExpectecLineInfo.takeError());
+ auto ExpectedLineInfo = Symbolizer->symbolizeCode(*Obj, Address);
+ if (!ExpectedLineInfo)
+ consumeError(ExpectedLineInfo.takeError());
else
- LineInfo = *ExpectecLineInfo;
+ LineInfo = *ExpectedLineInfo;
- if ((LineInfo.FileName == "<invalid>") || OldLineInfo.Line == LineInfo.Line ||
- LineInfo.Line == 0)
+ if ((LineInfo.FileName == "<invalid>") || LineInfo.Line == 0 ||
+ ((OldLineInfo.Line == LineInfo.Line) &&
+ (OldLineInfo.FileName == LineInfo.FileName)))
return;
if (PrintLines)
@@ -986,53 +621,79 @@ void SourcePrinter::printSourceLine(raw_ostream &OS, uint64_t Address,
if (SourceCache.find(LineInfo.FileName) == SourceCache.end())
if (!cacheSource(LineInfo))
return;
- auto FileBuffer = SourceCache.find(LineInfo.FileName);
- if (FileBuffer != SourceCache.end()) {
- auto LineBuffer = LineCache.find(LineInfo.FileName);
- if (LineBuffer != LineCache.end()) {
- if (LineInfo.Line > LineBuffer->second.size())
- return;
- // Vector begins at 0, line numbers are non-zero
- OS << Delimiter << LineBuffer->second[LineInfo.Line - 1].ltrim()
- << "\n";
- }
+ auto LineBuffer = LineCache.find(LineInfo.FileName);
+ if (LineBuffer != LineCache.end()) {
+ if (LineInfo.Line > LineBuffer->second.size())
+ return;
+ // Vector begins at 0, line numbers are non-zero
+ OS << Delimiter << LineBuffer->second[LineInfo.Line - 1] << '\n';
}
}
OldLineInfo = LineInfo;
}
+static bool isAArch64Elf(const ObjectFile *Obj) {
+ const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
+ return Elf && Elf->getEMachine() == ELF::EM_AARCH64;
+}
+
static bool isArmElf(const ObjectFile *Obj) {
- return (Obj->isELF() &&
- (Obj->getArch() == Triple::aarch64 ||
- Obj->getArch() == Triple::aarch64_be ||
- Obj->getArch() == Triple::arm || Obj->getArch() == Triple::armeb ||
- Obj->getArch() == Triple::thumb ||
- Obj->getArch() == Triple::thumbeb));
+ const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
+ return Elf && Elf->getEMachine() == ELF::EM_ARM;
+}
+
+static bool hasMappingSymbols(const ObjectFile *Obj) {
+ return isArmElf(Obj) || isAArch64Elf(Obj);
+}
+
+static void printRelocation(const RelocationRef &Rel, uint64_t Address,
+ bool Is64Bits) {
+ StringRef Fmt = Is64Bits ? "\t\t%016" PRIx64 ": " : "\t\t\t%08" PRIx64 ": ";
+ SmallString<16> Name;
+ SmallString<32> Val;
+ Rel.getTypeName(Name);
+ error(getRelocationValueString(Rel, Val));
+ outs() << format(Fmt.data(), Address) << Name << "\t" << Val << "\n";
}
class PrettyPrinter {
public:
virtual ~PrettyPrinter() = default;
virtual void printInst(MCInstPrinter &IP, const MCInst *MI,
- ArrayRef<uint8_t> Bytes, uint64_t Address,
- raw_ostream &OS, StringRef Annot,
- MCSubtargetInfo const &STI, SourcePrinter *SP,
+ ArrayRef<uint8_t> Bytes,
+ object::SectionedAddress Address, raw_ostream &OS,
+ StringRef Annot, MCSubtargetInfo const &STI,
+ SourcePrinter *SP,
std::vector<RelocationRef> *Rels = nullptr) {
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address);
- if (!NoLeadingAddr)
- OS << format("%8" PRIx64 ":", Address);
- if (!NoShowRawInsn) {
- OS << "\t";
- dumpBytes(Bytes, OS);
+
+ {
+ formatted_raw_ostream FOS(OS);
+ if (!NoLeadingAddr)
+ FOS << format("%8" PRIx64 ":", Address.Address);
+ if (!NoShowRawInsn) {
+ FOS << ' ';
+ dumpBytes(Bytes, FOS);
+ }
+ FOS.flush();
+ // The output of printInst starts with a tab. Print some spaces so that
+ // the tab has 1 column and advances to the target tab stop.
+ unsigned TabStop = NoShowRawInsn ? 16 : 40;
+ unsigned Column = FOS.getColumn();
+ FOS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8);
+
+ // The dtor calls flush() to ensure the indent comes before printInst().
}
+
if (MI)
IP.printInst(MI, OS, "", STI);
else
- OS << " <unknown>";
+ OS << "\t<unknown>";
}
};
PrettyPrinter PrettyPrinterInst;
+
class HexagonPrettyPrinter : public PrettyPrinter {
public:
void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address,
@@ -1044,17 +705,17 @@ public:
if (!NoShowRawInsn) {
OS << "\t";
dumpBytes(Bytes.slice(0, 4), OS);
- OS << format("%08" PRIx32, opcode);
+ OS << format("\t%08" PRIx32, opcode);
}
}
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
- uint64_t Address, raw_ostream &OS, StringRef Annot,
- MCSubtargetInfo const &STI, SourcePrinter *SP,
+ object::SectionedAddress Address, raw_ostream &OS,
+ StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
std::vector<RelocationRef> *Rels) override {
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address, "");
if (!MI) {
- printLead(Bytes, Address, OS);
+ printLead(Bytes, Address.Address, OS);
OS << " <unknown>";
return;
}
@@ -1070,21 +731,15 @@ public:
auto HeadTail = PacketBundle.first.split('\n');
auto Preamble = " { ";
auto Separator = "";
- StringRef Fmt = "\t\t\t%08" PRIx64 ": ";
- std::vector<RelocationRef>::const_iterator RelCur = Rels->begin();
- std::vector<RelocationRef>::const_iterator RelEnd = Rels->end();
// Hexagon's packets require relocations to be inline rather than
// clustered at the end of the packet.
+ std::vector<RelocationRef>::const_iterator RelCur = Rels->begin();
+ std::vector<RelocationRef>::const_iterator RelEnd = Rels->end();
auto PrintReloc = [&]() -> void {
- while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address)) {
- if (RelCur->getOffset() == Address) {
- SmallString<16> Name;
- SmallString<32> Val;
- RelCur->getTypeName(Name);
- error(getRelocationValueString(*RelCur, Val));
- OS << Separator << format(Fmt.data(), Address) << Name << "\t" << Val
- << "\n";
+ while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address.Address)) {
+ if (RelCur->getOffset() == Address.Address) {
+ printRelocation(*RelCur, Address.Address, false);
return;
}
++RelCur;
@@ -1096,7 +751,7 @@ public:
Separator = "\n";
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address, "");
- printLead(Bytes, Address, OS);
+ printLead(Bytes, Address.Address, OS);
OS << Preamble;
Preamble = " ";
StringRef Inst;
@@ -1114,7 +769,7 @@ public:
OS << " } " << PacketBundle.second;
PrintReloc();
Bytes = Bytes.slice(4);
- Address += 4;
+ Address.Address += 4;
}
}
};
@@ -1123,14 +778,12 @@ HexagonPrettyPrinter HexagonPrettyPrinterInst;
class AMDGCNPrettyPrinter : public PrettyPrinter {
public:
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
- uint64_t Address, raw_ostream &OS, StringRef Annot,
- MCSubtargetInfo const &STI, SourcePrinter *SP,
+ object::SectionedAddress Address, raw_ostream &OS,
+ StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
std::vector<RelocationRef> *Rels) override {
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address);
- typedef support::ulittle32_t U32;
-
if (MI) {
SmallString<40> InstStr;
raw_svector_ostream IS(InstStr);
@@ -1144,7 +797,7 @@ public:
// remaining
if (Bytes.size() >= 4) {
OS << format("\t.long 0x%08" PRIx32 " ",
- static_cast<uint32_t>(*reinterpret_cast<const U32*>(Bytes.data())));
+ support::endian::read32<support::little>(Bytes.data()));
OS.indent(42);
} else {
OS << format("\t.byte 0x%02" PRIx8, Bytes[0]);
@@ -1154,20 +807,21 @@ public:
}
}
- OS << format("// %012" PRIX64 ": ", Address);
- if (Bytes.size() >=4) {
- for (auto D : makeArrayRef(reinterpret_cast<const U32*>(Bytes.data()),
- Bytes.size() / sizeof(U32)))
- // D should be explicitly casted to uint32_t here as it is passed
- // by format to snprintf as vararg.
- OS << format("%08" PRIX32 " ", static_cast<uint32_t>(D));
+ OS << format("// %012" PRIX64 ":", Address.Address);
+ if (Bytes.size() >= 4) {
+ // D should be casted to uint32_t here as it is passed by format to
+ // snprintf as vararg.
+ for (uint32_t D : makeArrayRef(
+ reinterpret_cast<const support::little32_t *>(Bytes.data()),
+ Bytes.size() / 4))
+ OS << format(" %08" PRIX32, D);
} else {
- for (unsigned int i = 0; i < Bytes.size(); i++)
- OS << format("%02" PRIX8 " ", Bytes[i]);
+ for (unsigned char B : Bytes)
+ OS << format(" %02" PRIX8, B);
}
if (!Annot.empty())
- OS << "// " << Annot;
+ OS << " // " << Annot;
}
};
AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst;
@@ -1175,13 +829,13 @@ AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst;
class BPFPrettyPrinter : public PrettyPrinter {
public:
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
- uint64_t Address, raw_ostream &OS, StringRef Annot,
- MCSubtargetInfo const &STI, SourcePrinter *SP,
+ object::SectionedAddress Address, raw_ostream &OS,
+ StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
std::vector<RelocationRef> *Rels) override {
if (SP && (PrintSource || PrintLines))
SP->printSourceLine(OS, Address);
if (!NoLeadingAddr)
- OS << format("%8" PRId64 ":", Address / 8);
+ OS << format("%8" PRId64 ":", Address.Address / 8);
if (!NoShowRawInsn) {
OS << "\t";
dumpBytes(Bytes, OS);
@@ -1189,7 +843,7 @@ public:
if (MI)
IP.printInst(MI, OS, "", STI);
else
- OS << " <unknown>";
+ OS << "\t<unknown>";
}
};
BPFPrettyPrinter BPFPrettyPrinterInst;
@@ -1227,27 +881,25 @@ addDynamicElfSymbols(const ELFObjectFile<ELFT> *Obj,
std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
for (auto Symbol : Obj->getDynamicSymbolIterators()) {
uint8_t SymbolType = Symbol.getELFType();
- if (SymbolType != ELF::STT_FUNC || Symbol.getSize() == 0)
+ if (SymbolType == ELF::STT_SECTION)
continue;
- Expected<uint64_t> AddressOrErr = Symbol.getAddress();
- if (!AddressOrErr)
- report_error(Obj->getFileName(), AddressOrErr.takeError());
+ uint64_t Address = unwrapOrError(Symbol.getAddress(), Obj->getFileName());
+ // ELFSymbolRef::getAddress() returns size instead of value for common
+ // symbols which is not desirable for disassembly output. Overriding.
+ if (SymbolType == ELF::STT_COMMON)
+ Address = Obj->getSymbol(Symbol.getRawDataRefImpl())->st_value;
- Expected<StringRef> Name = Symbol.getName();
- if (!Name)
- report_error(Obj->getFileName(), Name.takeError());
- if (Name->empty())
+ StringRef Name = unwrapOrError(Symbol.getName(), Obj->getFileName());
+ if (Name.empty())
continue;
- Expected<section_iterator> SectionOrErr = Symbol.getSection();
- if (!SectionOrErr)
- report_error(Obj->getFileName(), SectionOrErr.takeError());
- section_iterator SecI = *SectionOrErr;
+ section_iterator SecI =
+ unwrapOrError(Symbol.getSection(), Obj->getFileName());
if (SecI == Obj->section_end())
continue;
- AllSymbols[*SecI].emplace_back(*AddressOrErr, *Name, SymbolType);
+ AllSymbols[*SecI].emplace_back(Address, Name, SymbolType);
}
}
@@ -1285,14 +937,10 @@ static void addPltEntries(const ObjectFile *Obj,
SymbolRef Symbol(PltEntry.first, ElfObj);
uint8_t SymbolType = getElfSymbolType(Obj, Symbol);
- Expected<StringRef> NameOrErr = Symbol.getName();
- if (!NameOrErr)
- report_error(Obj->getFileName(), NameOrErr.takeError());
- if (NameOrErr->empty())
- continue;
- StringRef Name = Saver.save((*NameOrErr + "@plt").str());
-
- AllSymbols[*Plt].emplace_back(PltEntry.second, Name, SymbolType);
+ StringRef Name = unwrapOrError(Symbol.getName(), Obj->getFileName());
+ if (!Name.empty())
+ AllSymbols[*Plt].emplace_back(
+ PltEntry.second, Saver.save((Name + "@plt").str()), SymbolType);
}
}
}
@@ -1301,10 +949,6 @@ static void addPltEntries(const ObjectFile *Obj,
// 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) {
- // When -z or --disassemble-zeroes are given we always dissasemble them.
- if (DisassembleZeroes)
- return 0;
-
// Find the number of leading zeroes.
size_t N = 0;
while (N < Buf.size() && !Buf[N])
@@ -1320,108 +964,160 @@ static size_t countSkippableZeroBytes(ArrayRef<uint8_t> Buf) {
return N & ~0x3;
}
-static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
- if (StartAddress > StopAddress)
- error("Start address should be less than stop address");
-
- const Target *TheTarget = getTarget(Obj);
-
- // Package up features to be passed to target/subtarget
- SubtargetFeatures Features = Obj->getFeatures();
- if (!MAttrs.empty())
- for (unsigned I = 0; I != MAttrs.size(); ++I)
- Features.AddFeature(MAttrs[I]);
-
- std::unique_ptr<const MCRegisterInfo> MRI(
- TheTarget->createMCRegInfo(TripleName));
- if (!MRI)
- report_error(Obj->getFileName(), "no register info for target " +
- TripleName);
-
- // Set up disassembler.
- std::unique_ptr<const MCAsmInfo> AsmInfo(
- TheTarget->createMCAsmInfo(*MRI, TripleName));
- if (!AsmInfo)
- report_error(Obj->getFileName(), "no assembly info for target " +
- TripleName);
- std::unique_ptr<const MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
- if (!STI)
- report_error(Obj->getFileName(), "no subtarget info for target " +
- TripleName);
- std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
- if (!MII)
- report_error(Obj->getFileName(), "no instruction info for target " +
- TripleName);
- MCObjectFileInfo MOFI;
- MCContext Ctx(AsmInfo.get(), MRI.get(), &MOFI);
- // FIXME: for now initialize MCObjectFileInfo with default values
- MOFI.InitMCObjectFileInfo(Triple(TripleName), false, Ctx);
-
- std::unique_ptr<MCDisassembler> DisAsm(
- TheTarget->createMCDisassembler(*STI, Ctx));
- if (!DisAsm)
- report_error(Obj->getFileName(), "no disassembler for target " +
- TripleName);
+// Returns a map from sections to their relocations.
+static std::map<SectionRef, std::vector<RelocationRef>>
+getRelocsMap(object::ObjectFile const &Obj) {
+ std::map<SectionRef, std::vector<RelocationRef>> Ret;
+ for (SectionRef Sec : Obj.sections()) {
+ section_iterator Relocated = Sec.getRelocatedSection();
+ if (Relocated == Obj.section_end() || !shouldKeep(*Relocated))
+ continue;
+ std::vector<RelocationRef> &V = Ret[*Relocated];
+ for (const RelocationRef &R : Sec.relocations())
+ V.push_back(R);
+ // Sort relocations by address.
+ llvm::stable_sort(V, isRelocAddressLess);
+ }
+ return Ret;
+}
- std::unique_ptr<const MCInstrAnalysis> MIA(
- TheTarget->createMCInstrAnalysis(MII.get()));
+// 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) {
+ const ObjectFile *Obj = Section.getObject();
+ if (isa<object::ELFObjectFileBase>(Obj))
+ return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
+ return false;
+}
- int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
- std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
- Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
- if (!IP)
- report_error(Obj->getFileName(), "no instruction printer for target " +
- TripleName);
- IP->setPrintImmHex(PrintImmHex);
- PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName));
- StringRef Fmt = Obj->getBytesInAddress() > 4 ? "\t\t%016" PRIx64 ": " :
- "\t\t\t%08" PRIx64 ": ";
+typedef std::pair<uint64_t, char> MappingSymbolPair;
+static char getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols,
+ uint64_t Address) {
+ auto It =
+ partition_point(MappingSymbols, [Address](const MappingSymbolPair &Val) {
+ return Val.first <= Address;
+ });
+ // Return zero for any address before the first mapping symbol; this means
+ // we should use the default disassembly mode, depending on the target.
+ if (It == MappingSymbols.begin())
+ return '\x00';
+ return (It - 1)->second;
+}
- SourcePrinter SP(Obj, TheTarget->getName());
+static uint64_t
+dumpARMELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End,
+ const ObjectFile *Obj, ArrayRef<uint8_t> Bytes,
+ ArrayRef<MappingSymbolPair> MappingSymbols) {
+ support::endianness Endian =
+ Obj->isLittleEndian() ? support::little : support::big;
+ while (Index < End) {
+ outs() << format("%8" PRIx64 ":", SectionAddr + Index);
+ outs() << "\t";
+ if (Index + 4 <= End) {
+ dumpBytes(Bytes.slice(Index, 4), outs());
+ outs() << "\t.word\t"
+ << format_hex(
+ support::endian::read32(Bytes.data() + Index, Endian), 10);
+ Index += 4;
+ } else if (Index + 2 <= End) {
+ dumpBytes(Bytes.slice(Index, 2), outs());
+ outs() << "\t\t.short\t"
+ << format_hex(
+ support::endian::read16(Bytes.data() + Index, Endian), 6);
+ Index += 2;
+ } else {
+ dumpBytes(Bytes.slice(Index, 1), outs());
+ outs() << "\t\t.byte\t" << format_hex(Bytes[0], 4);
+ ++Index;
+ }
+ outs() << "\n";
+ if (getMappingSymbolKind(MappingSymbols, Index) != 'd')
+ break;
+ }
+ return Index;
+}
- // Create a mapping, RelocSecs = SectionRelocMap[S], where sections
- // in RelocSecs contain the relocations for section S.
- std::error_code EC;
- std::map<SectionRef, SmallVector<SectionRef, 1>> SectionRelocMap;
- for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
- section_iterator Sec2 = Section.getRelocatedSection();
- if (Sec2 != Obj->section_end())
- SectionRelocMap[*Sec2].push_back(Section);
+static void dumpELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End,
+ ArrayRef<uint8_t> Bytes) {
+ // print out data up to 8 bytes at a time in hex and ascii
+ uint8_t AsciiData[9] = {'\0'};
+ uint8_t Byte;
+ int NumBytes = 0;
+
+ for (; Index < End; ++Index) {
+ if (NumBytes == 0)
+ outs() << format("%8" PRIx64 ":", SectionAddr + Index);
+ Byte = Bytes.slice(Index)[0];
+ outs() << format(" %02x", Byte);
+ AsciiData[NumBytes] = isPrint(Byte) ? Byte : '.';
+
+ uint8_t IndentOffset = 0;
+ NumBytes++;
+ if (Index == End - 1 || NumBytes > 8) {
+ // Indent the space for less than 8 bytes data.
+ // 2 spaces for byte and one for space between bytes
+ IndentOffset = 3 * (8 - NumBytes);
+ for (int Excess = NumBytes; Excess < 8; Excess++)
+ AsciiData[Excess] = '\0';
+ NumBytes = 8;
+ }
+ if (NumBytes == 8) {
+ AsciiData[8] = '\0';
+ outs() << std::string(IndentOffset, ' ') << " ";
+ outs() << reinterpret_cast<char *>(AsciiData);
+ outs() << '\n';
+ NumBytes = 0;
+ }
}
+}
+
+static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj,
+ MCContext &Ctx, MCDisassembler *PrimaryDisAsm,
+ MCDisassembler *SecondaryDisAsm,
+ const MCInstrAnalysis *MIA, MCInstPrinter *IP,
+ const MCSubtargetInfo *PrimarySTI,
+ const MCSubtargetInfo *SecondarySTI,
+ PrettyPrinter &PIP,
+ SourcePrinter &SP, bool InlineRelocs) {
+ const MCSubtargetInfo *STI = PrimarySTI;
+ MCDisassembler *DisAsm = PrimaryDisAsm;
+ bool PrimaryIsThumb = false;
+ if (isArmElf(Obj))
+ PrimaryIsThumb = STI->checkFeatures("+thumb-mode");
+
+ std::map<SectionRef, std::vector<RelocationRef>> RelocMap;
+ if (InlineRelocs)
+ RelocMap = getRelocsMap(*Obj);
+ bool Is64Bits = Obj->getBytesInAddress() > 4;
// Create a mapping from virtual address to symbol name. This is used to
// pretty print the symbols while disassembling.
std::map<SectionRef, SectionSymbolsTy> AllSymbols;
SectionSymbolsTy AbsoluteSymbols;
+ const StringRef FileName = Obj->getFileName();
for (const SymbolRef &Symbol : Obj->symbols()) {
- Expected<uint64_t> AddressOrErr = Symbol.getAddress();
- if (!AddressOrErr)
- report_error(Obj->getFileName(), AddressOrErr.takeError());
- uint64_t Address = *AddressOrErr;
-
- Expected<StringRef> Name = Symbol.getName();
- if (!Name)
- report_error(Obj->getFileName(), Name.takeError());
- if (Name->empty())
- continue;
+ uint64_t Address = unwrapOrError(Symbol.getAddress(), FileName);
- Expected<section_iterator> SectionOrErr = Symbol.getSection();
- if (!SectionOrErr)
- report_error(Obj->getFileName(), SectionOrErr.takeError());
+ StringRef Name = unwrapOrError(Symbol.getName(), FileName);
+ if (Name.empty())
+ continue;
uint8_t SymbolType = ELF::STT_NOTYPE;
- if (Obj->isELF())
+ if (Obj->isELF()) {
SymbolType = getElfSymbolType(Obj, Symbol);
+ if (SymbolType == ELF::STT_SECTION)
+ continue;
+ }
- section_iterator SecI = *SectionOrErr;
+ section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName);
if (SecI != Obj->section_end())
- AllSymbols[*SecI].emplace_back(Address, *Name, SymbolType);
+ AllSymbols[*SecI].emplace_back(Address, Name, SymbolType);
else
- AbsoluteSymbols.emplace_back(Address, *Name, SymbolType);
-
-
+ AbsoluteSymbols.emplace_back(Address, Name, SymbolType);
}
if (AllSymbols.empty() && Obj->isELF())
addDynamicElfSymbols(Obj, AllSymbols);
@@ -1448,31 +1144,28 @@ static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
error(ExportEntry.getExportRVA(RVA));
uint64_t VA = COFFObj->getImageBase() + RVA;
- auto Sec = std::upper_bound(
- SectionAddresses.begin(), SectionAddresses.end(), VA,
- [](uint64_t LHS, const std::pair<uint64_t, SectionRef> &RHS) {
- return LHS < RHS.first;
+ auto Sec = partition_point(
+ SectionAddresses, [VA](const std::pair<uint64_t, SectionRef> &O) {
+ return O.first <= VA;
});
- if (Sec != SectionAddresses.begin())
+ if (Sec != SectionAddresses.begin()) {
--Sec;
- else
- Sec = SectionAddresses.end();
-
- if (Sec != SectionAddresses.end())
AllSymbols[Sec->second].emplace_back(VA, Name, ELF::STT_NOTYPE);
- else
+ } else
AbsoluteSymbols.emplace_back(VA, Name, ELF::STT_NOTYPE);
}
}
// Sort all the symbols, this allows us to use a simple binary search to find
// a symbol near an address.
+ StringSet<> FoundDisasmFuncsSet;
for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
array_pod_sort(SecSyms.second.begin(), SecSyms.second.end());
array_pod_sort(AbsoluteSymbols.begin(), AbsoluteSymbols.end());
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
- if (!DisassembleAll && (!Section.isText() || Section.isVirtual()))
+ if (FilterSections.empty() && !DisassembleAll &&
+ (!Section.isText() || Section.isVirtual()))
continue;
uint64_t SectionAddr = Section.getAddress();
@@ -1482,25 +1175,23 @@ static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
// Get the list of all the symbols in this section.
SectionSymbolsTy &Symbols = AllSymbols[Section];
- std::vector<uint64_t> DataMappingSymsAddr;
- std::vector<uint64_t> TextMappingSymsAddr;
- if (isArmElf(Obj)) {
+ std::vector<MappingSymbolPair> MappingSymbols;
+ if (hasMappingSymbols(Obj)) {
for (const auto &Symb : Symbols) {
uint64_t Address = std::get<0>(Symb);
StringRef Name = std::get<1>(Symb);
if (Name.startswith("$d"))
- DataMappingSymsAddr.push_back(Address - SectionAddr);
+ MappingSymbols.emplace_back(Address - SectionAddr, 'd');
if (Name.startswith("$x"))
- TextMappingSymsAddr.push_back(Address - SectionAddr);
+ MappingSymbols.emplace_back(Address - SectionAddr, 'x');
if (Name.startswith("$a"))
- TextMappingSymsAddr.push_back(Address - SectionAddr);
+ MappingSymbols.emplace_back(Address - SectionAddr, 'a');
if (Name.startswith("$t"))
- TextMappingSymsAddr.push_back(Address - SectionAddr);
+ MappingSymbols.emplace_back(Address - SectionAddr, 't');
}
}
- llvm::sort(DataMappingSymsAddr);
- llvm::sort(TextMappingSymsAddr);
+ llvm::sort(MappingSymbols);
if (Obj->isELF() && Obj->getArch() == Triple::amdgcn) {
// AMDGPU disassembler uses symbolizer for printing labels
@@ -1514,19 +1205,6 @@ static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
}
}
- // Make a list of all the relocations for this section.
- std::vector<RelocationRef> Rels;
- if (InlineRelocs) {
- for (const SectionRef &RelocSec : SectionRelocMap[Section]) {
- for (const RelocationRef &Reloc : RelocSec.relocations()) {
- Rels.push_back(Reloc);
- }
- }
- }
-
- // Sort relocations by address.
- llvm::sort(Rels, isRelocAddressLess);
-
StringRef SegmentName = "";
if (const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj)) {
DataRefImpl DR = Section.getRawDataRefImpl();
@@ -1546,56 +1224,54 @@ static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
SmallString<40> Comments;
raw_svector_ostream CommentStream(Comments);
- StringRef BytesStr;
- error(Section.getContents(BytesStr));
- ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
- BytesStr.size());
+ ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(
+ unwrapOrError(Section.getContents(), Obj->getFileName()));
+
+ uint64_t VMAAdjustment = 0;
+ if (shouldAdjustVA(Section))
+ VMAAdjustment = AdjustVMA;
uint64_t Size;
uint64_t Index;
bool PrintedSection = false;
-
+ std::vector<RelocationRef> Rels = RelocMap[Section];
std::vector<RelocationRef>::const_iterator RelCur = Rels.begin();
std::vector<RelocationRef>::const_iterator RelEnd = Rels.end();
// Disassemble symbol by symbol.
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
- uint64_t Start = std::get<0>(Symbols[SI]) - SectionAddr;
- // The end is either the section end or the beginning of the next
- // symbol.
- uint64_t End = (SI == SE - 1)
- ? SectSize
- : std::get<0>(Symbols[SI + 1]) - SectionAddr;
- // Don't try to disassemble beyond the end of section contents.
- if (End > SectSize)
- End = SectSize;
- // If this symbol has the same address as the next symbol, then skip it.
- if (Start >= End)
- continue;
+ std::string SymbolName = std::get<1>(Symbols[SI]).str();
+ if (Demangle)
+ SymbolName = demangle(SymbolName);
- // Check if we need to skip symbol
- // Skip if the symbol's data is not between StartAddress and StopAddress
- if (End + SectionAddr < StartAddress ||
- Start + SectionAddr > StopAddress) {
+ // Skip if --disassemble-functions is not empty and the symbol is not in
+ // the list.
+ if (!DisasmFuncsSet.empty() && !DisasmFuncsSet.count(SymbolName))
continue;
- }
- /// Skip if user requested specific symbols and this is not in the list
- if (!DisasmFuncsSet.empty() &&
- !DisasmFuncsSet.count(std::get<1>(Symbols[SI])))
+ uint64_t Start = std::get<0>(Symbols[SI]);
+ if (Start < SectionAddr || StopAddress <= Start)
continue;
+ else
+ FoundDisasmFuncsSet.insert(SymbolName);
+
+ // The end is the section end, the beginning of the next symbol, or
+ // --stop-address.
+ uint64_t End = std::min<uint64_t>(SectionAddr + SectSize, StopAddress);
+ if (SI + 1 < SE)
+ End = std::min(End, std::get<0>(Symbols[SI + 1]));
+ if (Start >= End || End <= StartAddress)
+ continue;
+ Start -= SectionAddr;
+ End -= SectionAddr;
if (!PrintedSection) {
PrintedSection = true;
- outs() << "Disassembly of section ";
+ outs() << "\nDisassembly of section ";
if (!SegmentName.empty())
outs() << SegmentName << ",";
- outs() << SectionName << ':';
+ outs() << SectionName << ":\n";
}
- // Stop disassembly at the stop address specified
- if (End + SectionAddr > StopAddress)
- End = StopAddress - SectionAddr;
-
if (Obj->isELF() && Obj->getArch() == Triple::amdgcn) {
if (std::get<2>(Symbols[SI]) == ELF::STT_AMDGPU_HSA_KERNEL) {
// skip amd_kernel_code_t at the begining of kernel symbol (256 bytes)
@@ -1615,13 +1291,10 @@ static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
outs() << '\n';
if (!NoLeadingAddr)
- outs() << format("%016" PRIx64 " ", SectionAddr + Start);
+ outs() << format(Is64Bits ? "%016" PRIx64 " " : "%08" PRIx64 " ",
+ SectionAddr + Start + VMAAdjustment);
- StringRef SymbolName = std::get<1>(Symbols[SI]);
- if (Demangle)
- outs() << demangle(SymbolName) << ":\n";
- else
- outs() << SymbolName << ":\n";
+ outs() << SymbolName << ":\n";
// Don't print raw contents of a virtual section. A virtual section
// doesn't have any contents in the file.
@@ -1636,143 +1309,82 @@ static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
raw_ostream &DebugOut = nulls();
#endif
- for (Index = Start; Index < End; Index += Size) {
- MCInst Inst;
+ // Some targets (like WebAssembly) have a special prelude at the start
+ // of each symbol.
+ DisAsm->onSymbolStart(SymbolName, Size, Bytes.slice(Start, End - Start),
+ SectionAddr + Start, DebugOut, CommentStream);
+ Start += Size;
+
+ Index = Start;
+ if (SectionAddr < StartAddress)
+ Index = std::max<uint64_t>(Index, StartAddress - SectionAddr);
+
+ // If there is a data/common symbol inside an ELF text section and we are
+ // only disassembling text (applicable all architectures), we are in a
+ // situation where we must print the data and not disassemble it.
+ if (Obj->isELF() && !DisassembleAll && Section.isText()) {
+ uint8_t SymTy = std::get<2>(Symbols[SI]);
+ if (SymTy == ELF::STT_OBJECT || SymTy == ELF::STT_COMMON) {
+ dumpELFData(SectionAddr, Index, End, Bytes);
+ Index = End;
+ }
+ }
- if (Index + SectionAddr < StartAddress ||
- Index + SectionAddr > StopAddress) {
- // skip byte by byte till StartAddress is reached
- Size = 1;
+ bool CheckARMELFData = hasMappingSymbols(Obj) &&
+ std::get<2>(Symbols[SI]) != ELF::STT_OBJECT &&
+ !DisassembleAll;
+ while (Index < End) {
+ // ARM and AArch64 ELF binaries can interleave data and text in the
+ // same section. We rely on the markers introduced to understand what
+ // we need to dump. If the data marker is within a function, it is
+ // denoted as a word/short etc.
+ if (CheckARMELFData &&
+ getMappingSymbolKind(MappingSymbols, Index) == 'd') {
+ Index = dumpARMELFData(SectionAddr, Index, End, Obj, Bytes,
+ MappingSymbols);
continue;
}
- // AArch64 ELF binaries can interleave data and text in the
- // same section. We rely on the markers introduced to
- // understand what we need to dump. If the data marker is within a
- // function, it is denoted as a word/short etc
- if (isArmElf(Obj) && std::get<2>(Symbols[SI]) != ELF::STT_OBJECT &&
- !DisassembleAll) {
- uint64_t Stride = 0;
-
- auto DAI = std::lower_bound(DataMappingSymsAddr.begin(),
- DataMappingSymsAddr.end(), Index);
- if (DAI != DataMappingSymsAddr.end() && *DAI == Index) {
- // Switch to data.
- while (Index < End) {
- outs() << format("%8" PRIx64 ":", SectionAddr + Index);
- outs() << "\t";
- if (Index + 4 <= End) {
- Stride = 4;
- dumpBytes(Bytes.slice(Index, 4), outs());
- outs() << "\t.word\t";
- uint32_t Data = 0;
- if (Obj->isLittleEndian()) {
- const auto Word =
- reinterpret_cast<const support::ulittle32_t *>(
- Bytes.data() + Index);
- Data = *Word;
- } else {
- const auto Word = reinterpret_cast<const support::ubig32_t *>(
- Bytes.data() + Index);
- Data = *Word;
- }
- outs() << "0x" << format("%08" PRIx32, Data);
- } else if (Index + 2 <= End) {
- Stride = 2;
- dumpBytes(Bytes.slice(Index, 2), outs());
- outs() << "\t\t.short\t";
- uint16_t Data = 0;
- if (Obj->isLittleEndian()) {
- const auto Short =
- reinterpret_cast<const support::ulittle16_t *>(
- Bytes.data() + Index);
- Data = *Short;
- } else {
- const auto Short =
- reinterpret_cast<const support::ubig16_t *>(Bytes.data() +
- Index);
- Data = *Short;
- }
- outs() << "0x" << format("%04" PRIx16, Data);
- } else {
- Stride = 1;
- dumpBytes(Bytes.slice(Index, 1), outs());
- outs() << "\t\t.byte\t";
- outs() << "0x" << format("%02" PRIx8, Bytes.slice(Index, 1)[0]);
- }
- Index += Stride;
- outs() << "\n";
- auto TAI = std::lower_bound(TextMappingSymsAddr.begin(),
- TextMappingSymsAddr.end(), Index);
- if (TAI != TextMappingSymsAddr.end() && *TAI == Index)
- break;
- }
+
+ // When -z or --disassemble-zeroes are given we always dissasemble
+ // them. Otherwise we might want to skip zero bytes we see.
+ if (!DisassembleZeroes) {
+ uint64_t MaxOffset = End - Index;
+ // For -reloc: print zero blocks patched by relocations, so that
+ // relocations can be shown in the dump.
+ if (RelCur != RelEnd)
+ MaxOffset = RelCur->getOffset() - Index;
+
+ if (size_t N =
+ countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) {
+ outs() << "\t\t..." << '\n';
+ Index += N;
+ continue;
}
}
- // If there is a data symbol inside an ELF text section and we are only
- // disassembling text (applicable all architectures),
- // we are in a situation where we must print the data and not
- // disassemble it.
- if (Obj->isELF() && std::get<2>(Symbols[SI]) == ELF::STT_OBJECT &&
- !DisassembleAll && Section.isText()) {
- // print out data up to 8 bytes at a time in hex and ascii
- uint8_t AsciiData[9] = {'\0'};
- uint8_t Byte;
- int NumBytes = 0;
-
- for (Index = Start; Index < End; Index += 1) {
- if (((SectionAddr + Index) < StartAddress) ||
- ((SectionAddr + Index) > StopAddress))
- continue;
- if (NumBytes == 0) {
- outs() << format("%8" PRIx64 ":", SectionAddr + Index);
- outs() << "\t";
- }
- Byte = Bytes.slice(Index)[0];
- outs() << format(" %02x", Byte);
- AsciiData[NumBytes] = isPrint(Byte) ? Byte : '.';
-
- uint8_t IndentOffset = 0;
- NumBytes++;
- if (Index == End - 1 || NumBytes > 8) {
- // Indent the space for less than 8 bytes data.
- // 2 spaces for byte and one for space between bytes
- IndentOffset = 3 * (8 - NumBytes);
- for (int Excess = 8 - NumBytes; Excess < 8; Excess++)
- AsciiData[Excess] = '\0';
- NumBytes = 8;
- }
- if (NumBytes == 8) {
- AsciiData[8] = '\0';
- outs() << std::string(IndentOffset, ' ') << " ";
- outs() << reinterpret_cast<char *>(AsciiData);
- outs() << '\n';
- NumBytes = 0;
- }
+ if (SecondarySTI) {
+ if (getMappingSymbolKind(MappingSymbols, Index) == 'a') {
+ STI = PrimaryIsThumb ? SecondarySTI : PrimarySTI;
+ DisAsm = PrimaryIsThumb ? SecondaryDisAsm : PrimaryDisAsm;
+ } else if (getMappingSymbolKind(MappingSymbols, Index) == 't') {
+ STI = PrimaryIsThumb ? PrimarySTI : SecondarySTI;
+ DisAsm = PrimaryIsThumb ? PrimaryDisAsm : SecondaryDisAsm;
}
}
- if (Index >= End)
- break;
-
- if (size_t N =
- countSkippableZeroBytes(Bytes.slice(Index, End - Index))) {
- outs() << "\t\t..." << '\n';
- Index += N;
- if (Index >= End)
- break;
- }
// Disassemble a real instruction or a data when disassemble all is
// provided
- bool Disassembled = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
- SectionAddr + Index, DebugOut,
- CommentStream);
+ MCInst Inst;
+ bool Disassembled = DisAsm->getInstruction(
+ Inst, Size, Bytes.slice(Index), SectionAddr + Index, DebugOut,
+ CommentStream);
if (Size == 0)
Size = 1;
- PIP.printInst(*IP, Disassembled ? &Inst : nullptr,
- Bytes.slice(Index, Size), SectionAddr + Index, outs(), "",
- *STI, &SP, &Rels);
+ PIP.printInst(
+ *IP, Disassembled ? &Inst : nullptr, Bytes.slice(Index, Size),
+ {SectionAddr + Index + VMAAdjustment, Section.getIndex()}, outs(),
+ "", *STI, &SP, &Rels);
outs() << CommentStream.str();
Comments.clear();
@@ -1791,37 +1403,34 @@ static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
// N.B. We don't walk the relocations in the relocatable case yet.
auto *TargetSectionSymbols = &Symbols;
if (!Obj->isRelocatableObject()) {
- auto SectionAddress = std::upper_bound(
- SectionAddresses.begin(), SectionAddresses.end(), Target,
- [](uint64_t LHS,
- const std::pair<uint64_t, SectionRef> &RHS) {
- return LHS < RHS.first;
+ auto It = partition_point(
+ SectionAddresses,
+ [=](const std::pair<uint64_t, SectionRef> &O) {
+ return O.first <= Target;
});
- if (SectionAddress != SectionAddresses.begin()) {
- --SectionAddress;
- TargetSectionSymbols = &AllSymbols[SectionAddress->second];
+ if (It != SectionAddresses.begin()) {
+ --It;
+ TargetSectionSymbols = &AllSymbols[It->second];
} else {
TargetSectionSymbols = &AbsoluteSymbols;
}
}
- // Find the first symbol in the section whose offset is less than
+ // Find the last symbol in the section whose offset is less than
// or equal to the target. If there isn't a section that contains
// the target, find the nearest preceding absolute symbol.
- auto TargetSym = std::upper_bound(
- TargetSectionSymbols->begin(), TargetSectionSymbols->end(),
- Target, [](uint64_t LHS,
- const std::tuple<uint64_t, StringRef, uint8_t> &RHS) {
- return LHS < std::get<0>(RHS);
+ auto TargetSym = partition_point(
+ *TargetSectionSymbols,
+ [=](const std::tuple<uint64_t, StringRef, uint8_t> &O) {
+ return std::get<0>(O) <= Target;
});
if (TargetSym == TargetSectionSymbols->begin()) {
TargetSectionSymbols = &AbsoluteSymbols;
- TargetSym = std::upper_bound(
- AbsoluteSymbols.begin(), AbsoluteSymbols.end(),
- Target, [](uint64_t LHS,
- const std::tuple<uint64_t, StringRef, uint8_t> &RHS) {
- return LHS < std::get<0>(RHS);
- });
+ TargetSym = partition_point(
+ AbsoluteSymbols,
+ [=](const std::tuple<uint64_t, StringRef, uint8_t> &O) {
+ return std::get<0>(O) <= Target;
+ });
}
if (TargetSym != TargetSectionSymbols->begin()) {
--TargetSym;
@@ -1838,34 +1447,125 @@ static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
outs() << "\n";
// Hexagon does this in pretty printer
- if (Obj->getArch() != Triple::hexagon)
+ if (Obj->getArch() != Triple::hexagon) {
// Print relocation for instruction.
while (RelCur != RelEnd) {
- uint64_t Addr = RelCur->getOffset();
- SmallString<16> Name;
- SmallString<32> Val;
-
+ uint64_t Offset = RelCur->getOffset();
// If this relocation is hidden, skip it.
- if (getHidden(*RelCur) || ((SectionAddr + Addr) < StartAddress)) {
+ if (getHidden(*RelCur) || SectionAddr + Offset < StartAddress) {
++RelCur;
continue;
}
- // Stop when rel_cur's address is past the current instruction.
- if (Addr >= Index + Size)
+ // Stop when RelCur's offset is past the current instruction.
+ if (Offset >= Index + Size)
break;
- RelCur->getTypeName(Name);
- error(getRelocationValueString(*RelCur, Val));
- outs() << format(Fmt.data(), SectionAddr + Addr) << Name << "\t"
- << Val << "\n";
+
+ // When --adjust-vma is used, update the address printed.
+ if (RelCur->getSymbol() != Obj->symbol_end()) {
+ Expected<section_iterator> SymSI =
+ RelCur->getSymbol()->getSection();
+ if (SymSI && *SymSI != Obj->section_end() &&
+ shouldAdjustVA(**SymSI))
+ Offset += AdjustVMA;
+ }
+
+ printRelocation(*RelCur, SectionAddr + Offset, Is64Bits);
++RelCur;
}
+ }
+
+ Index += Size;
}
}
}
+ StringSet<> MissingDisasmFuncsSet =
+ set_difference(DisasmFuncsSet, FoundDisasmFuncsSet);
+ for (StringRef MissingDisasmFunc : MissingDisasmFuncsSet.keys())
+ warn("failed to disassemble missing function " + MissingDisasmFunc);
+}
+
+static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
+ const Target *TheTarget = getTarget(Obj);
+
+ // Package up features to be passed to target/subtarget
+ SubtargetFeatures Features = Obj->getFeatures();
+ if (!MAttrs.empty())
+ for (unsigned I = 0; I != MAttrs.size(); ++I)
+ Features.AddFeature(MAttrs[I]);
+
+ std::unique_ptr<const MCRegisterInfo> MRI(
+ TheTarget->createMCRegInfo(TripleName));
+ if (!MRI)
+ report_error(Obj->getFileName(),
+ "no register info for target " + TripleName);
+
+ // Set up disassembler.
+ std::unique_ptr<const MCAsmInfo> AsmInfo(
+ TheTarget->createMCAsmInfo(*MRI, TripleName));
+ if (!AsmInfo)
+ report_error(Obj->getFileName(),
+ "no assembly info for target " + TripleName);
+ std::unique_ptr<const MCSubtargetInfo> STI(
+ TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
+ if (!STI)
+ report_error(Obj->getFileName(),
+ "no subtarget info for target " + TripleName);
+ std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
+ if (!MII)
+ report_error(Obj->getFileName(),
+ "no instruction info for target " + TripleName);
+ MCObjectFileInfo MOFI;
+ MCContext Ctx(AsmInfo.get(), MRI.get(), &MOFI);
+ // FIXME: for now initialize MCObjectFileInfo with default values
+ MOFI.InitMCObjectFileInfo(Triple(TripleName), false, Ctx);
+
+ std::unique_ptr<MCDisassembler> DisAsm(
+ TheTarget->createMCDisassembler(*STI, Ctx));
+ if (!DisAsm)
+ report_error(Obj->getFileName(),
+ "no disassembler for target " + TripleName);
+
+ // If we have an ARM object file, we need a second disassembler, because
+ // ARM CPUs have two different instruction sets: ARM mode, and Thumb mode.
+ // We use mapping symbols to switch between the two assemblers, where
+ // appropriate.
+ std::unique_ptr<MCDisassembler> SecondaryDisAsm;
+ std::unique_ptr<const MCSubtargetInfo> SecondarySTI;
+ if (isArmElf(Obj) && !STI->checkFeatures("+mclass")) {
+ if (STI->checkFeatures("+thumb-mode"))
+ Features.AddFeature("-thumb-mode");
+ else
+ Features.AddFeature("+thumb-mode");
+ SecondarySTI.reset(TheTarget->createMCSubtargetInfo(TripleName, MCPU,
+ Features.getString()));
+ SecondaryDisAsm.reset(TheTarget->createMCDisassembler(*SecondarySTI, Ctx));
+ }
+
+ std::unique_ptr<const MCInstrAnalysis> MIA(
+ TheTarget->createMCInstrAnalysis(MII.get()));
+
+ int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
+ std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
+ Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
+ if (!IP)
+ report_error(Obj->getFileName(),
+ "no instruction printer for target " + TripleName);
+ IP->setPrintImmHex(PrintImmHex);
+
+ PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName));
+ SourcePrinter SP(Obj, TheTarget->getName());
+
+ for (StringRef Opt : DisassemblerOptions)
+ if (!IP->applyTargetSpecificCLOption(Opt))
+ error("Unrecognized disassembler option: " + Opt);
+
+ disassembleObject(TheTarget, Obj, Ctx, DisAsm.get(), SecondaryDisAsm.get(),
+ MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP,
+ SP, InlineRelocs);
}
-void llvm::printRelocations(const ObjectFile *Obj) {
+void printRelocations(const ObjectFile *Obj) {
StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 :
"%08" PRIx64;
// Regular objdump doesn't print relocations in non-relocatable object
@@ -1873,28 +1573,40 @@ void llvm::printRelocations(const ObjectFile *Obj) {
if (!Obj->isRelocatableObject())
return;
+ // Build a mapping from relocation target to a vector of relocation
+ // sections. Usually, there is an only one relocation section for
+ // each relocated section.
+ MapVector<SectionRef, std::vector<SectionRef>> SecToRelSec;
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
if (Section.relocation_begin() == Section.relocation_end())
continue;
+ const SectionRef TargetSec = *Section.getRelocatedSection();
+ SecToRelSec[TargetSec].push_back(Section);
+ }
+
+ for (std::pair<SectionRef, std::vector<SectionRef>> &P : SecToRelSec) {
StringRef SecName;
- error(Section.getName(SecName));
+ error(P.first.getName(SecName));
outs() << "RELOCATION RECORDS FOR [" << SecName << "]:\n";
- for (const RelocationRef &Reloc : Section.relocations()) {
- uint64_t Address = Reloc.getOffset();
- SmallString<32> RelocName;
- SmallString<32> ValueStr;
- if (Address < StartAddress || Address > StopAddress || getHidden(Reloc))
- continue;
- Reloc.getTypeName(RelocName);
- error(getRelocationValueString(Reloc, ValueStr));
- outs() << format(Fmt.data(), Address) << " " << RelocName << " "
- << ValueStr << "\n";
+
+ for (SectionRef Section : P.second) {
+ for (const RelocationRef &Reloc : Section.relocations()) {
+ uint64_t Address = Reloc.getOffset();
+ SmallString<32> RelocName;
+ SmallString<32> ValueStr;
+ if (Address < StartAddress || Address > StopAddress || getHidden(Reloc))
+ continue;
+ Reloc.getTypeName(RelocName);
+ error(getRelocationValueString(Reloc, ValueStr));
+ outs() << format(Fmt.data(), Address) << " " << RelocName << " "
+ << ValueStr << "\n";
+ }
}
outs() << "\n";
}
}
-void llvm::printDynamicRelocations(const ObjectFile *Obj) {
+void printDynamicRelocations(const ObjectFile *Obj) {
// For the moment, this option is for ELF only
if (!Obj->isELF())
return;
@@ -1911,9 +1623,7 @@ void llvm::printDynamicRelocations(const ObjectFile *Obj) {
outs() << "DYNAMIC RELOCATION RECORDS\n";
StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64;
- for (const SectionRef &Section : DynRelSec) {
- if (Section.relocation_begin() == Section.relocation_end())
- continue;
+ for (const SectionRef &Section : DynRelSec)
for (const RelocationRef &Reloc : Section.relocations()) {
uint64_t Address = Reloc.getOffset();
SmallString<32> RelocName;
@@ -1923,34 +1633,60 @@ void llvm::printDynamicRelocations(const ObjectFile *Obj) {
outs() << format(Fmt.data(), Address) << " " << RelocName << " "
<< ValueStr << "\n";
}
- }
}
-void llvm::printSectionHeaders(const ObjectFile *Obj) {
- outs() << "Sections:\n"
- "Idx Name Size Address Type\n";
+// 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) {
+ if (!Obj->isELF())
+ return false;
+ for (const SectionRef &S : ToolSectionFilter(*Obj))
+ if (S.getAddress() != getELFSectionLMA(S))
+ return true;
+ return ShowLMA;
+}
+
+void printSectionHeaders(const ObjectFile *Obj) {
+ bool HasLMAColumn = shouldDisplayLMA(Obj);
+ if (HasLMAColumn)
+ outs() << "Sections:\n"
+ "Idx Name Size VMA LMA "
+ "Type\n";
+ else
+ outs() << "Sections:\n"
+ "Idx Name Size VMA Type\n";
+
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
StringRef Name;
error(Section.getName(Name));
- uint64_t Address = Section.getAddress();
+ uint64_t VMA = Section.getAddress();
+ if (shouldAdjustVA(Section))
+ VMA += AdjustVMA;
+
uint64_t Size = Section.getSize();
bool Text = Section.isText();
bool Data = Section.isData();
bool BSS = Section.isBSS();
std::string Type = (std::string(Text ? "TEXT " : "") +
(Data ? "DATA " : "") + (BSS ? "BSS" : ""));
- outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n",
- (unsigned)Section.getIndex(), Name.str().c_str(), Size,
- Address, Type.c_str());
+
+ if (HasLMAColumn)
+ outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %016" PRIx64
+ " %s\n",
+ (unsigned)Section.getIndex(), Name.str().c_str(), Size,
+ VMA, getELFSectionLMA(Section), Type.c_str());
+ else
+ outs() << format("%3d %-13s %08" PRIx64 " %016" PRIx64 " %s\n",
+ (unsigned)Section.getIndex(), Name.str().c_str(), Size,
+ VMA, Type.c_str());
}
outs() << "\n";
}
-void llvm::printSectionContents(const ObjectFile *Obj) {
- std::error_code EC;
+void printSectionContents(const ObjectFile *Obj) {
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
StringRef Name;
- StringRef Contents;
error(Section.getName(Name));
uint64_t BaseAddr = Section.getAddress();
uint64_t Size = Section.getSize();
@@ -1965,7 +1701,7 @@ void llvm::printSectionContents(const ObjectFile *Obj) {
continue;
}
- error(Section.getContents(Contents));
+ StringRef Contents = unwrapOrError(Section.getContents(), Obj->getFileName());
// Dump out the content as hex and printable ascii characters.
for (std::size_t Addr = 0, End = Contents.size(); Addr < End; Addr += 16) {
@@ -1993,8 +1729,8 @@ void llvm::printSectionContents(const ObjectFile *Obj) {
}
}
-void llvm::printSymbolTable(const ObjectFile *O, StringRef ArchiveName,
- StringRef ArchitectureName) {
+void printSymbolTable(const ObjectFile *O, StringRef ArchiveName,
+ StringRef ArchitectureName) {
outs() << "SYMBOL TABLE:\n";
if (const COFFObjectFile *Coff = dyn_cast<const COFFObjectFile>(O)) {
@@ -2002,41 +1738,24 @@ void llvm::printSymbolTable(const ObjectFile *O, StringRef ArchiveName,
return;
}
+ const StringRef FileName = O->getFileName();
for (auto I = O->symbol_begin(), E = O->symbol_end(); I != E; ++I) {
- // Skip printing the special zero symbol when dumping an ELF file.
- // This makes the output consistent with the GNU objdump.
- if (I == O->symbol_begin() && isa<ELFObjectFileBase>(O))
- continue;
-
const SymbolRef &Symbol = *I;
- Expected<uint64_t> AddressOrError = Symbol.getAddress();
- if (!AddressOrError)
- report_error(ArchiveName, O->getFileName(), AddressOrError.takeError(),
- ArchitectureName);
- uint64_t Address = *AddressOrError;
+ uint64_t Address = unwrapOrError(Symbol.getAddress(), ArchiveName, FileName,
+ ArchitectureName);
if ((Address < StartAddress) || (Address > StopAddress))
continue;
- Expected<SymbolRef::Type> TypeOrError = Symbol.getType();
- if (!TypeOrError)
- report_error(ArchiveName, O->getFileName(), TypeOrError.takeError(),
- ArchitectureName);
- SymbolRef::Type Type = *TypeOrError;
+ SymbolRef::Type Type = unwrapOrError(Symbol.getType(), ArchiveName,
+ FileName, ArchitectureName);
uint32_t Flags = Symbol.getFlags();
- Expected<section_iterator> SectionOrErr = Symbol.getSection();
- if (!SectionOrErr)
- report_error(ArchiveName, O->getFileName(), SectionOrErr.takeError(),
- ArchitectureName);
- section_iterator Section = *SectionOrErr;
+ section_iterator Section = unwrapOrError(Symbol.getSection(), ArchiveName,
+ FileName, ArchitectureName);
StringRef Name;
- if (Type == SymbolRef::ST_Debug && Section != O->section_end()) {
+ if (Type == SymbolRef::ST_Debug && Section != O->section_end())
Section->getName(Name);
- } else {
- Expected<StringRef> NameOrErr = Symbol.getName();
- if (!NameOrErr)
- report_error(ArchiveName, O->getFileName(), NameOrErr.takeError(),
- ArchitectureName);
- Name = *NameOrErr;
- }
+ else
+ Name = unwrapOrError(Symbol.getName(), ArchiveName, FileName,
+ ArchitectureName);
bool Global = Flags & SymbolRef::SF_Global;
bool Weak = Flags & SymbolRef::SF_Weak;
@@ -2087,20 +1806,38 @@ void llvm::printSymbolTable(const ObjectFile *O, StringRef ArchiveName,
outs() << SectionName;
}
- outs() << '\t';
if (Common || isa<ELFObjectFileBase>(O)) {
uint64_t Val =
Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize();
- outs() << format("\t %08" PRIx64 " ", Val);
+ outs() << format("\t%08" PRIx64, Val);
}
- if (Hidden)
- outs() << ".hidden ";
+ if (isa<ELFObjectFileBase>(O)) {
+ uint8_t Other = ELFSymbolRef(Symbol).getOther();
+ switch (Other) {
+ case ELF::STV_DEFAULT:
+ break;
+ case ELF::STV_INTERNAL:
+ outs() << " .internal";
+ break;
+ case ELF::STV_HIDDEN:
+ outs() << " .hidden";
+ break;
+ case ELF::STV_PROTECTED:
+ outs() << " .protected";
+ break;
+ default:
+ outs() << format(" 0x%02x", Other);
+ break;
+ }
+ } else if (Hidden) {
+ outs() << " .hidden";
+ }
if (Demangle)
- outs() << demangle(Name) << '\n';
+ outs() << ' ' << demangle(Name) << '\n';
else
- outs() << Name << '\n';
+ outs() << ' ' << Name << '\n';
}
}
@@ -2118,59 +1855,9 @@ static void printUnwindInfo(const ObjectFile *O) {
"for COFF and MachO object files.\n";
}
-void llvm::printExportsTrie(const ObjectFile *o) {
- outs() << "Exports trie:\n";
- if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
- printMachOExportsTrie(MachO);
- else
- WithColor::error(errs(), ToolName)
- << "This operation is only currently supported "
- "for Mach-O executable files.\n";
-}
-
-void llvm::printRebaseTable(ObjectFile *o) {
- outs() << "Rebase table:\n";
- if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
- printMachORebaseTable(MachO);
- else
- WithColor::error(errs(), ToolName)
- << "This operation is only currently supported "
- "for Mach-O executable files.\n";
-}
-
-void llvm::printBindTable(ObjectFile *o) {
- outs() << "Bind table:\n";
- if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
- printMachOBindTable(MachO);
- else
- WithColor::error(errs(), ToolName)
- << "This operation is only currently supported "
- "for Mach-O executable files.\n";
-}
-
-void llvm::printLazyBindTable(ObjectFile *o) {
- outs() << "Lazy bind table:\n";
- if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
- printMachOLazyBindTable(MachO);
- else
- WithColor::error(errs(), ToolName)
- << "This operation is only currently supported "
- "for Mach-O executable files.\n";
-}
-
-void llvm::printWeakBindTable(ObjectFile *o) {
- outs() << "Weak bind table:\n";
- if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
- printMachOWeakBindTable(MachO);
- else
- WithColor::error(errs(), ToolName)
- << "This operation is only currently supported "
- "for Mach-O executable files.\n";
-}
-
/// Dump the raw contents of the __clangast section so the output can be piped
/// into llvm-bcanalyzer.
-void llvm::printRawClangAST(const ObjectFile *Obj) {
+void printRawClangAST(const ObjectFile *Obj) {
if (outs().is_displayed()) {
WithColor::error(errs(), ToolName)
<< "The -raw-clang-ast option will dump the raw binary contents of "
@@ -2197,8 +1884,8 @@ void llvm::printRawClangAST(const ObjectFile *Obj) {
if (!ClangASTSection)
return;
- StringRef ClangASTContents;
- error(ClangASTSection.getValue().getContents(ClangASTContents));
+ StringRef ClangASTContents = unwrapOrError(
+ ClangASTSection.getValue().getContents(), Obj->getFileName());
outs().write(ClangASTContents.data(), ClangASTContents.size());
}
@@ -2234,9 +1921,8 @@ static void printFaultMaps(const ObjectFile *Obj) {
return;
}
- StringRef FaultMapContents;
- error(FaultMapSection.getValue().getContents(FaultMapContents));
-
+ StringRef FaultMapContents =
+ unwrapOrError(FaultMapSection.getValue().getContents(), Obj->getFileName());
FaultMapParser FMP(FaultMapContents.bytes_begin(),
FaultMapContents.bytes_end());
@@ -2246,7 +1932,9 @@ static void printFaultMaps(const ObjectFile *Obj) {
static void printPrivateFileHeaders(const ObjectFile *O, bool OnlyFirst) {
if (O->isELF()) {
printELFFileHeader(O);
- return printELFDynamicSection(O);
+ printELFDynamicSection(O);
+ printELFSymbolVersionInfo(O);
+ return;
}
if (O->isCOFF())
return printCOFFFileHeader(O);
@@ -2267,12 +1955,9 @@ static void printFileHeaders(const ObjectFile *O) {
Triple::ArchType AT = O->getArch();
outs() << "architecture: " << Triple::getArchTypeName(AT) << "\n";
- Expected<uint64_t> StartAddrOrErr = O->getStartAddress();
- if (!StartAddrOrErr)
- report_error(O->getFileName(), StartAddrOrErr.takeError());
+ uint64_t Address = unwrapOrError(O->getStartAddress(), O->getFileName());
StringRef Fmt = O->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64;
- uint64_t Address = StartAddrOrErr.get();
outs() << "start address: "
<< "0x" << format(Fmt.data(), Address) << "\n\n";
}
@@ -2297,22 +1982,9 @@ static void printArchiveChild(StringRef Filename, const Archive::Child &C) {
outs() << " ";
- Expected<unsigned> UIDOrErr = C.getUID();
- if (!UIDOrErr)
- report_error(Filename, UIDOrErr.takeError());
- unsigned UID = UIDOrErr.get();
- outs() << format("%d/", UID);
-
- Expected<unsigned> GIDOrErr = C.getGID();
- if (!GIDOrErr)
- report_error(Filename, GIDOrErr.takeError());
- unsigned GID = GIDOrErr.get();
- outs() << format("%-d ", GID);
-
- Expected<uint64_t> Size = C.getRawSize();
- if (!Size)
- report_error(Filename, Size.takeError());
- outs() << format("%6" PRId64, Size.get()) << " ";
+ outs() << format("%d/%d %6" PRId64 " ", unwrapOrError(C.getUID(), Filename),
+ unwrapOrError(C.getGID(), Filename),
+ unwrapOrError(C.getRawSize(), Filename));
StringRef RawLastModified = C.getRawLastModified();
unsigned Seconds;
@@ -2331,10 +2003,7 @@ static void printArchiveChild(StringRef Filename, const Archive::Child &C) {
Expected<StringRef> NameOrErr = C.getName();
if (!NameOrErr) {
consumeError(NameOrErr.takeError());
- Expected<StringRef> RawNameOrErr = C.getRawName();
- if (!RawNameOrErr)
- report_error(Filename, NameOrErr.takeError());
- Name = RawNameOrErr.get();
+ Name = unwrapOrError(C.getRawName(), Filename);
} else {
Name = NameOrErr.get();
}
@@ -2386,7 +2055,7 @@ static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
printWeakBindTable(O);
if (RawClangAST)
printRawClangAST(O);
- if (PrintFaultMaps)
+ if (FaultMapSection)
printFaultMaps(O);
if (DwarfDumpType != DIDT_Null) {
std::unique_ptr<DIContext> DICtx = DWARFContext::create(*O);
@@ -2421,7 +2090,7 @@ static void dumpArchive(const Archive *A) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
- report_error(A->getFileName(), C, std::move(E));
+ report_error(std::move(E), A->getFileName(), C);
continue;
}
if (ObjectFile *O = dyn_cast<ObjectFile>(&*ChildOrErr.get()))
@@ -2429,10 +2098,11 @@ static void dumpArchive(const Archive *A) {
else if (COFFImportFile *I = dyn_cast<COFFImportFile>(&*ChildOrErr.get()))
dumpObject(I, A, &C);
else
- report_error(A->getFileName(), object_error::invalid_file_type);
+ report_error(errorCodeToError(object_error::invalid_file_type),
+ A->getFileName());
}
if (Err)
- report_error(A->getFileName(), std::move(Err));
+ report_error(std::move(Err), A->getFileName());
}
/// Open file and figure out how to dump it.
@@ -2446,10 +2116,8 @@ static void dumpInput(StringRef file) {
}
// Attempt to open the binary.
- Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(file);
- if (!BinaryOrErr)
- report_error(file, BinaryOrErr.takeError());
- Binary &Binary = *BinaryOrErr.get().getBinary();
+ OwningBinary<Binary> OBinary = unwrapOrError(createBinary(file), file);
+ Binary &Binary = *OBinary.getBinary();
if (Archive *A = dyn_cast<Archive>(&Binary))
dumpArchive(A);
@@ -2458,22 +2126,29 @@ static void dumpInput(StringRef file) {
else if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Binary))
parseInputMachO(UB);
else
- report_error(file, object_error::invalid_file_type);
+ report_error(errorCodeToError(object_error::invalid_file_type), file);
}
+} // namespace llvm
int main(int argc, char **argv) {
+ using namespace llvm;
InitLLVM X(argc, argv);
+ const cl::OptionCategory *OptionFilters[] = {&ObjdumpCat, &MachOCat};
+ cl::HideUnrelatedOptions(OptionFilters);
// Initialize targets and assembly printers/parsers.
- llvm::InitializeAllTargetInfos();
- llvm::InitializeAllTargetMCs();
- llvm::InitializeAllDisassemblers();
+ InitializeAllTargetInfos();
+ InitializeAllTargetMCs();
+ InitializeAllDisassemblers();
// Register the target printer for --version.
cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
cl::ParseCommandLineOptions(argc, argv, "llvm object file dumper\n");
+ if (StartAddress >= StopAddress)
+ error("start address should be less than stop address");
+
ToolName = argv[0];
// Defaults to a.out if no filenames specified.
@@ -2481,40 +2156,22 @@ int main(int argc, char **argv) {
InputFilenames.push_back("a.out");
if (AllHeaders)
- FileHeaders = PrivateHeaders = Relocations = SectionHeaders = SymbolTable =
- true;
+ ArchiveHeaders = FileHeaders = PrivateHeaders = Relocations =
+ SectionHeaders = SymbolTable = true;
- if (DisassembleAll || PrintSource || PrintLines)
+ if (DisassembleAll || PrintSource || PrintLines ||
+ (!DisassembleFunctions.empty()))
Disassemble = true;
- if (!Disassemble
- && !Relocations
- && !DynamicRelocations
- && !SectionHeaders
- && !SectionContents
- && !SymbolTable
- && !UnwindInfo
- && !PrivateHeaders
- && !FileHeaders
- && !FirstPrivateHeader
- && !ExportsTrie
- && !Rebase
- && !Bind
- && !LazyBind
- && !WeakBind
- && !RawClangAST
- && !(UniversalHeaders && MachOOpt)
- && !ArchiveHeaders
- && !(IndirectSymbols && MachOOpt)
- && !(DataInCode && MachOOpt)
- && !(LinkOptHints && MachOOpt)
- && !(InfoPlist && MachOOpt)
- && !(DylibsUsed && MachOOpt)
- && !(DylibId && MachOOpt)
- && !(ObjcMetaData && MachOOpt)
- && !(!FilterSections.empty() && MachOOpt)
- && !PrintFaultMaps
- && DwarfDumpType == DIDT_Null) {
+ if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null &&
+ !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST &&
+ !Relocations && !SectionHeaders && !SectionContents && !SymbolTable &&
+ !UnwindInfo && !FaultMapSection &&
+ !(MachOOpt &&
+ (Bind || DataInCode || DylibId || DylibsUsed || ExportsTrie ||
+ FirstPrivateHeader || IndirectSymbols || InfoPlist || LazyBind ||
+ LinkOptHints || ObjcMetaData || Rebase || UniversalHeaders ||
+ WeakBind || !FilterSections.empty()))) {
cl::PrintHelpMessage();
return 2;
}
@@ -2524,5 +2181,7 @@ int main(int argc, char **argv) {
llvm::for_each(InputFilenames, dumpInput);
+ warnOnNoMatchForSections();
+
return EXIT_SUCCESS;
}
diff --git a/tools/llvm-objdump/llvm-objdump.h b/tools/llvm-objdump/llvm-objdump.h
index fe2cb05fe227..e58d4a05c2e6 100644
--- a/tools/llvm-objdump/llvm-objdump.h
+++ b/tools/llvm-objdump/llvm-objdump.h
@@ -1,8 +1,7 @@
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
@@ -19,57 +18,86 @@ namespace llvm {
class StringRef;
namespace object {
- class COFFObjectFile;
- class COFFImportFile;
- class MachOObjectFile;
- class MachOUniversalBinary;
- class ObjectFile;
- class Archive;
- class RelocationRef;
+class COFFObjectFile;
+class COFFImportFile;
+class ELFObjectFileBase;
+class ELFSectionRef;
+class MachOObjectFile;
+class MachOUniversalBinary;
+class RelocationRef;
}
-extern cl::opt<std::string> TripleName;
-extern cl::opt<std::string> ArchName;
-extern cl::opt<std::string> MCPU;
-extern cl::list<std::string> MAttrs;
-extern cl::list<std::string> FilterSections;
-extern cl::opt<bool> AllHeaders;
extern cl::opt<bool> Demangle;
-extern cl::opt<bool> Disassemble;
-extern cl::opt<bool> DisassembleAll;
-extern cl::opt<bool> NoShowRawInsn;
-extern cl::opt<bool> NoLeadingAddr;
-extern cl::opt<bool> PrivateHeaders;
-extern cl::opt<bool> FileHeaders;
-extern cl::opt<bool> FirstPrivateHeader;
-extern cl::opt<bool> ExportsTrie;
-extern cl::opt<bool> Rebase;
-extern cl::opt<bool> Bind;
-extern cl::opt<bool> LazyBind;
-extern cl::opt<bool> WeakBind;
-extern cl::opt<bool> RawClangAST;
-extern cl::opt<bool> UniversalHeaders;
-extern cl::opt<bool> ArchiveHeaders;
-extern cl::opt<bool> IndirectSymbols;
-extern cl::opt<bool> DataInCode;
-extern cl::opt<bool> LinkOptHints;
-extern cl::opt<bool> InfoPlist;
-extern cl::opt<bool> DylibsUsed;
-extern cl::opt<bool> DylibId;
-extern cl::opt<bool> ObjcMetaData;
-extern cl::opt<std::string> DisSymName;
-extern cl::opt<bool> NonVerbose;
-extern cl::opt<bool> Relocations;
-extern cl::opt<bool> DynamicRelocations;
-extern cl::opt<bool> SectionHeaders;
-extern cl::opt<bool> SectionContents;
-extern cl::opt<bool> SymbolTable;
-extern cl::opt<bool> UnwindInfo;
-extern cl::opt<bool> PrintImmHex;
-extern cl::opt<DIDumpType> DwarfDumpType;
+
+typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;
+
+class SectionFilterIterator {
+public:
+ SectionFilterIterator(FilterPredicate P,
+ llvm::object::section_iterator const &I,
+ llvm::object::section_iterator const &E)
+ : Predicate(std::move(P)), Iterator(I), End(E) {
+ ScanPredicate();
+ }
+ const llvm::object::SectionRef &operator*() const { return *Iterator; }
+ SectionFilterIterator &operator++() {
+ ++Iterator;
+ ScanPredicate();
+ return *this;
+ }
+ bool operator!=(SectionFilterIterator const &Other) const {
+ return Iterator != Other.Iterator;
+ }
+
+private:
+ void ScanPredicate() {
+ while (Iterator != End && !Predicate(*Iterator)) {
+ ++Iterator;
+ }
+ }
+ FilterPredicate Predicate;
+ llvm::object::section_iterator Iterator;
+ llvm::object::section_iterator End;
+};
+
+class SectionFilter {
+public:
+ SectionFilter(FilterPredicate P, llvm::object::ObjectFile const &O)
+ : Predicate(std::move(P)), Object(O) {}
+ SectionFilterIterator begin() {
+ return SectionFilterIterator(Predicate, Object.section_begin(),
+ Object.section_end());
+ }
+ SectionFilterIterator end() {
+ return SectionFilterIterator(Predicate, Object.section_end(),
+ Object.section_end());
+ }
+
+private:
+ FilterPredicate Predicate;
+ llvm::object::ObjectFile const &Object;
+};
// Various helper functions.
+SectionFilter ToolSectionFilter(llvm::object::ObjectFile const &O);
+
+Error getELFRelocationValueString(const object::ELFObjectFileBase *Obj,
+ const object::RelocationRef &Rel,
+ llvm::SmallVectorImpl<char> &Result);
+Error getCOFFRelocationValueString(const object::COFFObjectFile *Obj,
+ const object::RelocationRef &Rel,
+ llvm::SmallVectorImpl<char> &Result);
+Error getWasmRelocationValueString(const object::WasmObjectFile *Obj,
+ const object::RelocationRef &RelRef,
+ llvm::SmallVectorImpl<char> &Result);
+Error getMachORelocationValueString(const object::MachOObjectFile *Obj,
+ const object::RelocationRef &RelRef,
+ llvm::SmallVectorImpl<char> &Result);
+
+uint64_t getELFSectionLMA(const object::ELFSectionRef& Sec);
+
void error(std::error_code ec);
+void error(Error E);
bool isRelocAddressLess(object::RelocationRef A, object::RelocationRef B);
void parseInputMachO(StringRef Filename);
void parseInputMachO(object::MachOUniversalBinary *UB);
@@ -82,6 +110,7 @@ void printMachOLazyBindTable(object::MachOObjectFile *O);
void printMachOWeakBindTable(object::MachOObjectFile *O);
void printELFFileHeader(const object::ObjectFile *O);
void printELFDynamicSection(const object::ObjectFile *Obj);
+void printELFSymbolVersionInfo(const object::ObjectFile *Obj);
void printCOFFFileHeader(const object::ObjectFile *O);
void printCOFFSymbolTable(const object::COFFImportFile *I);
void printCOFFSymbolTable(const object::COFFObjectFile *O);
@@ -103,18 +132,20 @@ void printSymbolTable(const object::ObjectFile *O, StringRef ArchiveName,
void warn(StringRef Message);
LLVM_ATTRIBUTE_NORETURN void error(Twine Message);
LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, Twine Message);
-LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, std::error_code EC);
-LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, llvm::Error E);
-LLVM_ATTRIBUTE_NORETURN void report_error(StringRef FileName,
- StringRef ArchiveName,
- llvm::Error E,
- StringRef ArchitectureName
- = StringRef());
-LLVM_ATTRIBUTE_NORETURN void report_error(StringRef ArchiveName,
- const object::Archive::Child &C,
- llvm::Error E,
- StringRef ArchitectureName
- = StringRef());
+LLVM_ATTRIBUTE_NORETURN void report_error(Error E, StringRef File);
+LLVM_ATTRIBUTE_NORETURN void
+report_error(Error E, StringRef FileName, StringRef ArchiveName,
+ StringRef ArchitectureName = StringRef());
+LLVM_ATTRIBUTE_NORETURN void
+report_error(Error E, StringRef ArchiveName, const object::Archive::Child &C,
+ StringRef ArchitectureName = StringRef());
+
+template <typename T, typename... Ts>
+T unwrapOrError(Expected<T> EO, Ts &&... Args) {
+ if (EO)
+ return std::move(*EO);
+ report_error(EO.takeError(), std::forward<Ts>(Args)...);
+}
} // end namespace llvm
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-11 18:35:47 +0000