/// Channel is the ChannelT instance to communicate on. It is assumed that
/// the channel is ready to be read from and written to.
static Expected<OrcRemoteTargetClient> Create(ChannelT &Channel) {
- Error Err;
+ Error Err = Error::success();
OrcRemoteTargetClient H(Channel, Err);
if (Err)
return std::move(Err);
static Error doNothing() { return Error::success(); }
ChannelT &Channel;
- Error ExistingError;
+ Error ExistingError = Error::success();
std::string RemoteTargetTriple;
uint32_t RemotePointerSize = 0;
uint32_t RemotePageSize = 0;
// error.
template <typename T> friend class Expected;
-public:
+protected:
/// Create a success value. Prefer using 'Error::success()' for readability
- /// where possible.
Error() : Payload(nullptr) {
setPtr(nullptr);
setChecked(false);
}
+public:
/// Create a success value. This is equivalent to calling the default
/// constructor, but should be preferred for readability where possible.
static Error success() { return Error(); }
assert(ResI == Res.end());
ThinLTO.ModuleMap[MBRef.getBufferIdentifier()] = MBRef;
- return Error();
+ return Error::success();
}
unsigned LTO::getMaxTasks() const {
if (Conf.PreOptModuleHook &&
!Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
- return Error();
+ return Error::success();
if (!Conf.CodeGenOnly) {
for (const auto &R : GlobalResolutions) {
if (Conf.PostInternalizeModuleHook &&
!Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
- return Error();
+ return Error::success();
}
return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
std::move(RegularLTO.CombinedModule));
if (AddStreamFn CacheAddStream = Cache(Task, Key))
return RunThinBackend(CacheAddStream);
- return Error();
+ return Error::success();
}
Error start(
MBRef, std::ref(CombinedIndex), std::ref(ImportList),
std::ref(ExportList), std::ref(ResolvedODR), std::ref(DefinedGlobals),
std::ref(ModuleMap));
- return Error();
+ return Error::success();
}
Error wait() override {
if (Err)
return std::move(*Err);
else
- return Error();
+ return Error::success();
}
};
if (ShouldEmitImportsFiles)
return errorCodeToError(
EmitImportsFiles(ModulePath, NewModulePath + ".imports", ImportList));
- return Error();
+ return Error::success();
}
- Error wait() override { return Error(); }
+ Error wait() override { return Error::success(); }
};
ThinBackend lto::createWriteIndexesThinBackend(std::string OldPrefix,
Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
bool HasRegularLTO) {
if (ThinLTO.ModuleMap.empty())
- return Error();
+ return Error::success();
if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
- return Error();
+ return Error::success();
// Collect for each module the list of function it defines (GUID ->
// Summary).
return true;
};
- return Error();
+ return Error::success();
}
namespace {
if (!C.CodeGenOnly)
if (!opt(C, TM.get(), 0, *Mod, /*IsThinLto=*/false))
- return Error();
+ return Error::success();
if (ParallelCodeGenParallelismLevel == 1) {
codegen(C, TM.get(), AddStream, 0, *Mod);
splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel,
std::move(Mod));
}
- return Error();
+ return Error::success();
}
Error lto::thinBackend(Config &Conf, unsigned Task, AddStreamFn AddStream,
if (Conf.CodeGenOnly) {
codegen(Conf, TM.get(), AddStream, Task, Mod);
- return Error();
+ return Error::success();
}
if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
- return Error();
+ return Error::success();
renameModuleForThinLTO(Mod, CombinedIndex);
thinLTOResolveWeakForLinkerModule(Mod, DefinedGlobals);
if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
- return Error();
+ return Error::success();
if (!DefinedGlobals.empty())
thinLTOInternalizeModule(Mod, DefinedGlobals);
if (Conf.PostInternalizeModuleHook &&
!Conf.PostInternalizeModuleHook(Task, Mod))
- return Error();
+ return Error::success();
auto ModuleLoader = [&](StringRef Identifier) {
assert(Mod.getContext().isODRUniquingDebugTypes() &&
return Err;
if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
- return Error();
+ return Error::success();
if (!opt(Conf, TM.get(), Task, Mod, /*IsThinLto=*/true))
- return Error();
+ return Error::success();
codegen(Conf, TM.get(), AddStream, Task, Mod);
- return Error();
+ return Error::success();
}
return malformedError(Msg + NameOrErr.get());
}
- Error Err;
+ Error Err = Error::success();
Child Ret(Parent, NextLoc, &Err);
if (Err)
return std::move(Err);
}
Expected<std::unique_ptr<Archive>> Archive::create(MemoryBufferRef Source) {
- Error Err;
+ Error Err = Error::success();
std::unique_ptr<Archive> Ret(new Archive(Source, Err));
if (Err)
return std::move(Err);
}
const char *Loc = Parent->getData().begin() + Offset;
- Error Err;
+ Error Err = Error::success();
Child C(Parent, Loc, &Err);
if (Err)
return std::move(Err);
llvm::Error llvm::object::isNotObjectErrorInvalidFileType(llvm::Error Err) {
if (auto Err2 =
- handleErrors(std::move(Err),
- [](std::unique_ptr<ECError> M) {
- // Try to handle 'M'. If successful, return a success value from
- // the handler.
- if (M->convertToErrorCode() == object_error::invalid_file_type)
- return Error::success();
+ handleErrors(std::move(Err), [](std::unique_ptr<ECError> M) -> Error {
+ // Try to handle 'M'. If successful, return a success value from
+ // the handler.
+ if (M->convertToErrorCode() == object_error::invalid_file_type)
+ return Error::success();
- // We failed to handle 'M' - return it from the handler.
- // This value will be passed back from catchErrors and
- // wind up in Err2, where it will be returned from this function.
- return Error(std::move(M));
- }))
+ // We failed to handle 'M' - return it from the handler.
+ // This value will be passed back from catchErrors and
+ // wind up in Err2, where it will be returned from this function.
+ return Error(std::move(M));
+ }))
return Err2;
return Err;
}
MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
bool Is64Bits, uint32_t UniversalCputype,
uint32_t UniversalIndex) {
- Error Err;
+ Error Err = Error::success();
std::unique_ptr<MachOObjectFile> Obj(
new MachOObjectFile(std::move(Object), IsLittleEndian,
Is64Bits, Err, UniversalCputype,
Expected<std::unique_ptr<MachOUniversalBinary>>
MachOUniversalBinary::create(MemoryBufferRef Source) {
- Error Err;
+ Error Err = Error::success();
std::unique_ptr<MachOUniversalBinary> Ret(
new MachOUniversalBinary(Source, Err));
if (Err)
StringRef Coverage;
uint8_t BytesInAddress;
support::endianness Endian;
- Error E;
+ Error E = Error::success();
consumeError(std::move(E));
if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic))
// This is a special format used for testing.
Buffers.reserve(CurrentArchives.size());
for (const auto &CurrentArchive : CurrentArchives) {
- Error Err;
+ Error Err = Error::success();
for (auto Child : CurrentArchive->children(Err)) {
if (auto NameOrErr = Child.getName()) {
if (*NameOrErr == Filename) {
bool Filter = !Members.empty();
{
- Error Err;
+ Error Err = Error::success();
for (auto &C : OldArchive->children(Err)) {
Expected<StringRef> NameOrErr = C.getName();
failIfError(NameOrErr.takeError());
int InsertPos = -1;
StringRef PosName = sys::path::filename(RelPos);
if (OldArchive) {
- Error Err;
+ Error Err = Error::success();
for (auto &Child : OldArchive->children(Err)) {
int Pos = Ret.size();
Expected<StringRef> NameOrErr = Child.getName();
fail("error opening '" + ArchiveName + "': " + EC.message() + "!");
if (!EC) {
- Error Err;
+ Error Err = Error::success();
object::Archive Archive(Buf.get()->getMemBufferRef(), Err);
EC = errorToErrorCode(std::move(Err));
failIfError(EC,
Archives.push_back(std::move(*LibOrErr));
object::Archive &Lib = *Archives.back();
{
- Error Err;
+ Error Err = Error::success();
for (auto &Member : Lib.children(Err))
addMember(NewMembers, Member);
failIfError(std::move(Err));
}
static void dumpArchive(const Archive *Arc) {
- Error Err;
+ Error Err = Error::success();
for (auto &ArcC : Arc->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = ArcC.getAsBinary();
if (!ChildOrErr) {
std::deque<SmallString<32>> &UncompressedSections, StringRef &Name,
StringRef &Contents) {
if (!Name.startswith("zdebug_"))
- return Error();
+ return Error::success();
UncompressedSections.emplace_back();
uint64_t OriginalSize;
if (!zlib::isAvailable())
.str());
Name = Name.substr(1);
Contents = UncompressedSections.back();
- return Error();
+ return Error::success();
}
static Error handleSection(
StringRef &AbbrevSection, StringRef &CurCUIndexSection,
StringRef &CurTUIndexSection) {
if (Section.isBSS())
- return Error();
+ return Error::success();
if (Section.isVirtual())
- return Error();
+ return Error::success();
StringRef Name;
if (std::error_code Err = Section.getName(Name))
auto SectionPair = KnownSections.find(Name);
if (SectionPair == KnownSections.end())
- return Error();
+ return Error::success();
if (DWARFSectionKind Kind = SectionPair->second.second) {
auto Index = Kind - DW_SECT_INFO;
Out.SwitchSection(OutSection);
Out.EmitBytes(Contents);
}
- return Error();
+ return Error::success();
}
static Error
writeIndex(Out, MCOFI.getDwarfCUIndexSection(), ContributionOffsets,
IndexEntries);
- return Error();
+ return Error::success();
}
static int error(const Twine &Error, const Twine &Context) {
}
{
- Error Err;
+ Error Err = Error::success();
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(&Context);
if (!ChildOrErr) {
} else if (Expected<std::unique_ptr<Archive>> AOrErr =
I->getAsArchive()) {
std::unique_ptr<Archive> &A = *AOrErr;
- Error Err;
+ Error Err = Error::success();
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr =
C.getAsBinary(&Context);
} else if (Expected<std::unique_ptr<Archive>> AOrErr =
I->getAsArchive()) {
std::unique_ptr<Archive> &A = *AOrErr;
- Error Err;
+ Error Err = Error::success();
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr =
C.getAsBinary(&Context);
} else if (Expected<std::unique_ptr<Archive>> AOrErr =
I->getAsArchive()) {
std::unique_ptr<Archive> &A = *AOrErr;
- Error Err;
+ Error Err = Error::success();
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr =
C.getAsBinary(&Context);
static void printArchiveHeaders(StringRef Filename, Archive *A, bool verbose,
bool print_offset,
StringRef ArchitectureName = StringRef()) {
- Error Err;
+ Error Err = Error::success();
+ ;
for (const auto &C : A->children(Err, false))
printArchiveChild(Filename, C, verbose, print_offset, ArchitectureName);
if (ArchiveHeaders)
printArchiveHeaders(Filename, A, !NonVerbose, ArchiveMemberOffsets);
- Error Err;
+ Error Err = Error::success();
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
if (ArchiveHeaders)
printArchiveHeaders(Filename, A.get(), !NonVerbose,
ArchiveMemberOffsets, ArchitectureName);
- Error Err;
+ Error Err = Error::success();
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
if (ArchiveHeaders)
printArchiveHeaders(Filename, A.get(), !NonVerbose,
ArchiveMemberOffsets);
- Error Err;
+ Error Err = Error::success();
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
if (ArchiveHeaders)
printArchiveHeaders(Filename, A.get(), !NonVerbose,
ArchiveMemberOffsets, ArchitectureName);
- Error Err;
+ Error Err = Error::success();
for (auto &C : A->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
/// @brief Dump each object file in \a a;
static void DumpArchive(const Archive *a) {
- Error Err;
+ Error Err = Error::success();
for (auto &C : a->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
/// @brief Dumps each object file in \a Arc;
static void dumpArchive(const Archive *Arc) {
- Error Err;
+ Error Err = Error::success();
for (auto &Child : Arc->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();
if (!ChildOrErr) {
if (Archive *a = dyn_cast<Archive>(&Bin)) {
// This is an archive. Iterate over each member and display its sizes.
- Error Err;
+ Error Err = Error::success();
for (auto &C : a->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
std::unique_ptr<Archive> &UA = *AOrErr;
// This is an archive. Iterate over each member and display its
// sizes.
- Error Err;
+ Error Err = Error::success();
for (auto &C : UA->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
std::unique_ptr<Archive> &UA = *AOrErr;
// This is an archive. Iterate over each member and display its
// sizes.
- Error Err;
+ Error Err = Error::success();
for (auto &C : UA->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
I->getAsArchive()) {
std::unique_ptr<Archive> &UA = *AOrErr;
// This is an archive. Iterate over each member and display its sizes.
- Error Err;
+ Error Err = Error::success();
for (auto &C : UA->children(Err)) {
Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
if (!ChildOrErr) {
Out << YAMLSleds;
}
-static CommandRegistration Unused(&Extract, [] {
- Error Err;
+static CommandRegistration Unused(&Extract, []() -> Error {
+ Error Err = Error::success();
xray::InstrumentationMapExtractor Extractor(
ExtractInput, InstrumentationMapExtractor::InputFormats::ELF, Err);
if (Err)
static void
visitObjectFiles(const object::Archive &A,
function_ref<void(const object::ObjectFile &)> Fn) {
- Error Err;
+ Error Err = Error::success();
for (auto &C : A.children(Err)) {
Expected<std::unique_ptr<object::Binary>> ChildOrErr = C.getAsBinary();
failIfError(ChildOrErr);
char CustomSubError::ID = 0;
-static Error handleCustomError(const CustomError &CE) { return Error(); }
+static Error handleCustomError(const CustomError &CE) {
+ return Error::success();
+}
static void handleCustomErrorVoid(const CustomError &CE) {}
static Error handleCustomErrorUP(std::unique_ptr<CustomError> CE) {
- return Error();
+ return Error::success();
}
static void handleCustomErrorUPVoid(std::unique_ptr<CustomError> CE) {}