This would trigger an assertion at runtime otherwise.
Differential Revision: https://reviews.llvm.org/D26482
llvm-svn: 286562
// Seen is a map from member files to boolean values. Initially
// all members are mapped to false, which indicates all these files
// are not read yet.
- Error Err;
+ Error Err = Error::success();
for (auto &Child : File->children(Err))
Seen[Child.getChildOffset()].clear();
if (Err)
}
static void checkError(Error E) {
- handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
+ handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) -> Error {
error(EIB.message());
return Error::success();
});
for (std::unique_ptr<Pass> &pass : _passes)
if (llvm::Error EC = pass->perform(file))
return EC;
- return llvm::Error();
+ return llvm::Error::success();
}
private:
if (auto ec = undefAddedOrError.takeError())
return ec;
- return llvm::Error();
+ return llvm::Error::success();
}
bool Resolver::doUndefinedAtom(OwningAtomPtr<UndefinedAtom> atom) {
addFile(path, ctx, forceLoad, false, diagnostics);
buffer = lineAndRest.second;
}
- return llvm::Error();
+ return llvm::Error::success();
}
/// Parse number assuming it is base 16, but allow 0x prefix.
parseAllMembers(std::vector<std::unique_ptr<File>> &result) override {
if (std::error_code ec = parse())
return ec;
- llvm::Error err;
+ llvm::Error err = llvm::Error::success();
for (auto mf = _archive->child_begin(err), me = _archive->child_end();
mf != me; ++mf) {
std::unique_ptr<File> file;
protected:
std::error_code doParse() override {
// Make Archive object which will be owned by FileArchive object.
- llvm::Error Err;
+ llvm::Error Err = llvm::Error::success();
_archive.reset(new Archive(_mb->getMemBufferRef(), Err));
if (Err)
return errorToErrorCode(std::move(Err));
// Instruction contains branch to addend.
displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
*addend = fixupAddress + 4 + displacement;
- return llvm::Error();
+ return llvm::Error::success();
case ARM_THUMB_RELOC_BR22 | rPcRel | rLength4:
// ex: bl _foo (and _foo is defined)
if ((instruction & 0xD000F800) == 0x9000F000)
// reloc.value is target atom's address. Instruction contains branch
// to atom+addend.
*addend += (targetAddress - reloc.value);
- return llvm::Error();
+ return llvm::Error::success();
case ARM_RELOC_BR24 | rPcRel | rExtern | rLength4:
// ex: bl _foo (and _foo is undefined)
if (((instruction & 0x0F000000) == 0x0A000000)
// Instruction contains branch to addend.
displacement = getDisplacementFromArmBranch(instruction);
*addend = fixupAddress + 8 + displacement;
- return llvm::Error();
+ return llvm::Error::success();
case ARM_RELOC_BR24 | rPcRel | rLength4:
// ex: bl _foo (and _foo is defined)
if (((instruction & 0x0F000000) == 0x0A000000)
// reloc.value is target atom's address. Instruction contains branch
// to atom+addend.
*addend += (targetAddress - reloc.value);
- return llvm::Error();
+ return llvm::Error::success();
case ARM_RELOC_VANILLA | rExtern | rLength4:
// ex: .long _foo (and _foo is undefined)
*kind = pointer32;
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = instruction;
- return llvm::Error();
+ return llvm::Error::success();
case ARM_RELOC_VANILLA | rLength4:
// ex: .long _foo (and _foo is defined)
*kind = pointer32;
if (auto ec = atomFromAddress(reloc.symbol, instruction, target, addend))
return ec;
*addend = clearThumbBit((uint32_t) * addend, *target);
- return llvm::Error();
+ return llvm::Error::success();
case ARM_RELOC_VANILLA | rScattered | rLength4:
// ex: .long _foo+a (and _foo is defined)
*kind = pointer32;
if (auto ec = atomFromAddress(0, reloc.value, target, addend))
return ec;
*addend += (clearThumbBit(instruction, *target) - reloc.value);
- return llvm::Error();
+ return llvm::Error::success();
default:
return llvm::make_error<GenericError>("unsupported arm relocation type");
}
- return llvm::Error();
+ return llvm::Error::success();
}
llvm::Error
value = clearThumbBit(value, *target);
int64_t ta = (int64_t) value - (toAddress - fromAddress);
*addend = ta - offsetInFrom;
- return llvm::Error();
+ return llvm::Error::success();
} else {
uint32_t sectIndex;
if (thumbReloc) {
}
}
- return llvm::Error();
+ return llvm::Error::success();
}
void ArchHandler_arm::applyFixupFinal(const Reference &ref, uint8_t *loc,
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_PAGE21 | rPcRel | rExtern | rLength4:
// ex: adrp x1, _foo@PAGE
*kind = page21;
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_PAGEOFF12 | rExtern | rLength4:
// ex: ldr x0, [x1, _foo@PAGEOFF]
*kind = offset12KindFromInstruction(*(const little32_t *)fixupContent);
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_GOT_LOAD_PAGE21 | rPcRel | rExtern | rLength4:
// ex: adrp x1, _foo@GOTPAGE
*kind = gotPage21;
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_GOT_LOAD_PAGEOFF12 | rExtern | rLength4:
// ex: ldr x0, [x1, _foo@GOTPAGEOFF]
*kind = gotOffset12;
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_TLVP_LOAD_PAGE21 | rPcRel | rExtern | rLength4:
// ex: adrp x1, _foo@TLVPAGE
*kind = tlvPage21;
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_TLVP_LOAD_PAGEOFF12 | rExtern | rLength4:
// ex: ldr x0, [x1, _foo@TLVPAGEOFF]
*kind = tlvOffset12;
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_UNSIGNED | rExtern | rLength8:
// ex: .quad _foo + N
*kind = pointer64;
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = *(const little64_t *)fixupContent;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_UNSIGNED | rLength8:
// ex: .quad Lfoo + N
*kind = pointer64;
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
case ARM64_RELOC_POINTER_TO_GOT | rPcRel | rExtern | rLength4:
// ex: .long _foo@GOT - .
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = 0;
- return llvm::Error();
+ return llvm::Error::success();
default:
return llvm::make_error<GenericError>("unsupported arm64 relocation type");
}
if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
return ec;
*addend = reloc1.symbol;
- return llvm::Error();
+ return llvm::Error::success();
case ((ARM64_RELOC_ADDEND | rLength4) << 16 |
ARM64_RELOC_PAGE21 | rPcRel | rExtern | rLength4):
// ex: adrp x1, _foo@PAGE
if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
return ec;
*addend = reloc1.symbol;
- return llvm::Error();
+ return llvm::Error::success();
case ((ARM64_RELOC_ADDEND | rLength4) << 16 |
ARM64_RELOC_PAGEOFF12 | rExtern | rLength4): {
// ex: ldr w0, [x1, _foo@PAGEOFF]
if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
return ec;
*addend = reloc1.symbol;
- return llvm::Error();
+ return llvm::Error::success();
}
case ((ARM64_RELOC_SUBTRACTOR | rExtern | rLength8) << 16 |
ARM64_RELOC_UNSIGNED | rExtern | rLength8):
return llvm::make_error<GenericError>(
"paired relocs must have the same offset");
*addend = (int64_t)*(const little64_t *)fixupContent + offsetInAtom;
- return llvm::Error();
+ return llvm::Error::success();
case ((ARM64_RELOC_SUBTRACTOR | rExtern | rLength4) << 16 |
ARM64_RELOC_UNSIGNED | rExtern | rLength4):
// ex: .quad _foo - .
if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
return ec;
*addend = (int32_t)*(const little32_t *)fixupContent + offsetInAtom;
- return llvm::Error();
+ return llvm::Error::success();
default:
return llvm::make_error<GenericError>("unsupported arm64 relocation pair");
}
default:
return llvm::make_error<GenericError>("unsupported i386 relocation type");
}
- return llvm::Error();
+ return llvm::Error::success();
}
llvm::Error
*addend = fromAddress + value - toAddress;
}
}
- return llvm::Error();
+ return llvm::Error::success();
break;
default:
return llvm::make_error<GenericError>("unsupported i386 relocation type");
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = *(const little32_t *)fixupContent;
- return llvm::Error();
+ return llvm::Error::success();
case ripRel32Minus1:
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = (int32_t)*(const little32_t *)fixupContent + 1;
- return llvm::Error();
+ return llvm::Error::success();
case ripRel32Minus2:
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = (int32_t)*(const little32_t *)fixupContent + 2;
- return llvm::Error();
+ return llvm::Error::success();
case ripRel32Minus4:
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = (int32_t)*(const little32_t *)fixupContent + 4;
- return llvm::Error();
+ return llvm::Error::success();
case ripRel32Anon:
targetAddress = fixupAddress + 4 + *(const little32_t *)fixupContent;
return atomFromAddress(reloc.symbol, targetAddress, target, addend);
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
return ec;
*addend = *(const little32_t *)fixupContent;
- return llvm::Error();
+ return llvm::Error::success();
case tlvInitSectionOffset:
case pointer64:
if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
assert(*addend == 0 && "TLV-init has non-zero addend?");
} else
*addend = *(const little64_t *)fixupContent;
- return llvm::Error();
+ return llvm::Error::success();
case pointer64Anon:
targetAddress = *(const little64_t *)fixupContent;
return atomFromAddress(reloc.symbol, targetAddress, target, addend);
*target = fromTarget;
} else
return llvm::make_error<GenericError>("Invalid pointer diff");
- return llvm::Error();
+ return llvm::Error::success();
}
case ((X86_64_RELOC_SUBTRACTOR | rExtern | rLength4) << 16 |
X86_64_RELOC_UNSIGNED | rExtern | rLength4): {
*target = fromTarget;
} else
return llvm::make_error<GenericError>("Invalid pointer diff");
- return llvm::Error();
+ return llvm::Error::success();
}
case ((X86_64_RELOC_SUBTRACTOR | rExtern | rLength8) << 16 |
X86_64_RELOC_UNSIGNED | rLength8):
// Skip rest of pass if no unwind info.
if (unwindLocs.empty() && dwarfFrames.empty())
- return llvm::Error();
+ return llvm::Error::success();
// FIXME: if there are more than 4 personality functions then we need to
// defer to DWARF info for the ones we don't put in the list. They should
return atom->contentType() == DefinedAtom::typeCompactUnwindInfo;
});
- return llvm::Error();
+ return llvm::Error::success();
}
void collectCompactUnwindEntries(
for (const GOTEntryAtom *slot : entries)
mergedFile.addAtom(*slot);
- return llvm::Error();
+ return llvm::Error::success();
}
bool shouldReplaceTargetWithGOTAtom(const Atom *target, bool canBypassGOT) {
});
DEBUG(llvm::dbgs() << "******** Finished laying out atoms\n");
- return llvm::Error();
+ return llvm::Error::success();
}
void addLayoutPass(PassManager &pm, const MachOLinkingContext &ctx) {
llvm::Error MachOLinkingContext::handleLoadedFile(File &file) {
auto *machoFile = dyn_cast<MachOFile>(&file);
if (!machoFile)
- return llvm::Error();
+ return llvm::Error::success();
// Check that the arch of the context matches that of the file.
// Also set the arch of the context if it didn't have one.
return llvm::make_error<GenericError>("different swift versions");
}
- return llvm::Error();
+ return llvm::Error::success();
}
} // end namespace lld
return llvm::make_error<GenericError>("Load command exceeds range");
if (func(slc->cmd, slc->cmdsize, p))
- return llvm::Error();
+ return llvm::Error::success();
p += slc->cmdsize;
}
- return llvm::Error();
+ return llvm::Error::success();
}
static std::error_code appendRelocations(Relocations &relocs, StringRef buffer,
++sout;
}
lc = next;
- return llvm::Error();
+ return llvm::Error::success();
}
template <typename T>
}
lc = reinterpret_cast<uint8_t*>(next);
}
- return llvm::Error();
+ return llvm::Error::success();
}
static void writeVersionMinLoadCommand(const NormalizedFile &_file,
lc += sizeof(linkedit_data_command);
}
}
- return llvm::Error();
+ return llvm::Error::success();
}
void MachOFileLayout::writeSectionContent() {
writeLinkEditContent();
fob->commit();
- return llvm::Error();
+ return llvm::Error::success();
}
/// Takes in-memory normalized view and writes a mach-o object file.
case Atom::scopeTranslationUnit:
scope = 0;
inGlobalsRegion = false;
- return llvm::Error();
+ return llvm::Error::success();
case Atom::scopeLinkageUnit:
if ((_ctx.exportMode() == MachOLinkingContext::ExportMode::whiteList) &&
_ctx.exportSymbolNamed(atom->name())) {
// -keep_private_externs means keep in globals region as N_PEXT.
scope = N_PEXT | N_EXT;
inGlobalsRegion = true;
- return llvm::Error();
+ return llvm::Error::success();
}
}
// scopeLinkageUnit symbols are no longer global once linked.
scope = N_PEXT;
inGlobalsRegion = false;
- return llvm::Error();
+ return llvm::Error::success();
case Atom::scopeGlobal:
if (_ctx.exportRestrictMode()) {
if (_ctx.exportSymbolNamed(atom->name())) {
scope = N_EXT;
inGlobalsRegion = true;
- return llvm::Error();
+ return llvm::Error::success();
} else {
scope = N_PEXT;
inGlobalsRegion = false;
- return llvm::Error();
+ return llvm::Error::success();
}
} else {
scope = N_EXT;
inGlobalsRegion = true;
- return llvm::Error();
+ return llvm::Error::success();
}
break;
}
file.undefinedSymbols.push_back(sym);
}
- return llvm::Error();
+ return llvm::Error::success();
}
const Atom *Util::targetOfLazyPointer(const DefinedAtom *lpAtom) {
// If section has no symbols and no content, there are no atoms.
if (symbols.empty() && section.content.empty())
- return llvm::Error();
+ return llvm::Error::success();
if (symbols.empty()) {
// Section has no symbols, put all content in one anoymous atom.
});
}
- return llvm::Error();
+ return llvm::Error::success();
}
llvm::Error processSection(DefinedAtom::ContentType atomType,
offset += size;
}
}
- return llvm::Error();
+ return llvm::Error::success();
}
const Section* findSectionCoveringAddress(const NormalizedFile &normalizedFile,
uint64_t offsetInSect = addr - sect->address;
*atom = file.findAtomCoveringAddress(*sect, offsetInSect, &offsetInTarget);
*addend = offsetInTarget;
- return llvm::Error();
+ return llvm::Error::success();
};
// Utility function for ArchHandler to find atom by its symbol index.
targetOffsetInSect);
if (target) {
*result = target;
- return llvm::Error();
+ return llvm::Error::success();
}
return llvm::make_error<GenericError>("no atom found for defined symbol");
} else if ((sym->type & N_TYPE) == N_UNDF) {
const lld::Atom *target = file.findUndefAtom(sym->name);
if (target) {
*result = target;
- return llvm::Error();
+ return llvm::Error::success();
}
return llvm::make_error<GenericError>("no undefined atom found for sym");
} else {
kind, offsetInAtom, target, addend);
}
- return llvm::Error();
+ return llvm::Error::success();
}
bool isDebugInfoSection(const Section §ion) {
if (augStr[0] == '\0') {
len = 1;
- return llvm::Error();
+ return llvm::Error::success();
}
if (augStr[0] != 'z')
cieInfo._augmentationDataLength = offsetInAugmentationData;
len = idx + 1;
- return llvm::Error();
+ return llvm::Error::success();
}
static llvm::Error processCIE(const NormalizedFile &normalizedFile,
cieInfos[atom] = std::move(cieInfo);
- return llvm::Error();
+ return llvm::Error::success();
}
static llvm::Error processFDE(const NormalizedFile &normalizedFile,
}
}
- return llvm::Error();
+ return llvm::Error::success();
}
llvm::Error addEHFrameReferences(const NormalizedFile &normalizedFile,
// No __eh_frame so nothing to do.
if (!ehFrameSection)
- return llvm::Error();
+ return llvm::Error::success();
- llvm::Error ehFrameErr;
+ llvm::Error ehFrameErr = llvm::Error::success();
CIEInfoMap cieInfos;
file.eachAtomInSection(*ehFrameSection,
file.setSwiftVersion((flags >> 8) & 0xFF);
- return llvm::Error();
+ return llvm::Error::success();
}
/// Converts normalized mach-o file into an lld::File and lld::Atoms.
if (auto err = parseDebugInfo(*file, normalizedFile, copyRefs))
return err;
- return llvm::Error();
+ return llvm::Error::success();
}
llvm::Error
if (dep.kind == llvm::MachO::LC_REEXPORT_DYLIB)
file->addReExportedDylib(dep.path);
}
- return llvm::Error();
+ return llvm::Error::success();
}
void relocatableSectionInfoForContentType(DefinedAtom::ContentType atomType,
// Add the image info.
mergedFile.addAtom(*getImageInfo());
- return llvm::Error();
+ return llvm::Error::success();
}
private:
}
// Exit early if no shims needed.
if (_targetToShim.empty())
- return llvm::Error();
+ return llvm::Error::success();
// Sort shim atoms so the layout order is stable.
std::vector<const DefinedAtom *> shims;
for (const DefinedAtom *shim : shims)
mergedFile.addAtom(*shim);
- return llvm::Error();
+ return llvm::Error::success();
}
private:
llvm::Error perform(SimpleFile &mergedFile) override {
// Skip this pass if output format uses text relocations instead of stubs.
if (!this->noTextRelocs())
- return llvm::Error();
+ return llvm::Error::success();
// Scan all references in all atoms.
for (const DefinedAtom *atom : mergedFile.defined()) {
// Exit early if no stubs needed.
if (_targetToUses.empty())
- return llvm::Error();
+ return llvm::Error::success();
// First add help-common and GOT slots used by lazy binding.
SimpleDefinedAtom *helperCommonAtom =
lazyOffset += target->name().size() + 12;
}
- return llvm::Error();
+ return llvm::Error::success();
}
private:
for (const TLVPEntryAtom *slot : entries)
mergedFile.addAtom(*slot);
- return llvm::Error();
+ return llvm::Error::success();
}
const DefinedAtom *makeTLVPEntry(const Atom *target) {
const lld::File *fileRef = &file;
yout << fileRef;
- return llvm::Error();
+ return llvm::Error::success();
}
private:
/// @return
/// Returns an error object.
//------------------------------------------------------------------
- virtual Error WillAttachToProcessWithID(lldb::pid_t pid) {
- return Error::success();
- }
+ virtual Error WillAttachToProcessWithID(lldb::pid_t pid) { return Error(); }
//------------------------------------------------------------------
/// Called before attaching to a process.
//------------------------------------------------------------------
virtual Error WillAttachToProcessWithName(const char *process_name,
bool wait_for_launch) {
- return Error::success();
+ return Error();
}
//------------------------------------------------------------------
/// @return
/// Returns an error object.
//------------------------------------------------------------------
- virtual Error WillLaunch(Module *module) { return Error::success(); }
+ virtual Error WillLaunch(Module *module) { return Error(); }
//------------------------------------------------------------------
/// Launch a new process.
/// @return
/// Returns an error object.
//------------------------------------------------------------------
- virtual Error WillResume() { return Error::success(); }
+ virtual Error WillResume() { return Error(); }
//------------------------------------------------------------------
/// Resumes all of a process's threads as configured using the
/// @return
/// Returns an error object.
//------------------------------------------------------------------
- virtual Error WillHalt() { return Error::success(); }
+ virtual Error WillHalt() { return Error(); }
//------------------------------------------------------------------
/// Halts a running process.
/// @return
/// Returns an error object.
//------------------------------------------------------------------
- virtual Error WillDetach() { return Error::success(); }
+ virtual Error WillDetach() { return Error(); }
//------------------------------------------------------------------
/// Detaches from a running or stopped process.
/// Process::DoSignal(int), otherwise an error describing what
/// prevents the signal from being sent.
//------------------------------------------------------------------
- virtual Error WillSignal() { return Error::success(); }
+ virtual Error WillSignal() { return Error(); }
//------------------------------------------------------------------
/// Sends a process a UNIX signal \a signal.
return error;
}
- virtual Error WillDestroy() { return Error::success(); }
+ virtual Error WillDestroy() { return Error(); }
virtual Error DoDestroy() = 0;
ExecutionContext *execution_context) {
if (!some_location_specified)
current_function = true;
- return Error::success();
+ return Error();
}
llvm::ArrayRef<OptionDefinition>
return Error("as it does not refer to a pointer");
if (pointee.IsVoidType())
return Error("as it refers to a pointer to void");
- return Error::success();
+ return Error();
}
bool CommandObjectExpression::EvaluateExpression(const char *expr,
*did_create_ptr = true;
shared_module_list.ReplaceEquivalent(module_sp);
- return Error::success();
+ return Error();
}
}
} else {
log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64
" already enabled, ignoring.",
__FUNCTION__, m_addr);
- return Error::success();
+ return Error();
}
// Log and enable.
log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64
" already disabled, ignoring.",
__FUNCTION__, m_addr);
- return Error::success();
+ return Error();
}
// Log and disable.
__FUNCTION__, addr);
iter->second->AddRef();
- return Error::success();
+ return Error();
}
// Create a new breakpoint using the given create func.
// Disable it.
breakpoint_sp = iter->second;
- return Error::success();
+ return Error();
}
Error NativeBreakpointList::RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf,
auto opcode_size = software_bp_sp->m_opcode_size;
::memcpy(opcode_addr, saved_opcodes, opcode_size);
}
- return Error::success();
+ return Error();
}
arch = module_specs.GetModuleSpecRefAtIndex(0).GetArchitecture();
if (arch.IsValid())
- return Error::success();
+ return Error();
else
return Error("failed to retrieve a valid architecture from the exe module");
}
Error NativeWatchpointList::Add(addr_t addr, size_t size, uint32_t watch_flags,
bool hardware) {
m_watchpoints[addr] = {addr, size, watch_flags, hardware};
- return Error::success();
+ return Error();
}
Error NativeWatchpointList::Remove(addr_t addr) {
m_watchpoints.erase(addr);
- return Error::success();
+ return Error();
}
const NativeWatchpointList::WatchpointMap &
// breakpoint.
breakpoint_sp.reset(new SoftwareBreakpoint(process, addr, saved_opcode_bytes,
bp_opcode_bytes, bp_opcode_size));
- return Error::success();
+ return Error();
}
Error SoftwareBreakpoint::EnableSoftwareBreakpoint(
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
__FUNCTION__, addr);
- return Error::success();
+ return Error();
}
// -------------------------------------------------------------------
} break;
case EEXIST: {
if (file_spec.IsDirectory())
- return Error::success(); // It is a directory and it already exists
+ return Error(); // It is a directory and it already exists
} break;
}
}
dst = FileSpec(real_path, false);
- return Error::success();
+ return Error();
}
#if defined(__NetBSD__)
it->second.callback(*this); // Do the work
if (m_terminate_request)
- return Error::success();
+ return Error();
}
for (int fd : read_fds) {
it->second(*this); // Do the work
if (m_terminate_request)
- return Error::success();
+ return Error();
}
}
- return Error::success();
+ return Error();
}
}
}
- return Error::success();
+ return Error();
}
int PipePosix::GetReadFileDescriptor() const { return m_fds[READ]; }
if (DataVisualization::NamedSummaryFormats::GetSummaryFormat(
ConstString(str), summary_sp) == false)
return Error("must specify a valid named summary");
- return Error::success();
+ return Error();
}
static Error ValidateSummaryString(const char *str, void *) {
if (!str || !str[0])
return Error("must specify a non-empty summary string");
- return Error::success();
+ return Error();
}
OptionGroupVariable::OptionGroupVariable(bool show_frame_options)
return error;
}
m_current_value.assign(value);
- return Error::success();
+ return Error();
}
Error OptionValueString::AppendToCurrentValue(const char *value) {
} else
m_current_value.append(value);
}
- return Error::success();
+ return Error();
}
}
// AD: Needs to be updated?
-Error DynamicLoaderHexagonDYLD::CanLoadImage() { return Error::success(); }
+Error DynamicLoaderHexagonDYLD::CanLoadImage() { return Error(); }
void DynamicLoaderHexagonDYLD::UpdateLoadedSections(ModuleSP module,
addr_t link_map_addr,
}
}
-Error DynamicLoaderPOSIXDYLD::CanLoadImage() { return Error::success(); }
+Error DynamicLoaderPOSIXDYLD::CanLoadImage() { return Error(); }
void DynamicLoaderPOSIXDYLD::UpdateLoadedSections(ModuleSP module,
addr_t link_map_addr,
void DynamicLoaderWindowsDYLD::DidLaunch() {}
-Error DynamicLoaderWindowsDYLD::CanLoadImage() { return Error::success(); }
+Error DynamicLoaderWindowsDYLD::CanLoadImage() { return Error(); }
ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
return GetPluginNameStatic();
std::string(output_buf.begin(), output_buf.end()).c_str());
}
- return Error::success();
+ return Error();
}
Error AdbClient::Shell(const char *command, uint32_t timeout_ms,
dst.close();
if (!dst)
return Error("Failed to write file %s", output_filename.c_str());
- return Error::success();
+ return Error();
}
std::unique_ptr<AdbClient::SyncService>
mode = extractor.GetU32(&offset);
size = extractor.GetU32(&offset);
mtime = extractor.GetU32(&offset);
- return Error::success();
+ return Error();
}
Error AdbClient::SyncService::PullFile(const FileSpec &remote_file,
} else
return Error("Pull failed with unknown response: %s", response_id.c_str());
- return Error::success();
+ return Error();
}
Error AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) {
// Default to the local case
local_file = platform_file;
- return Error::success();
+ return Error();
}
//------------------------------------------------------------------
Error PlatformKalimba::GetFileWithUUID(const FileSpec & /*platform_file*/,
const UUID * /*uuid_ptr*/,
FileSpec & /*local_file*/) {
- return Error::success();
+ return Error();
}
//------------------------------------------------------------------
// Default to the local case
local_file = platform_file;
- return Error::success();
+ return Error();
}
//------------------------------------------------------------------
if (spawned) {
launch_info.SetProcessID(spawned.GetPID());
- return Error::success();
+ return Error();
} else
return spawned.GetError();
#else
Error PlatformAppleSimulator::DisconnectRemote() {
#if defined(__APPLE__)
m_device.reset();
- return Error::success();
+ return Error();
#else
Error err;
err.SetErrorString(UNSUPPORTED_ERROR);
module_spec.GetArchitecture());
module_sp.reset(new Module(local_spec));
module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
- return Error::success();
+ return Error();
}
}
(IsHost() ? "host" : "remote"),
module_spec.GetFileSpec().GetDirectory().AsCString(),
module_spec.GetFileSpec().GetFilename().AsCString());
- return Error::success();
+ return Error();
}
// bring in the remote module file
ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
module_sp.reset(new Module(local_spec));
module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
- return Error::success();
+ return Error();
} else
return Error("unable to obtain valid module file");
} else
// Default to the local case
local_file = platform_file;
- return Error::success();
+ return Error();
}
lldb_private::Error
if (local_os_build.compare(remote_os_build) == 0) {
// same OS version: the local file is good enough
local_file = platform_file;
- return Error::success();
+ return Error();
} else {
// try to find the file in the cache
std::string cache_path(GetLocalCacheDirectory());
FileSpec module_cache_spec(cache_path, false);
if (module_cache_spec.Exists()) {
local_file = module_cache_spec;
- return Error::success();
+ return Error();
}
// bring in the remote module file
FileSpec module_cache_folder =
return err;
if (module_cache_spec.Exists()) {
local_file = module_cache_spec;
- return Error::success();
+ return Error();
} else
return Error("unable to obtain valid module file");
}
}
local_file = platform_file;
- return Error::success();
+ return Error();
}
bool PlatformMacOSX::GetSupportedArchitectureAtIndex(uint32_t idx,
// Default to the local case
local_file = platform_file;
- return Error::success();
+ return Error();
}
//------------------------------------------------------------------
if (IsHost()) {
if (FileSpec::Equal(source, destination, true))
- return Error::success();
+ return Error();
// cp src dst
// chown uid:gid dst
std::string src_path(source.GetPath());
if (status != 0)
return Error("unable to perform copy");
if (uid == UINT32_MAX && gid == UINT32_MAX)
- return Error::success();
+ return Error();
if (chown_file(this, dst_path.c_str(), uid, gid) != 0)
return Error("unable to perform chown");
- return Error::success();
+ return Error();
} else if (m_remote_platform_sp) {
if (GetSupportsRSync()) {
std::string src_path(source.GetPath());
// Don't chown a local file for a remote system
// if (chown_file(this,dst_path.c_str(),uid,gid) != 0)
// return Error("unable to perform chown");
- return Error::success();
+ return Error();
}
// if we are still here rsync has failed - let's try the slow way before
// giving up
RunShellCommand(cp_command.GetData(), NULL, &status, NULL, NULL, 10);
if (status != 0)
return Error("unable to perform copy");
- return Error::success();
+ return Error();
} else if (m_remote_platform_sp) {
if (GetSupportsRSync()) {
StreamString command;
int retcode;
Host::RunShellCommand(command.GetData(), NULL, &retcode, NULL, NULL, 60);
if (retcode == 0)
- return Error::success();
+ return Error();
// If we are here, rsync has failed - let's try the slow way before giving
// up
}
if (result_valobj_sp->GetError().Fail())
return result_valobj_sp->GetError();
- return Error::success();
+ return Error();
}
uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
return Error("expression failed: \"%s\"", expr.GetData());
process->ResetImageToken(image_token);
}
- return Error::success();
+ return Error();
}
lldb::ProcessSP PlatformPOSIX::ConnectProcess(const char *connect_url,
// Default to the local case
local_file = platform_file;
- return Error::success();
+ return Error();
}
Error PlatformWindows::GetSharedModule(
FileSpec &local_file) {
// Default to the local case
local_file = platform_file;
- return Error::success();
+ return Error();
}
//------------------------------------------------------------------
Error PlatformRemoteGDBServer::KillProcess(const lldb::pid_t pid) {
if (!KillSpawnedProcess(pid))
return Error("failed to kill remote spawned process");
- return Error::success();
+ return Error();
}
lldb::ProcessSP PlatformRemoteGDBServer::DebugProcess(
return m_dyld_ap.get();
}
-Error ProcessKDP::WillResume() { return Error::success(); }
+Error ProcessKDP::WillResume() { return Error(); }
Error ProcessKDP::DoResume() {
Error error;
void ProcessElfCore::RefreshStateAfterStop() {}
-Error ProcessElfCore::DoDestroy() { return Error::success(); }
+Error ProcessElfCore::DoDestroy() { return Error(); }
//------------------------------------------------------------------
// Process Queries
region_info.SetExecutable(MemoryRegionInfo::eNo);
region_info.SetMapped(MemoryRegionInfo::eNo);
}
- return Error::success();
+ return Error();
}
region_info.GetRange().SetRangeBase(load_addr);
region_info.SetWritable(MemoryRegionInfo::eNo);
region_info.SetExecutable(MemoryRegionInfo::eNo);
region_info.SetMapped(MemoryRegionInfo::eNo);
- return Error::success();
+ return Error();
}
size_t ProcessElfCore::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
response.GetEscapedBinaryData(output);
if (command_output)
command_output->assign(output);
- return Error::success();
+ return Error();
}
return Error("unable to send packet");
}
__FUNCTION__);
m_process_launch_info.SetArguments(const_cast<const char **>(args), true);
- return Error::success();
+ return Error();
}
Error GDBRemoteCommunicationServerLLGS::SetLaunchFlags(
unsigned int launch_flags) {
m_process_launch_info.GetFlags().Set(launch_flags);
- return Error::success();
+ return Error();
}
Error GDBRemoteCommunicationServerLLGS::LaunchProcess() {
return error;
}
- return Error::success();
+ return Error();
}
void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() {
m_continue_S_tids.clear();
m_jstopinfo_sp.reset();
m_jthreadsinfo_sp.reset();
- return Error::success();
+ return Error();
}
Error ProcessGDBRemote::DoResume() {
const ProcessInfo &process_info) {
// Make sure we aren't already connected?
if (m_gdb_comm.IsConnected())
- return Error::success();
+ return Error();
PlatformSP platform_sp(GetTarget().GetPlatform());
if (platform_sp && !platform_sp->IsHost())
XMLNode root_element = doc.GetRootElement("library-list-svr4");
if (!root_element)
- return Error::success();
+ return Error();
// main link map structure
llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm");
XMLNode root_element = doc.GetRootElement("library-list");
if (!root_element)
- return Error::success();
+ return Error();
root_element.ForEachChildElementWithName(
"library", [log, &list](const XMLNode &library) -> bool {
return Error(0, ErrorType::eErrorTypeGeneric);
}
- return Error::success();
+ return Error();
}
lldb::ModuleSP ProcessGDBRemote::LoadModuleAtAddress(const FileSpec &file,
// The file is not loaded into the inferior
is_loaded = false;
load_addr = LLDB_INVALID_ADDRESS;
- return Error::success();
+ return Error();
}
return Error(
if (response.IsNormalResponse()) {
is_loaded = true;
load_addr = response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
- return Error::success();
+ return Error();
}
return Error("Unknown error happened during sending the load address packet");
// SetThreadStopInfo (m_last_stop_packet);
}
-Error ProcessMachCore::DoDestroy() { return Error::success(); }
+Error ProcessMachCore::DoDestroy() { return Error(); }
//------------------------------------------------------------------
// Process Queries
region_info.SetExecutable(MemoryRegionInfo::eNo);
region_info.SetMapped(MemoryRegionInfo::eNo);
}
- return Error::success();
+ return Error();
}
region_info.GetRange().SetRangeBase(load_addr);
region_info.SetWritable(MemoryRegionInfo::eNo);
region_info.SetExecutable(MemoryRegionInfo::eNo);
region_info.SetMapped(MemoryRegionInfo::eNo);
- return Error::success();
+ return Error();
}
void ProcessMachCore::Clear() { m_thread_list.Clear(); }
uint32_t ProcessMinidump::GetPluginVersion() { return 1; }
-Error ProcessMinidump::DoDestroy() { return Error::success(); }
+Error ProcessMinidump::DoDestroy() { return Error(); }
void ProcessMinidump::RefreshStateAfterStop() {
if (!m_active_exception)
const UUID *uuid_ptr, FileSpec &local_file) {
// Default to the local case
local_file = platform_file;
- return Error::success();
+ return Error();
}
FileSpecList
"they are controlled by a process plugin");
}
Host::Kill(pid, SIGTERM);
- return Error::success();
+ return Error();
}
lldb::ProcessSP
const auto error = module_resolver(resolved_module_spec);
if (error.Fail()) {
if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr))
- return Error::success();
+ return Error();
}
return error;
RestoreProcessEvents();
SetExitStatus(SIGKILL, "Cancelled async attach.");
Destroy(false);
- return Error::success();
+ return Error();
}
// Wait for 10 second for the process to stop.
BroadcastEvent(event_sp);
- return Error::success();
+ return Error();
}
Error Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
if (!reg_ctx->SetPC(dest))
return Error("Cannot change PC to target address.");
- return Error::success();
+ return Error();
}
void Thread::DumpUsingSettingsFormat(Stream &strm, uint32_t frame_idx,
if (!dir_path.IsDirectory())
return Error("Invalid existing path");
- return Error::success();
+ return Error();
}
return FileSystem::MakeDirectory(dir_path, eFilePermissionsDirectoryDefault);
platform_module_spec.GetPath().c_str());
if (sysroot_module_path_spec.Exists()) {
if (!delete_existing)
- return Error::success();
+ return Error();
DecrementRefExistingModule(root_dir_spec, sysroot_module_path_spec);
}
if (error.Fail())
return Error("Failed to create link to %s: %s",
module_file_path.GetPath().c_str(), error.AsCString());
- return Error::success();
+ return Error();
}
Error ModuleCache::Get(const FileSpec &root_dir_spec, const char *hostname,
if (find_it != m_loaded_modules.end()) {
cached_module_sp = (*find_it).second.lock();
if (cached_module_sp)
- return Error::success();
+ return Error();
m_loaded_modules.erase(find_it);
}
m_loaded_modules.insert(
std::make_pair(module_spec.GetUUID().GetAsString(), cached_module_sp));
- return Error::success();
+ return Error();
}
Error ModuleCache::GetAndPut(const FileSpec &root_dir_spec,
// module might
// contain the necessary symbols and the debugging is also possible without
// a symfile.
- return Error::success();
+ return Error();
error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
tmp_download_sym_file_spec,
FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
- return Error::success();
+ return Error();
}
file_spec.GetPath().c_str(), err_code.message().c_str());
tmp_file_remover.releaseFile();
- return Error::success();
+ return Error();
}
//----------------------------------------------------------------------
std::error_code ec = llvm::sys::fs::copy_file(
s_test_executable, tmp_download_file_spec.GetCString());
EXPECT_FALSE(ec);
- return Error::success();
+ return Error();
},
[](const ModuleSP &module_sp, const FileSpec &tmp_download_file_spec) {
return Error("Not supported.");
class Error;
class ErrorList;
+class ErrorSuccess;
/// Base class for error info classes. Do not extend this directly: Extend
/// the ErrorInfo template subclass instead.
}
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(); }
+ /// Create a success value.
+ static ErrorSuccess success();
// Errors are not copy-constructable.
Error(const Error &Other) = delete;
ErrorInfoBase *Payload;
};
+/// Subclass of Error for the sole purpose of identifying the success path in
+/// the type system. This allows to catch invalid conversion to Expected<T> at
+/// compile time.
+class ErrorSuccess : public Error {};
+
+inline ErrorSuccess Error::success() { return ErrorSuccess(); }
+
/// Make a Error instance representing failure using the given error info
/// type.
template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
new (getErrorStorage()) error_type(Err.takePayload());
}
+ /// Forbid to convert from Error::success() implicitly, this avoids having
+ /// Expected<T> foo() { return Error::success(); } which compiles otherwise
+ /// but triggers the assertion above.
+ Expected(ErrorSuccess) = delete;
+
/// Create an Expected<T> success value from the given OtherT value, which
/// must be convertible to T.
template <typename OtherT>
case BitstreamEntry::Error:
return error("Malformed block");
case BitstreamEntry::EndBlock:
- return Error::success();
+ return "";
case BitstreamEntry::SubBlock:
if (Entry.ID == bitc::MODULE_BLOCK_ID)
// we need to make sure we aren't at the end of the stream before calling
// advance, otherwise we'll get an error.
if (Stream.AtEndOfStream())
- return Error::success();
+ return "";
BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) {
case BitstreamEntry::Error:
return error("Malformed block");
case BitstreamEntry::EndBlock:
- return Error::success();
+ return "";
case BitstreamEntry::SubBlock:
if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID) {
case BitstreamEntry::Error:
return error("Malformed block");
case BitstreamEntry::EndBlock:
- return Error::success();
+ return false;
case BitstreamEntry::SubBlock:
if (Entry.ID == bitc::MODULE_BLOCK_ID)
// Test that success values implicitly convert to false, and don't cause crashes
// once they've been implicitly converted.
TEST(Error, CheckedSuccess) {
- Error E;
+ Error E = Error::success();
EXPECT_FALSE(E) << "Unexpected error while testing Error 'Success'";
}
// Test that unchecked succes values cause an abort.
#ifndef NDEBUG
TEST(Error, UncheckedSuccess) {
- EXPECT_DEATH({ Error E; }, "Program aborted due to an unhandled Error:")
+ EXPECT_DEATH({ Error E = Error::success(); },
+ "Program aborted due to an unhandled Error:")
<< "Unchecked Error Succes value did not cause abort()";
}
#endif
// Test that ErrorAsOutParameter sets the checked flag on construction.
TEST(Error, ErrorAsOutParameterChecked) {
- Error E;
+ Error E = Error::success();
errAsOutParamHelper(E);
(void)!!E;
}
// Test that ErrorAsOutParameter clears the checked flag on destruction.
#ifndef NDEBUG
TEST(Error, ErrorAsOutParameterUnchecked) {
- EXPECT_DEATH({ Error E; errAsOutParamHelper(E); },
+ EXPECT_DEATH({ Error E = Error::success(); errAsOutParamHelper(E); },
"Program aborted due to an unhandled Error:")
<< "ErrorAsOutParameter did not clear the checked flag on destruction.";
}
handleAllErrors(
make_error<CustomError>(42),
- [](const CustomError &CE) mutable { return Error::success(); });
+ [](const CustomError &CE) mutable -> Error { return Error::success(); });
handleAllErrors(make_error<CustomError>(42),
[](const CustomError &CE) mutable {});
handleAllErrors(make_error<CustomError>(42),
- [](CustomError &CE) { return Error::success(); });
+ [](CustomError &CE) -> Error { return Error::success(); });
handleAllErrors(make_error<CustomError>(42), [](CustomError &CE) {});
handleAllErrors(make_error<CustomError>(42),
- [](CustomError &CE) mutable { return Error::success(); });
+ [](CustomError &CE) mutable -> Error { return Error::success(); });
handleAllErrors(make_error<CustomError>(42), [](CustomError &CE) mutable {});
handleAllErrors(
make_error<CustomError>(42),
- [](std::unique_ptr<CustomError> CE) { return Error::success(); });
+ [](std::unique_ptr<CustomError> CE) -> Error { return Error::success(); });
handleAllErrors(make_error<CustomError>(42),
[](std::unique_ptr<CustomError> CE) {});
handleAllErrors(
make_error<CustomError>(42),
- [](std::unique_ptr<CustomError> CE) mutable { return Error::success(); });
+ [](std::unique_ptr<CustomError> CE) mutable -> Error { return Error::success(); });
handleAllErrors(make_error<CustomError>(42),
[](std::unique_ptr<CustomError> CE) mutable {});
// Test that we can consume success values.
TEST(Error, ConsumeSuccess) {
- Error E;
+ Error E = Error::success();
consumeError(std::move(E));
}
projects / platform / upstream / llvm.git / commitdiff