template <class ELFT>
Expected<uint64_t>
ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const {
- uint64_t Result = getSymbolValue(Symb);
+ Expected<uint64_t> SymbolValueOrErr = getSymbolValue(Symb);
+ if (!SymbolValueOrErr)
+ // TODO: Test this error.
+ return SymbolValueOrErr.takeError();
+
+ uint64_t Result = *SymbolValueOrErr;
const Elf_Sym *ESym = getSymbol(Symb);
switch (ESym->st_shndx) {
case ELF::SHN_COMMON:
/// Return the value of the symbol depending on the object this can be an
/// offset or a virtual address.
- uint64_t getValue() const;
+ Expected<uint64_t> getValue() const;
/// Get the alignment of this symbol as the actual value (not log 2).
uint32_t getAlignment() const;
virtual void getRelocationTypeName(DataRefImpl Rel,
SmallVectorImpl<char> &Result) const = 0;
- uint64_t getSymbolValue(DataRefImpl Symb) const;
+ Expected<uint64_t> getSymbolValue(DataRefImpl Symb) const;
public:
ObjectFile() = delete;
return getObject()->getSymbolAddress(getRawDataRefImpl());
}
-inline uint64_t SymbolRef::getValue() const {
+inline Expected<uint64_t> SymbolRef::getValue() const {
return getObject()->getSymbolValue(getRawDataRefImpl());
}
consumeError(SymType.takeError());
continue;
}
- const uint64_t Addr = Sym.getValue();
+ Expected<uint64_t> AddrOrErr = Sym.getValue();
+ if (!AddrOrErr)
+ // TODO: Test this error.
+ return AddrOrErr.takeError();
+
if (SymType.get() != SymbolRef::Type::ST_Function ||
- !Gsym.IsValidTextAddress(Addr) || Gsym.hasFunctionInfoForAddress(Addr))
+ !Gsym.IsValidTextAddress(*AddrOrErr) ||
+ Gsym.hasFunctionInfoForAddress(*AddrOrErr))
continue;
// Function size for MachO files will be 0
constexpr bool NoCopy = false;
// for mach-o files.
if (IsMachO)
Name->consume_front("_");
- Gsym.addFunctionInfo(FunctionInfo(Addr, size,
- Gsym.insertString(*Name, NoCopy)));
+ Gsym.addFunctionInfo(
+ FunctionInfo(*AddrOrErr, size, Gsym.insertString(*Name, NoCopy)));
}
size_t FunctionsAddedCount = Gsym.getNumFunctionInfos() - NumBefore;
Log << "Loaded " << FunctionsAddedCount << " functions from symbol table.\n";
uint64_t RuntimeDyldCOFF::getSymbolOffset(const SymbolRef &Sym) {
// The value in a relocatable COFF object is the offset.
- return Sym.getValue();
+ return cantFail(Sym.getValue());
}
uint64_t RuntimeDyldCOFF::getDLLImportOffset(unsigned SectionID, StubMap &Stubs,
}
Expected<uint64_t> COFFObjectFile::getSymbolAddress(DataRefImpl Ref) const {
- uint64_t Result = getSymbolValue(Ref);
+ uint64_t Result = cantFail(getSymbolValue(Ref));
COFFSymbolRef Symb = getCOFFSymbol(Ref);
int32_t SectionNumber = Symb.getSectionNumber();
return *this == **SymSec;
}
-uint64_t ObjectFile::getSymbolValue(DataRefImpl Ref) const {
+Expected<uint64_t> ObjectFile::getSymbolValue(DataRefImpl Ref) const {
if (Expected<uint32_t> FlagsOrErr = getSymbolFlags(Ref)) {
if (*FlagsOrErr & SymbolRef::SF_Undefined)
return 0;
if (*FlagsOrErr & SymbolRef::SF_Common)
return getCommonSymbolSize(Ref);
} else
- // TODO: Actually report errors helpfully.
- report_fatal_error(FlagsOrErr.takeError());
+ // TODO: Test this error.
+ return FlagsOrErr.takeError();
return getSymbolValueImpl(Ref);
}
unsigned SymNum = 0;
for (symbol_iterator I = O.symbol_begin(), E = O.symbol_end(); I != E; ++I) {
SymbolRef Sym = *I;
- uint64_t Value = Sym.getValue();
- Addresses.push_back({I, Value, SymNum, getSymbolSectionID(O, Sym)});
+ Expected<uint64_t> ValueOrErr = Sym.getValue();
+ if (!ValueOrErr)
+ // TODO: Actually report errors helpfully.
+ report_fatal_error(ValueOrErr.takeError());
+ Addresses.push_back({I, *ValueOrErr, SymNum, getSymbolSectionID(O, Sym)});
++SymNum;
}
for (SectionRef Sec : O.sections()) {
if (SupportsRelocation && SupportsRelocation(Reloc.getType())) {
auto AddendOrErr = object::ELFRelocationRef(Reloc).getAddend();
auto A = AddendOrErr ? *AddendOrErr : 0;
- uint64_t resolved = Resolver(Reloc, Reloc.getSymbol()->getValue(), A);
- Relocs.insert({Reloc.getOffset(), resolved});
+ Expected<uint64_t> ValueOrErr = Reloc.getSymbol()->getValue();
+ if (!ValueOrErr)
+ // TODO: Test this error.
+ return ValueOrErr.takeError();
+ Relocs.insert({Reloc.getOffset(), Resolver(Reloc, *ValueOrErr, A)});
} else if (Reloc.getType() == RelativeRelocation) {
if (auto AddendOrErr = object::ELFRelocationRef(Reloc).getAddend())
Relocs.insert({Reloc.getOffset(), *AddendOrErr});
<< toString(std::move(Err)) << '\n';
} else {
for (const auto &Sym : Object->symbols()) {
- uint64_t Address = Sym.getValue();
+ Expected<uint64_t> AddressOrErr = Sym.getValue();
+ if (!AddressOrErr) {
+ // TODO: Actually report errors helpfully.
+ consumeError(AddressOrErr.takeError());
+ continue;
+ }
Expected<StringRef> Name = Sym.getName();
Expected<uint32_t> FlagsOrErr = Sym.getFlags();
if (!Name || !FlagsOrErr ||
consumeError(Name.takeError());
continue;
}
- SymbolAddresses[*Name] = Address;
+ SymbolAddresses[*Name] = *AddressOrErr;
}
}
}
CurrentObjectAddresses.clear();
for (auto Sym : Obj.symbols()) {
- uint64_t Addr = Sym.getValue();
+ uint64_t Addr = cantFail(Sym.getValue());
Expected<StringRef> Name = Sym.getName();
if (!Name) {
// TODO: Actually report errors helpfully.
Section = *SectionOrErr;
if (Section == MainBinary.section_end() || Section->isText())
continue;
- uint64_t Addr = Sym.getValue();
+ uint64_t Addr = cantFail(Sym.getValue());
Expected<StringRef> NameOrErr = Sym.getName();
if (!NameOrErr) {
// TODO: Actually report errors helpfully.
if (!BTypeOrErr)
reportError(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();
+ uint64_t AAddr =
+ (AType != SymbolRef::ST_Function) ? 0 : cantFail(A.getValue());
+ uint64_t BAddr =
+ (BType != SymbolRef::ST_Function) ? 0 : cantFail(B.getValue());
return AAddr < BAddr;
}
};
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();
+ uint64_t Address = cantFail(Symbol.getValue());
StringRef SymName = unwrapOrError(Symbol.getName(), FileName);
if (!SymName.startswith(".objc"))
(*AddrMap)[Address] = SymName;
// and return its name.
const char *SymbolName = nullptr;
if (reloc_found && isExtern) {
- n_value = Symbol.getValue();
+ n_value = cantFail(Symbol.getValue());
StringRef Name = unwrapOrError(Symbol.getName(), info->O->getFileName());
if (!Name.empty()) {
SymbolName = Name.data();
if (info->O->getAnyRelocationPCRel(RE)) {
unsigned Type = info->O->getAnyRelocationType(RE);
if (Type == MachO::X86_64_RELOC_SIGNED) {
- ReferenceValue = Symbol.getValue();
+ ReferenceValue = cantFail(Symbol.getValue());
}
}
}
unwrapOrError(Symbol.getType(), MachOOF->getFileName());
if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
ST == SymbolRef::ST_Other) {
- uint64_t Address = Symbol.getValue();
+ uint64_t Address = cantFail(Symbol.getValue());
StringRef SymName =
unwrapOrError(Symbol.getName(), MachOOF->getFileName());
AddrMap[Address] = SymName;
// Start at the address of the symbol relative to the section's address.
uint64_t SectSize = Sections[SectIdx].getSize();
- uint64_t Start = Symbols[SymIdx].getValue();
+ uint64_t Start = cantFail(Symbols[SymIdx].getValue());
uint64_t SectionAddress = Sections[SectIdx].getAddress();
Start -= SectionAddress;
if (NextSymType == SymbolRef::ST_Function) {
containsNextSym =
Sections[SectIdx].containsSymbol(Symbols[NextSymIdx]);
- NextSym = Symbols[NextSymIdx].getValue();
+ NextSym = cantFail(Symbols[NextSymIdx].getValue());
NextSym -= SectionAddress;
break;
}
if (Section == Obj->section_end())
continue;
- uint64_t Addr = SymRef.getValue();
+ uint64_t Addr = cantFail(SymRef.getValue());
Symbols.insert(std::make_pair(Addr, SymRef));
}