return Triple::UnknownObjectFormat;
}
- static std::error_code checkOffset(MemoryBufferRef M, uintptr_t Addr,
- const uint64_t Size) {
+ static Error checkOffset(MemoryBufferRef M, uintptr_t Addr,
+ const uint64_t Size) {
if (Addr + Size < Addr || Addr + Size < Size ||
Addr + Size > uintptr_t(M.getBufferEnd()) ||
Addr < uintptr_t(M.getBufferStart())) {
- return object_error::unexpected_eof;
+ return errorCodeToError(object_error::unexpected_eof);
}
- return std::error_code();
+ return Error::success();
}
};
const Elf_Shdr *EShdr = getSection(Sec);
if (EShdr->sh_type == ELF::SHT_NOBITS)
return makeArrayRef((const uint8_t *)base(), 0);
- if (std::error_code EC =
+ if (Error E =
checkOffset(getMemoryBufferRef(),
(uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size))
- return errorCodeToError(EC);
+ return std::move(E);
return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset,
EShdr->sh_size);
}
const void *Ptr,
const uint64_t Size = sizeof(T)) {
uintptr_t Addr = uintptr_t(Ptr);
- if (std::error_code EC = Binary::checkOffset(M, Addr, Size))
- return EC;
+ if (Error E = Binary::checkOffset(M, Addr, Size))
+ return errorToErrorCode(std::move(E));
Obj = reinterpret_cast<const T *>(Addr);
return std::error_code();
}
// relocations.
begin++;
}
- if (Binary::checkOffset(M, uintptr_t(begin),
- sizeof(coff_relocation) * NumRelocs))
+ if (auto E = Binary::checkOffset(M, uintptr_t(begin),
+ sizeof(coff_relocation) * NumRelocs)) {
+ consumeError(std::move(E));
return nullptr;
+ }
return begin;
}
uintptr_t IntPtr = 0;
if (std::error_code EC = getRvaPtr(ImportTableRva, IntPtr))
return EC;
- if (std::error_code EC = checkOffset(Data, IntPtr, DataEntry->Size))
- return EC;
+ if (Error E = checkOffset(Data, IntPtr, DataEntry->Size))
+ return errorToErrorCode(std::move(E));
ImportDirectory = reinterpret_cast<
const coff_import_directory_table_entry *>(IntPtr);
return std::error_code();
// data, as there's nothing that says that is not allowed.
uintptr_t ConStart = uintptr_t(base()) + Sec->PointerToRawData;
uint32_t SectionSize = getSectionSize(Sec);
- if (checkOffset(Data, ConStart, SectionSize))
- return make_error<BinaryError>();
+ if (Error E = checkOffset(Data, ConStart, SectionSize))
+ return E;
Res = makeArrayRef(reinterpret_cast<const uint8_t *>(ConStart), SectionSize);
return Error::success();
}
static Expected<const T *> getObject(MemoryBufferRef M, const void *Ptr,
const uint64_t Size = sizeof(T)) {
uintptr_t Addr = uintptr_t(Ptr);
- if (std::error_code EC = Binary::checkOffset(M, Addr, Size))
- return errorCodeToError(EC);
+ if (Error E = Binary::checkOffset(M, Addr, Size))
+ return std::move(E);
return reinterpret_cast<const T *>(Addr);
}