[llvm] 77ecf90 - [COFF] Migrate COFFObjectFile to Expected<T>
Reid Kleckner via llvm-commits
llvm-commits at lists.llvm.org
Fri May 8 14:10:42 PDT 2020
Author: Reid Kleckner
Date: 2020-05-08T14:01:39-07:00
New Revision: 77ecf90c52641aadedf6bad7c8bea5b217b49729
URL: https://github.com/llvm/llvm-project/commit/77ecf90c52641aadedf6bad7c8bea5b217b49729
DIFF: https://github.com/llvm/llvm-project/commit/77ecf90c52641aadedf6bad7c8bea5b217b49729.diff
LOG: [COFF] Migrate COFFObjectFile to Expected<T>
I noticed that std::error_code() does one-time initialization. Avoid
that overhead with Expected<T> and llvm::Error. Also, it is consistent
with the virtual interface and ELF, and generally cleaner.
Reviewed By: MaskRay
Differential Revision: https://reviews.llvm.org/D79643
Added:
Modified:
lld/COFF/Chunks.cpp
lld/COFF/InputFiles.cpp
lld/COFF/Symbols.cpp
llvm/include/llvm/Object/COFF.h
llvm/lib/Object/COFFObjectFile.cpp
llvm/tools/llvm-objcopy/COFF/Reader.cpp
llvm/tools/llvm-objdump/COFFDump.cpp
llvm/tools/llvm-readobj/COFFDumper.cpp
llvm/tools/obj2yaml/coff2yaml.cpp
Removed:
################################################################################
diff --git a/lld/COFF/Chunks.cpp b/lld/COFF/Chunks.cpp
index 0e43d2b478b4..e04ceed505c2 100644
--- a/lld/COFF/Chunks.cpp
+++ b/lld/COFF/Chunks.cpp
@@ -333,7 +333,7 @@ static void maybeReportRelocationToDiscarded(const SectionChunk *fromChunk,
} else {
COFFSymbolRef coffSym =
check(file->getCOFFObj()->getSymbol(rel.SymbolTableIndex));
- file->getCOFFObj()->getSymbolName(coffSym, name);
+ name = check(file->getCOFFObj()->getSymbolName(coffSym));
}
std::vector<std::string> symbolLocations =
diff --git a/lld/COFF/InputFiles.cpp b/lld/COFF/InputFiles.cpp
index afe8ef455336..7b09709ce1a8 100644
--- a/lld/COFF/InputFiles.cpp
+++ b/lld/COFF/InputFiles.cpp
@@ -169,8 +169,7 @@ void LazyObjFile::parse() {
if (coffSym.isUndefined() || !coffSym.isExternal() ||
coffSym.isWeakExternal())
continue;
- StringRef name;
- coffObj->getSymbolName(coffSym, name);
+ StringRef name = check(coffObj->getSymbolName(coffSym));
if (coffSym.isAbsolute() && ignoredSymbolName(name))
continue;
symtab->addLazyObject(this, name);
@@ -196,11 +195,11 @@ void ObjFile::parse() {
initializeDependencies();
}
-const coff_section* ObjFile::getSection(uint32_t i) {
- const coff_section *sec;
- if (auto ec = coffObj->getSection(i, sec))
- fatal("getSection failed: #" + Twine(i) + ": " + ec.message());
- return sec;
+const coff_section *ObjFile::getSection(uint32_t i) {
+ auto sec = coffObj->getSection(i);
+ if (!sec)
+ fatal("getSection failed: #" + Twine(i) + ": " + toString(sec.takeError()));
+ return *sec;
}
// We set SectionChunk pointers in the SparseChunks vector to this value
@@ -308,9 +307,9 @@ void ObjFile::readAssociativeDefinition(COFFSymbolRef sym,
int32_t sectionNumber = sym.getSectionNumber();
auto diag = [&]() {
- StringRef name, parentName;
- coffObj->getSymbolName(sym, name);
+ StringRef name = check(coffObj->getSymbolName(sym));
+ StringRef parentName;
const coff_section *parentSec = getSection(parentIndex);
if (Expected<StringRef> e = coffObj->getSectionName(parentSec))
parentName = *e;
@@ -351,7 +350,7 @@ void ObjFile::recordPrevailingSymbolForMingw(
SectionChunk *sc = sparseChunks[sectionNumber];
if (sc && sc->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE) {
StringRef name;
- coffObj->getSymbolName(sym, name);
+ name = check(coffObj->getSymbolName(sym));
if (getMachineType() == I386)
name.consume_front("_");
prevailingSectionMap[name] = sectionNumber;
@@ -361,8 +360,7 @@ void ObjFile::recordPrevailingSymbolForMingw(
void ObjFile::maybeAssociateSEHForMingw(
COFFSymbolRef sym, const coff_aux_section_definition *def,
const DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
- StringRef name;
- coffObj->getSymbolName(sym, name);
+ StringRef name = check(coffObj->getSymbolName(sym));
if (name.consume_front(".pdata$") || name.consume_front(".xdata$") ||
name.consume_front(".eh_frame$")) {
// For MinGW, treat .[px]data$<func> and .eh_frame$<func> as implicitly
@@ -376,8 +374,7 @@ void ObjFile::maybeAssociateSEHForMingw(
Symbol *ObjFile::createRegular(COFFSymbolRef sym) {
SectionChunk *sc = sparseChunks[sym.getSectionNumber()];
if (sym.isExternal()) {
- StringRef name;
- coffObj->getSymbolName(sym, name);
+ StringRef name = check(coffObj->getSymbolName(sym));
if (sc)
return symtab->addRegular(this, name, sym.getGeneric(), sc,
sym.getValue());
@@ -445,8 +442,7 @@ void ObjFile::initializeSymbols() {
maybeAssociateSEHForMingw(sym, def, prevailingSectionMap);
}
if (sparseChunks[sym.getSectionNumber()] == pendingComdat) {
- StringRef name;
- coffObj->getSymbolName(sym, name);
+ StringRef name = check(coffObj->getSymbolName(sym));
log("comdat section " + name +
" without leader and unassociated, discarding");
continue;
@@ -462,8 +458,7 @@ void ObjFile::initializeSymbols() {
}
Symbol *ObjFile::createUndefined(COFFSymbolRef sym) {
- StringRef name;
- coffObj->getSymbolName(sym, name);
+ StringRef name = check(coffObj->getSymbolName(sym));
return symtab->addUndefined(name, this, sym.isWeakExternal());
}
@@ -559,8 +554,7 @@ void ObjFile::handleComdatSelection(COFFSymbolRef sym, COMDATType &selection,
case IMAGE_COMDAT_SELECT_LARGEST:
if (leaderChunk->getSize() < getSection(sym)->SizeOfRawData) {
// Replace the existing comdat symbol with the new one.
- StringRef name;
- coffObj->getSymbolName(sym, name);
+ StringRef name = check(coffObj->getSymbolName(sym));
// FIXME: This is incorrect: With /opt:noref, the previous sections
// make it into the final executable as well. Correct handling would
// be to undo reading of the whole old section that's being replaced,
@@ -584,11 +578,7 @@ Optional<Symbol *> ObjFile::createDefined(
std::vector<const coff_aux_section_definition *> &comdatDefs,
bool &prevailing) {
prevailing = false;
- auto getName = [&]() {
- StringRef s;
- coffObj->getSymbolName(sym, s);
- return s;
- };
+ auto getName = [&]() { return check(coffObj->getSymbolName(sym)); };
if (sym.isCommon()) {
auto *c = make<CommonChunk>(sym);
diff --git a/lld/COFF/Symbols.cpp b/lld/COFF/Symbols.cpp
index 9cbd245244e8..60ff72aeb522 100644
--- a/lld/COFF/Symbols.cpp
+++ b/lld/COFF/Symbols.cpp
@@ -56,8 +56,8 @@ void Symbol::computeName() {
assert(nameData == nullptr &&
"should only compute the name once for DefinedCOFF symbols");
auto *d = cast<DefinedCOFF>(this);
- StringRef nameStr;
- cast<ObjFile>(d->file)->getCOFFObj()->getSymbolName(d->sym, nameStr);
+ StringRef nameStr =
+ check(cast<ObjFile>(d->file)->getCOFFObj()->getSymbolName(d->sym));
nameData = nameStr.data();
nameSize = nameStr.size();
assert(nameSize == nameStr.size() && "name length truncated");
diff --git a/llvm/include/llvm/Object/COFF.h b/llvm/include/llvm/Object/COFF.h
index 230217830809..51d1f58cd260 100644
--- a/llvm/include/llvm/Object/COFF.h
+++ b/llvm/include/llvm/Object/COFF.h
@@ -787,7 +787,7 @@ class COFFObjectFile : public ObjectFile {
// Either coff_load_configuration32 or coff_load_configuration64.
const void *LoadConfig = nullptr;
- std::error_code getString(uint32_t offset, StringRef &Res) const;
+ Expected<StringRef> getString(uint32_t offset) const;
template <typename coff_symbol_type>
const coff_symbol_type *toSymb(DataRefImpl Symb) const;
@@ -985,32 +985,15 @@ class COFFObjectFile : public ObjectFile {
std::error_code getDataDirectory(uint32_t index,
const data_directory *&Res) const;
- std::error_code getSection(int32_t index, const coff_section *&Res) const;
- std::error_code getSection(StringRef SectionName,
- const coff_section *&Res) const;
+ Expected<const coff_section *> getSection(int32_t index) const;
- template <typename coff_symbol_type>
- std::error_code getSymbol(uint32_t Index,
- const coff_symbol_type *&Res) const {
- if (Index >= getNumberOfSymbols())
- return object_error::parse_failed;
-
- Res = reinterpret_cast<coff_symbol_type *>(getSymbolTable()) + Index;
- return std::error_code();
- }
Expected<COFFSymbolRef> getSymbol(uint32_t index) const {
- if (SymbolTable16) {
- const coff_symbol16 *Symb = nullptr;
- if (std::error_code EC = getSymbol(index, Symb))
- return errorCodeToError(EC);
- return COFFSymbolRef(Symb);
- }
- if (SymbolTable32) {
- const coff_symbol32 *Symb = nullptr;
- if (std::error_code EC = getSymbol(index, Symb))
- return errorCodeToError(EC);
- return COFFSymbolRef(Symb);
- }
+ if (index >= getNumberOfSymbols())
+ return errorCodeToError(object_error::parse_failed);
+ if (SymbolTable16)
+ return COFFSymbolRef(SymbolTable16 + index);
+ if (SymbolTable32)
+ return COFFSymbolRef(SymbolTable32 + index);
return errorCodeToError(object_error::parse_failed);
}
@@ -1023,9 +1006,8 @@ class COFFObjectFile : public ObjectFile {
return std::error_code();
}
- std::error_code getSymbolName(COFFSymbolRef Symbol, StringRef &Res) const;
- std::error_code getSymbolName(const coff_symbol_generic *Symbol,
- StringRef &Res) const;
+ Expected<StringRef> getSymbolName(COFFSymbolRef Symbol) const;
+ Expected<StringRef> getSymbolName(const coff_symbol_generic *Symbol) const;
ArrayRef<uint8_t> getSymbolAuxData(COFFSymbolRef Symbol) const;
diff --git a/llvm/lib/Object/COFFObjectFile.cpp b/llvm/lib/Object/COFFObjectFile.cpp
index 28233f8bdc77..3a81223beb99 100644
--- a/llvm/lib/Object/COFFObjectFile.cpp
+++ b/llvm/lib/Object/COFFObjectFile.cpp
@@ -147,11 +147,7 @@ void COFFObjectFile::moveSymbolNext(DataRefImpl &Ref) const {
}
Expected<StringRef> COFFObjectFile::getSymbolName(DataRefImpl Ref) const {
- COFFSymbolRef Symb = getCOFFSymbol(Ref);
- StringRef Result;
- if (std::error_code EC = getSymbolName(Symb, Result))
- return errorCodeToError(EC);
- return Result;
+ return getSymbolName(getCOFFSymbol(Ref));
}
uint64_t COFFObjectFile::getSymbolValueImpl(DataRefImpl Ref) const {
@@ -174,10 +170,10 @@ Expected<uint64_t> COFFObjectFile::getSymbolAddress(DataRefImpl Ref) const {
COFF::isReservedSectionNumber(SectionNumber))
return Result;
- const coff_section *Section = nullptr;
- if (std::error_code EC = getSection(SectionNumber, Section))
- return errorCodeToError(EC);
- Result += Section->VirtualAddress;
+ Expected<const coff_section *> Section = getSection(SectionNumber);
+ if (!Section)
+ return Section.takeError();
+ Result += (*Section)->VirtualAddress;
// The section VirtualAddress does not include ImageBase, and we want to
// return virtual addresses.
@@ -250,11 +246,11 @@ COFFObjectFile::getSymbolSection(DataRefImpl Ref) const {
COFFSymbolRef Symb = getCOFFSymbol(Ref);
if (COFF::isReservedSectionNumber(Symb.getSectionNumber()))
return section_end();
- const coff_section *Sec = nullptr;
- if (std::error_code EC = getSection(Symb.getSectionNumber(), Sec))
- return errorCodeToError(EC);
+ Expected<const coff_section *> Sec = getSection(Symb.getSectionNumber());
+ if (!Sec)
+ return Sec.takeError();
DataRefImpl Ret;
- Ret.p = reinterpret_cast<uintptr_t>(Sec);
+ Ret.p = reinterpret_cast<uintptr_t>(*Sec);
return section_iterator(SectionRef(Ret, this));
}
@@ -961,67 +957,43 @@ COFFObjectFile::getDataDirectory(uint32_t Index,
return std::error_code();
}
-std::error_code COFFObjectFile::getSection(int32_t Index,
- const coff_section *&Result) const {
- Result = nullptr;
+Expected<const coff_section *> COFFObjectFile::getSection(int32_t Index) const {
+ // Perhaps getting the section of a reserved section index should be an error,
+ // but callers rely on this to return null.
if (COFF::isReservedSectionNumber(Index))
- return std::error_code();
+ return (const coff_section *)nullptr;
if (static_cast<uint32_t>(Index) <= getNumberOfSections()) {
// We already verified the section table data, so no need to check again.
- Result = SectionTable + (Index - 1);
- return std::error_code();
- }
- return object_error::parse_failed;
-}
-
-std::error_code COFFObjectFile::getSection(StringRef SectionName,
- const coff_section *&Result) const {
- Result = nullptr;
- for (const SectionRef &Section : sections()) {
- auto NameOrErr = Section.getName();
- if (!NameOrErr)
- return errorToErrorCode(NameOrErr.takeError());
-
- if (*NameOrErr == SectionName) {
- Result = getCOFFSection(Section);
- return std::error_code();
- }
+ return SectionTable + (Index - 1);
}
- return object_error::parse_failed;
+ return errorCodeToError(object_error::parse_failed);
}
-std::error_code COFFObjectFile::getString(uint32_t Offset,
- StringRef &Result) const {
+Expected<StringRef> COFFObjectFile::getString(uint32_t Offset) const {
if (StringTableSize <= 4)
// Tried to get a string from an empty string table.
- return object_error::parse_failed;
+ return errorCodeToError(object_error::parse_failed);
if (Offset >= StringTableSize)
- return object_error::unexpected_eof;
- Result = StringRef(StringTable + Offset);
- return std::error_code();
+ return errorCodeToError(object_error::unexpected_eof);
+ return StringRef(StringTable + Offset);
}
-std::error_code COFFObjectFile::getSymbolName(COFFSymbolRef Symbol,
- StringRef &Res) const {
- return getSymbolName(Symbol.getGeneric(), Res);
+Expected<StringRef> COFFObjectFile::getSymbolName(COFFSymbolRef Symbol) const {
+ return getSymbolName(Symbol.getGeneric());
}
-std::error_code COFFObjectFile::getSymbolName(const coff_symbol_generic *Symbol,
- StringRef &Res) const {
+Expected<StringRef>
+COFFObjectFile::getSymbolName(const coff_symbol_generic *Symbol) const {
// Check for string table entry. First 4 bytes are 0.
- if (Symbol->Name.Offset.Zeroes == 0) {
- if (std::error_code EC = getString(Symbol->Name.Offset.Offset, Res))
- return EC;
- return std::error_code();
- }
+ if (Symbol->Name.Offset.Zeroes == 0)
+ return getString(Symbol->Name.Offset.Offset);
+ // Null terminated, let ::strlen figure out the length.
if (Symbol->Name.ShortName[COFF::NameSize - 1] == 0)
- // Null terminated, let ::strlen figure out the length.
- Res = StringRef(Symbol->Name.ShortName);
- else
- // Not null terminated, use all 8 bytes.
- Res = StringRef(Symbol->Name.ShortName, COFF::NameSize);
- return std::error_code();
+ return StringRef(Symbol->Name.ShortName);
+
+ // Not null terminated, use all 8 bytes.
+ return StringRef(Symbol->Name.ShortName, COFF::NameSize);
}
ArrayRef<uint8_t>
@@ -1079,8 +1051,7 @@ COFFObjectFile::getSectionName(const coff_section *Sec) const {
return createStringError(object_error::parse_failed,
"invalid section name");
}
- if (std::error_code EC = getString(Offset, Name))
- return errorCodeToError(EC);
+ return getString(Offset);
}
return Name;
@@ -1829,15 +1800,16 @@ ResourceSectionRef::getContents(const coff_resource_data_entry &Entry) {
Expected<COFFSymbolRef> Sym = Obj->getSymbol(R.SymbolTableIndex);
if (!Sym)
return Sym.takeError();
- const coff_section *Section = nullptr;
// And the symbol's section
- if (std::error_code EC = Obj->getSection(Sym->getSectionNumber(), Section))
- return errorCodeToError(EC);
+ Expected<const coff_section *> Section =
+ Obj->getSection(Sym->getSectionNumber());
+ if (!Section)
+ return Section.takeError();
// Add the initial value of DataRVA to the symbol's offset to find the
// data it points at.
uint64_t Offset = Entry.DataRVA + Sym->getValue();
ArrayRef<uint8_t> Contents;
- if (Error E = Obj->getSectionContents(Section, Contents))
+ if (Error E = Obj->getSectionContents(*Section, Contents))
return std::move(E);
if (Offset + Entry.DataSize > Contents.size())
return createStringError(object_error::parse_failed,
diff --git a/llvm/tools/llvm-objcopy/COFF/Reader.cpp b/llvm/tools/llvm-objcopy/COFF/Reader.cpp
index 7be9cce2be3d..2b1aab7f5dc0 100644
--- a/llvm/tools/llvm-objcopy/COFF/Reader.cpp
+++ b/llvm/tools/llvm-objcopy/COFF/Reader.cpp
@@ -57,9 +57,10 @@ Error COFFReader::readSections(Object &Obj) const {
std::vector<Section> Sections;
// Section indexing starts from 1.
for (size_t I = 1, E = COFFObj.getNumberOfSections(); I <= E; I++) {
- const coff_section *Sec;
- if (auto EC = COFFObj.getSection(I, Sec))
- return errorCodeToError(EC);
+ Expected<const coff_section *> SecOrErr = COFFObj.getSection(I);
+ if (!SecOrErr)
+ return SecOrErr.takeError();
+ const coff_section *Sec = *SecOrErr;
Sections.push_back(Section());
Section &S = Sections.back();
S.Header = *Sec;
@@ -99,8 +100,10 @@ Error COFFReader::readSymbols(Object &Obj, bool IsBigObj) const {
else
copySymbol(Sym.Sym,
*reinterpret_cast<const coff_symbol16 *>(SymRef.getRawPtr()));
- if (auto EC = COFFObj.getSymbolName(SymRef, Sym.Name))
- return errorCodeToError(EC);
+ auto NameOrErr = COFFObj.getSymbolName(SymRef);
+ if (!NameOrErr)
+ return NameOrErr.takeError();
+ Sym.Name = *NameOrErr;
ArrayRef<uint8_t> AuxData = COFFObj.getSymbolAuxData(SymRef);
size_t SymSize = IsBigObj ? sizeof(coff_symbol32) : sizeof(coff_symbol16);
diff --git a/llvm/tools/llvm-objdump/COFFDump.cpp b/llvm/tools/llvm-objdump/COFFDump.cpp
index aea0d266f98d..1e817d8645de 100644
--- a/llvm/tools/llvm-objdump/COFFDump.cpp
+++ b/llvm/tools/llvm-objdump/COFFDump.cpp
@@ -664,9 +664,10 @@ void objdump::printCOFFSymbolTable(const COFFObjectFile *coff) {
if (!Symbol)
reportError(Symbol.takeError(), coff->getFileName());
- StringRef Name;
- if (std::error_code EC = coff->getSymbolName(*Symbol, Name))
- reportError(errorCodeToError(EC), coff->getFileName());
+ Expected<StringRef> NameOrErr = coff->getSymbolName(*Symbol);
+ if (!NameOrErr)
+ reportError(NameOrErr.takeError(), coff->getFileName());
+ StringRef Name = *NameOrErr;
outs() << "[" << format("%2d", SI) << "]"
<< "(sec " << format("%2d", int(Symbol->getSectionNumber())) << ")"
diff --git a/llvm/tools/llvm-readobj/COFFDumper.cpp b/llvm/tools/llvm-readobj/COFFDumper.cpp
index af19a160deb6..b1d15f71df8f 100644
--- a/llvm/tools/llvm-readobj/COFFDumper.cpp
+++ b/llvm/tools/llvm-readobj/COFFDumper.cpp
@@ -1469,21 +1469,25 @@ void COFFDumper::printSymbol(const SymbolRef &Sym) {
DictScope D(W, "Symbol");
COFFSymbolRef Symbol = Obj->getCOFFSymbol(Sym);
- const coff_section *Section;
- if (std::error_code EC = Obj->getSection(Symbol.getSectionNumber(), Section)) {
- W.startLine() << "Invalid section number: " << EC.message() << "\n";
+ Expected<const coff_section *> SecOrErr =
+ Obj->getSection(Symbol.getSectionNumber());
+ if (!SecOrErr) {
+ W.startLine() << "Invalid section number: " << Symbol.getSectionNumber()
+ << "\n";
W.flush();
+ consumeError(SecOrErr.takeError());
return;
}
+ const coff_section *Section = *SecOrErr;
StringRef SymbolName;
- if (Obj->getSymbolName(Symbol, SymbolName))
- SymbolName = "";
+ if (Expected<StringRef> SymNameOrErr = Obj->getSymbolName(Symbol))
+ SymbolName = *SymNameOrErr;
StringRef SectionName;
- if (Expected<StringRef> NameOrErr =
+ if (Expected<StringRef> SecNameOrErr =
getSectionName(Obj, Symbol.getSectionNumber(), Section))
- SectionName = *NameOrErr;
+ SectionName = *SecNameOrErr;
W.printString("Name", SymbolName);
W.printNumber("Value", Symbol.getValue());
@@ -1516,12 +1520,12 @@ void COFFDumper::printSymbol(const SymbolRef &Sym) {
if (!Linked)
reportError(Linked.takeError(), Obj->getFileName());
- StringRef LinkedName;
- if (std::error_code EC = Obj->getSymbolName(*Linked, LinkedName))
- reportError(errorCodeToError(EC), Obj->getFileName());
+ Expected<StringRef> LinkedName = Obj->getSymbolName(*Linked);
+ if (!LinkedName)
+ reportError(LinkedName.takeError(), Obj->getFileName());
DictScope AS(W, "AuxWeakExternal");
- W.printNumber("Linked", LinkedName, Aux->TagIndex);
+ W.printNumber("Linked", *LinkedName, Aux->TagIndex);
W.printEnum ("Search", Aux->Characteristics,
makeArrayRef(WeakExternalCharacteristics));
@@ -1552,16 +1556,14 @@ void COFFDumper::printSymbol(const SymbolRef &Sym) {
if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT
&& Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
- const coff_section *Assoc;
- StringRef AssocName = "";
- if (std::error_code EC = Obj->getSection(AuxNumber, Assoc))
- reportError(errorCodeToError(EC), Obj->getFileName());
- Expected<StringRef> Res = getSectionName(Obj, AuxNumber, Assoc);
- if (!Res)
- reportError(Res.takeError(), Obj->getFileName());
- AssocName = *Res;
-
- W.printNumber("AssocSection", AssocName, AuxNumber);
+ Expected<const coff_section *> Assoc = Obj->getSection(AuxNumber);
+ if (!Assoc)
+ reportError(Assoc.takeError(), Obj->getFileName());
+ Expected<StringRef> AssocName = getSectionName(Obj, AuxNumber, *Assoc);
+ if (!AssocName)
+ reportError(AssocName.takeError(), Obj->getFileName());
+
+ W.printNumber("AssocSection", *AssocName, AuxNumber);
}
} else if (Symbol.isCLRToken()) {
const coff_aux_clr_token *Aux;
@@ -1573,14 +1575,14 @@ void COFFDumper::printSymbol(const SymbolRef &Sym) {
if (!ReferredSym)
reportError(ReferredSym.takeError(), Obj->getFileName());
- StringRef ReferredName;
- if (std::error_code EC = Obj->getSymbolName(*ReferredSym, ReferredName))
- reportError(errorCodeToError(EC), Obj->getFileName());
+ Expected<StringRef> ReferredName = Obj->getSymbolName(*ReferredSym);
+ if (!ReferredName)
+ reportError(ReferredName.takeError(), Obj->getFileName());
DictScope AS(W, "AuxCLRToken");
W.printNumber("AuxType", Aux->AuxType);
W.printNumber("Reserved", Aux->Reserved);
- W.printNumber("SymbolTableIndex", ReferredName, Aux->SymbolTableIndex);
+ W.printNumber("SymbolTableIndex", *ReferredName, Aux->SymbolTableIndex);
} else {
W.startLine() << "<unhandled auxiliary record>\n";
@@ -1969,11 +1971,11 @@ void COFFDumper::printAddrsig() {
if (!Sym)
reportError(Sym.takeError(), Obj->getFileName());
- StringRef SymName;
- if (std::error_code EC = Obj->getSymbolName(*Sym, SymName))
- reportError(errorCodeToError(EC), Obj->getFileName());
+ Expected<StringRef> SymName = Obj->getSymbolName(*Sym);
+ if (!SymName)
+ reportError(SymName.takeError(), Obj->getFileName());
- W.printNumber("Sym", SymName, SymIndex);
+ W.printNumber("Sym", *SymName, SymIndex);
Cur += Size;
}
}
diff --git a/llvm/tools/obj2yaml/coff2yaml.cpp b/llvm/tools/obj2yaml/coff2yaml.cpp
index b75630302528..0ca19802024c 100644
--- a/llvm/tools/obj2yaml/coff2yaml.cpp
+++ b/llvm/tools/obj2yaml/coff2yaml.cpp
@@ -100,7 +100,7 @@ static void
initializeFileAndStringTable(const llvm::object::COFFObjectFile &Obj,
codeview::StringsAndChecksumsRef &SC) {
- ExitOnError Err("Invalid .debug$S section!");
+ ExitOnError Err("invalid .debug$S section");
// Iterate all .debug$S sections looking for the checksums and string table.
// Exit as soon as both sections are found.
for (const auto &S : Obj.sections()) {
@@ -139,11 +139,10 @@ void COFFDumper::dumpSections(unsigned NumSections) {
codeview::StringsAndChecksumsRef SC;
initializeFileAndStringTable(Obj, SC);
+ ExitOnError Err("invalid section table");
StringMap<bool> SymbolUnique;
for (const auto &S : Obj.symbols()) {
- object::COFFSymbolRef Symbol = Obj.getCOFFSymbol(S);
- StringRef Name;
- Obj.getSymbolName(Symbol, Name);
+ StringRef Name = Err(Obj.getSymbolName(Obj.getCOFFSymbol(S)));
StringMap<bool>::iterator It;
bool Inserted;
std::tie(It, Inserted) = SymbolUnique.insert(std::make_pair(Name, true));
@@ -277,11 +276,13 @@ dumpCLRTokenDefinition(COFFYAML::Symbol *Sym,
}
void COFFDumper::dumpSymbols(unsigned NumSymbols) {
+ ExitOnError Err("invalid symbol table");
+
std::vector<COFFYAML::Symbol> &Symbols = YAMLObj.Symbols;
for (const auto &S : Obj.symbols()) {
object::COFFSymbolRef Symbol = Obj.getCOFFSymbol(S);
COFFYAML::Symbol Sym;
- Obj.getSymbolName(Symbol, Sym.Name);
+ Sym.Name = Err(Obj.getSymbolName(Symbol));
Sym.SimpleType = COFF::SymbolBaseType(Symbol.getBaseType());
Sym.ComplexType = COFF::SymbolComplexType(Symbol.getComplexType());
Sym.Header.StorageClass = Symbol.getStorageClass();
More information about the llvm-commits
mailing list