Prevent at compile time converting from Error::success() to Expected<T>

[mehdi_amini]

Summary

This would trigger an assertion at runtime otherwise.

[lhames]

Very cool! LGTM. :)

• Lang.

lld/trunk/COFF/InputFiles.cpp

void ArchiveFile::parse() {
 
   // Read the symbol table to construct Lazy objects.
   for (const Archive::Symbol &Sym : File->symbols())
     LazySymbols.emplace_back(this, Sym);
 
   // 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)
     fatal(Err, getShortName());
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 // This function is thread-safe.

lld/trunk/ELF/LTO.cpp

static void diagnosticHandler(const DiagnosticInfo &DI) {
   SmallString<128> ErrStorage;
   raw_svector_ostream OS(ErrStorage);
   DiagnosticPrinterRawOStream DP(OS);
   DI.print(DP);
   warn(ErrStorage);
 }
 
 static void checkError(Error E) {
-  handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
+  handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) -> Error {
     error(EIB.message());
     return Error::success();
   });
 }
 
 static std::unique_ptr<lto::LTO> createLTO() {
   lto::Config Conf;
 

lld/trunk/include/lld/Core/PassManager.h

public:
   void add(std::unique_ptr<Pass> pass) {
     _passes.push_back(std::move(pass));
   }
 
   llvm::Error runOnFile(SimpleFile &file) {
     for (std::unique_ptr<Pass> &pass : _passes)
       if (llvm::Error EC = pass->perform(file))
         return EC;
-    return llvm::Error();
+    return llvm::Error::success();
   }
 
 private:
   /// \brief Passes in the order they should run.
   std::vector<std::unique_ptr<Pass>> _passes;
 };
 } // end namespace lld
 
 #endif

lld/trunk/lib/Core/Resolver.cpp

undefAddedOrError =
         auto atom = sharedLibrary->exports(undefName);
         if (atom.get())
           doSharedLibraryAtom(std::move(atom));
         return false;
       });
 
   if (auto ec = undefAddedOrError.takeError())
     return ec;
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 bool Resolver::doUndefinedAtom(OwningAtomPtr<UndefinedAtom> atom) {
   DEBUG_WITH_TYPE("resolver", llvm::dbgs()
                     << "       UndefinedAtom: "
                     << llvm::format("0x%09lX", atom.get())
                     << ", name=" << atom.get()->name() << "\n");
 

lld/trunk/lib/Driver/DarwinLdDriver.cpp

if (!ctx.pathExists(path)) {
                                             + "'");
     }
     if (ctx.testingFileUsage()) {
       diagnostics << "Found filelist entry " << canonicalizePath(path) << '\n';
     }
     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.
 static bool parseNumberBase16(StringRef numStr, uint64_t &baseAddress) {
   if (numStr.startswith_lower("0x"))
     numStr = numStr.drop_front(2);
   return numStr.getAsInteger(16, baseAddress);
 }

lld/trunk/lib/ReaderWriter/FileArchive.cpp

File *find(StringRef name) override {
     return file;
   }
 
   /// \brief parse each member
   std::error_code
   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;
       if (std::error_code ec = instantiateMember(*mf, file)) {
         // err is Success (or we wouldn't be in the loop body) but we can't
         // return without testing or consuming it.
         consumeError(std::move(err));
         return ec;
void clearAtoms() override {
     _noUndefinedAtoms.clear();
     _noSharedLibraryAtoms.clear();
     _noAbsoluteAtoms.clear();
   }
 
 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));
     std::error_code ec;
     if ((ec = buildTableOfContents()))
       return ec;
     return std::error_code();
   }

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_arm.cpp

if ((instruction & 0xD000F800) == 0x9000F000)
       *kind = thumb_b22;
     else
       *kind = thumb_bl22;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     // 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)
       *kind = thumb_b22;
     else
       *kind = thumb_bl22;
     displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
     targetAddress = fixupAddress + 4 + displacement;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
   case ARM_THUMB_RELOC_BR22 | rScattered | rPcRel | rLength4:
     // ex: bl _foo+4 (and _foo is defined)
     if ((instruction & 0xD000F800) == 0x9000F000)
       *kind = thumb_b22;
     else
       *kind = thumb_bl22;
     displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
     targetAddress = fixupAddress + 4 + displacement;
     if (auto ec = atomFromAddress(0, reloc.value, target, addend))
       return ec;
     // 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 & 0xF0000000) != 0xF0000000))
       *kind = arm_b24;
     else
       *kind = arm_bl24;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     // 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)
         && ((instruction & 0xF0000000) != 0xF0000000))
       *kind = arm_b24;
     else
       *kind = arm_bl24;
     displacement = getDisplacementFromArmBranch(instruction);
     targetAddress = fixupAddress + 8 + displacement;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
   case ARM_RELOC_BR24 | rScattered | rPcRel | rLength4:
     // ex: bl _foo+4 (and _foo is defined)
     if (((instruction & 0x0F000000) == 0x0A000000)
         && ((instruction & 0xF0000000) != 0xF0000000))
       *kind = arm_b24;
     else
       *kind = arm_bl24;
     displacement = getDisplacementFromArmBranch(instruction);
     targetAddress = fixupAddress + 8 + displacement;
     if (auto ec = atomFromAddress(0, reloc.value, target, addend))
       return ec;
     // 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
 ArchHandler_arm::getPairReferenceInfo(const normalized::Relocation &reloc1,
                                      const normalized::Relocation &reloc2,
                                      const DefinedAtom *inAtom,
                                      uint32_t offsetInAtom,
                                      uint64_t fixupAddress, bool isBig,
if (pointerDiff) {
     }
     if (top)
       value = (instruction16 << 16) | other16;
     else
       value = (other16 << 16) | instruction16;
     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) {
       if (top) {
         if (!isThumbMovt(instruction))
           return llvm::make_error<GenericError>("expected movt instruction");
       }
       else {
if (reloc1.isExtern) {
         sectIndex = reloc1.symbol;
       }
       if (auto ec = atomFromAddr(sectIndex, toAddress, target, &offsetInTo))
         return ec;
       *addend = value - toAddress;
     }
   }
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 void ArchHandler_arm::applyFixupFinal(const Reference &ref, uint8_t *loc,
                                       uint64_t fixupAddress,
                                       uint64_t targetAddress,
                                       uint64_t inAtomAddress,
                                       bool &thumbMode, bool targetIsThumb) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_arm64.cpp

llvm::Error ArchHandler_arm64::getReferenceInfo(
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   switch (relocPattern(reloc)) {
   case ARM64_RELOC_BRANCH26           | rPcRel | rExtern | rLength4:
     // ex: bl _foo
     *kind = branch26;
     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;
      return atomFromAddress(reloc.symbol, *(const little64_t *)fixupContent,
                             target, addend);
   case ARM64_RELOC_POINTER_TO_GOT              | rExtern | rLength8:
     // ex: .quad _foo@GOT
     *kind = pointer64ToGOT;
     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 we are in an .eh_frame section, then the kind of the relocation should
     // not be delta32ToGOT.  It may instead be unwindCIEToPersonalityFunction.
     if (inAtom->contentType() == DefinedAtom::typeCFI)
       *kind = unwindCIEToPersonalityFunction;
     else
       *kind = delta32ToGOT;
 
     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");
   }
 }
 
 llvm::Error ArchHandler_arm64::getPairReferenceInfo(
     const normalized::Relocation &reloc1, const normalized::Relocation &reloc2,
     const DefinedAtom *inAtom, uint32_t offsetInAtom, uint64_t fixupAddress,
     bool swap, bool scatterable, FindAtomBySectionAndAddress atomFromAddress,
     FindAtomBySymbolIndex atomFromSymbolIndex, Reference::KindValue *kind,
     const lld::Atom **target, Reference::Addend *addend) {
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   switch (relocPattern(reloc1) << 16 | relocPattern(reloc2)) {
   case ((ARM64_RELOC_ADDEND                                | rLength4) << 16 |
          ARM64_RELOC_BRANCH26           | rPcRel | rExtern | rLength4):
     // ex: bl _foo+8
     *kind = branch26;
     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
     *kind = page21;
     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]
     uint32_t cont32 = (int32_t)*(const little32_t *)fixupContent;
     *kind = offset12KindFromInstruction(cont32);
     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):
     // ex: .quad _foo - .
     if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
       return ec;
 
     // If we are in an .eh_frame section, then the kind of the relocation should
     // not be delta64.  It may instead be unwindFDEToFunction.
     if (inAtom->contentType() == DefinedAtom::typeCFI)
       *kind = unwindFDEToFunction;
     else
       *kind = delta64;
 
     // The offsets of the 2 relocations must match
     if (reloc1.offset != reloc2.offset)
       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 - .
     *kind = delta32;
     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");
   }
 }
 
 void ArchHandler_arm64::generateAtomContent(
     const DefinedAtom &atom, bool relocatable, FindAddressForAtom findAddress,
     FindAddressForAtom findSectionAddress, uint64_t imageBaseAddress,

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_x86.cpp

*kind =
                                                                  : pointer32;
     if (auto ec = atomFromAddress(0, reloc.value, target, addend))
       return ec;
     *addend = *(const ulittle32_t *)fixupContent - reloc.value;
     break;
   default:
     return llvm::make_error<GenericError>("unsupported i386 relocation type");
   }
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 llvm::Error
 ArchHandler_x86::getPairReferenceInfo(const normalized::Relocation &reloc1,
                                       const normalized::Relocation &reloc2,
                                       const DefinedAtom *inAtom,
                                       uint32_t offsetInAtom,
                                       uint64_t fixupAddress, bool swap,
if (fromTarget != inAtom) {
         *kind = funcRel32;
         uint32_t ta = fromAddress + value - toAddress;
         *addend = ta - offsetInFrom;
       } else {
         *kind = delta32;
         *addend = fromAddress + value - toAddress;
       }
     }
-    return llvm::Error();
+    return llvm::Error::success();
     break;
   default:
     return llvm::make_error<GenericError>("unsupported i386 relocation type");
   }
 }
 
 void ArchHandler_x86::generateAtomContent(const DefinedAtom &atom,
                                           bool relocatable,

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_x86_64.cpp

ArchHandler_x86_64::getReferenceInfo(const Relocation &reloc,
   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
   uint64_t targetAddress;
   switch (*kind) {
   case branch32:
   case ripRel32:
     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);
   case ripRel32Minus1Anon:
     targetAddress = fixupAddress + 5 + *(const little32_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
   case ripRel32Minus2Anon:
     targetAddress = fixupAddress + 6 + *(const little32_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
   case ripRel32Minus4Anon:
     targetAddress = fixupAddress + 8 + *(const little32_t *)fixupContent;
     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
   case ripRel32GotLoad:
   case ripRel32Got:
   case ripRel32Tlv:
     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))
       return ec;
     // If this is the 3rd pointer of a tlv-thunk (i.e. the pointer to the TLV's
     // initial value) we need to handle it specially.
     if (inAtom->contentType() == DefinedAtom::typeThunkTLV &&
         offsetInAtom == 16) {
       *kind = tlvInitSectionOffset;
       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);
   default:
     llvm_unreachable("bad reloc kind");
   }
 }
 
if (inAtom == fromTarget) {
         *kind = delta64;
       *addend = encodedAddend + offsetInAtom;
     } else if (inAtom == *target) {
       *kind = negDelta64;
       *addend = encodedAddend - offsetInAtom;
       *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): {
     if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
       return ec;
     uint32_t encodedAddend = (int32_t)*(const little32_t *)fixupContent;
     if (inAtom == fromTarget) {
       *kind = delta32;
       *addend = encodedAddend + offsetInAtom;
     } else if (inAtom == *target) {
       *kind = negDelta32;
       *addend = encodedAddend - offsetInAtom;
       *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):
     if (fromTarget != inAtom)
       return llvm::make_error<GenericError>("pointer diff not in base atom");
     *kind = delta64Anon;
     targetAddress = offsetInAtom + (int64_t)*(const little64_t *)fixupContent;
     return atomFromAddress(reloc2.symbol, targetAddress, target, addend);

lld/trunk/lib/ReaderWriter/MachO/CompactUnwindPass.cpp

llvm::Error perform(SimpleFile &mergedFile) override {
     // the function referred to.
     collectCompactUnwindEntries(mergedFile, unwindLocs, personalities,
                                 numLSDAs);
 
     collectDwarfFrameEntries(mergedFile, dwarfFrames);
 
     // 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
     // also probably be sorted by frequency.
     assert(personalities.size() <= 4);
 
     // TODO: Find commmon encodings for use by compressed pages.
     std::vector<uint32_t> commonEncodings;
auto *unwind = new (_file.allocator())
                        commonEncodings, pages, numLSDAs);
     mergedFile.addAtom(*unwind);
 
     // Finally, remove all __compact_unwind atoms now that we've processed them.
     mergedFile.removeDefinedAtomsIf([](const DefinedAtom *atom) {
       return atom->contentType() == DefinedAtom::typeCompactUnwindInfo;
     });
 
-    return llvm::Error();
+    return llvm::Error::success();
   }
 
   void collectCompactUnwindEntries(
       const SimpleFile &mergedFile,
       std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
       std::vector<const Atom *> &personalities, uint32_t &numLSDAs) {
     DEBUG(llvm::dbgs() << "  Collecting __compact_unwind entries\n");
 

lld/trunk/lib/ReaderWriter/MachO/GOTPass.cpp

for (auto &it : _targetToGOT)
       entries.push_back(it.second);
     std::sort(entries.begin(), entries.end(),
               [](const GOTEntryAtom *left, const GOTEntryAtom *right) {
       return (left->slotName().compare(right->slotName()) < 0);
     });
     for (const GOTEntryAtom *slot : entries)
       mergedFile.addAtom(*slot);
 
-    return llvm::Error();
+      return llvm::Error::success();
   }
 
   bool shouldReplaceTargetWithGOTAtom(const Atom *target, bool canBypassGOT) {
     // Accesses to shared library symbols must go through GOT.
     if (isa<SharedLibraryAtom>(target))
       return true;
     // Accesses to interposable symbols in same linkage unit must also go
     // through GOT.

lld/trunk/lib/ReaderWriter/MachO/LayoutPass.cpp

llvm::Error LayoutPass::perform(SimpleFile &mergedFile) {
   undecorate(atomRange, vec);
 
   DEBUG({
     llvm::dbgs() << "sorted atoms:\n";
     printDefinedAtoms(atomRange);
   });
 
   DEBUG(llvm::dbgs() << "******** Finished laying out atoms\n");
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 void addLayoutPass(PassManager &pm, const MachOLinkingContext &ctx) {
   pm.add(llvm::make_unique<LayoutPass>(
       ctx.registry(), [&](const DefinedAtom * left, const DefinedAtom * right,
                           bool & leftBeforeRight) ->bool {
     return ctx.customAtomOrderer(left, right, leftBeforeRight);
   }));
 }
 
 } // namespace mach_o
 } // namespace lld

lld/trunk/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

std::stable_sort(elements.begin(), elements.end(),
                    });
   size_t numLibs = std::count_if(elements.begin(), elements.end(), isLibrary);
   elements.push_back(llvm::make_unique<GroupEnd>(numLibs));
 }
 
 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.
   if (_arch == arch_unknown) {
     _arch = machoFile->arch();
   } else if (machoFile->arch() != arch_unknown && machoFile->arch() != _arch) {
     // Archs are different.
     return llvm::make_error<GenericError>(file.path() +
llvm::Error MachOLinkingContext::handleLoadedFile(File &file) {
   if (!_swiftVersion) {
     _swiftVersion = machoFile->swiftVersion();
   } else if (machoFile->swiftVersion() &&
              machoFile->swiftVersion() != _swiftVersion) {
     // Swift versions are different.
     return llvm::make_error<GenericError>("different swift versions");
   }
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 } // end namespace lld

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

if (isBig != llvm::sys::IsBigEndianHost) {
       memcpy(&lcCopy, lc, sizeof(load_command));
       swapStruct(lcCopy);
       slc = &lcCopy;
     }
     if ( (p + slc->cmdsize) > lcRange.end() )
       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,
                                          bool bigEndian,
                                          uint32_t reloff, uint32_t nreloc) {
   if ((reloff + nreloc*8) > buffer.size())
     return make_error_code(llvm::errc::executable_format_error);
   const any_relocation_info* relocsArray =

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

for (const Section &sin : _file.sections) {
     sout->reserved1 = indirectSymbolIndex(sin, indirectSymRunningIndex);
     sout->reserved2 = indirectSymbolElementSize(sin);
     relOffset += sin.relocations.size() * sizeof(any_relocation_info);
     if (_swap)
       swapStruct(*sout);
     ++sout;
   }
   lc = next;
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 template <typename T>
 llvm::Error MachOFileLayout::writeSegmentLoadCommands(uint8_t *&lc) {
   uint32_t indirectSymRunningIndex = 0;
   for (const Segment &seg : _file.segments) {
     // Link edit has no sections and a custom range of address, so handle it
     // specially.
for (const Section *section : segInfo.sections) {
       sect->reserved1 = indirectSymbolIndex(*section, indirectSymRunningIndex);
       sect->reserved2 = indirectSymbolElementSize(*section);
       if (_swap)
         swapStruct(*sect);
       ++sect;
     }
     lc = reinterpret_cast<uint8_t*>(next);
   }
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 static void writeVersionMinLoadCommand(const NormalizedFile &_file,
                                        bool _swap,
                                        uint8_t *&lc) {
   if (!_file.hasMinVersionLoadCommand)
     return;
   version_min_command *vm = reinterpret_cast<version_min_command*>(lc);
if (_file.generateDataInCodeLoadCommand) {
       dl->cmdsize  = sizeof(linkedit_data_command);
       dl->dataoff  = _startOfDataInCode;
       dl->datasize = _dataInCodeSize;
       if (_swap)
         swapStruct(*dl);
       lc += sizeof(linkedit_data_command);
     }
   }
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 void MachOFileLayout::writeSectionContent() {
   for (const Section &s : _file.sections) {
     // Copy all section content to output buffer.
     if (isZeroFillSection(s.type))
       continue;
     if (s.content.empty())
llvm::Error MachOFileLayout::writeBinary(StringRef path) {
   _buffer = fob->getBufferStart();
   writeMachHeader();
   if (auto ec = writeLoadCommands())
     return ec;
   writeSectionContent();
   writeLinkEditContent();
   fob->commit();
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 /// Takes in-memory normalized view and writes a mach-o object file.
 llvm::Error writeBinary(const NormalizedFile &file, StringRef path) {
   MachOFileLayout layout(file);
   return layout.writeBinary(path);
 }
 
 } // namespace normalized
 } // namespace mach_o
 } // namespace lld

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

 llvm::Error Util::getSymbolTableRegion(const DefinedAtom* atom,
                                        bool &inGlobalsRegion,
                                        SymbolScope &scope) {
   bool rMode = (_ctx.outputMachOType() == llvm::MachO::MH_OBJECT);
   switch (atom->scope()) {
   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())) {
       return llvm::make_error<GenericError>(
                           Twine("cannot export hidden symbol ") + atom->name());
     }
     if (rMode) {
       if (_ctx.keepPrivateExterns()) {
         // -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;
   }
   llvm_unreachable("atom->scope() unknown enum value");
 }
 
 
 
for (AtomAndIndex &ai : undefs) {
     sym.scope = ai.scope;
     sym.sect  = 0;
     sym.desc  = desc;
     sym.value = 0;
     _atomToSymbolIndex[ai.atom] = file.undefinedSymbols.size() + start;
     file.undefinedSymbols.push_back(sym);
   }
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 const Atom *Util::targetOfLazyPointer(const DefinedAtom *lpAtom) {
   for (const Reference *ref : *lpAtom) {
     if (_archHandler.isLazyPointer(*ref)) {
       return ref->target();
     }
   }

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

llvm::Error processSymboledSection(DefinedAtom::ContentType atomType,
   // Debug logging of symbols.
   //for (const Symbol *sym : symbols)
   //  llvm::errs() << "  sym: "
   //    << llvm::format("0x%08llx ", (uint64_t)sym->value)
   //    << ", " << sym->name << "\n";
 
   // 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.
     atomFromSymbol(atomType, section, file, section.address, StringRef(),
                   0, Atom::scopeTranslationUnit,
                   section.address + section.content.size(),
                   scatterable, copyRefs);
   }
file.eachAtomInSection(section,
       if (prevAtom)
         prevAtom->addReference(Reference::KindNamespace::all,
                                Reference::KindArch::all,
                                Reference::kindLayoutAfter, 0, atom, 0);
       prevAtom = atom;
     });
   }
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 llvm::Error processSection(DefinedAtom::ContentType atomType,
                            const Section &section,
                            bool customSectionName,
                            const NormalizedFile &normalizedFile,
                            MachOFile &file, bool scatterable,
                            bool copyRefs) {
for (unsigned int offset = 0, e = section.content.size(); offset != e;) {
                                            size, segSectName, true, &section);
       } else {
         file.addDefinedAtom(StringRef(), scope, atomType, merge, offset, size,
                             false, false, copyRefs, &section);
       }
       offset += size;
     }
   }
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 const Section* findSectionCoveringAddress(const NormalizedFile &normalizedFile,
                                           uint64_t address) {
   for (const Section &s : normalizedFile.sections) {
     uint64_t sAddr = s.address;
     if ((sAddr <= address) && (address < sAddr+s.content.size())) {
       return &s;
if (sectIndex == 0) {
                                        + ") is not in any section"));
     } else {
       sect = &normalizedFile.sections[sectIndex-1];
     }
     uint32_t offsetInTarget;
     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.
   auto atomBySymbol = [&] (uint32_t symbolIndex, const lld::Atom **result)
                            -> llvm::Error {
     // Find symbol from index.
     const Symbol *sym = nullptr;
     uint32_t numStabs  = normalizedFile.stabsSymbols.size();
if ((sym->type & N_TYPE) == N_SECT) {
         return llvm::make_error<GenericError>(Twine("symbol section index (")
                                         + Twine(sym->sect) + ") out of range ");
       const Section &symSection = normalizedFile.sections[sym->sect-1];
       uint64_t targetOffsetInSect = sym->value - symSection.address;
       MachODefinedAtom *target = file.findAtomCoveringAddress(symSection,
                                                             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 {
       // Search undefs
       return llvm::make_error<GenericError>("no atom found for symbol");
     }
   };
 
else {
       }
     }
     // Instantiate an lld::Reference object and add to its atom.
     inAtom->addReference(Reference::KindNamespace::mach_o,
                          handler.kindArch(),
                          kind, offsetInAtom, target, addend);
   }
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 bool isDebugInfoSection(const Section &section) {
   if ((section.attributes & S_ATTR_DEBUG) == 0)
     return false;
   return section.segmentName.equals("__DWARF");
 }
 

 typedef llvm::DenseMap<const MachODefinedAtom*, CIEInfo> CIEInfoMap;
 
 static llvm::Error processAugmentationString(const uint8_t *augStr,
                                              CIEInfo &cieInfo,
                                              unsigned &len) {
 
   if (augStr[0] == '\0') {
     len = 1;
-    return llvm::Error();
+    return llvm::Error::success();
   }
 
   if (augStr[0] != 'z')
     return llvm::make_error<GenericError>("expected 'z' at start of "
                                           "augmentation string");
 
   cieInfo._augmentationDataPresent = true;
   uint64_t idx = 1;
if (augStr[idx] == 'e') {
       continue;
     }
     ++idx;
   }
 
   cieInfo._augmentationDataLength = offsetInAugmentationData;
 
   len = idx + 1;
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 static llvm::Error processCIE(const NormalizedFile &normalizedFile,
                               MachOFile &file,
                               mach_o::ArchHandler &handler,
                               const Section *ehFrameSection,
                               MachODefinedAtom *atom,
                               uint64_t offset,
if (cieInfo._offsetOfPersonality != ~0U) {
     // Otherwise, we expect there to be no relocations in this atom as the only
     // relocation would have been to the personality function.
     return llvm::make_error<GenericError>("unexpected relocation in CIE");
   }
 
 
   cieInfos[atom] = std::move(cieInfo);
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 static llvm::Error processFDE(const NormalizedFile &normalizedFile,
                               MachOFile &file,
                               mach_o::ArchHandler &handler,
                               const Section *ehFrameSection,
                               MachODefinedAtom *atom,
                               uint64_t offset,
if (cieInfo._offsetOfLSDA != ~0U && augmentationDataLength > 0) {
         lsdaFromFDE;
 
       verifyOrAddReference(lsdaStart,
                            handler.unwindRefToFunctionKind(),
                            augmentationDataFieldInFDE, true);
     }
   }
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 llvm::Error addEHFrameReferences(const NormalizedFile &normalizedFile,
                                  MachOFile &file,
                                  mach_o::ArchHandler &handler) {
 
   const Section *ehFrameSection = nullptr;
   for (auto &section : normalizedFile.sections)
     if (section.segmentName == "__TEXT" &&
         section.sectionName == "__eh_frame") {
       ehFrameSection = &section;
       break;
     }
 
   // 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,
                          [&](MachODefinedAtom *atom, uint64_t offset) -> void {
     assert(atom->contentType() == DefinedAtom::typeCFI);
 
     // Bail out if we've encountered an error.
     if (ehFrameErr)
llvm::Error parseObjCImageInfo(const Section &sect,
 
   if (flags & MachOLinkingContext::objc_retainReleaseForSimulator)
     file.setObjcConstraint(MachOLinkingContext::objc_retainReleaseForSimulator);
   else
     file.setObjcConstraint(MachOLinkingContext::objc_retainRelease);
 
   file.setSwiftVersion((flags >> 8) & 0xFF);
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 /// Converts normalized mach-o file into an lld::File and lld::Atoms.
 llvm::Expected<std::unique_ptr<lld::File>>
 objectToAtoms(const NormalizedFile &normalizedFile, StringRef path,
               bool copyRefs) {
   std::unique_ptr<MachOFile> file(new MachOFile(path));
   if (auto ec = normalizedObjectToAtoms(file.get(), normalizedFile, copyRefs))
normalizedObjectToAtoms(MachOFile *file,
   // Sort references in each atom to their canonical order.
   for (const DefinedAtom* defAtom : file->defined()) {
     reinterpret_cast<const SimpleDefinedAtom*>(defAtom)->sortReferences();
   }
 
   if (auto err = parseDebugInfo(*file, normalizedFile, copyRefs))
     return err;
 
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 llvm::Error
 normalizedDylibToAtoms(MachODylibFile *file,
                        const NormalizedFile &normalizedFile,
                        bool copyRefs) {
   file->setInstallName(normalizedFile.installName);
   file->setCompatVersion(normalizedFile.compatVersion);
for (auto &sym : normalizedFile.globalSymbols) {
       file->addExportedSymbol(sym.name, weakDef, copyRefs);
     }
   }
   // Tell MachODylibFile object about all dylibs it re-exports.
   for (const DependentDylib &dep : normalizedFile.dependentDylibs) {
     if (dep.kind == llvm::MachO::LC_REEXPORT_DYLIB)
       file->addReExportedDylib(dep.path);
   }
-  return llvm::Error();
+  return llvm::Error::success();
 }
 
 void relocatableSectionInfoForContentType(DefinedAtom::ContentType atomType,
                                           StringRef &segmentName,
                                           StringRef &sectionName,
                                           SectionType &sectionType,
                                           SectionAttr &sectionAttrs,
                                           bool &relocsToDefinedCanBeImplicit) {

lld/trunk/lib/ReaderWriter/MachO/ObjCPass.cpp

ObjCPass(const MachOLinkingContext &context)
         _file(*_ctx.make_file<MachOFile>("<mach-o objc pass>")) {
     _file.setOrdinal(_ctx.getNextOrdinalAndIncrement());
   }
 
   llvm::Error perform(SimpleFile &mergedFile) override {
     // Add the image info.
     mergedFile.addAtom(*getImageInfo());
 
-    return llvm::Error();
+    return llvm::Error::success();
   }
 
 private:
 
   const DefinedAtom* getImageInfo() {
     return new (_file.allocator()) ObjCImageInfoAtom(_file,
                                                      _ctx.objcConstraint(),
                                                      _ctx.swiftVersion());

lld/trunk/lib/ReaderWriter/MachO/ShimPass.cpp

for (const DefinedAtom *atom : mergedFile.defined()) {
           bool targetIsThumb = _archHandler.isThumbFunction(*daTarget);
           if (atomIsThumb != targetIsThumb)
             updateBranchToUseShim(atomIsThumb, *daTarget, ref);
         }
       }
     }
     // 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;
     shims.reserve(_targetToShim.size());
     for (auto element : _targetToShim) {
       shims.push_back(element.second);
     }
     std::sort(shims.begin(), shims.end(),
               [](const DefinedAtom *l, const DefinedAtom *r) {
                 return (l->name() < r->name());
               });
 
     // Add all shims to master file.
     for (const DefinedAtom *shim : shims)
       mergedFile.addAtom(*shim);
 
-    return llvm::Error();
+    return llvm::Error::success();
   }
 
 private:
 
   void updateBranchToUseShim(bool thumbToArm, const DefinedAtom& target,
                              const Reference *ref) {
     // Make file-format specific stub and other support atoms.
     const DefinedAtom *shim = this->getShim(thumbToArm, target);

lld/trunk/lib/ReaderWriter/MachO/StubsPass.cpp

StubsPass(const MachOLinkingContext &context)
         _stubInfo(_archHandler.stubInfo()),
         _file(*_ctx.make_file<MachOFile>("<mach-o Stubs pass>")) {
     _file.setOrdinal(_ctx.getNextOrdinalAndIncrement());
   }
 
   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()) {
       for (const Reference *ref : *atom) {
         // Look at call-sites.
         if (!this->isCallSite(*ref))
           continue;
         const Atom *target = ref->target();
for (const DefinedAtom *atom : mergedFile.defined()) {
           assert(defTarget->scope() != DefinedAtom::scopeTranslationUnit);
           _targetToUses[target].push_back(ref);
         }
       }
     }
 
     // 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 =
         new (_file.allocator()) StubHelperCommonAtom(_file, _stubInfo);
     SimpleDefinedAtom *helperCacheNLPAtom =
         new (_file.allocator()) NonLazyPointerAtom(_file, _ctx.is64Bit(),
                                     _stubInfo.stubHelperImageCacheContentType);
     SimpleDefinedAtom *helperBinderNLPAtom =
for (const Atom *target : targetsNeedingStubs) {
         // Switch call site to reference stub atom instead.
         const_cast<Reference *>(ref)->setTarget(stub);
       }
 
       // Calculate new offset
       lazyOffset += target->name().size() + 12;
     }
 
-    return llvm::Error();
+    return llvm::Error::success();
   }
 
 private:
   bool noTextRelocs() {
     return true;
   }
 
   bool isCallSite(const Reference &ref) {

lld/trunk/lib/ReaderWriter/MachO/TLVPass.cpp

llvm::Error perform(SimpleFile &mergedFile) override {
     std::sort(entries.begin(), entries.end(),
               [](const TLVPEntryAtom *lhs, const TLVPEntryAtom *rhs) {
                 return (lhs->slotName().compare(rhs->slotName()) < 0);
               });
 
     for (const TLVPEntryAtom *slot : entries)
       mergedFile.addAtom(*slot);
 
-    return llvm::Error();
+    return llvm::Error::success();
   }
 
   const DefinedAtom *makeTLVPEntry(const Atom *target) {
     auto pos = _targetToTLVP.find(target);
 
     if (pos != _targetToTLVP.end())
       return pos->second;
 

lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

llvm::Error writeFile(const lld::File &file, StringRef outPath) override {
     yamlContext._ctx = &_ctx;
     yamlContext._registry = &_ctx.registry();
     llvm::yaml::Output yout(out, &yamlContext);
 
     // Write yaml output.
     const lld::File *fileRef = &file;
     yout << fileRef;
 
-    return llvm::Error();
+    return llvm::Error::success();
   }
 
 private:
   const LinkingContext &_ctx;
 };
 
 } // end namespace yaml
 

lldb/trunk/include/lldb/Target/Process.h

#endif
   /// Called before attaching to a process.
   ///
   /// Allow Process plug-ins to execute some code before attaching a
   /// process.
   ///
   /// @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.
   ///
   /// Allow Process plug-ins to execute some code before attaching a
   /// process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
   virtual Error WillAttachToProcessWithName(const char *process_name,
                                             bool wait_for_launch) {
-    return Error::success();
+    return Error();
   }
 
   //------------------------------------------------------------------
   /// Attach to a remote system via a URL
   ///
   /// @param[in] strm
   ///     A stream where output intended for the user
   ///     (if the driver has a way to display that) generated during
#endif
   /// Called before launching to a process.
   ///
   /// Allow Process plug-ins to execute some code before launching a
   /// process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
-  virtual Error WillLaunch(Module *module) { return Error::success(); }
+  virtual Error WillLaunch(Module *module) { return Error(); }
 
   //------------------------------------------------------------------
   /// Launch a new process.
   ///
   /// Launch a new process by spawning a new process using
   /// \a exe_module's file as the file to launch. Launch details are
   /// provided in \a launch_info.
   ///
#endif
   /// Called before resuming to a process.
   ///
   /// Allow Process plug-ins to execute some code before resuming a
   /// 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
   /// Thread run control functions.
   ///
   /// Threads for a process should be updated with one of the run
   /// control actions (resume, step, or suspend) that they should take
   /// when the process is resumed. If no run control action is given
#endif
   /// Called before halting to a process.
   ///
   /// Allow Process plug-ins to execute some code before halting a
   /// process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
-  virtual Error WillHalt() { return Error::success(); }
+  virtual Error WillHalt() { return Error(); }
 
   //------------------------------------------------------------------
   /// Halts a running process.
   ///
   /// DoHalt must produce one and only one stop StateChanged event if it
   /// actually
   /// stops the process.  If the stop happens through some natural event (for
   /// instance a SIGSTOP), then forwarding that event will do.  Otherwise, you
#endif
   /// Called before detaching from a process.
   ///
   /// Allow Process plug-ins to execute some code before detaching
   /// from a process.
   ///
   /// @return
   ///     Returns an error object.
   //------------------------------------------------------------------
-  virtual Error WillDetach() { return Error::success(); }
+  virtual Error WillDetach() { return Error(); }
 
   //------------------------------------------------------------------
   /// Detaches from a running or stopped process.
   ///
   /// @return
   ///     Returns \b true if the process successfully detaches, \b
   ///     false otherwise.
   //------------------------------------------------------------------
#endif
   /// Allow Process plug-ins to execute some code before sending a
   /// signal to a process.
   ///
   /// @return
   ///     Returns no error if it is safe to proceed with a call to
   ///     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
   ///     Returns an error object.
   //------------------------------------------------------------------
   virtual Error DoSignal(int signal) {
     Error error;
     error.SetErrorStringWithFormat(
         "error: %s does not support sending signals to processes",
         GetPluginName().GetCString());
     return error;
   }
 
-  virtual Error WillDestroy() { return Error::success(); }
+  virtual Error WillDestroy() { return Error(); }
 
   virtual Error DoDestroy() = 0;
 
   virtual void DidDestroy() {}
 
   virtual bool DestroyRequiresHalt() { return true; }
 
   //------------------------------------------------------------------

lldb/trunk/source/Commands/CommandObjectDisassemble.cpp

void CommandObjectDisassemble::CommandOptions::OptionParsingStarting(
   arch.Clear();
   some_location_specified = false;
 }
 
 Error CommandObjectDisassemble::CommandOptions::OptionParsingFinished(
     ExecutionContext *execution_context) {
   if (!some_location_specified)
     current_function = true;
-  return Error::success();
+  return Error();
 }
 
 llvm::ArrayRef<OptionDefinition>
 CommandObjectDisassemble::CommandOptions::GetDefinitions() {
   return llvm::makeArrayRef(g_disassemble_options);
 }
 
 //-------------------------------------------------------------------------

lldb/trunk/source/Commands/CommandObjectExpression.cpp

 static lldb_private::Error
 CanBeUsedForElementCountPrinting(ValueObject &valobj) {
   CompilerType type(valobj.GetCompilerType());
   CompilerType pointee;
   if (!type.IsPointerType(&pointee))
     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,
                                                  Stream *output_stream,
                                                  Stream *error_stream,
                                                  CommandReturnObject *result) {
   // Don't use m_exe_ctx as this might be called asynchronously
   // after the command object DoExecute has finished when doing

lldb/trunk/source/Core/ModuleList.cpp

for (size_t idx = 0; idx < num_directories; ++idx) {
           if (module_sp->GetObjectFile()->GetType() ==
               ObjectFile::eTypeStubLibrary) {
             module_sp.reset();
           } else {
             if (did_create_ptr)
               *did_create_ptr = true;
 
             shared_module_list.ReplaceEquivalent(module_sp);
-            return Error::success();
+            return Error();
           }
         }
       } else {
         module_sp.reset();
       }
     }
   }
 

lldb/trunk/source/Host/common/NativeBreakpoint.cpp

Error NativeBreakpoint::Enable() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
   if (m_enabled) {
     // We're already enabled. Just log and exit.
     if (log)
       log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64
                   " already enabled, ignoring.",
                   __FUNCTION__, m_addr);
-    return Error::success();
+    return Error();
   }
 
   // Log and enable.
   if (log)
     log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64 " enabling...",
                 __FUNCTION__, m_addr);
 
   Error error = DoEnable();
Error NativeBreakpoint::Disable() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
   if (!m_enabled) {
     // We're already disabled. Just log and exit.
     if (log)
       log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64
                   " already disabled, ignoring.",
                   __FUNCTION__, m_addr);
-    return Error::success();
+    return Error();
   }
 
   // Log and disable.
   if (log)
     log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64 " disabling...",
                 __FUNCTION__, m_addr);
 
   Error error = DoDisable();

lldb/trunk/source/Host/common/NativeBreakpointList.cpp

Error NativeBreakpointList::AddRef(lldb::addr_t addr, size_t size_hint,
   if (iter != m_breakpoints.end()) {
     // Yes - bump up ref count.
     if (log)
       log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64
                   " -- already enabled, upping ref count",
                   __FUNCTION__, addr);
 
     iter->second->AddRef();
-    return Error::success();
+    return Error();
   }
 
   // Create a new breakpoint using the given create func.
   if (log)
     log->Printf(
         "NativeBreakpointList::%s creating breakpoint for addr = 0x%" PRIx64
         ", size_hint = %zu, hardware = %s",
         __FUNCTION__, addr, size_hint, hardware ? "true" : "false");
Error NativeBreakpointList::GetBreakpoint(lldb::addr_t addr,
   if (iter == m_breakpoints.end()) {
     // Not found!
     breakpoint_sp.reset();
     return Error("breakpoint not found");
   }
 
   // Disable it.
   breakpoint_sp = iter->second;
-  return Error::success();
+  return Error();
 }
 
 Error NativeBreakpointList::RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf,
                                                   size_t size) const {
   for (const auto &map : m_breakpoints) {
     lldb::addr_t bp_addr = map.first;
     // Breapoint not in range, ignore
     if (bp_addr < addr || addr + size <= bp_addr)
       continue;
     const auto &bp_sp = map.second;
     // Not software breakpoint, ignore
     if (!bp_sp->IsSoftwareBreakpoint())
       continue;
     auto software_bp_sp = std::static_pointer_cast<SoftwareBreakpoint>(bp_sp);
     auto opcode_addr = static_cast<char *>(buf) + bp_addr - addr;
     auto saved_opcodes = software_bp_sp->m_saved_opcodes;
     auto opcode_size = software_bp_sp->m_opcode_size;
     ::memcpy(opcode_addr, saved_opcodes, opcode_size);
   }
-  return Error::success();
+  return Error();
 }

lldb/trunk/source/Host/common/NativeProcessProtocol.cpp

Error NativeProcessProtocol::ResolveProcessArchitecture(lldb::pid_t pid,
   ModuleSpecList module_specs;
   if (!ObjectFile::GetModuleSpecifications(process_info.GetExecutableFile(), 0,
                                            0, module_specs))
     return Error("failed to get module specifications");
   lldbassert(module_specs.GetSize() == 1);
 
   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");
 }
 
 #ifndef __linux__
 // These need to be implemented to support lldb-gdb-server on a given platform.
 // Stubs are
 // provided to make the rest of the code link on non-supported platforms.

lldb/trunk/source/Host/common/NativeWatchpointList.cpp

 #include "lldb/Core/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 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 &
 NativeWatchpointList::GetWatchpointMap() const {
   return m_watchpoints;
 }

lldb/trunk/source/Host/common/SoftwareBreakpoint.cpp

if (log)
     log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
                 __FUNCTION__, addr);
 
   // Set the breakpoint and verified it was written properly.  Now
   // create a breakpoint remover that understands how to undo this
   // 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(
     NativeProcessProtocol &process, lldb::addr_t addr, size_t bp_opcode_size,
     const uint8_t *bp_opcode_bytes, uint8_t *saved_opcode_bytes) {
   assert(bp_opcode_size <= MAX_TRAP_OPCODE_SIZE &&
          "bp_opcode_size out of valid range");
   assert(bp_opcode_bytes && "bp_opcode_bytes is NULL");
return Error("SoftwareBreakpoint::%s: verification of software breakpoint "
                  "after writing when setting breakpoint at 0x%" PRIx64,
                  __FUNCTION__, addr);
   }
 
   if (log)
     log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
                 __FUNCTION__, addr);
 
-  return Error::success();
+  return Error();
 }
 
 // -------------------------------------------------------------------
 // instance-level members
 // -------------------------------------------------------------------
 
 SoftwareBreakpoint::SoftwareBreakpoint(NativeProcessProtocol &process,
                                        lldb::addr_t addr,

lldb/trunk/source/Host/posix/FileSystem.cpp

if (::mkdir(file_spec.GetCString(), file_permissions) == -1) {
         // made successfully
         if (::mkdir(file_spec.GetCString(), file_permissions) == -1) {
           error.SetErrorToErrno();
         }
         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;
       }
     }
     return error;
   }
   return Error("empty path");
 }
 
Error FileSystem::ResolveSymbolicLink(const FileSpec &src, FileSpec &dst) {
   if (realpath(resolved_path, real_path) == nullptr) {
     Error err;
     err.SetErrorToErrno();
     return err;
   }
 
   dst = FileSpec(real_path, false);
 
-  return Error::success();
+  return Error();
 }
 
 #if defined(__NetBSD__)
 static bool IsLocal(const struct statvfs &info) {
   return (info.f_flag & MNT_LOCAL) != 0;
 }
 #else
 static bool IsLocal(const struct statfs &info) {

lldb/trunk/source/Host/posix/MainLoopPosix.cpp

for (int sig : signals) {
 
       auto it = m_signals.find(sig);
       if (it == m_signals.end())
         continue; // Signal must have gotten unregistered in the meantime
 
       it->second.callback(*this); // Do the work
 
       if (m_terminate_request)
-        return Error::success();
+        return Error();
     }
 
     for (int fd : read_fds) {
       if (!FD_ISSET(fd, &read_fd_set))
         continue; // Not ready
 
       auto it = m_read_fds.find(fd);
       if (it == m_read_fds.end())
         continue; // File descriptor must have gotten unregistered in the
                   // meantime
 
       it->second(*this); // Do the work
 
       if (m_terminate_request)
-        return Error::success();
+        return Error();
     }
   }
-  return Error::success();
+  return Error();
 }

lldb/trunk/source/Host/posix/PipePosix.cpp

if (fd == -1) {
 
       std::this_thread::sleep_for(
           milliseconds(OPEN_WRITER_SLEEP_TIMEOUT_MSECS));
     } else {
       m_fds[WRITE] = fd;
     }
   }
 
-  return Error::success();
+  return Error();
 }
 
 int PipePosix::GetReadFileDescriptor() const { return m_fds[READ]; }
 
 int PipePosix::GetWriteFileDescriptor() const { return m_fds[WRITE]; }
 
 int PipePosix::ReleaseReadFileDescriptor() {
   const int fd = m_fds[READ];

lldb/trunk/source/Interpreter/OptionGroupVariable.cpp

 
 static Error ValidateNamedSummary(const char *str, void *) {
   if (!str || !str[0])
     return Error("must specify a valid named summary");
   TypeSummaryImplSP summary_sp;
   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)
     : OptionGroup(), include_frame_options(show_frame_options),
       summary(ValidateNamedSummary), summary_string(ValidateSummaryString) {}
 
 OptionGroupVariable::~OptionGroupVariable() {}
 

lldb/trunk/source/Interpreter/OptionValueString.cpp

 
 Error OptionValueString::SetCurrentValue(llvm::StringRef value) {
   if (m_validator) {
     Error error(m_validator(value.str().c_str(), m_validator_baton));
     if (error.Fail())
       return error;
   }
   m_current_value.assign(value);
-  return Error::success();
+  return Error();
 }
 
 Error OptionValueString::AppendToCurrentValue(const char *value) {
   if (value && value[0]) {
     if (m_validator) {
       std::string new_value(m_current_value);
       new_value.append(value);
       Error error(m_validator(value, m_validator_baton));
       if (error.Fail())
         return error;
       m_current_value.assign(new_value);
     } else
       m_current_value.append(value);
   }
-  return Error::success();
+  return Error();
 }

lldb/trunk/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

if (executable.get() != target.GetExecutableModulePointer()) {
     const bool get_dependent_images = false;
     target.SetExecutableModule(executable, get_dependent_images);
   }
 
   return executable;
 }
 
 // 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,
                                                     addr_t base_addr,
                                                     bool base_addr_is_offset) {
   Target &target = m_process->GetTarget();
   const SectionList *sections = GetSectionListFromModule(module);
 

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (log)
       log->Printf("DynamicLoaderPOSIXDYLD::%s about to call ProbeEntry()",
                   __FUNCTION__);
     ProbeEntry();
 
     m_process->GetTarget().ModulesDidLoad(module_list);
   }
 }
 
-Error DynamicLoaderPOSIXDYLD::CanLoadImage() { return Error::success(); }
+Error DynamicLoaderPOSIXDYLD::CanLoadImage() { return Error(); }
 
 void DynamicLoaderPOSIXDYLD::UpdateLoadedSections(ModuleSP module,
                                                   addr_t link_map_addr,
                                                   addr_t base_addr,
                                                   bool base_addr_is_offset) {
   m_loaded_modules[module] = link_map_addr;
   UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
 }

lldb/trunk/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process,
 
   return nullptr;
 }
 
 void DynamicLoaderWindowsDYLD::DidAttach() {}
 
 void DynamicLoaderWindowsDYLD::DidLaunch() {}
 
-Error DynamicLoaderWindowsDYLD::CanLoadImage() { return Error::success(); }
+Error DynamicLoaderWindowsDYLD::CanLoadImage() { return Error(); }
 
 ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion() { return 1; }
 
 ThreadPlanSP
 DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread,
                                                        bool stop) {
   return ThreadPlanSP();
 }

lldb/trunk/source/Plugins/Platform/Android/AdbClient.cpp

Error AdbClient::internalShell(const char *command, uint32_t timeout_ms,
   // output starts with /system/bin/sh: most likely command failed.
   static const char *kShellPrefix = "/system/bin/sh:";
   if (output_buf.size() > strlen(kShellPrefix)) {
     if (!memcmp(&output_buf[0], kShellPrefix, strlen(kShellPrefix)))
       return Error("Shell command %s failed: %s", command,
                    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,
                        std::string *output) {
   std::vector<char> output_buffer;
   auto error = internalShell(command, timeout_ms, output_buffer);
   if (error.Fail())
     return error;
Error AdbClient::ShellToFile(const char *command, uint32_t timeout_ms,
   std::ofstream dst(output_filename, std::ios::out | std::ios::binary);
   if (!dst.is_open())
     return Error("Unable to open local file %s", output_filename.c_str());
 
   dst.write(&output_buffer[0], output_buffer.size());
   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>
 AdbClient::GetSyncService(Error &error) {
   std::unique_ptr<SyncService> sync_service;
   error = StartSync();
   if (error.Success())
     sync_service.reset(new SyncService(std::move(m_conn)));
if (!command)
     return Error("Failed to get response command");
   const char *command_str = static_cast<const char *>(command);
   if (strncmp(command_str, kSTAT, stat_len))
     return Error("Got invalid stat command: %s", command_str);
 
   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,
                                        const FileSpec &local_file) {
   return executeCommand([this, &remote_file, &local_file]() {
     return internalPullFile(remote_file, local_file);
   });
 }
if (response_id == kDATA) {
     std::string error_message(data_len, 0);
     error = ReadAllBytes(&error_message[0], data_len);
     if (error.Fail())
       return Error("Failed to read pull error message: %s", error.AsCString());
     return Error("Failed to pull file: %s", error_message.c_str());
   } 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) {
   return ::ReadAllBytes(*m_conn, buffer, size);
 }

lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

Error PlatformFreeBSD::GetFileWithUUID(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error::success();
+  return Error();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformFreeBSD::PlatformFreeBSD(bool is_host)
     : Platform(is_host), m_remote_platform_sp() {}
 

lldb/trunk/source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

Error PlatformKalimba::ResolveExecutable(
   }
 
   return error;
 }
 
 Error PlatformKalimba::GetFileWithUUID(const FileSpec & /*platform_file*/,
                                        const UUID * /*uuid_ptr*/,
                                        FileSpec & /*local_file*/) {
-  return Error::success();
+  return Error();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformKalimba::PlatformKalimba(bool is_host)
     : Platform(is_host), // This is the local host platform
       m_remote_platform_sp() {}

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp

Error PlatformLinux::GetFileWithUUID(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error::success();
+  return Error();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformLinux::PlatformLinux(bool is_host)
     : PlatformPOSIX(is_host) // This is the local host platform
 {}

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

if (device.GetState() != CoreSimulatorSupport::Device::State::Booted) {
     if (boot_err.Fail())
       return boot_err;
   }
 
   auto spawned = device.Spawn(launch_info);
 
   if (spawned) {
     launch_info.SetProcessID(spawned.GetPID());
-    return Error::success();
+    return Error();
   } else
     return spawned.GetError();
 #else
   Error err;
   err.SetErrorString(UNSUPPORTED_ERROR);
   return err;
 #endif
 }
#else
   err.SetErrorString(UNSUPPORTED_ERROR);
   return err;
 #endif
 }
 
 Error PlatformAppleSimulator::DisconnectRemote() {
 #if defined(__APPLE__)
   m_device.reset();
-  return Error::success();
+  return Error();
 #else
   Error err;
   err.SetErrorString(UNSUPPORTED_ERROR);
   return err;
 #endif
 }
 
 lldb::ProcessSP PlatformAppleSimulator::DebugProcess(

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (!cache_path.empty()) {
             log->Printf("[%s] module %s/%s was rsynced and is now there",
                         (IsHost() ? "host" : "remote"),
                         module_spec.GetFileSpec().GetDirectory().AsCString(),
                         module_spec.GetFileSpec().GetFilename().AsCString());
           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();
         }
       }
 
       // try to find the module in the cache
       if (module_cache_spec.Exists()) {
         // get the local and remote MD5 and compare
         if (m_remote_platform_sp) {
           // when going over the *slow* GDB remote transfer mechanism we first
if (!cache_path.empty()) {
         module_sp.reset(new Module(local_spec));
         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
         Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
         if (log)
           log->Printf("[%s] module %s/%s was found in the cache",
                       (IsHost() ? "host" : "remote"),
                       module_spec.GetFileSpec().GetDirectory().AsCString(),
                       module_spec.GetFileSpec().GetFilename().AsCString());
-        return Error::success();
+        return Error();
       }
 
       // bring in the remote module file
       if (log)
         log->Printf("[%s] module %s/%s needs to come in remotely",
                     (IsHost() ? "host" : "remote"),
                     module_spec.GetFileSpec().GetDirectory().AsCString(),
                     module_spec.GetFileSpec().GetFilename().AsCString());
       Error err = BringInRemoteFile(this, module_spec, module_cache_spec);
       if (err.Fail())
         return err;
       if (module_cache_spec.Exists()) {
         Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
         if (log)
           log->Printf("[%s] module %s/%s is now cached and fine",
                       (IsHost() ? "host" : "remote"),
                       module_spec.GetFileSpec().GetDirectory().AsCString(),
                       module_spec.GetFileSpec().GetFilename().AsCString());
         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
       return Error("no cache path");
   } else
     return Error("unable to resolve module");
 }
 

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

Error PlatformMacOSX::GetSymbolFile(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error::success();
+  return Error();
 }
 
 lldb_private::Error
 PlatformMacOSX::GetFileWithUUID(const lldb_private::FileSpec &platform_file,
                                 const lldb_private::UUID *uuid_ptr,
                                 lldb_private::FileSpec &local_file) {
   if (IsRemote() && m_remote_platform_sp) {
     std::string local_os_build;
 #if !defined(__linux__)
     HostInfo::GetOSBuildString(local_os_build);
 #endif
     std::string remote_os_build;
     m_remote_platform_sp->GetOSBuildString(remote_os_build);
     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());
       std::string module_path(platform_file.GetPath());
       cache_path.append(module_path);
       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 =
           module_cache_spec.CopyByRemovingLastPathComponent();
       // try to make the local directory first
       Error err = FileSystem::MakeDirectory(module_cache_folder,
                                             eFilePermissionsDirectoryDefault);
       if (err.Fail())
         return err;
       err = GetFile(platform_file, module_cache_spec);
       if (err.Fail())
         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,
                                                      ArchSpec &arch) {
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   return ARMGetSupportedArchitectureAtIndex(idx, arch);
 #else
   return x86GetSupportedArchitectureAtIndex(idx, arch);

lldb/trunk/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

Error PlatformNetBSD::GetFileWithUUID(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error::success();
+  return Error();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformNetBSD::PlatformNetBSD(bool is_host)
     : Platform(is_host), m_remote_platform_sp() {}
 

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 lldb_private::Error
 PlatformPOSIX::PutFile(const lldb_private::FileSpec &source,
                        const lldb_private::FileSpec &destination, uint32_t uid,
                        uint32_t gid) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
   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 (src_path.empty())
       return Error("unable to get file path for source");
     std::string dst_path(destination.GetPath());
     if (dst_path.empty())
       return Error("unable to get file path for destination");
     StreamString command;
     command.Printf("cp %s %s", src_path.c_str(), dst_path.c_str());
     int status;
     RunShellCommand(command.GetData(), NULL, &status, NULL, NULL, 10);
     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());
       if (src_path.empty())
         return Error("unable to get file path for source");
       std::string dst_path(destination.GetPath());
       if (dst_path.empty())
         return Error("unable to get file path for destination");
if (GetSupportsRSync()) {
       if (log)
         log->Printf("[PutFile] Running command: %s\n", command.GetData());
       int retcode;
       Host::RunShellCommand(command.GetData(), NULL, &retcode, NULL, NULL, 60);
       if (retcode == 0) {
         // 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
     }
   }
   return Platform::PutFile(source, destination, uid, gid);
 }
 
if (FileSpec::Equal(source, destination, true))
                    "path: no operation performed");
     // cp src dst
     StreamString cp_command;
     cp_command.Printf("cp %s %s", src_path.c_str(), dst_path.c_str());
     int status;
     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;
       if (GetIgnoresRemoteHostname()) {
         if (!GetRSyncPrefix())
           command.Printf("rsync %s %s %s", GetRSyncOpts(), src_path.c_str(),
                          dst_path.c_str());
         else
           command.Printf("rsync %s %s%s %s", GetRSyncOpts(), GetRSyncPrefix(),
                          src_path.c_str(), dst_path.c_str());
       } else
         command.Printf("rsync %s %s:%s %s", GetRSyncOpts(),
                        m_remote_platform_sp->GetHostname(), src_path.c_str(),
                        dst_path.c_str());
       if (log)
         log->Printf("[GetFile] Running command: %s\n", command.GetData());
       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
     }
     // open src and dst
     // read/write, read/write, read/write, ...
     // close src
     // close dst
     if (log)
Error PlatformPOSIX::EvaluateLibdlExpression(
   ExpressionResults result =
       UserExpression::Evaluate(exe_ctx, expr_options, expr_cstr, expr_prefix,
                                result_valobj_sp, expr_error);
   if (result != eExpressionCompleted)
     return expr_error;
 
   if (result_valobj_sp->GetError().Fail())
     return result_valobj_sp->GetError();
-  return Error::success();
+  return Error();
 }
 
 uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
                                     const lldb_private::FileSpec &remote_file,
                                     lldb_private::Error &error) {
   char path[PATH_MAX];
   remote_file.GetPath(path, sizeof(path));
 
if (result_valobj_sp->GetError().Fail())
     return result_valobj_sp->GetError();
 
   Scalar scalar;
   if (result_valobj_sp->ResolveValue(scalar)) {
     if (scalar.UInt(1))
       return Error("expression failed: \"%s\"", expr.GetData());
     process->ResetImageToken(image_token);
   }
-  return Error::success();
+  return Error();
 }
 
 lldb::ProcessSP PlatformPOSIX::ConnectProcess(const char *connect_url,
                                               const char *plugin_name,
                                               lldb_private::Debugger &debugger,
                                               lldb_private::Target *target,
                                               lldb_private::Error &error) {
   if (m_remote_platform_sp)

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp

Error PlatformWindows::GetFileWithUUID(const FileSpec &platform_file,
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }
 
   // Default to the local case
   local_file = platform_file;
-  return Error::success();
+  return Error();
 }
 
 Error PlatformWindows::GetSharedModule(
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,
     bool *did_create_ptr) {
   Error error;
   module_sp.reset();

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

bool PlatformRemoteGDBServer::GetModuleSpec(const FileSpec &module_file_spec,
   return true;
 }
 
 Error PlatformRemoteGDBServer::GetFileWithUUID(const FileSpec &platform_file,
                                                const UUID *uuid_ptr,
                                                FileSpec &local_file) {
   // Default to the local case
   local_file = platform_file;
-  return Error::success();
+  return Error();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformRemoteGDBServer::PlatformRemoteGDBServer()
     : Platform(false), // This is a remote platform
       m_gdb_client() {}
error.SetErrorStringWithFormat("'A' packet returned an error: %i",
                                    arg_packet_err);
   }
   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(
     ProcessLaunchInfo &launch_info, Debugger &debugger,
     Target *target, // Can be NULL, if NULL create a new target, else use
                     // existing one
     Error &error) {
   lldb::ProcessSP process_sp;

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 lldb_private::DynamicLoader *ProcessKDP::GetDynamicLoader() {
   if (m_dyld_ap.get() == NULL)
     m_dyld_ap.reset(DynamicLoader::FindPlugin(
         this,
         m_dyld_plugin_name.IsEmpty() ? NULL : m_dyld_plugin_name.GetCString()));
   return m_dyld_ap.get();
 }
 
-Error ProcessKDP::WillResume() { return Error::success(); }
+Error ProcessKDP::WillResume() { return Error(); }
 
 Error ProcessKDP::DoResume() {
   Error error;
   Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
   // Only start the async thread if we try to do any process control
   if (!m_async_thread.IsJoinable())
     StartAsyncThread();
 

lldb/trunk/source/Plugins/Process/elf-core/ProcessElfCore.cpp

for (lldb::tid_t tid = 0; tid < num_threads; ++tid) {
     lldb::ThreadSP thread_sp(new ThreadElfCore(*this, td));
     new_thread_list.AddThread(thread_sp);
   }
   return new_thread_list.GetSize(false) > 0;
 }
 
 void ProcessElfCore::RefreshStateAfterStop() {}
 
-Error ProcessElfCore::DoDestroy() { return Error::success(); }
+Error ProcessElfCore::DoDestroy() { return Error(); }
 
 //------------------------------------------------------------------
 // Process Queries
 //------------------------------------------------------------------
 
 bool ProcessElfCore::IsAlive() { return true; }
 
 //------------------------------------------------------------------
if (permission_entry) {
     } else if (load_addr < permission_entry->GetRangeBase()) {
       region_info.GetRange().SetRangeBase(load_addr);
       region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
       region_info.SetReadable(MemoryRegionInfo::eNo);
       region_info.SetWritable(MemoryRegionInfo::eNo);
       region_info.SetExecutable(MemoryRegionInfo::eNo);
       region_info.SetMapped(MemoryRegionInfo::eNo);
     }
-    return Error::success();
+    return Error();
   }
 
   region_info.GetRange().SetRangeBase(load_addr);
   region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
   region_info.SetReadable(MemoryRegionInfo::eNo);
   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,
                                     Error &error) {
   ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
 
   if (core_objfile == NULL)
     return 0;

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
     if (signo_ptr)
       *signo_ptr = signo;
     if (response.GetChar() != ',')
       return Error("malformed reply");
     std::string output;
     response.GetEscapedBinaryData(output);
     if (command_output)
       command_output->assign(output);
-    return Error::success();
+    return Error();
   }
   return Error("unable to send packet");
 }
 
 Error GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec,
                                                   uint32_t file_permissions) {
   std::string path{file_spec.GetPath(false)};
   lldb_private::StreamString stream;

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 
 Error GDBRemoteCommunicationServerLLGS::SetLaunchArguments(
     const char *const args[], int argc) {
   if ((argc < 1) || !args || !args[0] || !args[0][0])
     return Error("%s: no process command line specified to launch",
                  __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() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   if (!m_process_launch_info.GetArguments().GetArgumentCount())
     return Error("%s: no process command line specified to launch",
                  __FUNCTION__);
Error GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor(int fd) {
   m_stdio_communication.SetCloseOnEOF(false);
   m_stdio_communication.SetConnection(conn_up.release());
   if (!m_stdio_communication.IsConnected()) {
     error.SetErrorString(
         "failed to set connection for inferior I/O communication");
     return error;
   }
 
-  return Error::success();
+  return Error();
 }
 
 void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() {
   // Don't forward if not connected (e.g. when attaching).
   if (!m_stdio_communication.IsConnected())
     return;
 
   Error error;

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 
 Error ProcessGDBRemote::WillResume() {
   m_continue_c_tids.clear();
   m_continue_C_tids.clear();
   m_continue_s_tids.clear();
   m_continue_S_tids.clear();
   m_jstopinfo_sp.reset();
   m_jthreadsinfo_sp.reset();
-  return Error::success();
+  return Error();
 }
 
 Error ProcessGDBRemote::DoResume() {
   Error error;
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
   if (log)
     log->Printf("ProcessGDBRemote::Resume()");
 
if (!m_gdb_comm.SendAsyncSignal(signo))
     error.SetErrorStringWithFormat("failed to send signal %i", signo);
   return error;
 }
 
 Error ProcessGDBRemote::EstablishConnectionIfNeeded(
     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())
     return Error("Lost debug server connection");
 
   auto error = LaunchAndConnectToDebugserver(process_info);
   if (error.Fail()) {
     const char *error_string = error.AsCString();
if (log)
       log->Printf("parsing: %s", raw.c_str());
     XMLDocument doc;
 
     if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
       return Error(0, ErrorType::eErrorTypeGeneric);
 
     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");
     if (!main_lm.empty()) {
       list.m_link_map =
           StringConvert::ToUInt64(main_lm.data(), LLDB_INVALID_ADDRESS, 0);
     }
 
if (log)
       log->Printf("parsing: %s", raw.c_str());
     XMLDocument doc;
 
     if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
       return Error(0, ErrorType::eErrorTypeGeneric);
 
     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 {
           LoadedModuleInfoList::LoadedModuleInfo module;
 
           llvm::StringRef name = library.GetAttributeValue("name");
           module.set_name(name.str());
 
if (comm.GetQXferLibrariesSVR4ReadSupported()) {
 
     if (log)
       log->Printf("found %" PRId32 " modules in total",
                   (int)list.m_list.size());
   } else {
     return Error(0, ErrorType::eErrorTypeGeneric);
   }
 
-  return Error::success();
+  return Error();
 }
 
 lldb::ModuleSP ProcessGDBRemote::LoadModuleAtAddress(const FileSpec &file,
                                                      lldb::addr_t link_map,
                                                      lldb::addr_t base_addr,
                                                      bool value_is_offset) {
   DynamicLoader *loader = GetDynamicLoader();
   if (!loader)
if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
       GDBRemoteCommunication::PacketResult::Success)
     return Error("Sending qFileLoadAddress packet failed");
 
   if (response.IsErrorResponse()) {
     if (response.GetError() == 1) {
       // The file is not loaded into the inferior
       is_loaded = false;
       load_addr = LLDB_INVALID_ADDRESS;
-      return Error::success();
+      return Error();
     }
 
     return Error(
         "Fetching file load address from remote server returned an 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");
 }
 
 void ProcessGDBRemote::ModulesDidLoad(ModuleList &module_list) {
   // We must call the lldb_private::Process::ModulesDidLoad () first before we
   // do anything

lldb/trunk/source/Plugins/Process/mach-core/ProcessMachCore.cpp

 
 void ProcessMachCore::RefreshStateAfterStop() {
   // Let all threads recover from stopping and do any clean up based
   // on the previous thread state (if any).
   m_thread_list.RefreshStateAfterStop();
   // SetThreadStopInfo (m_last_stop_packet);
 }
 
-Error ProcessMachCore::DoDestroy() { return Error::success(); }
+Error ProcessMachCore::DoDestroy() { return Error(); }
 
 //------------------------------------------------------------------
 // Process Queries
 //------------------------------------------------------------------
 
 bool ProcessMachCore::IsAlive() { return true; }
 
 bool ProcessMachCore::WarnBeforeDetach() const { return false; }
if (permission_entry) {
     } else if (load_addr < permission_entry->GetRangeBase()) {
       region_info.GetRange().SetRangeBase(load_addr);
       region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
       region_info.SetReadable(MemoryRegionInfo::eNo);
       region_info.SetWritable(MemoryRegionInfo::eNo);
       region_info.SetExecutable(MemoryRegionInfo::eNo);
       region_info.SetMapped(MemoryRegionInfo::eNo);
     }
-    return Error::success();
+    return Error();
   }
 
   region_info.GetRange().SetRangeBase(load_addr);
   region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
   region_info.SetReadable(MemoryRegionInfo::eNo);
   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(); }
 
 void ProcessMachCore::Initialize() {
   static std::once_flag g_once_flag;
 
   std::call_once(g_once_flag, []() {

lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp

if (m_dyld_ap.get() == nullptr)
     m_dyld_ap.reset(DynamicLoader::FindPlugin(this, nullptr));
   return m_dyld_ap.get();
 }
 
 ConstString ProcessMinidump::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t ProcessMinidump::GetPluginVersion() { return 1; }
 
-Error ProcessMinidump::DoDestroy() { return Error::success(); }
+Error ProcessMinidump::DoDestroy() { return Error(); }
 
 void ProcessMinidump::RefreshStateAfterStop() {
   if (!m_active_exception)
     return;
 
   if (m_active_exception->exception_record.exception_code ==
       MinidumpException::DumpRequested) {
     return;

lldb/trunk/source/Target/Platform.cpp

if (platform_sp) {
     GetPlatformList().push_back(platform_sp);
   }
 }
 
 Error Platform::GetFileWithUUID(const FileSpec &platform_file,
                                 const UUID *uuid_ptr, FileSpec &local_file) {
   // Default to the local case
   local_file = platform_file;
-  return Error::success();
+  return Error();
 }
 
 FileSpecList
 Platform::LocateExecutableScriptingResources(Target *target, Module &module,
                                              Stream *feedback_stream) {
   return FileSpecList();
 }
 
Error Platform::KillProcess(const lldb::pid_t pid) {
   }
 
   if (!IsHost()) {
     return Error(
         "base lldb_private::Platform class can't kill remote processes unless "
         "they are controlled by a process plugin");
   }
   Host::Kill(pid, SIGTERM);
-  return Error::success();
+  return Error();
 }
 
 lldb::ProcessSP
 Platform::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
                        Target *target, // Can be nullptr, if nullptr create a
                                        // new target, else use existing one
                        Error &error) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
Error Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
   if (module_spec.GetUUID().IsValid()) {
     resolved_module_spec.GetUUID() = module_spec.GetUUID();
   }
 
   // Trying to find a module by UUID on local file system.
   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;
 }
 
 bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec,
                                      lldb::ModuleSP &module_sp,
                                      bool *did_create_ptr) {

lldb/trunk/source/Target/Process.cpp

Error Process::Halt(bool clear_thread_plans, bool use_run_lock) {
   SendAsyncInterrupt();
 
   if (m_public_state.GetValue() == eStateAttaching) {
     // Don't hijack and eat the eStateExited as the code that was doing
     // the attach will be waiting for this event...
     RestoreProcessEvents();
     SetExitStatus(SIGKILL, "Cancelled async attach.");
     Destroy(false);
-    return Error::success();
+    return Error();
   }
 
   // Wait for 10 second for the process to stop.
   StateType state =
       WaitForProcessToStop(std::chrono::seconds(10), &event_sp, true,
                            halt_listener_sp, nullptr, use_run_lock);
   RestoreProcessEvents();
 
   if (state == eStateInvalid || !event_sp) {
     // We timed out and didn't get a stop event...
     return Error("Halt timed out. State = %s", StateAsCString(GetState()));
   }
 
   BroadcastEvent(event_sp);
 
-  return Error::success();
+  return Error();
 }
 
 Error Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
   Error error;
 
   // Check both the public & private states here.  If we're hung evaluating an
   // expression, for instance, then
   // the public state will be stopped, but we still need to interrupt.

lldb/trunk/source/Target/Thread.cpp

sstr.Printf("%s:%i appears multiple times in this function, selecting the "
                 file.GetFilename().AsCString(), line);
     DumpAddressList(sstr, candidates, target);
     *warnings = sstr.GetString();
   }
 
   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,
                                      bool stop_format) {
   ExecutionContext exe_ctx(shared_from_this());
   Process *process = exe_ctx.GetProcessPtr();
   if (process == nullptr)
     return;

lldb/trunk/source/Utility/ModuleCache.cpp

FileSpec JoinPath(const FileSpec &path1, const char *path2) {
   return result_spec;
 }
 
 Error MakeDirectory(const FileSpec &dir_path) {
   if (dir_path.Exists()) {
     if (!dir_path.IsDirectory())
       return Error("Invalid existing path");
 
-    return Error::success();
+    return Error();
   }
 
   return FileSystem::MakeDirectory(dir_path, eFilePermissionsDirectoryDefault);
 }
 
 FileSpec GetModuleDirectory(const FileSpec &root_dir_spec, const UUID &uuid) {
   const auto modules_dir_spec = JoinPath(root_dir_spec, kModulesSubdir);
   return JoinPath(modules_dir_spec, uuid.GetAsString().c_str());
Error CreateHostSysRootModuleLink(const FileSpec &root_dir_spec,
                                   const FileSpec &platform_module_spec,
                                   const FileSpec &local_module_spec,
                                   bool delete_existing) {
   const auto sysroot_module_path_spec =
       JoinPath(JoinPath(root_dir_spec, hostname),
                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);
   }
 
   const auto error = MakeDirectory(
       FileSpec(sysroot_module_path_spec.GetDirectory().AsCString(), false));
   if (error.Fail())
     return error;
return Error("Failed to rename file %s to %s: %s", tmp_file_path.c_str(),
                  module_file_path.GetPath().c_str(),
                  err_code.message().c_str());
 
   const auto error = CreateHostSysRootModuleLink(
       root_dir_spec, hostname, target_file, module_file_path, true);
   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,
                        const ModuleSpec &module_spec,
                        ModuleSP &cached_module_sp, bool *did_create_ptr) {
   const auto find_it =
       m_loaded_modules.find(module_spec.GetUUID().GetAsString());
   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);
   }
 
   const auto module_spec_dir =
       GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
   const auto module_file_path = JoinPath(
       module_spec_dir, module_spec.GetFileSpec().GetFilename().AsCString());
 
Error ModuleCache::Get(const FileSpec &root_dir_spec, const char *hostname,
 
   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
   if (symfile_spec.Exists())
     cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
 
   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,
                              const char *hostname,
                              const ModuleSpec &module_spec,
                              const ModuleDownloader &module_downloader,
                              const SymfileDownloader &symfile_downloader,
                              lldb::ModuleSP &cached_module_sp,
const auto tmp_download_sym_file_spec =
       JoinPath(module_spec_dir, kTempSymFileName);
   error = symfile_downloader(cached_module_sp, tmp_download_sym_file_spec);
   llvm::FileRemover tmp_symfile_remover(tmp_download_sym_file_spec.GetPath());
   if (error.Fail())
     // Failed to download a symfile but fetching the module was successful. The
     // 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,
               GetSymbolFileSpec(module_spec.GetFileSpec()));
   if (error.Fail())
     return Error("Failed to put symbol file into cache: %s", error.AsCString());
 
   tmp_symfile_remover.releaseFile();
 
   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
   cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
-  return Error::success();
+  return Error();
 }

lldb/trunk/tools/lldb-server/lldb-platform.cpp

static Error save_socket_id_to_file(const std::string &socket_id,
   }
 
   err_code = llvm::sys::fs::rename(temp_file_path.c_str(), file_spec.GetPath());
   if (err_code)
     return Error("Failed to rename file %s to %s: %s", temp_file_path.c_str(),
                  file_spec.GetPath().c_str(), err_code.message().c_str());
 
   tmp_file_remover.releaseFile();
-  return Error::success();
+  return Error();
 }
 
 //----------------------------------------------------------------------
 // main
 //----------------------------------------------------------------------
 int main_platform(int argc, char *argv[]) {
   const char *progname = argv[0];
   const char *subcommand = argv[1];

lldb/trunk/unittests/Utility/ModuleCacheTest.cpp

Error error = mc.GetAndPut(
       [this, &download_called](const ModuleSpec &module_spec,
                                const FileSpec &tmp_download_file_spec) {
         download_called = true;
         EXPECT_STREQ(GetDummyRemotePath().GetCString(),
                      module_spec.GetFileSpec().GetCString());
         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.");
       },
       module_sp, &did_create);
   EXPECT_EQ(expect_download, download_called);
 
   EXPECT_TRUE(error.Success()) << "Error was: " << error.AsCString();

llvm/trunk/include/llvm/Support/Error.h

 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 namespace llvm {
 
 class Error;
 class ErrorList;
+class ErrorSuccess;
 
 /// Base class for error info classes. Do not extend this directly: Extend
 /// the ErrorInfo template subclass instead.
 class ErrorInfoBase {
 public:
   virtual ~ErrorInfoBase() {}
 
   /// Print an error message to an output stream.

 protected:
   /// Create a success value. Prefer using 'Error::success()' for readability
   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(); }
+  /// Create a success value.
+  static ErrorSuccess success();
 
   // Errors are not copy-constructable.
   Error(const Error &Other) = delete;
 
   /// Move-construct an error value. The newly constructed error is considered
   /// unchecked, even if the source error had been checked. The original error
   /// becomes a checked Success value, regardless of its original state.
   Error(Error &&Other) : Payload(nullptr) {
std::unique_ptr<ErrorInfoBase> takePayload() {
     setPtr(nullptr);
     setChecked(true);
     return Tmp;
   }
 
   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) {
   return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
 }
 
 /// Base class for user error types. Users should declare their error types
 /// like:
#else
         Unchecked(false)
 #endif
 
   {
     assert(Err && "Cannot create Expected<T> from Error success value.");
     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>
   Expected(OtherT &&Val,
            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
                * = nullptr)
       : HasError(false),
 #ifndef NDEBUG

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

Expected<std::string> BitcodeReader::parseTriple() {
   // need to understand them all.
   while (true) {
     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::MODULE_BLOCK_ID)
         return parseModuleTriple();
 
       // Ignore other sub-blocks.
       if (Stream.SkipBlock())
         return error("Malformed block");
Expected<std::string> BitcodeReader::parseIdentificationBlock() {
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.
   while (true) {
     // This loop iterates at the top-level: since there is no enclosing block
     // 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) {
         if (Error Err = parseBitcodeVersion())
           return std::move(Err);
         return ProducerIdentification;
       }
       // Ignore other sub-blocks.
Expected<bool> BitcodeReader::hasObjCCategory() {
   // need to understand them all.
   while (true) {
     BitstreamEntry Entry = Stream.advance();
 
     switch (Entry.Kind) {
     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)
         return hasObjCCategoryInModule();
 
       // Ignore other sub-blocks.
       if (Stream.SkipBlock())
         return error("Malformed block");

llvm/trunk/unittests/Support/ErrorTest.cpp

static Error handleCustomErrorUP(std::unique_ptr<CustomError> CE) {
   return Error::success();
 }
 
 static void handleCustomErrorUPVoid(std::unique_ptr<CustomError> CE) {}
 
 // 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
 
 // ErrorAsOutParameter tester.
 void errAsOutParamHelper(Error &Err) {
   ErrorAsOutParameter ErrAsOutParam(&Err);
   // Verify that checked flag is raised - assignment should not crash.
   Err = Error::success();
   // Raise the checked bit manually - caller should still have to test the
   // error.
   (void)!!Err;
 }
 
 // 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.";
 }
 #endif
 
 // Check that we abort on unhandled failure cases. (Force conversion to bool
 // to make sure that we don't accidentally treat checked errors as handled).
 // Test runs in debug mode only.

 // Error (unique_ptr<Err>) mutable
 // void (unique_ptr<Err>) mutable
 TEST(Error, HandlerTypeDeduction) {
 
   handleAllErrors(make_error<CustomError>(42), [](const CustomError &CE) {});
 
   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 {});
 
   // Check that named handlers of type 'Error (const Err&)' work.
   handleAllErrors(make_error<CustomError>(42), handleCustomError);
 
   // Check that named handlers of type 'void (const Err&)' work.
handleAllErrors(
           Sum += CE.getInfo();
         });
     EXPECT_EQ(Sum, 28) << "Failed to correctly concatenate erorr lists.";
   }
 }
 
 // Test that we can consume success values.
 TEST(Error, ConsumeSuccess) {
-  Error E;
+  Error E = Error::success();
   consumeError(std::move(E));
 }
 
 TEST(Error, ConsumeError) {
   Error E = make_error<CustomError>(7);
   consumeError(std::move(E));
 }