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();
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);
}
// 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()) {
- Expected<uint64_t> Addr = Symbol.getAddress();
- if (!Addr)
- report_error(O->getFileName(), Addr.takeError());
- if (*Addr != Val)
+ uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName);
+ if (Addr != Val)
continue;
- Expected<StringRef> Name = Symbol.getName();
- if (!Name)
- report_error(O->getFileName(), Name.takeError());
- Fmt << *Name;
+ Fmt << unwrapOrError(Symbol.getName(), FileName);
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;
+ S = unwrapOrError(SI->getName(), FileName);
} else {
section_iterator SI = O->section_begin();
// Adjust for the fact that sections are 1-indexed.
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() << "?";
}
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;
}
});
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;
}
});
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)
// 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;
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.
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) {
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";
}
}
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() {
// 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;
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())) {
}
}
if (Err)
- report_error(Filename, std::move(Err));
+ report_error(std::move(Err), Filename);
return;
}
if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) {
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())
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 =
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 " +
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)
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 =
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 " +
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())
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 =
}
}
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 " +
}
}
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;
// 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;
// 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;
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
}
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) {
// 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;
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();
}
}
}
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();
}
}
}
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;
ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
MemoryBuffer::getFileOrSTDIN(DSYMFile);
if (std::error_code EC = BufOrErr.getError()) {
- report_error(DSYMFile, errorCodeToError(EC));
- return;
- }
-
- Expected<std::unique_ptr<MachOObjectFile>> DbgObjCheck =
- ObjectFile::createMachOObjectFile(BufOrErr.get()->getMemBufferRef());
-
- if (Error E = DbgObjCheck.takeError()) {
- report_error(DSYMFile, std::move(E));
+ report_error(errorCodeToError(EC), DSYMFile);
return;
}
- DbgObj = DbgObjCheck.get().release();
+ std::unique_ptr<MachOObjectFile> DbgObjCheck = unwrapOrError(
+ ObjectFile::createMachOObjectFile(BufOrErr.get()->getMemBufferRef()),
+ DSYMFile.getValue());
+ DbgObj = DbgObjCheck.release();
// We need to keep the file alive, because we're replacing DbgObj with it.
DSYMBuf = std::move(BufOrErr.get());
}
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;
// 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;
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]);
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;
}
// 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;
}
outs() << "\n";
}
if (Err)
- report_error(Obj->getFileName(), std::move(Err));
+ report_error(std::move(Err), Obj->getFileName());
}
//===----------------------------------------------------------------------===//
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) {
<< Entry.symbolName() << Attr << "\n";
}
if (Err)
- report_error(Obj->getFileName(), std::move(Err));
+ report_error(std::move(Err), Obj->getFileName());
}
//===----------------------------------------------------------------------===//
<< Entry.symbolName() << "\n";
}
if (Err)
- report_error(Obj->getFileName(), std::move(Err));
+ report_error(std::move(Err), Obj->getFileName());
}
//===----------------------------------------------------------------------===//
<< "\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
(*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;
exit(1);
}
-LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef File,
- llvm::Error E) {
+LLVM_ATTRIBUTE_NORETURN void llvm::report_error(Error E, StringRef File) {
assert(E);
std::string Buf;
raw_string_ostream OS(Buf);
exit(1);
}
-LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName,
+LLVM_ATTRIBUTE_NORETURN void llvm::report_error(Error E, StringRef ArchiveName,
StringRef FileName,
- llvm::Error E,
StringRef ArchitectureName) {
assert(E);
WithColor::error(errs(), ToolName);
exit(1);
}
-LLVM_ATTRIBUTE_NORETURN void llvm::report_error(StringRef ArchiveName,
+LLVM_ATTRIBUTE_NORETURN void llvm::report_error(Error E, StringRef ArchiveName,
const object::Archive::Child &C,
- llvm::Error E,
StringRef ArchitectureName) {
Expected<StringRef> NameOrErr = C.getName();
// TODO: if we have a error getting the name then it would be nice to print
// archive instead of "???" as the name.
if (!NameOrErr) {
consumeError(NameOrErr.takeError());
- llvm::report_error(ArchiveName, "???", std::move(E), ArchitectureName);
+ llvm::report_error(std::move(E), ArchiveName, "???", ArchitectureName);
} else
- llvm::report_error(ArchiveName, NameOrErr.get(), std::move(E),
+ llvm::report_error(std::move(E), ArchiveName, NameOrErr.get(),
ArchitectureName);
}
if (SymbolType != ELF::STT_FUNC || Symbol.getSize() == 0)
continue;
- Expected<uint64_t> AddressOrErr = Symbol.getAddress();
- if (!AddressOrErr)
- report_error(Obj->getFileName(), AddressOrErr.takeError());
-
- Expected<StringRef> Name = Symbol.getName();
- if (!Name)
- report_error(Obj->getFileName(), Name.takeError());
- if (Name->empty())
+ uint64_t Address = unwrapOrError(Symbol.getAddress(), Obj->getFileName());
+ 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);
}
}
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);
}
}
}
// 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()) {
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);
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.
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;
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";
}
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;
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();
}
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()))
report_error(A->getFileName(), object_error::invalid_file_type);
}
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.
}
// 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);
projects / llvm / commitdiff