MemoryBuffer: Migrate to Expected/llvm::Error from ErrorOr/std::error_code

[dblaikie]

Summary

Specifically to improve diagnostic/error messages - including the
filename in any error of an API that takes a file name (so not APIs that
take raw MemoryBuffers - don't uset the MemoryBuffer's identifier as the
name, because sometimes that's not adequate (such as for MemoryBuffer's
referring to files inside an archive) - and not for APIs taking a raw
file descriptor either).

This was spotted as a defficiency in llvm-jitlink which was complaining
about a missing file but not reporting which file.

Rather than patching that one case of a missing filename up in the
caller as most other callers do to workaround this, I figured I'd try
fixing this at a lower level - which involved plumbing Expected/Error
through those APIs to be able to carry the file name - and then fixing
up lots of callers and lots of test cases for slight differences in
syntax (mostly made diagnostic messages more consistent across tools
about quoting versus not quoting the filename, etc).

One or two cases got a bit worse - like llvm-symbolizer's yaml output,
now the diagnostic itself includes the filename, in addition to the file
yaml field. This could probably be improved/fixed by special-casing
FileError in the diagnostic printing to pull out/separate the file name
in the diagnostic.

Otherwise it's I think just a lot of cleanup.

Oh, it also included changing FileError's convertToErrorCode to look
down through it's nested ErrorInfo for error codes - this makes it
possible to use FileError when a caller is trying to check for a
specific file related error (such as 'file not found') which was being
done in a couple of places (& without this fix would've created a
strange tension where APIs wanting to support such callers would have to
use StringError or ECError instead of FileError, which seemed
counterintuitive/inelegant/difficult to deal with - in terms of then
trying to have consistent syntax/handling for file errors, and to
support the possibility of splitting out filenames as mentioned above
for the symbolizer output).

The Windows/Path.inc is entirely untested - will have to test it out on
buildbots, unless someone wants to give it a go before I submit.

[thopre]

Is there no way to split this patch further? It's going to be hard finding someone who can review something so big. If there's no way to split it in incremental changes, you could perhaps split per subsystem only for review and refer to this diff for CI as well as when landing.

[dblaikie]

In D109345#2986297, @thopre wrote:

Is there no way to split this patch further? It's going to be hard finding someone who can review something so big. If there's no way to split it in incremental changes, you could perhaps split per subsystem only for review and refer to this diff for CI as well as when landing.

The long migration path would be to do this one function at. time (I did a whole cluster of functions in MemoryBuffer for consistency - this does reduce total code changes somewhat, since some of those APIs are used in similar contexts (eg: branches of a conditional operator - so having them differ means more revisions to those call sites)) and probably introducing separate names for the Expected versions of the functions, migrating call sites incrementally, then doing a mechanical rename at the end of all that.

I don't think it's probably worth that level of granularity - it's a fairly mechanical patch as it is.

Mostly I sent this out as an FYI and to get feedback on the general direction - whether folks thought it was worth doing at all, and if they feel strongly it should be done another way (like the incremental ones above) - but I don't think it needs a /huge/ amount of scrutiny, review by separate code owners, etc. I'd generally be comfortable committing this as other cross-project cleanup/refactoring like function renaming, etc.

[dexonsmith]

This seems like the right direction to me! Especially like the look-through-the-ErrorInfo change for FileError -- I hit this before and found it annoying.

IMO, it'd be valuable to split out the consequential functional changes:

• Improvements/changes you made to FileError could be committed ahead of time
• Other improvements you discussed to avoid regressions in (e.g.) llvm-symbolizer (seems potentially important?)

I agree the other changes are mostly mechanical and don't all need careful review-by-subcomponents.

That said, it looks very painful for downstream clients of the LLVM C++ API since it's structured as an all-or-nothing change. Especially for managing cherry-picks to long-lived stable branches. It's painful because clients will have code like this:

if (auto MaybeFile = MemoryBuffer::getFileOrSTDIN()) {
  // Do something with MaybeFile
}
// Else path doesn't care about the specific error code.

that will suddenly start crashing at runtime. I even wonder if there like that introduced in-tree by your current all-in-one patch, since I think our filesystem-error paths are often missing test coverage. (It'd be difficult to do a thorough audit.)

I thought through a potential staging that could mitigate the pain:

1. Add using MemoryBufferCompat = MemoryBuffer and search/replace all static MemoryBuffer:: API calls over to MemoryBufferCompat::. No direct impact on downstreams.
2. Change MemoryBuffer to use Error and Expected, leaving behind std::error_code and ErrorOr wrappers in a no-longer-just-a-typedef MemoryBufferCompat. Easy for downstreams to temporarily revert, and cherry-pick once they've finished adapting in the example of (1).
3. Update all code to use the new APIs. Could be done all at once since it's mostly mechanical, as you said. Also an option to split up by component (e.g., maybe the llvm-symbolizer regression is okay, but it could be nice to get that reviewed separately / in isolation).
4. Delete MemoryBufferCompat. Downstreams can temporarily revert while they follow the example of on (3).

(Given that (1) and (2) are easy to write, you already have tree state for (4), and (3) is easy to create from (4), then I think you could construct the above commit sequence without having to redo all the work... then if you wanted to split (3) up from there it'd be easy enough.)

(2) seems like the commit mostly likely to cause functional regressions, and it'd be isolated and easy to revert/reapply (downstream and/or upstream) without much churn.

WDYT?

[MaskRay]

ninja clang on Windows works.

check-llvm-tools has a few REQUIRES: system-windows tests. They still passed.

[dblaikie]

In D109345#2987565, @dexonsmith wrote:

This seems like the right direction to me! Especially like the look-through-the-ErrorInfo change for FileError -- I hit this before and found it annoying.

Thanks for taking a look!

IMO, it'd be valuable to split out the consequential functional changes:

• Improvements/changes you made to FileError could be committed ahead of time

Sure sure, can be committed and unit tested separately for sure.

• Other improvements you discussed to avoid regressions in (e.g.) llvm-symbolizer (seems potentially important?)

I didn't think the yaml symbolizer output was that important - but turned out not to be super hard to fix, so I've done that. (were there other regressions I mentioned/should think about?)

I agree the other changes are mostly mechanical and don't all need careful review-by-subcomponents.

That said, it looks very painful for downstream clients of the LLVM C++ API since it's structured as an all-or-nothing change.

Yeah, certainly crossed my mind.

Especially for managing cherry-picks to long-lived stable branches. It's painful because clients will have code like this:

if (auto MaybeFile = MemoryBuffer::getFileOrSTDIN()) {
  // Do something with MaybeFile
}
// Else path doesn't care about the specific error code.

that will suddenly start crashing at runtime. I even wonder if there like that introduced in-tree by your current all-in-one patch, since I think our filesystem-error paths are often missing test coverage. (It'd be difficult to do a thorough audit.)

Yeah, that came up in a handful of cases that used 'auto' (without using auto it's a compile failure).

I thought through a potential staging that could mitigate the pain:

1. Add using MemoryBufferCompat = MemoryBuffer and search/replace all static MemoryBuffer:: API calls over to MemoryBufferCompat::. No direct impact on downstreams.

Yeah, that's some of the extra churn I was thinking of/hoping to avoid - but yeah, it's probably worthwhile.

What's the benefit of having the extra step where everything's renamed twice? (if it's going to be a monolithic commit - as mentioned in (3)) Compared to doing the mass change while keeping the (1 & 2) pieces for backwards compatibility if needed?

2. Change MemoryBuffer to use Error and Expected, leaving behind std::error_code and ErrorOr wrappers in a no-longer-just-a-typedef MemoryBufferCompat. Easy for downstreams to temporarily revert, and cherry-pick once they've finished adapting in the example of (1).
3. Update all code to use the new APIs. Could be done all at once since it's mostly mechanical, as you said. Also an option to split up by component (e.g., maybe the llvm-symbolizer regression is okay, but it could be nice to get that reviewed separately / in isolation).
4. Delete MemoryBufferCompat. Downstreams can temporarily revert while they follow the example of on (3).

(Given that (1) and (2) are easy to write, you already have tree state for (4), and (3) is easy to create from (4), then I think you could construct the above commit sequence without having to redo all the work... then if you wanted to split (3) up from there it'd be easy enough.)

(2) seems like the commit mostly likely to cause functional regressions, and it'd be isolated and easy to revert/reapply (downstream and/or upstream) without much churn.

(3) would be more likely to cause regression? Presumably (2) is really uninteresting because it adds a new API (re-adding MemoryBuffer, but unused since everything's using MemoryBufferCompat) without any usage, yeah?

Plausible, though a fair bit more churn - I'd probably be up for it, though.

• Dave

[dblaikie]

Address the llvm-symbolizer regression by special casing FileError and extracting the non-filename portion of the error when emitting json since the filename is conveyed separately

[dblaikie]

Fix a couple of spurious letters/modifications to a couple of test files

[dblaikie]

Rebase on top of pushed FileError API improvements

[dexonsmith]

In D109345#2990527, @dblaikie wrote:

(were there other regressions I mentioned/should think about?)

I don't have specific concerns; I was just reading between the lines of your description...

1. Add using MemoryBufferCompat = MemoryBuffer and search/replace all static MemoryBuffer:: API calls over to MemoryBufferCompat::. No direct impact on downstreams.

Yeah, that's some of the extra churn I was thinking of/hoping to avoid - but yeah, it's probably worthwhile.

What's the benefit of having the extra step where everything's renamed twice? (if it's going to be a monolithic commit - as mentioned in (3)) Compared to doing the mass change while keeping the (1 & 2) pieces for backwards compatibility if needed?

Benefits I was seeing of splitting (1-3) up are:

• makes (2) easy for downstreams to integrate separately from (1) and (3) (see below for why (2) is interesting)
• prevents any reverts of (3) on main from resulting in churn in downstream efforts to migrate in response to (1-2)
• enables (3) to NOT be monolithic -- still debatable how useful it is, but if split up then individual pieces can run through buildbots separately (and be reverted separately)

2. Change MemoryBuffer to use Error and Expected, leaving behind std::error_code and ErrorOr wrappers in a no-longer-just-a-typedef MemoryBufferCompat. Easy for downstreams to temporarily revert, and cherry-pick once they've finished adapting in the example of (1).
3. Update all code to use the new APIs. Could be done all at once since it's mostly mechanical, as you said. Also an option to split up by component (e.g., maybe the llvm-symbolizer regression is okay, but it could be nice to get that reviewed separately / in isolation).
4. Delete MemoryBufferCompat. Downstreams can temporarily revert while they follow the example of on (3).

(Given that (1) and (2) are easy to write, you already have tree state for (4), and (3) is easy to create from (4), then I think you could construct the above commit sequence without having to redo all the work... then if you wanted to split (3) up from there it'd be easy enough.)

(2) seems like the commit mostly likely to cause functional regressions, and it'd be isolated and easy to revert/reapply (downstream and/or upstream) without much churn.

(3) would be more likely to cause regression? Presumably (2) is really uninteresting because it adds a new API (re-adding MemoryBuffer, but unused since everything's using MemoryBufferCompat) without any usage, yeah?

(2) changes all downstream clients of MemoryBuffer APIs from std::error_code to Error

• Mostly will cause build failures
• Also runtime regressions, due to auto, etc.

The fix is to do a search/replace of MemoryBuffer:: to MemoryBufferCompat:: on only the downstream code.

• Splitting from (1) means you can sequence this change between (1) and (2) — code always builds.
• Splitting from (3) means you can do a simple search/replace. If (2) is packed up with (3) it seems a lot more awkward, since you have to avoid accidentally undoing (3) during the search/replace. Then if somehow (3) gets reverted you need to start over when it relands.

Plausible, though a fair bit more churn - I'd probably be up for it, though.

• Dave

[dblaikie]

In D109345#2990577, @dexonsmith wrote:

In D109345#2990527, @dblaikie wrote:

(were there other regressions I mentioned/should think about?)

I don't have specific concerns; I was just reading between the lines of your description...

Fair - probably my own hedging there.

1. Add using MemoryBufferCompat = MemoryBuffer and search/replace all static MemoryBuffer:: API calls over to MemoryBufferCompat::. No direct impact on downstreams.

Yeah, that's some of the extra churn I was thinking of/hoping to avoid - but yeah, it's probably worthwhile.

What's the benefit of having the extra step where everything's renamed twice? (if it's going to be a monolithic commit - as mentioned in (3)) Compared to doing the mass change while keeping the (1 & 2) pieces for backwards compatibility if needed?

Benefits I was seeing of splitting (1-3) up are:

• makes (2) easy for downstreams to integrate separately from (1) and (3) (see below for why (2) is interesting)
• prevents any reverts of (3) on main from resulting in churn in downstream efforts to migrate in response to (1-2)
• enables (3) to NOT be monolithic -- still debatable how useful it is, but if split up then individual pieces can run through buildbots separately (and be reverted separately)

2. Change MemoryBuffer to use Error and Expected, leaving behind std::error_code and ErrorOr wrappers in a no-longer-just-a-typedef MemoryBufferCompat. Easy for downstreams to temporarily revert, and cherry-pick once they've finished adapting in the example of (1).
3. Update all code to use the new APIs. Could be done all at once since it's mostly mechanical, as you said. Also an option to split up by component (e.g., maybe the llvm-symbolizer regression is okay, but it could be nice to get that reviewed separately / in isolation).
4. Delete MemoryBufferCompat. Downstreams can temporarily revert while they follow the example of on (3).

(Given that (1) and (2) are easy to write, you already have tree state for (4), and (3) is easy to create from (4), then I think you could construct the above commit sequence without having to redo all the work... then if you wanted to split (3) up from there it'd be easy enough.)

(2) seems like the commit mostly likely to cause functional regressions, and it'd be isolated and easy to revert/reapply (downstream and/or upstream) without much churn.

(3) would be more likely to cause regression? Presumably (2) is really uninteresting because it adds a new API (re-adding MemoryBuffer, but unused since everything's using MemoryBufferCompat) without any usage, yeah?

(2) changes all downstream clients of MemoryBuffer APIs from std::error_code to Error

• Mostly will cause build failures
• Also runtime regressions, due to auto, etc.

Oooh, right. Good point - thanks for walking me through it!

The fix is to do a search/replace of MemoryBuffer:: to MemoryBufferCompat:: on only the downstream code.

• Splitting from (1) means you can sequence this change between (1) and (2) — code always builds.
• Splitting from (3) means you can do a simple search/replace. If (2) is packed up with (3) it seems a lot more awkward, since you have to avoid accidentally undoing (3) during the search/replace. Then if somehow (3) gets reverted you need to start over when it relands.

Yeah, think I'm with you.

Given the amount of churn this means, though - reckon it's worth it? Reckon it needs more llvm-dev thread/buy-in/etc? Any other bike-shedding for MemoryBufferCompat? (MemoryBufferDeprecated? but I don't really mind)

[dexonsmith]

In D109345#2990612, @dblaikie wrote:

Given the amount of churn this means, though - reckon it's worth it? Reckon it needs more llvm-dev thread/buy-in/etc?

I think the churn is worth since my intuition is that it has high value for downstreams/clients (in terms of mitigating risk/etc.). (For example, the Swift compiler also uses MemoryBuffer and uses auto quite heavily.)

Not sure if this needs more buy-in, but probably worth communicating the plan on llvm-dev. If nothing else, makes it easy for relevant commits to point to it on lists.llvm.org. Could even add a working sed -e or perl command for the renames?

Any other bike-shedding for MemoryBufferCompat? (MemoryBufferDeprecated? but I don't really mind)

• MemoryBufferDeprecated SGTM (more descriptive than "compat"), MemoryBufferLegacy would work too
• MemoryBufferErrorCodeAPI is even more descriptive -- see related idea below
• could also rename all the (relevant) functions instead of the class... but since these are all static anyway renaming the class feels easier?

Thinking the names through gave me an idea for a refined staging:

1. Add MemoryBufferErrorAPI (wrapping APIs with errorOrToExpected) and MemoryBufferErrorCodeAPI (alias for MemoryBuffer) in the same commit.
2. Migrate in-tree callers to MemoryBufferErrorCodeAPI (via mass rename). (Could even move some to MemoryBufferErrorAPI?)
3. Update MemoryBuffer to use Error/Expected APIs, change MemoryBufferErrorAPI to an alias of it, and leave behind MemoryBufferErrorCodeAPI (wrapping APIs with expectedToErrorOr).
4. One or more commits:
   1. Migrate in-tree callers to MemoryBuffer.
   2. Delete MemoryBufferErrorAPI alias.
5. Delete MemoryBufferErrorCodeAPI wrappers.

The refinement is that the new (1) is better designed for cherry-picking to a stable branch:

• Isolated to MemoryBuffer (no changes to callers), making conflict resolution trivial.
• Downstreams / clients can migrate to MemoryBufferError without integrating the change to the default behaviour of MemoryBuffer.
• Particularly useful for clients that want to cherry-pick/merge changes between a branch that builds against ToT LLVM and one that builds against a "stable" version that predates the transition.

The new (3) and (5) are the same as the old (2) and (4) -- isolated changes that are easy to revert.

(But if you're not convinced, I think my previous idea for staging would still be a huge help.)

[dexonsmith]

In D109345#2992274, @dexonsmith wrote:

4. One or more commits:
   1. Migrate in-tree callers to MemoryBuffer.
   2. Delete MemoryBufferErrorAPI alias.
5. Delete MemoryBufferErrorCodeAPI wrappers.

(Potentially MemoryBufferErrorAPI and MemoryBufferErrorAPI could be kept across an LLVM release branch boundary to help LLVM clients that use those... not sure how useful that'd be?)

[dblaikie]

Thanks for the suggestions/details, @dexonsmith - I've posted to llvm-dev here: https://groups.google.com/g/llvm-dev/c/m9UVRhzJvh4/m/qdd_SyPuCQAJ and will wait for some follow-up (or dead silence) before starting along probably your latter suggestion.

[dexonsmith]

In D109345#3008426, @dblaikie wrote:

Thanks for the suggestions/details, @dexonsmith - I've posted to llvm-dev here: https://groups.google.com/g/llvm-dev/c/m9UVRhzJvh4/m/qdd_SyPuCQAJ and will wait for some follow-up (or dead silence) before starting along probably your latter suggestion.

SGTM, thanks David!

clang-tools-extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

if (filename(I->path())[0] == '.') {
       continue;
     }
 
     if (extension(I->path()) != ".yaml")
       continue;
 
     TUFiles.push_back(I->path());
 
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Out =
+    Expected<std::unique_ptr<MemoryBuffer>> Out =
         MemoryBuffer::getFile(I->path());
-    if (std::error_code BufferError = Out.getError()) {
-      errs() << "Error reading " << I->path() << ": " << BufferError.message()
+    if (Error E = Out.takeError()) {
+      errs() << "Error reading " << I->path() << ": " << toString(std::move(E))
              << "\n";
       continue;
     }
 
     yaml::Input YIn(Out.get()->getBuffer(), nullptr, &eatDiagnostics);
     tooling::TranslationUnitReplacements TU;
     YIn >> TU;
     if (YIn.error()) {
if (filename(I->path())[0] == '.') {
       continue;
     }
 
     if (extension(I->path()) != ".yaml")
       continue;
 
     TUFiles.push_back(I->path());
 
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Out =
+    Expected<std::unique_ptr<MemoryBuffer>> Out =
         MemoryBuffer::getFile(I->path());
-    if (std::error_code BufferError = Out.getError()) {
-      errs() << "Error reading " << I->path() << ": " << BufferError.message()
+    if (Error E = Out.takeError()) {
+      errs() << "Error reading " << I->path() << ": " << toString(std::move(E))
              << "\n";
       continue;
     }
 
     yaml::Input YIn(Out.get()->getBuffer(), nullptr, &eatDiagnostics);
     tooling::TranslationUnitDiagnostics TU;
     YIn >> TU;
     if (YIn.error()) {

clang-tools-extra/clang-change-namespace/tool/ClangChangeNamespace.cpp

cl::opt<std::string> AllowedFile(
     cl::init(""), cl::cat(ChangeNamespaceCategory));
 
 llvm::ErrorOr<std::vector<std::string>> GetAllowedSymbolPatterns() {
   std::vector<std::string> Patterns;
   if (AllowedFile.empty())
     return Patterns;
 
   llvm::SmallVector<StringRef, 8> Lines;
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> File =
       llvm::MemoryBuffer::getFile(AllowedFile);
-  if (!File)
-    return File.getError();
+  if (Error E = File.takeError())
+    return errorToErrorCode(std::move(E));
   llvm::StringRef Content = File.get()->getBuffer();
   Content.split(Lines, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
   for (auto Line : Lines)
     Patterns.push_back(std::string(Line.trim()));
   return Patterns;
 }
 
 } // anonymous namespace

clang-tools-extra/clang-include-fixer/FuzzySymbolIndex.cpp

for (size_t I = 0; I < Tokens.size(); ++I) {
     }
   }
   return Result;
 }
 
 llvm::Expected<std::unique_ptr<FuzzySymbolIndex>>
 FuzzySymbolIndex::createFromYAML(StringRef FilePath) {
   auto Buffer = llvm::MemoryBuffer::getFile(FilePath);
-  if (!Buffer)
-    return llvm::errorCodeToError(Buffer.getError());
+  if (llvm::Error E = Buffer.takeError())
+    return E;
   return std::make_unique<MemSymbolIndex>(
       find_all_symbols::ReadSymbolInfosFromYAML(Buffer.get()->getBuffer()));
 }
 
 } // namespace include_fixer
 } // namespace clang

clang-tools-extra/clang-include-fixer/YamlSymbolIndex.cpp

 using clang::find_all_symbols::SymbolAndSignals;
 
 namespace clang {
 namespace include_fixer {
 
 llvm::ErrorOr<std::unique_ptr<YamlSymbolIndex>>
 YamlSymbolIndex::createFromFile(llvm::StringRef FilePath) {
   auto Buffer = llvm::MemoryBuffer::getFile(FilePath);
-  if (!Buffer)
-    return Buffer.getError();
+  if (llvm::Error E = Buffer.takeError())
+    return errorToErrorCode(std::move(E));
 
   return std::unique_ptr<YamlSymbolIndex>(new YamlSymbolIndex(
       find_all_symbols::ReadSymbolInfosFromYAML(Buffer.get()->getBuffer())));
 }
 
 llvm::ErrorOr<std::unique_ptr<YamlSymbolIndex>>
 YamlSymbolIndex::createFromDirectory(llvm::StringRef Directory,
                                      llvm::StringRef Name) {

clang-tools-extra/clang-include-fixer/tool/ClangIncludeFixer.cpp

int includeFixerMain(int argc, const char **argv) {
   llvm::StringRef SourceFilePath = options.getSourcePathList().front();
   // In STDINMode, we override the file content with the <stdin> input.
   // Since `tool.mapVirtualFile` takes `StringRef`, we define `Code` outside of
   // the if-block so that `Code` is not released after the if-block.
   std::unique_ptr<llvm::MemoryBuffer> Code;
   if (STDINMode) {
     assert(options.getSourcePathList().size() == 1 &&
            "Expect exactly one file path in STDINMode.");
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CodeOrErr =
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> CodeOrErr =
         MemoryBuffer::getSTDIN();
-    if (std::error_code EC = CodeOrErr.getError()) {
-      errs() << EC.message() << "\n";
+    if (Error E = CodeOrErr.takeError()) {
+      errs() << toString(std::move(E)) << "\n";
       return 1;
     }
     Code = std::move(CodeOrErr.get());
     if (Code->getBufferSize() == 0)
       return 0;  // Skip empty files.
 
     tool.mapVirtualFile(SourceFilePath, Code->getBuffer());
   }
for (const auto &Context : Contexts) {
     StringRef FilePath = Context.getFilePath();
     auto InsertStyle =
         format::getStyle(format::DefaultFormatStyle, FilePath, Style);
     if (!InsertStyle) {
       llvm::errs() << llvm::toString(InsertStyle.takeError()) << "\n";
       return 1;
     }
     auto Buffer = llvm::MemoryBuffer::getFile(FilePath);
-    if (!Buffer) {
+    if (Error E = Buffer.takeError()) {
       errs() << "Couldn't open file: " + FilePath.str() + ": "
-             << Buffer.getError().message() + "\n";
+             << toString(std::move(E)) + "\n";
       return 1;
     }
 
     auto Replacements = clang::include_fixer::createIncludeFixerReplacements(
         Buffer.get()->getBuffer(), Context, *InsertStyle);
     if (!Replacements) {
       errs() << "Failed to create replacement: "
              << llvm::toString(Replacements.takeError()) << "\n";

clang-tools-extra/clang-query/tool/ClangQuery.cpp

 static cl::opt<std::string> PreloadFile(
     "preload",
     cl::desc("Preload commands from file and start interactive mode"),
     cl::value_desc("file"), cl::cat(ClangQueryCategory));
 
 bool runCommandsInFile(const char *ExeName, std::string const &FileName,
                        QuerySession &QS) {
   auto Buffer = llvm::MemoryBuffer::getFile(FileName);
-  if (!Buffer) {
+  if (Error E = Buffer.takeError()) {
     llvm::errs() << ExeName << ": cannot open " << FileName << ": "
-                 << Buffer.getError().message() << "\n";
+                 << toString(std::move(E)) << "\n";
     return true;
   }
 
   StringRef FileContentRef(Buffer.get()->getBuffer());
 
   while (!FileContentRef.empty()) {
     QueryRef Q = QueryParser::parse(FileContentRef, QS);
     if (!Q->run(llvm::outs(), QS))

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

static std::unique_ptr<ClangTidyOptionsProvider> createOptionsProvider(
 
   if (ConfigFile.getNumOccurrences() > 0) {
     if (Config.getNumOccurrences() > 0) {
       llvm::errs() << "Error: --config-file and --config are "
                       "mutually exclusive. Specify only one.\n";
       return nullptr;
     }
 
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> Text =
         llvm::MemoryBuffer::getFile(ConfigFile);
-    if (std::error_code EC = Text.getError()) {
+    if (Error E = Text.takeError()) {
       llvm::errs() << "Error: can't read config-file '" << ConfigFile
-                   << "': " << EC.message() << "\n";
+                   << "': " << toString(std::move(E)) << "\n";
       return nullptr;
     }
 
     return LoadConfig((*Text)->getBuffer(), ConfigFile);
   }
 
   if (Config.getNumOccurrences() > 0)
     return LoadConfig(Config, "<command-line-config>");

clang-tools-extra/clangd/CompileCommands.cpp

if (Ret != 0) {
     log("xcrun exists but failed with code {0}. "
         "If you have a non-apple toolchain, this is OK. "
         "Otherwise, try xcode-select --install.",
         Ret);
     return llvm::None;
   }
 
   auto Buf = llvm::MemoryBuffer::getFile(OutFile);
-  if (!Buf) {
-    log("Can't read xcrun output: {0}", Buf.getError().message());
+  if (llvm::Error E = Buf.takeError()) {
+    log("Can't read xcrun output: {0}", toString(std::move(E)));
     return llvm::None;
   }
   StringRef Path = Buf->get()->getBuffer().trim();
   if (Path.empty()) {
     log("xcrun produced no output");
     return llvm::None;
   }
   return Path.str();

clang-tools-extra/clangd/QueryDriverDatabase.cpp

if (int RC = llvm::sys::ExecuteAndWait(Driver, Args, /*Env=*/llvm::None,
                                          /*MemoryLimit=*/0, &ErrMsg)) {
     elog("System include extraction: driver execution failed with return code: "
          "{0} - '{1}'. Args: [{2}]",
          llvm::to_string(RC), ErrMsg, printArgv(Args));
     return llvm::None;
   }
 
   auto BufOrError = llvm::MemoryBuffer::getFile(StdErrPath);
-  if (!BufOrError) {
+  if (llvm::Error E = BufOrError.takeError()) {
     elog("System include extraction: failed to read {0} with error {1}",
-         StdErrPath, BufOrError.getError().message());
+         StdErrPath, toString(std::move(E)));
     return llvm::None;
   }
 
   llvm::Optional<DriverInfo> Info =
       parseDriverOutput(BufOrError->get()->getBuffer());
   if (!Info)
     return llvm::None;
   log("System includes extractor: successfully executed {0}\n\tgot includes: "

clang-tools-extra/clangd/index/BackgroundIndexStorage.cpp

DiskBackedIndexStorage(llvm::StringRef Directory) : DiskShardRoot(Directory) {
     }
   }
 
   std::unique_ptr<IndexFileIn>
   loadShard(llvm::StringRef ShardIdentifier) const override {
     const std::string ShardPath =
         getShardPathFromFilePath(DiskShardRoot, ShardIdentifier);
     auto Buffer = llvm::MemoryBuffer::getFile(ShardPath);
-    if (!Buffer)
+    if (!Buffer) {
+      consumeError(Buffer.takeError());
       return nullptr;
+    }
     if (auto I = readIndexFile(Buffer->get()->getBuffer()))
       return std::make_unique<IndexFileIn>(std::move(*I));
     else
       elog("Error while reading shard {0}: {1}", ShardIdentifier,
            I.takeError());
     return nullptr;
   }
 

clang-tools-extra/clangd/index/Serialization.cpp

return error("Not a RIFF file and failed to parse as YAML: {0}",
                  YAMLContents.takeError());
   }
 }
 
 std::unique_ptr<SymbolIndex> loadIndex(llvm::StringRef SymbolFilename,
                                        bool UseDex) {
   trace::Span OverallTracer("LoadIndex");
   auto Buffer = llvm::MemoryBuffer::getFile(SymbolFilename);
-  if (!Buffer) {
-    elog("Can't open {0}: {1}", SymbolFilename, Buffer.getError().message());
+  if (llvm::Error E = Buffer.takeError()) {
+    elog("Can't open {0}: {1}", SymbolFilename, toString(std::move(E)));
     return nullptr;
   }
 
   SymbolSlab Symbols;
   RefSlab Refs;
   RelationSlab Relations;
   {
     trace::Span Tracer("ParseIndex");

clang-tools-extra/modularize/ModularizeUtilities.cpp

 //===--- extra/modularize/ModularizeUtilities.cpp -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a class for loading and validating a module map or
 // header list by checking that all headers in the corresponding directories
 // are accounted for.
 //
 //===----------------------------------------------------------------------===//
 
+#include "ModularizeUtilities.h"
+#include "CoverageChecker.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
-#include "CoverageChecker.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
-#include "ModularizeUtilities.h"
 
 using namespace clang;
 using namespace llvm;
 using namespace Modularize;
 
 namespace {
 // Subclass TargetOptions so we can construct it inline with
 // the minimal option, the triple.
std::error_code ModularizeUtilities::loadSingleHeaderListsAndDependencies(
   SmallString<256> CurrentDirectory;
   llvm::sys::fs::current_path(CurrentDirectory);
 
   // Get the prefix if we have one.
   if (HeaderPrefix.size() != 0)
     HeaderDirectory = HeaderPrefix;
 
   // Read the header list file into a buffer.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> listBuffer =
+  Expected<std::unique_ptr<MemoryBuffer>> listBuffer =
       MemoryBuffer::getFile(InputPath);
-  if (std::error_code EC = listBuffer.getError())
-    return EC;
+  if (Error E = listBuffer.takeError()) {
+    return errorToErrorCode(std::move(E));
+  }
 
   // Parse the header list into strings.
   SmallVector<StringRef, 32> Strings;
   listBuffer.get()->getBuffer().split(Strings, "\n", -1, false);
 
   // Collect the header file names from the string list.
   for (SmallVectorImpl<StringRef>::iterator I = Strings.begin(),
     E = Strings.end();
std::error_code ModularizeUtilities::loadProblemHeaderList(
   SmallString<256> CurrentDirectory;
   llvm::sys::fs::current_path(CurrentDirectory);
 
   // Get the prefix if we have one.
   if (HeaderPrefix.size() != 0)
     HeaderDirectory = HeaderPrefix;
 
   // Read the header list file into a buffer.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> listBuffer =
+  Expected<std::unique_ptr<MemoryBuffer>> listBuffer =
       MemoryBuffer::getFile(InputPath);
-  if (std::error_code EC = listBuffer.getError())
-    return EC;
+  if (Error E = listBuffer.takeError())
+    return errorToErrorCode(std::move(E));
 
   // Parse the header list into strings.
   SmallVector<StringRef, 32> Strings;
   listBuffer.get()->getBuffer().split(Strings, "\n", -1, false);
 
   // Collect the header file names from the string list.
   for (SmallVectorImpl<StringRef>::iterator I = Strings.begin(),
     E = Strings.end();

clang/include/clang/Basic/DiagnosticFrontendKinds.td

def err_fe_invalid_alignment : Error<
     "invalid value '%1' in '%0'; alignment must be a power of 2">;
 def err_fe_invalid_exception_model
    : Error<"invalid exception model '%select{none|sjlj|seh|dwarf|wasm}0' for target '%1'">;
 def warn_fe_concepts_ts_flag : Warning<
   "-fconcepts-ts is deprecated - use '-std=c++20' for Concepts support">,
   InGroup<Deprecated>;
 
 def err_fe_unable_to_load_basic_block_sections_file : Error<
-    "unable to load basic block sections function list: '%0'">;
+    "unable to load basic block sections function list: %0">;
 
 def warn_fe_serialized_diag_merge_failure : Warning<
     "unable to merge a subprocess's serialized diagnostics">,
     InGroup<SerializedDiagnostics>;
 def warn_fe_serialized_diag_failure : Warning<
     "unable to open file %0 for serializing diagnostics (%1)">,
     InGroup<SerializedDiagnostics>;
 def warn_fe_serialized_diag_failure_during_finalisation : Warning<

clang/lib/ARCMigrate/FileRemapper.cpp

bool FileRemapper::initFromFile(StringRef filePath, DiagnosticsEngine &Diag,
   assert(FromToMappings.empty() &&
          "initFromDisk should be called before any remap calls");
   std::string infoFile = std::string(filePath);
   if (!llvm::sys::fs::exists(infoFile))
     return false;
 
   std::vector<std::pair<const FileEntry *, const FileEntry *> > pairs;
 
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileBuf =
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> fileBuf =
       llvm::MemoryBuffer::getFile(infoFile, /*IsText=*/true);
-  if (!fileBuf)
-    return report("Error opening file: " + infoFile, Diag);
+  if (llvm::Error E = fileBuf.takeError())
+    return report("Error opening file: " + infoFile + ": " +
+                      toString(std::move(E)),
+                  Diag);
 
   SmallVector<StringRef, 64> lines;
   fileBuf.get()->getBuffer().split(lines, "\n");
 
   for (unsigned idx = 0; idx+3 <= lines.size(); idx += 3) {
     StringRef fromFilename = lines[idx];
     unsigned long long timeModified;
     if (lines[idx+1].getAsInteger(10, timeModified))

clang/lib/ARCMigrate/ObjCMT.cpp

class RemapFileParser {
   FileManager &FileMgr;
 
 public:
   RemapFileParser(FileManager &FileMgr) : FileMgr(FileMgr) { }
 
   bool parse(StringRef File, SmallVectorImpl<EditEntry> &Entries) {
     using namespace llvm::yaml;
 
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileBufOrErr =
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> FileBufOrErr =
         llvm::MemoryBuffer::getFile(File);
-    if (!FileBufOrErr)
+    if (llvm::Error E = FileBufOrErr.takeError()) {
+      consumeError(std::move(E));
       return true;
+    }
 
     llvm::SourceMgr SM;
     Stream YAMLStream(FileBufOrErr.get()->getMemBufferRef(), SM);
     document_iterator I = YAMLStream.begin();
     if (I == YAMLStream.end())
       return true;
     Node *Root = I->getRoot();
     if (!Root)

clang/lib/Basic/FileManager.cpp

llvm::Expected<FileEntryRef> FileManager::getSTDIN() {
   // Only read stdin once.
   if (STDIN)
     return *STDIN;
 
   std::unique_ptr<llvm::MemoryBuffer> Content;
   if (auto ContentOrError = llvm::MemoryBuffer::getSTDIN())
     Content = std::move(*ContentOrError);
   else
-    return llvm::errorCodeToError(ContentOrError.getError());
+    return ContentOrError.takeError();
 
   STDIN = getVirtualFileRef(Content->getBufferIdentifier(),
                             Content->getBufferSize(), 0);
   FileEntry &FE = const_cast<FileEntry &>(STDIN->getFileEntry());
   FE.Content = std::move(Content);
   FE.IsNamedPipe = true;
   return *STDIN;
 }

clang/lib/CodeGen/BackendUtil.cpp

Options.BBSections =
       llvm::StringSwitch<llvm::BasicBlockSection>(CodeGenOpts.BBSections)
           .Case("all", llvm::BasicBlockSection::All)
           .Case("labels", llvm::BasicBlockSection::Labels)
           .StartsWith("list=", llvm::BasicBlockSection::List)
           .Case("none", llvm::BasicBlockSection::None)
           .Default(llvm::BasicBlockSection::None);
 
   if (Options.BBSections == llvm::BasicBlockSection::List) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> MBOrErr =
         MemoryBuffer::getFile(CodeGenOpts.BBSections.substr(5));
-    if (!MBOrErr) {
+    if (Error E = MBOrErr.takeError()) {
       Diags.Report(diag::err_fe_unable_to_load_basic_block_sections_file)
-          << MBOrErr.getError().message();
+          << toString(std::move(E));
       return false;
     }
     Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
   }
 
   Options.EnableMachineFunctionSplitter = CodeGenOpts.SplitMachineFunctions;
   Options.FunctionSections = CodeGenOpts.FunctionSections;
   Options.DataSections = CodeGenOpts.DataSections;

clang/lib/CodeGen/CGCUDANV.cpp

llvm::StructType *FatbinWrapperTy =
       llvm::StructType::get(IntTy, IntTy, VoidPtrTy, VoidPtrTy);
 
   // Register GPU binary with the CUDA runtime, store returned handle in a
   // global variable and save a reference in GpuBinaryHandle to be cleaned up
   // in destructor on exit. Then associate all known kernels with the GPU binary
   // handle so CUDA runtime can figure out what to call on the GPU side.
   std::unique_ptr<llvm::MemoryBuffer> CudaGpuBinary = nullptr;
   if (!CudaGpuBinaryFileName.empty()) {
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CudaGpuBinaryOrErr =
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> CudaGpuBinaryOrErr =
         llvm::MemoryBuffer::getFileOrSTDIN(CudaGpuBinaryFileName);
-    if (std::error_code EC = CudaGpuBinaryOrErr.getError()) {
+    if (llvm::Error E = CudaGpuBinaryOrErr.takeError()) {
       CGM.getDiags().Report(diag::err_cannot_open_file)
-          << CudaGpuBinaryFileName << EC.message();
+          << CudaGpuBinaryFileName << toString(std::move(E));
       return nullptr;
     }
     CudaGpuBinary = std::move(CudaGpuBinaryOrErr.get());
   }
 
   llvm::Function *ModuleCtorFunc = llvm::Function::Create(
       llvm::FunctionType::get(VoidTy, VoidPtrTy, false),
       llvm::GlobalValue::InternalLinkage,

clang/lib/CodeGen/CGOpenMPRuntime.cpp

void CGOpenMPRuntime::loadOffloadInfoMetadata() {
 
   if (!CGM.getLangOpts().OpenMPIsDevice)
     return;
 
   if (CGM.getLangOpts().OMPHostIRFile.empty())
     return;
 
   auto Buf = llvm::MemoryBuffer::getFile(CGM.getLangOpts().OMPHostIRFile);
-  if (auto EC = Buf.getError()) {
+  if (llvm::Error E = Buf.takeError()) {
     CGM.getDiags().Report(diag::err_cannot_open_file)
-        << CGM.getLangOpts().OMPHostIRFile << EC.message();
+        << CGM.getLangOpts().OMPHostIRFile << toString(std::move(E));
     return;
   }
 
   llvm::LLVMContext C;
   auto ME = expectedToErrorOrAndEmitErrors(
       C, llvm::parseBitcodeFile(Buf.get()->getMemBufferRef(), C));
 
   if (auto EC = ME.getError()) {

clang/lib/CrossTU/CrossTranslationUnit.cpp

 
 llvm::Error CrossTranslationUnitContext::ASTLoader::lazyInitInvocationList() {
   /// Lazily initialize the invocation list member used for on-demand parsing.
   if (InvocationList)
     return llvm::Error::success();
   if (index_error_code::success != PreviousParsingResult)
     return llvm::make_error<IndexError>(PreviousParsingResult);
 
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileContent =
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> FileContent =
       llvm::MemoryBuffer::getFile(InvocationListFilePath);
-  if (!FileContent) {
+  if (llvm::Error E = FileContent.takeError()) {
+    consumeError(std::move(E));
     PreviousParsingResult = index_error_code::invocation_list_file_not_found;
     return llvm::make_error<IndexError>(PreviousParsingResult);
   }
   std::unique_ptr<llvm::MemoryBuffer> ContentBuffer = std::move(*FileContent);
   assert(ContentBuffer && "If no error was produced after loading, the pointer "
                           "should not be nullptr.");
 
   llvm::Expected<InvocationListTy> ExpectedInvocationList =

clang/lib/Driver/Driver.cpp

#endif
   // by this driver invocation.
   for (fs::directory_iterator File(CrashDiagDir, EC), FileEnd;
        File != FileEnd && !EC; File.increment(EC)) {
     StringRef FileName = path::filename(File->path());
     if (!FileName.startswith(Name))
       continue;
     if (fs::status(File->path(), FileStatus))
       continue;
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CrashFile =
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> CrashFile =
         llvm::MemoryBuffer::getFile(File->path());
-    if (!CrashFile)
+    if (llvm::Error E = CrashFile.takeError()) {
+      consumeError(std::move(E));
       continue;
+    }
     // The first line should start with "Process:", otherwise this isn't a real
     // .crash file.
     StringRef Data = CrashFile.get()->getBuffer();
     if (!Data.startswith("Process:"))
       continue;
     // Parse parent process pid line, e.g: "Parent Process: clang-4.0 [79141]"
     size_t ParentProcPos = Data.find("Parent Process:");
     if (ParentProcPos == StringRef::npos)

clang/lib/Driver/ToolChains/AMDGPU.cpp

if (int Result = llvm::sys::ExecuteAndWait(
     } else {
       ErrorMessage = "Crashed: " + ErrorMessage;
     }
 
     return llvm::createStringError(std::error_code(),
                                    Program + ": " + ErrorMessage);
   }
 
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> OutputBuf =
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> OutputBuf =
       llvm::MemoryBuffer::getFile(OutputFile.c_str());
-  if (!OutputBuf) {
-    return llvm::createStringError(OutputBuf.getError(),
-                                   "Failed to read stdout of " + Program +
-                                       ": " + OutputBuf.getError().message());
+  if (llvm::Error E = OutputBuf.takeError()) {
+    return llvm::make_error<llvm::StringError>(
+        "Failed to read stdout of " + Program + ": " + toString(std::move(E)),
+        llvm::inconvertibleErrorCode());
   }
 
   for (llvm::line_iterator LineIt(**OutputBuf); !LineIt.is_at_end(); ++LineIt) {
     GPUArchs.push_back(LineIt->str());
   }
   return llvm::Error::success();
 }
 
ROCMToolChain::getCommonDeviceLibNames(const llvm::opt::ArgList &DriverArgs,
   bool CorrectSqrt = DriverArgs.hasFlag(
       options::OPT_fhip_fp32_correctly_rounded_divide_sqrt,
       options::OPT_fno_hip_fp32_correctly_rounded_divide_sqrt);
   bool Wave64 = isWave64(DriverArgs, Kind);
 
   return RocmInstallation.getCommonBitcodeLibs(
       DriverArgs, LibDeviceFile, Wave64, DAZ, FiniteOnly, UnsafeMathOpt,
       FastRelaxedMath, CorrectSqrt);
-}
+}
 

clang/lib/Frontend/CompilerInstance.cpp

 static void collectVFSEntries(CompilerInstance &CI,
                               std::shared_ptr<ModuleDependencyCollector> MDC) {
   if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
     return;
 
   // Collect all VFS found.
   SmallVector<llvm::vfs::YAMLVFSEntry, 16> VFSEntries;
   for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
         llvm::MemoryBuffer::getFile(VFSFile);
-    if (!Buffer)
+    if (llvm::Error E = Buffer.takeError()) {
+      consumeError(std::move(E));
       return;
+    }
     llvm::vfs::collectVFSFromYAML(std::move(Buffer.get()),
                                   /*DiagHandler*/ nullptr, VFSFile, VFSEntries);
   }
 
   for (auto &E : VFSEntries)
     MDC->addFile(E.VPath, E.RPath);
 }
 

clang/lib/Serialization/GlobalModuleIndex.cpp

 
 std::pair<GlobalModuleIndex *, llvm::Error>
 GlobalModuleIndex::readIndex(StringRef Path) {
   // Load the index file, if it's there.
   llvm::SmallString<128> IndexPath;
   IndexPath += Path;
   llvm::sys::path::append(IndexPath, IndexFileName);
 
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> BufferOrErr =
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> BufferOrErr =
       llvm::MemoryBuffer::getFile(IndexPath.c_str());
-  if (!BufferOrErr)
-    return std::make_pair(nullptr,
-                          llvm::errorCodeToError(BufferOrErr.getError()));
+  if (llvm::Error E = BufferOrErr.takeError())
+    return std::make_pair(nullptr, std::move(E));
   std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(BufferOrErr.get());
 
   /// The main bitstream cursor for the main block.
   llvm::BitstreamCursor Cursor(*Buffer);
 
   // Sniff for the signature.
   for (unsigned char C : {'B', 'C', 'G', 'I'}) {
     if (Expected<llvm::SimpleBitstreamCursor::word_t> Res = Cursor.Read(8)) {

clang/lib/Serialization/ModuleManager.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/DOTGraphTraits.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <algorithm>
 #include <cassert>
 #include <memory>
 #include <string>
if (std::unique_ptr<llvm::MemoryBuffer> Buffer = lookupBuffer(FileName)) {
     Entry->closeFile();
   } else if (getModuleCache().shouldBuildPCM(FileName)) {
     // Report that the module is out of date, since we tried (and failed) to
     // import it earlier.
     Entry->closeFile();
     return OutOfDate;
   } else {
     // Open the AST file.
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buf((std::error_code()));
-    if (FileName == "-") {
-      Buf = llvm::MemoryBuffer::getSTDIN();
-    } else {
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> Buf =
+        FileName == "-"
+            ? llvm::MemoryBuffer::getSTDIN()
+            :
             // Get a buffer of the file and close the file descriptor when done.
-      // The file is volatile because in a parallel build we expect multiple
-      // compiler processes to use the same module file rebuilding it if needed.
+            // The file is volatile because in a parallel build we expect
+            // multiple compiler processes to use the same module file
+            // rebuilding it if needed.
             //
-      // RequiresNullTerminator is false because module files don't need it, and
-      // this allows the file to still be mmapped.
-      Buf = FileMgr.getBufferForFile(NewModule->File,
+            // RequiresNullTerminator is false because module files don't need
+            // it, and this allows the file to still be mmapped.
+            llvm::errorOrToExpected(
+                FileMgr.getBufferForFile(NewModule->File,
                                          /*IsVolatile=*/true,
-                                     /*RequiresNullTerminator=*/false);
-    }
+                                         /*RequiresNullTerminator=*/false));
 
-    if (!Buf) {
-      ErrorStr = Buf.getError().message();
+    if (llvm::Error E = Buf.takeError()) {
+      ErrorStr = toString(std::move(E));
       return Missing;
     }
 
     NewModule->Buffer = &getModuleCache().addPCM(FileName, std::move(*Buf));
   }
 
   // Initialize the stream.
   NewModule->Data = PCHContainerRdr.ExtractPCH(*NewModule->Buffer);

clang/lib/Tooling/CompilationDatabase.cpp

FixedCompilationDatabase::loadFromCommandLine(int &Argc,
   if (!stripPositionalArgs(CommandLine, StrippedArgs, ErrorMsg))
     return nullptr;
   return std::make_unique<FixedCompilationDatabase>(Directory, StrippedArgs);
 }
 
 std::unique_ptr<FixedCompilationDatabase>
 FixedCompilationDatabase::loadFromFile(StringRef Path, std::string &ErrorMsg) {
   ErrorMsg.clear();
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> File =
       llvm::MemoryBuffer::getFile(Path);
-  if (std::error_code Result = File.getError()) {
-    ErrorMsg = "Error while opening fixed database: " + Result.message();
+  if (llvm::Error E = File.takeError()) {
+    ErrorMsg = "Error while opening fixed database: " + toString(std::move(E));
     return nullptr;
   }
   return loadFromBuffer(llvm::sys::path::parent_path(Path),
                         (*File)->getBuffer(), ErrorMsg);
 }
 
 std::unique_ptr<FixedCompilationDatabase>
 FixedCompilationDatabase::loadFromBuffer(StringRef Directory, StringRef Data,

clang/lib/Tooling/JSONCompilationDatabase.cpp

 } // namespace tooling
 } // namespace clang
 
 std::unique_ptr<JSONCompilationDatabase>
 JSONCompilationDatabase::loadFromFile(StringRef FilePath,
                                       std::string &ErrorMessage,
                                       JSONCommandLineSyntax Syntax) {
   // Don't mmap: if we're a long-lived process, the build system may overwrite.
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> DatabaseBuffer =
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> DatabaseBuffer =
       llvm::MemoryBuffer::getFile(FilePath, /*IsText=*/false,
                                   /*RequiresNullTerminator=*/true,
                                   /*IsVolatile=*/true);
-  if (std::error_code Result = DatabaseBuffer.getError()) {
-    ErrorMessage = "Error while opening JSON database: " + Result.message();
+  if (llvm::Error E = DatabaseBuffer.takeError()) {
+    ErrorMessage =
+        "Error while opening JSON database: " + toString(std::move(E));
     return nullptr;
   }
   std::unique_ptr<JSONCompilationDatabase> Database(
       new JSONCompilationDatabase(std::move(*DatabaseBuffer), Syntax));
   if (!Database->parse(ErrorMessage))
     return nullptr;
   return Database;
 }

clang/test/CodeGen/basic-block-sections.c

 // BB_ALL: .section .text.another,"ax",@progbits
 // BB_ALL: another.__part.1:
 // BB_LIST-NOT: .section .text.another,"ax",@progbits
 // BB_LIST: another:
 // BB_LIST-NOT: another.__part.1:
 //
 // UNIQUE: .section .text.world.world.__part.1,
 // UNIQUE: .section .text.another.another.__part.1,
-// ERROR: error:  unable to load basic block sections function list: '[[MSG]]'
+// ERROR: error:  unable to load basic block sections function list: '': [[MSG]]

clang/tools/apinotes-test/APINotesTest.cpp

int main(int argc, const char **argv) {
   auto Out = std::make_unique<llvm::ToolOutputFile>(OutputFileName, EC,
                                                     llvm::sys::fs::OF_None);
   if (EC) {
     Error("failed to open '" + OutputFileName + "': " + EC.message());
     return EXIT_FAILURE;
   }
 
   for (const std::string &Notes : APINotes) {
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> NotesOrError =
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> NotesOrError =
         llvm::MemoryBuffer::getFileOrSTDIN(Notes);
-    if (std::error_code EC = NotesOrError.getError()) {
-      llvm::errs() << EC.message() << '\n';
+    if (llvm::Error E = NotesOrError.takeError()) {
+      llvm::errs() << toString(std::move(E)) << '\n';
       return EXIT_FAILURE;
     }
 
     clang::api_notes::parseAndDumpAPINotes((*NotesOrError)->getBuffer(),
                                            Out->os());
   }
 
   return EXIT_SUCCESS;
 }

clang/tools/arcmt-test/arcmt-test.cpp

static bool performTransformations(StringRef resourcesPath,
   // FIXME: TestResultForARC
 
   return false;
 }
 
 static bool filesCompareEqual(StringRef fname1, StringRef fname2) {
   using namespace llvm;
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> file1 =
+  Expected<std::unique_ptr<MemoryBuffer>> file1 =
       MemoryBuffer::getFile(fname1, /*IsText=*/true);
-  if (!file1)
+  if (!file1) {
+    consumeError(file1.takeError());
     return false;
+  }
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> file2 =
+  Expected<std::unique_ptr<MemoryBuffer>> file2 =
       MemoryBuffer::getFile(fname2, /*IsText=*/true);
-  if (!file2)
+  if (!file2) {
+    consumeError(file2.takeError());
     return false;
+  }
 
   return file1.get()->getBuffer() == file2.get()->getBuffer();
 }
 
 static bool verifyTransformedFiles(ArrayRef<std::string> resultFiles) {
   using namespace llvm;
 
   assert(!resultFiles.empty());
 
   std::map<StringRef, StringRef> resultMap;
 
   for (ArrayRef<std::string>::iterator
          I = resultFiles.begin(), E = resultFiles.end(); I != E; ++I) {
     StringRef fname(*I);
     if (!fname.endswith(".result")) {
       errs() << "error: filename '" << fname
                    << "' does not have '.result' extension\n";
       return true;
     }
     resultMap[sys::path::stem(fname)] = fname;
   }
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> inputBuf = std::error_code();
-  if (RemappingsFile.empty())
-    inputBuf = MemoryBuffer::getSTDIN();
-  else
-    inputBuf = MemoryBuffer::getFile(RemappingsFile, /*IsText=*/true);
+  Expected<std::unique_ptr<MemoryBuffer>> inputBuf =
+      RemappingsFile.empty()
+          ? MemoryBuffer::getSTDIN()
+          : MemoryBuffer::getFile(RemappingsFile, /*IsText=*/true);
   if (!inputBuf) {
-    errs() << "error: could not read remappings input\n";
+    errs() << "error: could not read remappings input: " +
+                  toString(inputBuf.takeError()) + "\n";
     return true;
   }
 
   SmallVector<StringRef, 8> strs;
   inputBuf.get()->getBuffer().split(strs, "\n", /*MaxSplit=*/-1,
                                     /*KeepEmpty=*/false);
 
   if (strs.empty()) {

clang/tools/clang-format/ClangFormat.cpp

 // Returns true on error.
 static bool format(StringRef FileName) {
   if (!OutputXML && Inplace && FileName == "-") {
     errs() << "error: cannot use -i when reading from stdin.\n";
     return false;
   }
   // On Windows, overwriting a file with an open file mapping doesn't work,
   // so read the whole file into memory when formatting in-place.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> CodeOrErr =
       !OutputXML && Inplace ? MemoryBuffer::getFileAsStream(FileName)
                             : MemoryBuffer::getFileOrSTDIN(FileName);
-  if (std::error_code EC = CodeOrErr.getError()) {
-    errs() << EC.message() << "\n";
+  if (Error E = CodeOrErr.takeError()) {
+    errs() << toString(std::move(E)) << "\n";
     return true;
   }
   std::unique_ptr<llvm::MemoryBuffer> Code = std::move(CodeOrErr.get());
   if (Code->getBufferSize() == 0)
     return false; // Empty files are formatted correctly.
 
   StringRef BufStr = Code->getBuffer();
 
static int dumpConfig() {
   std::unique_ptr<llvm::MemoryBuffer> Code;
   if (FileNames.empty()) {
     // We can't read the code to detect the language if there's no
     // file name, so leave Code empty here.
     FileName = AssumeFileName;
   } else {
     // Read in the code in case the filename alone isn't enough to
     // detect the language.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> CodeOrErr =
         MemoryBuffer::getFileOrSTDIN(FileNames[0]);
-    if (std::error_code EC = CodeOrErr.getError()) {
-      llvm::errs() << EC.message() << "\n";
+    if (Error E = CodeOrErr.takeError()) {
+      errs() << toString(std::move(E)) << "\n";
       return 1;
     }
     FileName = (FileNames[0] == "-") ? AssumeFileName : FileNames[0];
     Code = std::move(CodeOrErr.get());
   }
   llvm::Expected<clang::format::FormatStyle> FormatStyle =
       clang::format::getStyle(Style, FileName, FallbackStyle,
                               Code ? Code->getBuffer() : "");

clang/tools/clang-nvlink-wrapper/ClangNvlinkWrapper.cpp

static Error runNVLink(std::string NVLinkPath,
   return Error::success();
 }
 
 static Error extractArchiveFiles(StringRef Filename,
                                  SmallVectorImpl<std::string> &Args,
                                  SmallVectorImpl<std::string> &TmpFiles) {
   std::vector<std::unique_ptr<MemoryBuffer>> ArchiveBuffers;
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename, false, false);
-  if (std::error_code EC = BufOrErr.getError())
-    return createFileError(Filename, EC);
+  if (Error E = BufOrErr.takeError())
+    return E;
 
   ArchiveBuffers.push_back(std::move(*BufOrErr));
   Expected<std::unique_ptr<llvm::object::Archive>> LibOrErr =
       object::Archive::create(ArchiveBuffers.back()->getMemBufferRef());
   if (!LibOrErr)
     return LibOrErr.takeError();
 
   auto Archive = std::move(*LibOrErr);

clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp

static Error BundleFiles() {
   raw_fd_ostream OutputFile(OutputFileNames.front(), EC, sys::fs::OF_None);
   if (EC)
     return createFileError(OutputFileNames.front(), EC);
 
   // Open input files.
   SmallVector<std::unique_ptr<MemoryBuffer>, 8u> InputBuffers;
   InputBuffers.reserve(InputFileNames.size());
   for (auto &I : InputFileNames) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> CodeOrErr =
         MemoryBuffer::getFileOrSTDIN(I);
-    if (std::error_code EC = CodeOrErr.getError())
-      return createFileError(I, EC);
+    if (Error E = CodeOrErr.takeError())
+      return E;
     InputBuffers.emplace_back(std::move(*CodeOrErr));
   }
 
   // Get the file handler. We use the host buffer as reference.
   assert((HostInputIndex != ~0u || AllowNoHost) &&
          "Host input index undefined??");
   Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
       CreateFileHandler(*InputBuffers[AllowNoHost ? 0 : HostInputIndex]);
for (auto &Triple : TargetNames) {
     ++Input;
   }
   return Error::success();
 }
 
 // List bundle IDs. Return true if an error was found.
 static Error ListBundleIDsInFile(StringRef InputFileName) {
   // Open Input file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> CodeOrErr =
       MemoryBuffer::getFileOrSTDIN(InputFileName);
-  if (std::error_code EC = CodeOrErr.getError())
-    return createFileError(InputFileName, EC);
+  if (Error E = CodeOrErr.takeError())
+    return E;
 
   MemoryBuffer &Input = **CodeOrErr;
 
   // Select the right files handler.
   Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
       CreateFileHandler(Input);
   if (!FileHandlerOrErr)
     return FileHandlerOrErr.takeError();
 
   std::unique_ptr<FileHandler> &FH = *FileHandlerOrErr;
   assert(FH);
   return FH->listBundleIDs(Input);
 }
 
 // Unbundle the files. Return true if an error was found.
 static Error UnbundleFiles() {
   // Open Input file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> CodeOrErr =
       MemoryBuffer::getFileOrSTDIN(InputFileNames.front());
-  if (std::error_code EC = CodeOrErr.getError())
-    return createFileError(InputFileNames.front(), EC);
+  if (Error E = CodeOrErr.takeError())
+    return E;
 
   MemoryBuffer &Input = **CodeOrErr;
 
   // Select the right files handler.
   Expected<std::unique_ptr<FileHandler>> FileHandlerOrErr =
       CreateFileHandler(Input);
   if (!FileHandlerOrErr)
     return FileHandlerOrErr.takeError();
static Error UnbundleArchive() {
 
   auto Output = OutputFileNames.begin();
   for (auto &Target : TargetNames) {
     TargetOutputFileNameMap[Target] = *Output;
     ++Output;
   }
 
   StringRef IFName = InputFileNames.front();
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFileOrSTDIN(IFName, true, false);
-  if (std::error_code EC = BufOrErr.getError())
-    return createFileError(InputFileNames.front(), EC);
+  if (Error E = BufOrErr.takeError())
+    return E;
 
   ArchiveBuffers.push_back(std::move(*BufOrErr));
   Expected<std::unique_ptr<llvm::object::Archive>> LibOrErr =
       Archive::create(ArchiveBuffers.back()->getMemBufferRef());
   if (!LibOrErr)
     return LibOrErr.takeError();
 
   auto Archive = std::move(*LibOrErr);

clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp

(void)sys::ExecuteAndWait(ObjcopyPath, Args,
                               /*MemoryLimit=*/0, &ErrMsg, &ExecutionFailed);
 
     if (ExecutionFailed) {
       warningOS() << ErrMsg << "\n";
       return Buf;
     }
 
     // Substitute the original ELF with new one.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
         MemoryBuffer::getFile(ELFTmpFileName);
-    if (!BufOrErr) {
-      handleErrorAsWarning(
-          createFileError(ELFTmpFileName, BufOrErr.getError()));
+    if (Error E = BufOrErr.takeError()) {
+      handleErrorAsWarning(std::move(E));
       return Buf;
     }
 
     return std::move(*BufOrErr);
   }
 };
 
 } // anonymous namespace
int main(int argc, const char **argv) {
   BinaryWrapper Wrapper(Target, argv[0]);
 
   // Read device binaries.
   SmallVector<std::unique_ptr<MemoryBuffer>, 4u> Buffers;
   SmallVector<ArrayRef<char>, 4u> Images;
   Buffers.reserve(Inputs.size());
   Images.reserve(Inputs.size());
   for (const std::string &File : Inputs) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
         MemoryBuffer::getFileOrSTDIN(File);
-    if (!BufOrErr) {
-      reportError(createFileError(File, BufOrErr.getError()));
+    if (Error E = BufOrErr.takeError()) {
+      reportError(std::move(E));
       return 1;
     }
     std::unique_ptr<MemoryBuffer> Buffer(std::move(*BufOrErr));
     if (File != "-" && AddOpenMPOffloadNotes) {
       // Adding ELF notes for STDIN is not supported yet.
       Buffer = Wrapper.addELFNotes(std::move(Buffer), File);
     }
     const std::unique_ptr<MemoryBuffer> &Buf =

clang/tools/clang-refactor/ClangRefactor.cpp

bool applySourceChanges() {
     std::set<std::string> Files;
     for (const auto &Change : Changes)
       Files.insert(Change.getFilePath());
     // FIXME: Add automatic formatting support as well.
     tooling::ApplyChangesSpec Spec;
     // FIXME: We should probably cleanup the result by default as well.
     Spec.Cleanup = false;
     for (const auto &File : Files) {
-      llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> BufferErr =
+      llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> BufferErr =
           llvm::MemoryBuffer::getFile(File);
-      if (!BufferErr) {
-        llvm::errs() << "error: failed to open " << File << " for rewriting\n";
+      if (llvm::Error E = BufferErr.takeError()) {
+        llvm::errs() << "error: failed to open " << File
+                     << " for rewriting: " + toString(std::move(E)) + "\n";
         return true;
       }
       auto Result = tooling::applyAtomicChanges(File, (*BufferErr)->getBuffer(),
                                                 Changes, Spec);
       if (!Result) {
         llvm::errs() << toString(Result.takeError());
         return true;
       }

clang/tools/clang-refactor/TestSupport.cpp

 bool printRewrittenSources(const tooling::AtomicChanges &Changes,
                            raw_ostream &OS) {
   std::set<std::string> Files;
   for (const auto &Change : Changes)
     Files.insert(Change.getFilePath());
   tooling::ApplyChangesSpec Spec;
   Spec.Cleanup = false;
   for (const auto &File : Files) {
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> BufferErr =
+    llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> BufferErr =
         llvm::MemoryBuffer::getFile(File);
-    if (!BufferErr) {
-      llvm::errs() << "failed to open" << File << "\n";
+    if (Error E = BufferErr.takeError()) {
+      llvm::errs() << "failed to open" << File << ": " << toString(std::move(E))
+                   << "\n";
       return true;
     }
     auto Result = tooling::applyAtomicChanges(File, (*BufferErr)->getBuffer(),
                                               Changes, Spec);
     if (!Result) {
       llvm::errs() << toString(Result.takeError());
       return true;
     }
private:
   }
 
   const TestSelectionRangesInFile &TestRanges;
   std::vector<std::vector<Expected<tooling::AtomicChanges>>> Results;
 };
 
 std::pair<unsigned, unsigned> getLineColumn(StringRef Filename,
                                             unsigned Offset) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> ErrOrFile =
+  Expected<std::unique_ptr<MemoryBuffer>> ErrOrFile =
       MemoryBuffer::getFile(Filename);
-  if (!ErrOrFile)
+  if (Error E = ErrOrFile.takeError()) {
+    consumeError(std::move(E));
     return {0, 0};
+  }
   StringRef Source = ErrOrFile.get()->getBuffer();
   Source = Source.take_front(Offset);
   size_t LastLine = Source.find_last_of("\r\n");
   return {Source.count('\n') + 1,
           (LastLine == StringRef::npos ? Offset : Offset - LastLine) + 1};
 }
 
 } // end anonymous namespace
static unsigned addEndLineOffsetAndEndColumn(StringRef Source, unsigned Offset,
   // Source now points to the line at +lineOffset;
   size_t LineStart = Source.find_last_of("\r\n", /*From=*/Offset + LineOffset);
   return addColumnOffset(
       Source, LineStart == StringRef::npos ? 0 : LineStart + 1, Column - 1);
 }
 
 Optional<TestSelectionRangesInFile>
 findTestSelectionRanges(StringRef Filename) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> ErrOrFile =
+  Expected<std::unique_ptr<MemoryBuffer>> ErrOrFile =
       MemoryBuffer::getFile(Filename);
-  if (!ErrOrFile) {
+  if (Error E = ErrOrFile.takeError()) {
     llvm::errs() << "error: -selection=test:" << Filename
-                 << " : could not open the given file";
+                 << " : could not open the given file: "
+                 << toString(std::move(E));
     return None;
   }
   StringRef Source = ErrOrFile.get()->getBuffer();
 
   // See the doc comment for this function for the explanation of this
   // syntax.
   static const Regex RangeRegex(
       "range[[:blank:]]*([[:alpha:]_]*)?[[:blank:]]*=[[:"

clang/tools/clang-rename/ClangRename.cpp

int main(int argc, const char **argv) {
   if (!ExpectedParser) {
     llvm::errs() << ExpectedParser.takeError();
     return 1;
   }
   tooling::CommonOptionsParser &OP = ExpectedParser.get();
 
   if (!Input.empty()) {
     // Populate QualifiedNames and NewNames from a YAML file.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
+    Expected<std::unique_ptr<MemoryBuffer>> Buffer =
         llvm::MemoryBuffer::getFile(Input);
-    if (!Buffer) {
+    if (Error E = Buffer.takeError()) {
       errs() << "clang-rename: failed to read " << Input << ": "
-             << Buffer.getError().message() << "\n";
+             << toString(std::move(E)) << "\n";
       return 1;
     }
 
     std::vector<RenameAllInfo> Infos;
     llvm::yaml::Input YAML(Buffer.get()->getBuffer());
     YAML >> Infos;
     for (const auto &Info : Infos) {
       if (!Info.QualifiedName.empty())

clang/tools/driver/cc1as_main.cpp

 static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
                                  DiagnosticsEngine &Diags) {
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
   if (!TheTarget)
     return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
+  Expected<std::unique_ptr<MemoryBuffer>> Buffer =
       MemoryBuffer::getFileOrSTDIN(Opts.InputFile, /*IsText=*/true);
 
-  if (std::error_code EC = Buffer.getError()) {
-    Error = EC.message();
+  if (llvm::Error E = Buffer.takeError()) {
+    Error = toString(std::move(E));
     return Diags.Report(diag::err_fe_error_reading) << Opts.InputFile;
   }
 
   SourceMgr SrcMgr;
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   unsigned BufferIndex = SrcMgr.AddNewSourceBuffer(std::move(*Buffer), SMLoc());
 

clang/tools/driver/cc1gen_reproducer_main.cpp

 int cc1gen_reproducer_main(ArrayRef<const char *> Argv, const char *Argv0,
                            void *MainAddr) {
   if (Argv.size() < 1) {
     llvm::errs() << "error: missing invocation file\n";
     return 1;
   }
   // Parse the invocation descriptor.
   StringRef Input = Argv[0];
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
       llvm::MemoryBuffer::getFile(Input, /*IsText=*/true);
-  if (!Buffer) {
+  if (llvm::Error E = Buffer.takeError()) {
     llvm::errs() << "error: failed to read " << Input << ": "
-                 << Buffer.getError().message() << "\n";
+                 << toString(std::move(E)) << "\n";
     return 1;
   }
   llvm::yaml::Input YAML(Buffer.get()->getBuffer());
   ClangInvocationInfo InvocationInfo;
   YAML >> InvocationInfo;
   if (Argv.size() > 1 && Argv[1] == StringRef("-v"))
     InvocationInfo.Dump = true;
 

lld/COFF/Driver.cpp

#if _WIN64
   // of threads
   auto strategy = std::launch::async;
 #else
   auto strategy = std::launch::deferred;
 #endif
   return std::async(strategy, [=]() {
     auto mbOrErr = MemoryBuffer::getFile(path, /*IsText=*/false,
                                          /*RequiresNullTerminator=*/false);
-    if (!mbOrErr)
-      return MBErrPair{nullptr, mbOrErr.getError()};
+    if (Error e = mbOrErr.takeError())
+      return MBErrPair{nullptr, errorToErrorCode(std::move(e))};
     return MBErrPair{std::move(*mbOrErr), std::error_code()};
   });
 }
 
 // Symbol names are mangled by prepending "_" on x86.
 static StringRef mangle(StringRef sym) {
   assert(config->machine != IMAGE_FILE_MACHINE_UNKNOWN);
   if (config->machine == I386)
static void createImportLibrary(bool asLib) {
   if (!config->incremental) {
     handleError(writeImportLibrary(libName, path, exports, config->machine,
                                    config->mingw));
     return;
   }
 
   // If the import library already exists, replace it only if the contents
   // have changed.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> oldBuf = MemoryBuffer::getFile(
+  Expected<std::unique_ptr<MemoryBuffer>> oldBuf = MemoryBuffer::getFile(
       path, /*IsText=*/false, /*RequiresNullTerminator=*/false);
-  if (!oldBuf) {
+  if (Error e = oldBuf.takeError()) {
+    consumeError(std::move(e));
     handleError(writeImportLibrary(libName, path, exports, config->machine,
                                    config->mingw));
     return;
   }
 
   SmallString<128> tmpName;
   if (std::error_code ec =
           sys::fs::createUniqueFile(path + ".tmp-%%%%%%%%.lib", tmpName))

lld/COFF/PDB.cpp

if (!config->debugGHashes) {
     printLargeInputTypeRecs("IPI", tMerger.ipiCounts, tMerger.getIDTable());
   }
 
   message(buffer);
 }
 
 void PDBLinker::addNatvisFiles() {
   for (StringRef file : config->natvisFiles) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> dataOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> dataOrErr =
         MemoryBuffer::getFile(file);
-    if (!dataOrErr) {
-      warn("Cannot open input file: " + file);
+    if (Error e = dataOrErr.takeError()) {
+      warn("Cannot open input file: " + file + ": " + toString(std::move(e)));
       continue;
     }
     std::unique_ptr<MemoryBuffer> data = std::move(*dataOrErr);
 
     // Can't use takeBuffer() here since addInjectedSource() takes ownership.
     if (driver->tar)
       driver->tar->append(relativeToRoot(data->getBufferIdentifier()),
                           data->getBuffer());
 
     builder.addInjectedSource(file, std::move(data));
   }
 }
 
 void PDBLinker::addNamedStreams() {
   for (const auto &streamFile : config->namedStreams) {
     const StringRef stream = streamFile.getKey(), file = streamFile.getValue();
-    ErrorOr<std::unique_ptr<MemoryBuffer>> dataOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> dataOrErr =
         MemoryBuffer::getFile(file);
-    if (!dataOrErr) {
-      warn("Cannot open input file: " + file);
+    if (Error e = dataOrErr.takeError()) {
+      warn("Cannot open input file: " + file + ": " + toString(std::move(e)));
       continue;
     }
     std::unique_ptr<MemoryBuffer> data = std::move(*dataOrErr);
     exitOnErr(builder.addNamedStream(stream, data->getBuffer()));
     driver->takeBuffer(std::move(data));
   }
 }
 

lld/ELF/InputFiles.cpp

Optional<MemoryBufferRef> elf::readFile(StringRef path) {
   if (!config->chroot.empty() && path.startswith("/"))
     path = saver.save(config->chroot + path);
 
   log(path);
   config->dependencyFiles.insert(llvm::CachedHashString(path));
 
   auto mbOrErr = MemoryBuffer::getFile(path, /*IsText=*/false,
                                        /*RequiresNullTerminator=*/false);
-  if (auto ec = mbOrErr.getError()) {
-    error("cannot open " + path + ": " + ec.message());
+  if (Error e = mbOrErr.takeError()) {
+    error("cannot open " + toString(std::move(e)));
     return None;
   }
 
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
 
   if (tar)

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   if (!config->ltoBasicBlockSections.empty()) {
     if (config->ltoBasicBlockSections == "all") {
       c.Options.BBSections = BasicBlockSection::All;
     } else if (config->ltoBasicBlockSections == "labels") {
       c.Options.BBSections = BasicBlockSection::Labels;
     } else if (config->ltoBasicBlockSections == "none") {
       c.Options.BBSections = BasicBlockSection::None;
     } else {
-      ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+      Expected<std::unique_ptr<MemoryBuffer>> MBOrErr =
           MemoryBuffer::getFile(config->ltoBasicBlockSections.str());
-      if (!MBOrErr) {
+      if (Error E = MBOrErr.takeError()) {
         error("cannot open " + config->ltoBasicBlockSections + ":" +
-              MBOrErr.getError().message());
+              toString(std::move(E)));
       } else {
         c.Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
       }
       c.Options.BBSections = BasicBlockSection::List;
     }
   }
 
   c.Options.PseudoProbeForProfiling = config->ltoPseudoProbeForProfiling;

lld/MachO/InputFiles.cpp

warn(toString(input) + " has version " + it->minimum.getAsString() +
          ", which is newer than target minimum of " +
          config->platformInfo.minimum.getAsString());
 
   return true;
 }
 
 // Open a given file path and return it as a memory-mapped file.
 Optional<MemoryBufferRef> macho::readFile(StringRef path) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = MemoryBuffer::getFile(path);
-  if (std::error_code ec = mbOrErr.getError()) {
-    error("cannot open " + path + ": " + ec.message());
+  Expected<std::unique_ptr<MemoryBuffer>> mbOrErr = MemoryBuffer::getFile(path);
+  if (Error e = mbOrErr.takeError()) {
+    error("cannot open " + toString(std::move(e)));
     return None;
   }
 
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take mb ownership
 
   // If this is a regular non-fat file, return it.

lld/lib/Driver/DarwinLdDriver.cpp

for (std::unique_ptr<File> &file : files)
     ctx.getNodes().push_back(std::make_unique<FileNode>(std::move(file)));
 }
 
 // Export lists are one symbol per line.  Blank lines are ignored.
 // Trailing comments start with #.
 static std::error_code parseExportsList(StringRef exportFilePath,
                                         MachOLinkingContext &ctx) {
   // Map in export list file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
-                                   MemoryBuffer::getFileOrSTDIN(exportFilePath);
-  if (std::error_code ec = mb.getError())
-    return ec;
+  Expected<std::unique_ptr<MemoryBuffer>> mb =
+  if (Error e = mb.takeError())
+    return llvm::errorToErrorCode(std::move(e));
   ctx.addInputFileDependency(exportFilePath);
   StringRef buffer = mb->get()->getBuffer();
   while (!buffer.empty()) {
     // Split off each line in the file.
     std::pair<StringRef, StringRef> lineAndRest = buffer.split('\n');
     StringRef line = lineAndRest.first;
     // Ignore trailing # comments.
     std::pair<StringRef, StringRef> symAndComment = line.split('#');

 /// architecture name and/or .o leaf name.  Examples:
 ///     _foo
 ///     bar.o:_bar
 ///     libfrob.a(bar.o):_bar
 ///     x86_64:_foo64
 static std::error_code parseOrderFile(StringRef orderFilePath,
                                       MachOLinkingContext &ctx) {
   // Map in order file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
-                                   MemoryBuffer::getFileOrSTDIN(orderFilePath);
-  if (std::error_code ec = mb.getError())
-    return ec;
+  Expected<std::unique_ptr<MemoryBuffer>> mb =
+  if (Error e = mb.takeError())
+    return llvm::errorToErrorCode(std::move(e));
   ctx.addInputFileDependency(orderFilePath);
   StringRef buffer = mb->get()->getBuffer();
   while (!buffer.empty()) {
     // Split off each line in the file.
     std::pair<StringRef, StringRef> lineAndRest = buffer.split('\n');
     StringRef line = lineAndRest.first;
     buffer = lineAndRest.second;
     // Ignore trailing # comments.

 static llvm::Error loadFileList(StringRef fileListPath,
                                 MachOLinkingContext &ctx, bool forceLoad) {
   // If there is a comma, split off <dir>.
   std::pair<StringRef, StringRef> opt = fileListPath.split(',');
   StringRef filePath = opt.first;
   StringRef dirName = opt.second;
   ctx.addInputFileDependency(filePath);
   // Map in file list file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
-                                        MemoryBuffer::getFileOrSTDIN(filePath);
-  if (std::error_code ec = mb.getError())
-    return llvm::errorCodeToError(ec);
+  Expected<std::unique_ptr<MemoryBuffer>> mb =
+  if (Error e = mb.takeError())
+    return e;
   StringRef buffer = mb->get()->getBuffer();
   while (!buffer.empty()) {
     // Split off each line in the file.
     std::pair<StringRef, StringRef> lineAndRest = buffer.split('\n');
     StringRef line = lineAndRest.first;
     StringRef path;
     if (!dirName.empty()) {
       // If there is a <dir> then prepend dir to each line.
case OPT_filelist:
         return false;
       }
       break;
     case OPT_sectcreate: {
         const char* seg  = arg->getValue(0);
         const char* sect = arg->getValue(1);
         const char* fileName = arg->getValue(2);
 
-        ErrorOr<std::unique_ptr<MemoryBuffer>> contentOrErr =
+        Expected<std::unique_ptr<MemoryBuffer>> contentOrErr =
             MemoryBuffer::getFile(fileName);
 
-        if (!contentOrErr) {
-          error("can't open -sectcreate file " + Twine(fileName));
+        if (Error e = contentOrErr.takeError()) {
+          error("can't open -sectcreate file " + Twine(fileName) + ": " +
+                toString(std::move(e)));
           return false;
         }
 
         ctx.addSectCreateSection(seg, sect, std::move(*contentOrErr));
       }
       break;
     }
   }

lld/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 //===- lib/ReaderWriter/MachO/MachOLinkingContext.cpp ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "lld/Common/ErrorHandler.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "ArchHandler.h"
 #include "File.h"
 #include "FlatNamespaceFile.h"
 #include "MachONormalizedFile.h"
 #include "MachOPasses.h"
 #include "SectCreateFile.h"
 #include "lld/Common/Driver.h"
+#include "lld/Common/ErrorHandler.h"
 #include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/PassManager.h"
 #include "lld/Core/Reader.h"
 #include "lld/Core/Writer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include <algorithm>
 
 using lld::mach_o::ArchHandler;
 using lld::mach_o::MachOFile;
 using lld::mach_o::MachODylibFile;
 using namespace llvm::MachO;
if (!_writer)
     _writer = createWriterMachO(*this);
   return *_writer;
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 MachOLinkingContext::getMemoryBuffer(StringRef path) {
   addInputFileDependency(path);
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> mbOrErr =
       MemoryBuffer::getFileOrSTDIN(path);
-  if (std::error_code ec = mbOrErr.getError())
-    return ec;
+  if (Error e = mbOrErr.takeError())
+    return llvm::errorToErrorCode(std::move(e));
   std::unique_ptr<MemoryBuffer> mb = std::move(mbOrErr.get());
 
   // If buffer contains a fat file, find required arch in fat buffer
   // and switch buffer to point to just that required slice.
   uint32_t offset;
   uint32_t size;
   if (sliceFromFatFile(mb->getMemBufferRef(), offset, size))
-    return MemoryBuffer::getFileSlice(path, size, offset);
+    return llvm::expectedToErrorOr(
+        MemoryBuffer::getFileSlice(path, size, offset));
   return std::move(mb);
 }
 
 MachODylibFile* MachOLinkingContext::loadIndirectDylib(StringRef path) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = getMemoryBuffer(path);
   if (mbOrErr.getError())
     return nullptr;
 

lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

static bool isMachOHeader(const mach_header *mh, bool &is64, bool &isBig) {
   default:
     return false;
   }
 }
 
 
 bool isThinObjectFile(StringRef path, MachOLinkingContext::Arch &arch) {
   // Try opening and mapping file at path.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> b = MemoryBuffer::getFileOrSTDIN(path);
-  if (b.getError())
+  Expected<std::unique_ptr<MemoryBuffer>> b =
+      MemoryBuffer::getFileOrSTDIN(path);
+  if (Error e = b.takeError()) {
+    consumeError(std::move(e));
     return false;
+  }
 
   // If file length < 32 it is too small to be mach-o object file.
   StringRef fileBuffer = b->get()->getBuffer();
   if (fileBuffer.size() < 32)
     return false;
 
   // If file buffer does not start with MH_MAGIC (and variants), not obj file.
   const mach_header *mh = reinterpret_cast<const mach_header *>(

lld/test/ELF/basic.s

 # RUN: ld.lld %t --rsp-quoting=posix @%t.responsefile
 # RUN: llvm-readobj --file-headers --sections -l --symbols %t2 \
 # RUN:   | FileCheck %s
 
 # Test for the response file (Windows quoting style)
 # RUN: echo " c:\blah\foo" > %t.responsefile
 # RUN: not ld.lld --rsp-quoting=windows %t @%t.responsefile 2>&1 | FileCheck \
 # RUN:   %s --check-prefix=WINRSP
-# WINRSP: cannot open c:\blah\foo
+# WINRSP: cannot open 'c:\blah\foo'
 
 # Test for the response file (invalid quoting style)
 # RUN: not ld.lld --rsp-quoting=patatino %t 2>&1 | FileCheck %s \
 # RUN:   --check-prefix=INVRSP
 # INVRSP: invalid response file quoting: patatino
 
 # RUN: not ld.lld %t.foo -o /dev/null 2>&1 | \
 # RUN:  FileCheck -DMSG=%errc_ENOENT --check-prefix=MISSING %s
-# MISSING: cannot open {{.*}}.foo: [[MSG]]
+# MISSING: cannot open '{{.*}}.foo': [[MSG]]
 
 # RUN: not ld.lld -o /dev/null 2>&1 | \
 # RUN:  FileCheck --check-prefix=NO_INPUT %s
 # NO_INPUT: ld.lld{{.*}}: no input files
 
 # RUN: not ld.lld %t.no.such.file -o /dev/null 2>&1 | \
 # RUN:  FileCheck -DMSG=%errc_ENOENT --check-prefix=CANNOT_OPEN %s
-# CANNOT_OPEN: cannot open {{.*}}.no.such.file: [[MSG]]
+# CANNOT_OPEN: cannot open '{{.*}}.no.such.file': [[MSG]]
 
 # RUN: not ld.lld --foo 2>&1 | FileCheck --check-prefix=UNKNOWN %s
 # UNKNOWN: unknown argument '--foo'
 
 # RUN: not ld.lld %t -o /dev/null -m wrong_emul_fbsd 2>&1 | FileCheck --check-prefix=UNKNOWN_EMUL %s
 # UNKNOWN_EMUL: unknown emulation: wrong_emul_fbsd

lld/test/ELF/color-diagnostics.test

 # Windows command prompt doesn't support ANSI escape sequences.
 # REQUIRES: shell
 
 # RUN: not ld.lld -xyz -color-diagnostics /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=COLOR %s
 # RUN: not ld.lld -xyz -color-diagnostics=always /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=COLOR %s
 
 # COLOR: {{ld.lld: .\[0;31merror: .\[0munknown argument '-xyz'}}
-# COLOR: {{ld.lld: .\[0;31merror: .\[0mcannot open /nosuchfile}}
+# COLOR: {{ld.lld: .\[0;31merror: .\[0mcannot open '/nosuchfile'}}
 
 # RUN: not ld.lld -color-diagnostics=foobar 2>&1 | FileCheck -check-prefix=ERR %s
 # ERR: unknown option: --color-diagnostics=foobar
 
 # RUN: not ld.lld /nosuchfile 2>&1 | FileCheck -check-prefix=NOCOLOR %s
 # RUN: not ld.lld -color-diagnostics=never /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=NOCOLOR %s
 # RUN: not ld.lld -color-diagnostics=always -no-color-diagnostics \
 # RUN:   /nosuchfile 2>&1 | FileCheck -check-prefix=NOCOLOR %s
 
-# NOCOLOR: ld.lld: error: cannot open /nosuchfile
+# NOCOLOR: ld.lld: error: cannot open '/nosuchfile'

lld/test/ELF/driver.test

 # REQUIRES: x86
 
 # RUN: not ld.lld --unknown1 --unkn=own2 -m foo /no/such/file -lnosuchlib \
 # RUN:   2>&1 | FileCheck -check-prefix=UNKNOWN %s
 
 # UNKNOWN: unknown argument '--unknown1'
 # UNKNOWN: unknown argument '--unkn=own2'
 # UNKNOWN: unknown emulation: foo
-# UNKNOWN: cannot open /no/such/file
+# UNKNOWN: cannot open '/no/such/file'
 # UNKNOWN: unable to find library -lnosuchlib
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t -o /no/such/file 2>&1 | FileCheck -check-prefix=MISSING %s
 # MISSING: cannot open output file /no/such/file
 
 # RUN: ld.lld --help 2>&1 | FileCheck -check-prefix=HELP %s
 # HELP: USAGE:

lld/test/ELF/error-limit.test

 RUN: not ld.lld 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 \
 RUN:   21 22 2>&1 | FileCheck -check-prefix=DEFAULT %s
 
-DEFAULT:      cannot open 01
-DEFAULT:      cannot open 20
+DEFAULT:      cannot open '01'
+DEFAULT:      cannot open '20'
 DEFAULT-NEXT: too many errors emitted, stopping now (use -error-limit=0 to see all errors)
-DEFAULT-NOT:  cannot open 21
+DEFAULT-NOT:  cannot open '21'
 
 RUN: not ld.lld -error-limit=5 01 02 03 04 05 06 07 08 09 10 2>&1 \
 RUN:   | FileCheck -check-prefix=LIMIT5 %s
 RUN: not ld.lld -error-limit 5 01 02 03 04 05 06 07 08 09 10 2>&1 \
 RUN:   | FileCheck -check-prefix=LIMIT5 %s
 
-LIMIT5:      cannot open 01
-LIMIT5:      cannot open 05
+LIMIT5:      cannot open '01'
+LIMIT5:      cannot open '05'
 LIMIT5-NEXT: too many errors emitted, stopping now (use -error-limit=0 to see all errors)
-LIMIT5-NOT:  cannot open 06
+LIMIT5-NOT:  cannot open '06'
 
 RUN: not ld.lld -error-limit=0 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 \
 RUN:   16 17 18 19 20 21 22 2>&1 | FileCheck -check-prefix=UNLIMITED %s
 
-UNLIMITED:     cannot open 01
-UNLIMITED:     cannot open 20
-UNLIMITED:     cannot open 21
-UNLIMITED:     cannot open 22
+UNLIMITED:     cannot open '01'
+UNLIMITED:     cannot open '20'
+UNLIMITED:     cannot open '21'
+UNLIMITED:     cannot open '22'
 UNLIMITED-NOT: too many errors emitted, stopping now (use -error-limit=0 to see all errors)

lld/test/ELF/invalid-linkerscript.test

 
 ## Note that we are using "cannot open no-such-file: " as a marker that the
 ## linker keep going when it found an error. That specific error message is not
 ## related to the linker script tests.
 
 # RUN: echo foobar > %t1
 # RUN: not ld.lld %t1 no-such-file 2>&1 | FileCheck -check-prefix=ERR1 %s
 # ERR1: unexpected EOF
-# ERR1: cannot open no-such-file:
+# ERR1: cannot open 'no-such-file':
 
 # RUN: echo "foo \"bar" > %t2
 # RUN: not ld.lld %t2 no-such-file 2>&1 | FileCheck -check-prefix=ERR2 %s
 # ERR2: unclosed quote
-# ERR2: cannot open no-such-file:
+# ERR2: cannot open 'no-such-file':
 
 # RUN: echo "/*" > %t3
 # RUN: not ld.lld %t3 no-such-file 2>&1 | FileCheck -check-prefix=ERR3 %s
 # ERR3: unclosed comment
-# ERR3: cannot open no-such-file:
+# ERR3: cannot open 'no-such-file':
 
 # RUN: echo "EXTERN (" > %t4
 # RUN: not ld.lld %t4 no-such-file 2>&1 | FileCheck -check-prefix=ERR4 %s
 # ERR4: unexpected EOF
-# ERR4: cannot open no-such-file:
+# ERR4: cannot open 'no-such-file':
 
 # RUN: echo "EXTERN (" > %t5
 # RUN: not ld.lld %t5 no-such-file 2>&1 | FileCheck -check-prefix=ERR5 %s
 # ERR5: unexpected EOF
-# ERR5: cannot open no-such-file:
+# ERR5: cannot open 'no-such-file':
 
 # RUN: echo "EXTERN xyz" > %t6
 # RUN: not ld.lld %t6 no-such-file 2>&1 | FileCheck -check-prefix=ERR6 %s
 # ERR6: ( expected, but got xyz
-# ERR6: cannot open no-such-file:
+# ERR6: cannot open 'no-such-file':
 
 # RUN: echo "INCLUDE /no/such/file" > %t7
 # RUN: not ld.lld %t7 no-such-file 2>&1 | FileCheck -check-prefix=ERR7 %s
 # ERR7: cannot find linker script /no/such/file
-# ERR7: cannot open no-such-file:
+# ERR7: cannot open 'no-such-file':
 
 # RUN: echo "OUTPUT_FORMAT(x y z)" > %t8
 # RUN: not ld.lld %t8 no-such-file 2>&1 | FileCheck -check-prefix=ERR8 %s
 # RUN: not ld.lld -m elf_amd64 %t8 no-such-file 2>&1 | FileCheck -check-prefix=ERR8 %s
 # ERR8: , expected, but got y
-# ERR8: cannot open no-such-file:
+# ERR8: cannot open 'no-such-file':
 
 # RUN: echo "OUTPUT_FORMAT(elf64-x86-64 y z)" > %t9
 # RUN: not ld.lld %t9 no-such-file 2>&1 | FileCheck -check-prefix=ERR9 %s
 # ERR9: , expected, but got y
-# ERR9: cannot open no-such-file:
+# ERR9: cannot open 'no-such-file':

lld/test/ELF/linkerscript/group.s

 # RUN: echo "GROUP(\"%t\")" > %t.script2
 # RUN: ld.lld -o %t2 %t.script1
 # RUN: llvm-readobj %t2 > /dev/null
 
 # RUN: echo "GROUP(AS_NEEDED(\"%t\"))" > %t.script
 # RUN: ld.lld -o %t2 %t.script
 # RUN: llvm-readobj %t2 > /dev/null
 
-# CANNOT_OPEN: error: cannot open [[FILE]]: {{.*}}
+# CANNOT_OPEN: error: cannot open '[[FILE]]': {{.*}}
 
 .globl _start
 _start:
   ret

lld/test/ELF/reproduce-error.s

 # RUN: rm -rf %t.dir
 # RUN: mkdir -p %t.dir
 # RUN: cd %t.dir
 
 # RUN: not ld.lld --reproduce repro.tar abc -o t 2>&1 | FileCheck -DMSG=%errc_ENOENT %s
-# CHECK: cannot open abc: [[MSG]]
+# CHECK: cannot open 'abc': [[MSG]]
 
 # RUN: tar xOf repro.tar repro/response.txt | FileCheck --check-prefix=RSP %s
 # RSP: abc
 # RSP: -o t

lld/test/ELF/symbol-ordering-file.s

 # AFTER-NEXT:  44337755 662211
 # AFTER:      Contents of section .init:
 # AFTER-NEXT:  1122
 
 ## Show that a nonexistent symbol ordering file causes an error.
 # RUN: not ld.lld --symbol-ordering-file=%t.nonexistent %t.o -o %t3.out 2>&1 | \
 # RUN:   FileCheck -DMSG=%errc_ENOENT %s --check-prefix=ERR -DFILE=%t.nonexistent
 
-# ERR: error: cannot open [[FILE]]: [[MSG]]
+# ERR: error: cannot open '[[FILE]]': [[MSG]]
 
 ## Show that an empty ordering file can be handled (symbols remain in their
 ## normal order).
 # RUN: touch %t.empty
 # RUN: ld.lld --symbol-ordering-file=%t.empty %t.o -o %t4.out
 # RUN: llvm-objdump -s %t4.out | FileCheck %s --check-prefix=BEFORE
 
 .section .foo,"ax",@progbits,unique,1

lld/test/MachO/color-diagnostics.test

 # Windows command prompt doesn't support ANSI escape sequences.
 # REQUIRES: shell
 
 # RUN: not %lld -xyz --color-diagnostics /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=COLOR %s
 # RUN: not %lld -xyz --color-diagnostics=always /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=COLOR %s
 
 # COLOR: {{lld: .\[0;31merror: .\[0munknown argument '-xyz'}}
-# COLOR: {{lld: .\[0;31merror: .\[0mcannot open /nosuchfile}}
+# COLOR: {{lld: .\[0;31merror: .\[0mcannot open '/nosuchfile'}}
 
 # RUN: not %lld --color-diagnostics=foobar 2>&1 | FileCheck -check-prefix=ERR %s
 # ERR: unknown option: --color-diagnostics=foobar
 
 # RUN: not %lld /nosuchfile 2>&1 | FileCheck -check-prefix=NOCOLOR %s
 # RUN: not %lld --color-diagnostics=never /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=NOCOLOR %s
 # RUN: not %lld --color-diagnostics=always --no-color-diagnostics \
 # RUN:   /nosuchfile 2>&1 | FileCheck -check-prefix=NOCOLOR %s
 
-# NOCOLOR: lld: error: cannot open /nosuchfile
+# NOCOLOR: lld: error: cannot open '/nosuchfile'

lld/test/MachO/error-limit.test

 ## Check that we only see 20 (the default error-limit) "cannot open" errors
 RUN: not %lld A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 2>&1 | \
 RUN:     FileCheck -check-prefix=DEFAULT %s
 
-DEFAULT:      cannot open A:
-DEFAULT:      cannot open T:
-DEFAULT-NOT:  cannot open U:
+DEFAULT:      cannot open 'A':
+DEFAULT:      cannot open 'T':
+DEFAULT-NOT:  cannot open 'U':
 DEFAULT-NEXT: too many errors emitted, stopping now (use --error-limit=0 to see all errors)
 
 ## Check that we only see 5 "cannot open" errors when --error-limit=5
 RUN: not %lld --error-limit=5 A B C D E F G H I J 2>&1 \
 RUN:   | FileCheck -check-prefix=LIMIT5 %s
 
-LIMIT5:      cannot open A:
-LIMIT5:      cannot open E:
-LIMIT5-NOT:  cannot open F:
+LIMIT5:      cannot open 'A':
+LIMIT5:      cannot open 'E':
+LIMIT5-NOT:  cannot open 'F':
 LIMIT5-NEXT: too many errors emitted, stopping now (use --error-limit=0 to see all errors)
 
 ## Check that we see all "cannot open" errors when --error-limit=0 (unimited)
 RUN: not %lld --error-limit=0 A B C D E F G H I J K L M N O P Q R S T U V W 2>&1 | \
 RUN:     FileCheck -check-prefix=UNLIMITED %s
 
-UNLIMITED:     cannot open A:
-UNLIMITED:     cannot open T:
-UNLIMITED:     cannot open U:
-UNLIMITED:     cannot open V:
-UNLIMITED:     cannot open W:
+UNLIMITED:     cannot open 'A':
+UNLIMITED:     cannot open 'T':
+UNLIMITED:     cannot open 'U':
+UNLIMITED:     cannot open 'V':
+UNLIMITED:     cannot open 'W':
 UNLIMITED-NOT: too many errors emitted, stopping now (use --error-limit=0 to see all errors)

lld/test/MachO/invalid/no-filelist.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: not %lld -filelist nonexistent %t.o -o %t 2>&1 | FileCheck -DMSG=%errc_ENOENT %s
-# CHECK: cannot open nonexistent: [[MSG]]
+# CHECK: cannot open 'nonexistent': [[MSG]]
 
 .globl _main
 
 _main:
   ret

lld/test/MachO/reroot-path.s

 
 ## The {{^}} ensures that we only match relative paths if DIR is relative.
 # CHECK: {{^}}[[DIR]]/{{(lib)?}}bar
 
 ## Paths to object files don't get rerooted.
 # RUN: mv %t/bar.o %t/%:t/bar.o
 # RUN: not %lld -lSystem -syslibroot %t %t/foo.o %t/bar.o %t/test.o -o \
 # RUN:   /dev/null 2>&1 | FileCheck %s --check-prefix=OBJ
-# OBJ: error: cannot open {{.*[\\/]}}bar.o: {{[Nn]}}o such file or directory
+# OBJ: error: cannot open '{{.*[\\/]}}bar.o': {{[Nn]}}o such file or directory
 
 ## Now create a "decoy" libfoo.dylib under %t/%:t to demonstrate that the
 ## rerooted path takes precedence over the original path. We will get an
 ## undefined symbol error since we aren't loading %t/libfoo.dylib.
 # RUN: cp %t/%:t/libbar.dylib %t/%:t/libfoo.dylib
 # RUN: not %lld --reproduce %t/repro6.tar -lSystem -syslibroot %t %t/libfoo.dylib %t/libbar.dylib %t/test.o \
 # RUN:   -o /dev/null -t 2> %t/error | FileCheck %s -DDIR="%t/%:t" --check-prefix=FOO
 # RUN: FileCheck %s --check-prefix=UNDEF < %t/error

lld/unittests/MachOTests/MachONormalizedFileBinaryWriterTests.cpp

 using namespace llvm::MachO;
 using namespace lld::mach_o::normalized;
 
 // Parses binary mach-o file at specified path and returns
 // ownership of buffer to mb parameter and ownership of
 // Normalized file to nf parameter.
 static void fromBinary(StringRef path, std::unique_ptr<MemoryBuffer> &mb,
                        std::unique_ptr<NormalizedFile> &nf, StringRef archStr) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = MemoryBuffer::getFile(path);
-  std::error_code ec = mbOrErr.getError();
-  EXPECT_FALSE(ec);
+  llvm::Expected<std::unique_ptr<MemoryBuffer>> mbOrErr =
+      MemoryBuffer::getFile(path);
+  EXPECT_FALSE(!mbOrErr);
   mb = std::move(mbOrErr.get());
 
   llvm::Expected<std::unique_ptr<NormalizedFile>> r =
       lld::mach_o::normalized::readBinary(
           mb, lld::MachOLinkingContext::archFromName(archStr));
   EXPECT_FALSE(!r);
   nf.reset(r->release());
 }

lld/wasm/InputFiles.cpp

 }
 
 std::unique_ptr<llvm::TarWriter> tar;
 
 Optional<MemoryBufferRef> readFile(StringRef path) {
   log("Loading: " + path);
 
   auto mbOrErr = MemoryBuffer::getFile(path);
-  if (auto ec = mbOrErr.getError()) {
-    error("cannot open " + path + ": " + ec.message());
+  if (Error e = mbOrErr.takeError()) {
+    error("cannot open " + path + ": " + toString(std::move(e)));
     return None;
   }
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
 
   if (tar)
     tar->append(relativeToRoot(path), mbref.getBuffer());

lldb/include/lldb/Utility/ReproducerProvider.h

static std::unique_ptr<MultiLoader> Create(Loader *loader) {
     if (!loader)
       return {};
 
     FileSpec file = loader->GetFile<typename T::Info>();
     if (!file)
       return {};
 
     auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
-    if (auto err = error_or_file.getError())
+    if (llvm::Error e = error_or_file.takeError()) {
+      consumeError(std::move(e));
       return {};
+    }
 
     std::vector<std::string> files;
     llvm::yaml::Input yin((*error_or_file)->getBuffer());
     yin >> files;
 
     if (auto err = yin.error())
       return {};
 

lldb/source/API/SBReproducer.cpp

if (auto e = Reproducer::Initialize(ReproducerMode::PassiveReplay,
                                       FileSpec(path))) {
     error = llvm::toString(std::move(e));
     return error.c_str();
   }
 
   if (auto *l = lldb_private::repro::Reproducer::Instance().GetLoader()) {
     FileSpec file = l->GetFile<SBProvider::Info>();
     auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
-    if (!error_or_file) {
-      error =
-          "unable to read SB API data: " + error_or_file.getError().message();
+    if (llvm::Error e = error_or_file.takeError()) {
+      error = "unable to read SB API data: " + toString(std::move(e));
       return error.c_str();
     }
     static ReplayData r(std::move(*error_or_file));
     InstrumentationData::Initialize(r.GetDeserializer(), r.GetRegistry());
   }
 
   return nullptr;
 }

lldb/source/Commands/CommandObjectReproducer.cpp

 #include "CommandOptions.inc"
 
 #define LLDB_OPTIONS_reproducer_verify
 #include "CommandOptions.inc"
 
 template <typename T>
 llvm::Expected<T> static ReadFromYAML(StringRef filename) {
   auto error_or_file = MemoryBuffer::getFile(filename);
-  if (auto err = error_or_file.getError()) {
-    return errorCodeToError(err);
-  }
+  if (Error e = error_or_file.takeError())
+    return e;
 
   T t;
   yaml::Input yin((*error_or_file)->getBuffer());
   yin >> t;
 
   if (auto err = yin.error()) {
     return errorCodeToError(err);
   }
case eReproducerProviderCommands: {
 
       // Iterate over the command files and dump them.
       llvm::Optional<std::string> command_file;
       while ((command_file = multi_loader->GetNextFile())) {
         if (!command_file)
           break;
 
         auto command_buffer = llvm::MemoryBuffer::getFile(*command_file);
-        if (auto err = command_buffer.getError()) {
-          SetError(result, errorCodeToError(err));
+        if (Error e = command_buffer.takeError()) {
+          SetError(result, std::move(e));
           return false;
         }
         result.AppendMessage((*command_buffer)->getBuffer());
       }
 
       result.SetStatus(eReturnStatusSuccessFinishResult);
       return true;
     }

lldb/source/Commands/CommandObjectTrace.cpp

 //===-- CommandObjectTrace.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectTrace.h"
 
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include <system_error>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
auto end_with_failure = [&result](llvm::Error err) -> bool {
       result.AppendErrorWithFormat("%s\n",
                                    llvm::toString(std::move(err)).c_str());
       return false;
     };
 
     FileSpec json_file(command[0].ref());
 
     auto buffer_or_error = llvm::MemoryBuffer::getFile(json_file.GetPath());
-    if (!buffer_or_error) {
+    if (Error e = buffer_or_error.takeError()) {
       return end_with_failure(llvm::createStringError(
-          std::errc::invalid_argument, "could not open input file: %s - %s.",
-          json_file.GetPath().c_str(),
-          buffer_or_error.getError().message().c_str()));
+          std::make_error_code(std::errc::invalid_argument),
+          Twine("could not open input file: ") + json_file.GetPath() + " - " +
+              toString(std::move(e)) + "."));
     }
 
     llvm::Expected<json::Value> session_file =
         json::parse(buffer_or_error.get()->getBuffer().str());
     if (!session_file)
       return end_with_failure(session_file.takeError());
 
     if (Expected<lldb::TraceSP> traceOrErr =

lldb/source/Host/common/FileSystem.cpp

if (size == 0) {
     auto buffer_or_error =
         llvm::WritableMemoryBuffer::getFile(*external_path, is_volatile);
     if (!buffer_or_error)
       return nullptr;
     buffer = std::move(*buffer_or_error);
   } else {
     auto buffer_or_error = llvm::WritableMemoryBuffer::getFileSlice(
         *external_path, size, offset, is_volatile);
-    if (!buffer_or_error)
+    if (!buffer_or_error) {
+      consumeError(buffer_or_error.takeError());
       return nullptr;
+    }
     buffer = std::move(*buffer_or_error);
   }
   return std::shared_ptr<DataBufferLLVM>(new DataBufferLLVM(std::move(buffer)));
 }
 
 std::shared_ptr<DataBufferLLVM>
 FileSystem::CreateDataBuffer(const FileSpec &file_spec, uint64_t size,
                              uint64_t offset) {

lldb/source/Host/linux/Support.cpp

 #include "llvm/Support/MemoryBuffer.h"
 
 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
 lldb_private::getProcFile(::pid_t pid, ::pid_t tid, const llvm::Twine &file) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::string File =
       ("/proc/" + llvm::Twine(pid) + "/task/" + llvm::Twine(tid) + "/" + file)
           .str();
-  auto Ret = llvm::MemoryBuffer::getFileAsStream(File);
+  auto Ret = expectedToErrorOr(llvm::MemoryBuffer::getFileAsStream(File));
   if (!Ret)
     LLDB_LOG(log, "Failed to open {0}: {1}", File, Ret.getError().message());
   return Ret;
 }
 
 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
 lldb_private::getProcFile(::pid_t pid, const llvm::Twine &file) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::string File = ("/proc/" + llvm::Twine(pid) + "/" + file).str();
-  auto Ret = llvm::MemoryBuffer::getFileAsStream(File);
+  auto Ret = expectedToErrorOr(llvm::MemoryBuffer::getFileAsStream(File));
   if (!Ret)
     LLDB_LOG(log, "Failed to open {0}: {1}", File, Ret.getError().message());
   return Ret;
 }
 
 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
 lldb_private::getProcFile(const llvm::Twine &file) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   std::string File = ("/proc/" + file).str();
-  auto Ret = llvm::MemoryBuffer::getFileAsStream(File);
+  auto Ret = expectedToErrorOr(llvm::MemoryBuffer::getFileAsStream(File));
   if (!Ret)
     LLDB_LOG(log, "Failed to open {0}: {1}", File, Ret.getError().message());
   return Ret;
 }

lldb/source/Plugins/ObjectFile/Minidump/MinidumpFileBuilder.cpp

void MinidumpFileBuilder::AddMiscInfo(const lldb::ProcessSP &process_sp) {
 
   m_data.AppendData(&misc_info,
                     sizeof(lldb_private::minidump::MinidumpMiscInfo));
 }
 
 std::unique_ptr<llvm::MemoryBuffer>
 getFileStreamHelper(const std::string &path) {
   auto maybe_stream = llvm::MemoryBuffer::getFileAsStream(path);
-  if (!maybe_stream)
+  if (!maybe_stream) {
+    consumeError(maybe_stream.takeError());
     return nullptr;
+  }
   return std::move(maybe_stream.get());
 }
 
 void MinidumpFileBuilder::AddLinuxFileStreams(
     const lldb::ProcessSP &process_sp) {
   std::vector<std::pair<StreamType, std::string>> files_with_stream_types = {
       {StreamType::LinuxCPUInfo, "/proc/cpuinfo"},
       {StreamType::LinuxLSBRelease, "/etc/lsb-release"},

 }
 
 size_t MinidumpFileBuilder::GetDirectoriesNum() const {
   return m_directories.size();
 }
 
 size_t MinidumpFileBuilder::GetCurrentDataEndOffset() const {
   return sizeof(llvm::minidump::Header) + m_data.GetByteSize();
-}
+}
 

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

 ObjectFilePDB::ObjectFilePDB(const ModuleSP &module_sp, DataBufferSP &data_sp,
                              offset_t data_offset, const FileSpec *file,
                              offset_t offset, offset_t length)
     : ObjectFile(module_sp, file, offset, length, data_sp, data_offset) {}
 
 std::unique_ptr<PDBFile>
 ObjectFilePDB::loadPDBFile(std::string PdbPath,
                            llvm::BumpPtrAllocator &Allocator) {
-  llvm::file_magic magic;
-  auto ec = llvm::identify_magic(PdbPath, magic);
-  if (ec || magic != llvm::file_magic::pdb)
+  auto magic = llvm::identify_magic_in_file(PdbPath);
+  if (llvm::Error e = magic.takeError()) {
+    consumeError(std::move(e));
     return nullptr;
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ErrorOrBuffer =
+  }
+  if (*magic != llvm::file_magic::pdb)
+    return nullptr;
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> ErrorOrBuffer =
       llvm::MemoryBuffer::getFile(PdbPath, /*IsText=*/false,
                                   /*RequiresNullTerminator=*/false);
-  if (!ErrorOrBuffer)
+  if (llvm::Error e = ErrorOrBuffer.takeError()) {
+    consumeError(std::move(e));
     return nullptr;
+  }
   std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
 
   llvm::StringRef Path = Buffer->getBufferIdentifier();
   auto Stream = std::make_unique<llvm::MemoryBufferByteStream>(
       std::move(Buffer), llvm::support::little);
 
   auto File = std::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
   if (auto EC = File->parseFileHeaders()) {

lldb/source/Plugins/Process/Linux/IntelPTManager.cpp

enum IntelPTConfigFileType {
   // a bit index file always starts with the prefix config: following by an int,
   // which represents the offset of the perf_event_attr.config value where to
   // store a given configuration.
   BitOffset
 };
 
 static Expected<uint32_t> ReadIntelPTConfigFile(const char *file,
                                                 IntelPTConfigFileType type) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> stream =
+  Expected<std::unique_ptr<MemoryBuffer>> stream =
       MemoryBuffer::getFileAsStream(file);
 
-  if (!stream)
-    return createStringError(inconvertibleErrorCode(),
-                             "Can't open the file '%s'", file);
+  if (Error E = stream.takeError())
+    return E;
 
   uint32_t value = 0;
   StringRef text_buffer = stream.get()->getBuffer();
 
   if (type == BitOffset) {
     const char *prefix = "config:";
     if (!text_buffer.startswith(prefix))
       return createStringError(inconvertibleErrorCode(),

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp

#endif
   quit = true;
 
   return packet_result;
 }
 
 llvm::Error
 GDBRemoteCommunicationReplayServer::LoadReplayHistory(const FileSpec &path) {
   auto error_or_file = MemoryBuffer::getFile(path.GetPath());
-  if (auto err = error_or_file.getError())
-    return errorCodeToError(err);
+  if (Error e = error_or_file.takeError())
+    return e;
 
   yaml::Input yin((*error_or_file)->getBuffer());
   yin >> m_packet_history;
 
   if (auto err = yin.error())
     return errorCodeToError(err);
 
   // We want to manipulate the vector like a stack so we need to reverse the

lldb/source/Utility/ProcessInfo.cpp

repro::GetReplayProcessInstanceInfoList() {
   if (!loader)
     return {};
 
   llvm::Optional<std::string> nextfile = loader->GetNextFile();
   if (!nextfile)
     return {};
 
   auto error_or_file = llvm::MemoryBuffer::getFile(*nextfile);
-  if (std::error_code err = error_or_file.getError())
+  if (llvm::Error e = error_or_file.takeError()) {
+    consumeError(std::move(e));
     return {};
+  }
 
   ProcessInstanceInfoList infos;
   llvm::yaml::Input yin((*error_or_file)->getBuffer());
   yin >> infos;
 
   if (auto err = yin.error())
     return {};
 
   return infos;
 }

lldb/source/Utility/Reproducer.cpp

 //===-- Reproducer.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/ReproducerProvider.h"
 #include "lldb/Utility/Timer.h"
 
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;
 using namespace lldb_private::repro;
 using namespace llvm;
 using namespace llvm::yaml;

 
 llvm::Error Loader::LoadIndex() {
   if (m_loaded)
     return llvm::Error::success();
 
   FileSpec index = m_root.CopyByAppendingPathComponent("index.yaml");
 
   auto error_or_file = MemoryBuffer::getFile(index.GetPath());
-  if (auto err = error_or_file.getError())
-    return make_error<StringError>("unable to load reproducer index", err);
+  if (llvm::Error e = error_or_file.takeError())
+    return make_error<StringError>("unable to load reproducer index: " +
+                                       toString(std::move(e)),
+                                   inconvertibleErrorCode());
 
   yaml::Input yin((*error_or_file)->getBuffer());
   yin >> m_files;
   if (auto err = yin.error())
     return make_error<StringError>("unable to read reproducer index", err);
 
   // Sort files to speed up search.
   llvm::sort(m_files);
for (; iter != end && !ec; iter.increment(ec)) {
                      "': " + status.getError().message());
     }
   }
 }
 
 static llvm::Error addPaths(StringRef path,
                             function_ref<void(StringRef)> callback) {
   auto buffer = llvm::MemoryBuffer::getFile(path);
-  if (!buffer)
-    return errorCodeToError(buffer.getError());
+  if (Error e = buffer.takeError())
+    return e;
 
   SmallVector<StringRef, 0> paths;
   (*buffer)->getBuffer().split(paths, '\0');
   for (StringRef p : paths) {
     if (!p.empty() && llvm::sys::fs::exists(p))
       callback(p);
   }
 

lldb/source/Utility/ReproducerInstrumentation.cpp

llvm::report_fatal_error(
         "function. This is probably the result of concurrent "
         "use of the SB API during capture, which is currently not "
         "supported.");
   m_expected_sequence.reset();
 }
 
 bool Registry::Replay(const FileSpec &file) {
   auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
-  if (auto err = error_or_file.getError())
+  if (llvm::Error e = error_or_file.takeError()) {
+    consumeError(std::move(e));
     return false;
+  }
 
   return Replay((*error_or_file)->getBuffer());
 }
 
 bool Registry::Replay(llvm::StringRef buffer) {
   Deserializer deserializer(buffer);
   return Replay(deserializer);
 }

lldb/source/Utility/ReproducerProvider.cpp

SymbolFileLoader::SymbolFileLoader(Loader *loader) {
   if (!loader)
     return;
 
   FileSpec file = loader->GetFile<SymbolFileProvider::Info>();
   if (!file)
     return;
 
   auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
-  if (auto err = error_or_file.getError())
+  if (Error e = error_or_file.takeError()) {
+    consumeError(std::move(e));
     return;
+  }
 
   llvm::yaml::Input yin((*error_or_file)->getBuffer());
   yin >> m_symbol_files;
 }
 
 std::pair<FileSpec, FileSpec>
 SymbolFileLoader::GetPaths(const UUID *uuid) const {
   if (!uuid)

lldb/source/Utility/StructuredData.cpp

StructuredData::ParseJSON(const std::string &json_text) {
   return ParseJSONValue(*value);
 }
 
 StructuredData::ObjectSP
 StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
   StructuredData::ObjectSP return_sp;
 
   auto buffer_or_error = llvm::MemoryBuffer::getFile(input_spec.GetPath());
-  if (!buffer_or_error) {
+  if (Error e = buffer_or_error.takeError()) {
     error.SetErrorStringWithFormatv("could not open input file: {0} - {1}.",
                                     input_spec.GetPath(),
-                                    buffer_or_error.getError().message());
+                                    toString(std::move(e)));
     return return_sp;
   }
   llvm::Expected<json::Value> value =
       json::parse(buffer_or_error.get()->getBuffer().str());
   if (value)
     return ParseJSONValue(*value);
   error.SetErrorString(toString(value.takeError()));
   return StructuredData::ObjectSP();

lldb/tools/lldb-test/lldb-test.cpp

if (ST.Fail()) {
     errs() << formatv("Failed to create target '{0}: {1}\n", Filename, ST);
     exit(1);
   }
   return Target;
 }
 
 std::unique_ptr<MemoryBuffer> opts::openFile(const std::string &Filename) {
   auto MB = MemoryBuffer::getFileOrSTDIN(Filename);
-  if (!MB) {
+  if (Error E = MB.takeError()) {
     errs() << formatv("Could not open file '{0}: {1}\n", Filename,
-                      MB.getError().message());
+                      toString(std::move(E)));
     exit(1);
   }
   return std::move(*MB);
 }
 
 void opts::breakpoint::dumpState(const BreakpointList &List, LinePrinter &P) {
   P.formatLine("{0} breakpoint{1}", List.GetSize(), plural(List.GetSize()));
   if (List.GetSize() > 0)

lldb/unittests/TestingSupport/TestUtilities.cpp

return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "convertYAML() failed");
   return TestFile(std::move(Buffer));
 }
 
 llvm::Expected<TestFile> TestFile::fromYamlFile(const llvm::Twine &Name) {
   auto BufferOrError =
       llvm::MemoryBuffer::getFile(GetInputFilePath(Name), /*IsText=*/false,
                                   /*RequiresNullTerminator=*/false);
-  if (!BufferOrError)
-    return llvm::errorCodeToError(BufferOrError.getError());
+  if (llvm::Error E = BufferOrError.takeError())
+    return E;
   return fromYaml(BufferOrError.get()->getBuffer());
 }

llvm/examples/OrcV2Examples/LLJITWithThinLTOSummaries/LLJITWithThinLTOSummaries.cpp

 }
 
 // Parse the bitcode module from the given path into a ThreadSafeModule.
 Expected<ThreadSafeModule> loadModule(StringRef Path,
                                       orc::ThreadSafeContext TSCtx) {
   outs() << "About to load module: " << Path << "\n";
 
   Expected<std::unique_ptr<MemoryBuffer>> BitcodeBuffer =
-      errorOrToExpected(MemoryBuffer::getFile(Path));
+      MemoryBuffer::getFile(Path);
   if (!BitcodeBuffer)
     return BitcodeBuffer.takeError();
 
   MemoryBufferRef BitcodeBufferRef = (**BitcodeBuffer).getMemBufferRef();
   Expected<std::unique_ptr<Module>> M =
       parseBitcodeFile(BitcodeBufferRef, *TSCtx.getContext());
   if (!M)
     return M.takeError();
int main(int Argc, char *Argv[]) {
 
   cl::ParseCommandLineOptions(Argc, Argv, "LLJITWithThinLTOSummaries");
 
   ExitOnError ExitOnErr;
   ExitOnErr.setBanner(std::string(Argv[0]) + ": ");
 
   // (1) Read the index file and parse the module summary index.
   std::unique_ptr<MemoryBuffer> SummaryBuffer =
-      ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(IndexFile)));
+      ExitOnErr(MemoryBuffer::getFile(IndexFile));
 
   std::unique_ptr<ModuleSummaryIndex> SummaryIndex =
       ExitOnErr(getModuleSummaryIndex(SummaryBuffer->getMemBufferRef()));
 
   // (2) Find the path of the module that defines "main".
   std::string MainFunctionName = "main";
   StringRef MainModulePath =
       ExitOnErr(getMainModulePath(MainFunctionName, *SummaryIndex));

llvm/include/llvm/BinaryFormat/Magic.h

 //===- llvm/BinaryFormat/Magic.h - File magic identification ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BINARYFORMAT_MAGIC_H
 #define LLVM_BINARYFORMAT_MAGIC_H
 
+#include "llvm/Support/Error.h"
 #include <system_error>
 
 namespace llvm {
 class StringRef;
 class Twine;
 
 /// file_magic - An "enum class" enumeration of file types based on magic (the
 /// first N bytes of the file).

 };
 
 /// Identify the type of a binary file based on how magical it is.
 file_magic identify_magic(StringRef magic);
 
 /// Get and identify \a path's type based on its content.
 ///
 /// @param path Input path.
-/// @param result Set to the type of file, or file_magic::unknown.
-/// @returns errc::success if result has been successfully set, otherwise a
-///          platform-specific error_code.
-std::error_code identify_magic(const Twine &path, file_magic &result);
+/// @returns the type of the file, otherwise an llvm::Error
+Expected<file_magic> identify_magic_in_file(const Twine &path);
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/Error.h

 /// show more detailed information to the user.
 class FileError final : public ErrorInfo<FileError> {
 
   friend Error createFileError(const Twine &, Error);
   friend Error createFileError(const Twine &, size_t, Error);
 
 public:
   void log(raw_ostream &OS) const override {
-    assert(Err && !FileName.empty() && "Trying to log after takeError().");
+    assert(Err && "Trying to log after takeError().");
     OS << "'" << FileName << "': ";
     if (Line.hasValue())
       OS << "line " << Line.getValue() << ": ";
     Err->log(OS);
   }
 
+  std::string messageWithoutFileInfo() const {
+    std::string Msg;
+    raw_string_ostream OS(Msg);
+    Err->log(OS);
+    return OS.str();
+  }
+
   StringRef getFileName() { return FileName; }
 
   Error takeError() { return Error(std::move(Err)); }
 
   std::error_code convertToErrorCode() const override;
 
   // Used by ErrorInfo::classID.
   static char ID;
 
 private:
   FileError(const Twine &F, Optional<size_t> LineNum,
             std::unique_ptr<ErrorInfoBase> E) {
     assert(E && "Cannot create FileError from Error success value.");
-    assert(!F.isTriviallyEmpty() &&
-           "The file name provided to FileError must not be empty.");
     FileName = F.str();
     Err = std::move(E);
     Line = std::move(LineNum);
   }
 
   static Error build(const Twine &F, Optional<size_t> Line, Error E) {
     std::unique_ptr<ErrorInfoBase> Payload;
     handleAllErrors(std::move(E),

llvm/include/llvm/Support/MemoryBuffer.h

 #ifndef LLVM_SUPPORT_MEMORYBUFFER_H
 #define LLVM_SUPPORT_MEMORYBUFFER_H
 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CBindingWrapping.h"
-#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBufferRef.h"
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 
 namespace llvm {
 namespace sys {
 namespace fs {
public:
   /// if successful, otherwise returning null.
   ///
   /// \param IsText Set to true to indicate that the file should be read in
   /// text mode.
   ///
   /// \param IsVolatile Set to true to indicate that the contents of the file
   /// can change outside the user's control, e.g. when libclang tries to parse
   /// while the user is editing/updating the file or if the file is on an NFS.
-  static ErrorOr<std::unique_ptr<MemoryBuffer>>
+  static Expected<std::unique_ptr<MemoryBuffer>>
   getFile(const Twine &Filename, bool IsText = false,
           bool RequiresNullTerminator = true, bool IsVolatile = false);
 
   /// Read all of the specified file into a MemoryBuffer as a stream
   /// (i.e. until EOF reached). This is useful for special files that
   /// look like a regular file but have 0 size (e.g. /proc/cpuinfo on Linux).
-  static ErrorOr<std::unique_ptr<MemoryBuffer>>
+  static Expected<std::unique_ptr<MemoryBuffer>>
   getFileAsStream(const Twine &Filename);
 
   /// Given an already-open file descriptor, map some slice of it into a
   /// MemoryBuffer. The slice is specified by an \p Offset and \p MapSize.
   /// Since this is in the middle of a file, the buffer is not null terminated.
-  static ErrorOr<std::unique_ptr<MemoryBuffer>>
+  static Expected<std::unique_ptr<MemoryBuffer>>
   getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize,
                    int64_t Offset, bool IsVolatile = false);
 
   /// Given an already-open file descriptor, read the file and return a
   /// MemoryBuffer.
   ///
   /// \param IsVolatile Set to true to indicate that the contents of the file
   /// can change outside the user's control, e.g. when libclang tries to parse
   /// while the user is editing/updating the file or if the file is on an NFS.
-  static ErrorOr<std::unique_ptr<MemoryBuffer>>
+  static Expected<std::unique_ptr<MemoryBuffer>>
   getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
               bool RequiresNullTerminator = true, bool IsVolatile = false);
 
   /// Open the specified memory range as a MemoryBuffer. Note that InputData
   /// must be null terminated if RequiresNullTerminator is true.
   static std::unique_ptr<MemoryBuffer>
   getMemBuffer(StringRef InputData, StringRef BufferName = "",
                bool RequiresNullTerminator = true);
 
   static std::unique_ptr<MemoryBuffer>
   getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator = true);
 
   /// Open the specified memory range as a MemoryBuffer, copying the contents
   /// and taking ownership of it. InputData does not have to be null terminated.
   static std::unique_ptr<MemoryBuffer>
   getMemBufferCopy(StringRef InputData, const Twine &BufferName = "");
 
   /// Read all of stdin into a file buffer, and return it.
-  static ErrorOr<std::unique_ptr<MemoryBuffer>> getSTDIN();
+  static Expected<std::unique_ptr<MemoryBuffer>> getSTDIN();
 
   /// Open the specified file as a MemoryBuffer, or open stdin if the Filename
   /// is "-".
-  static ErrorOr<std::unique_ptr<MemoryBuffer>>
+  static Expected<std::unique_ptr<MemoryBuffer>>
   getFileOrSTDIN(const Twine &Filename, bool IsText = false,
                  bool RequiresNullTerminator = true);
 
   /// Map a subrange of the specified file as a MemoryBuffer.
-  static ErrorOr<std::unique_ptr<MemoryBuffer>>
+  static Expected<std::unique_ptr<MemoryBuffer>>
   getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
                bool IsVolatile = false);
 
   //===--------------------------------------------------------------------===//
   // Provided for performance analysis.
   //===--------------------------------------------------------------------===//
 
   /// The kind of memory backing used to support the MemoryBuffer.
public:
   }
   char *getBufferEnd() {
     return const_cast<char *>(MemoryBuffer::getBufferEnd());
   }
   MutableArrayRef<char> getBuffer() {
     return {getBufferStart(), getBufferEnd()};
   }
 
-  static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
+  static Expected<std::unique_ptr<WritableMemoryBuffer>>
   getFile(const Twine &Filename, bool IsVolatile = false);
 
   /// Map a subrange of the specified file as a WritableMemoryBuffer.
-  static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
+  static Expected<std::unique_ptr<WritableMemoryBuffer>>
   getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
                bool IsVolatile = false);
 
   /// Allocate a new MemoryBuffer of the specified size that is not initialized.
   /// Note that the caller should initialize the memory allocated by this
   /// method. The memory is owned by the MemoryBuffer object.
   static std::unique_ptr<WritableMemoryBuffer>
   getNewUninitMemBuffer(size_t Size, const Twine &BufferName = "");
public:
   }
   char *getBufferEnd() {
     return const_cast<char *>(MemoryBuffer::getBufferEnd());
   }
   MutableArrayRef<char> getBuffer() {
     return {getBufferStart(), getBufferEnd()};
   }
 
-  static ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
+  static Expected<std::unique_ptr<WriteThroughMemoryBuffer>>
   getFile(const Twine &Filename, int64_t FileSize = -1);
 
   /// Map a subrange of the specified file as a ReadWriteMemoryBuffer.
-  static ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
+  static Expected<std::unique_ptr<WriteThroughMemoryBuffer>>
   getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset);
 
 private:
   // Hide these base class factory function so one can't write
   //   WritableMemoryBuffer::getXXX()
   // and be surprised that he got a read-only Buffer.
   using MemoryBuffer::getFileAsStream;
   using MemoryBuffer::getFileOrSTDIN;

llvm/lib/Analysis/ReplayInlineAdvisor.cpp

 
 ReplayInlineAdvisor::ReplayInlineAdvisor(
     Module &M, FunctionAnalysisManager &FAM, LLVMContext &Context,
     std::unique_ptr<InlineAdvisor> OriginalAdvisor, StringRef RemarksFile,
     bool EmitRemarks)
     : InlineAdvisor(M, FAM), OriginalAdvisor(std::move(OriginalAdvisor)),
       HasReplayRemarks(false), EmitRemarks(EmitRemarks) {
   auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(RemarksFile);
-  std::error_code EC = BufferOrErr.getError();
-  if (EC) {
-    Context.emitError("Could not open remarks file: " + EC.message());
+  if (Error E = BufferOrErr.takeError()) {
+    Context.emitError("Could not open remarks file: " + toString(std::move(E)));
     return;
   }
 
   // Example for inline remarks to parse:
   //   main:3:1.1: '_Z3subii' inlined into 'main' at callsite sum:1 @ main:3:1.1
   // We use the callsite string after `at callsite` to replay inlining.
   line_iterator LineIt(*BufferOrErr.get(), /*SkipBlanks=*/true);
   for (; !LineIt.is_at_eof(); ++LineIt) {

llvm/lib/AsmParser/Parser.cpp

llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context,
 
   return M;
 }
 
 std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename,
                                                 SMDiagnostic &Err,
                                                 LLVMContext &Context,
                                                 SlotMapping *Slots) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  if (std::error_code EC = FileOrErr.getError()) {
+  if (Error E = FileOrErr.takeError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
-                       "Could not open input file: " + EC.message());
+                       "Could not open input file: " + toString(std::move(E)));
     return nullptr;
   }
 
   return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots);
 }
 
 static ParsedModuleAndIndex
 parseAssemblyWithIndex(MemoryBufferRef F, SMDiagnostic &Err,
return ::parseAssemblyWithIndex(F, Err, Context, Slots,
                                   [](StringRef) { return None; });
 }
 
 static ParsedModuleAndIndex
 parseAssemblyFileWithIndex(StringRef Filename, SMDiagnostic &Err,
                            LLVMContext &Context, SlotMapping *Slots,
                            bool UpgradeDebugInfo,
                            DataLayoutCallbackTy DataLayoutCallback) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
-  if (std::error_code EC = FileOrErr.getError()) {
+  if (Error E = FileOrErr.takeError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
-                       "Could not open input file: " + EC.message());
+                       "Could not open input file: " + toString(std::move(E)));
     return {nullptr, nullptr};
   }
 
   return parseAssemblyWithIndex(FileOrErr.get()->getMemBufferRef(), Err,
                                 Context, Slots, UpgradeDebugInfo,
                                 DataLayoutCallback);
 }
 
llvm::parseSummaryIndexAssembly(MemoryBufferRef F, SMDiagnostic &Err) {
   if (parseSummaryIndexAssemblyInto(F, *Index, Err))
     return nullptr;
 
   return Index;
 }
 
 std::unique_ptr<ModuleSummaryIndex>
 llvm::parseSummaryIndexAssemblyFile(StringRef Filename, SMDiagnostic &Err) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  if (std::error_code EC = FileOrErr.getError()) {
+  if (Error E = FileOrErr.takeError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
-                       "Could not open input file: " + EC.message());
+                       "Could not open input file: " + toString(std::move(E)));
     return nullptr;
   }
 
   return parseSummaryIndexAssembly(FileOrErr.get()->getMemBufferRef(), Err);
 }
 
 Constant *llvm::parseConstantValue(StringRef Asm, SMDiagnostic &Err,
                                    const Module &M, const SlotMapping *Slots) {

llvm/lib/BinaryFormat/Magic.cpp

case 0x2d: // YAML '-'
     break;
 
   default:
     break;
   }
   return file_magic::unknown;
 }
 
-std::error_code llvm::identify_magic(const Twine &Path, file_magic &Result) {
+Expected<file_magic> llvm::identify_magic_in_file(const Twine &Path) {
   auto FileOrError = MemoryBuffer::getFile(Path, /*IsText=*/false,
                                            /*RequiresNullTerminator=*/false);
   if (!FileOrError)
-    return FileOrError.getError();
+    return FileOrError.takeError();
 
   std::unique_ptr<MemoryBuffer> FileBuffer = std::move(*FileOrError);
-  Result = identify_magic(FileBuffer->getBuffer());
-
-  return std::error_code();
+  return identify_magic(FileBuffer->getBuffer());
 }

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

if (!BM)
     return BM.takeError();
 
   return BM->getLTOInfo();
 }
 
 Expected<std::unique_ptr<ModuleSummaryIndex>>
 llvm::getModuleSummaryIndexForFile(StringRef Path,
                                    bool IgnoreEmptyThinLTOIndexFile) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Path);
   if (!FileOrErr)
-    return errorCodeToError(FileOrErr.getError());
+    return FileOrErr.takeError();
   if (IgnoreEmptyThinLTOIndexFile && !(*FileOrErr)->getBufferSize())
     return nullptr;
   return getModuleSummaryIndex(**FileOrErr);
 }

llvm/lib/CodeGen/CommandFlags.cpp

 codegen::getBBSectionsMode(llvm::TargetOptions &Options) {
   if (getBBSections() == "all")
     return BasicBlockSection::All;
   else if (getBBSections() == "labels")
     return BasicBlockSection::Labels;
   else if (getBBSections() == "none")
     return BasicBlockSection::None;
   else {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> MBOrErr =
         MemoryBuffer::getFile(getBBSections());
-    if (!MBOrErr) {
+    if (Error E = MBOrErr.takeError()) {
       errs() << "Error loading basic block sections function list file: "
-             << MBOrErr.getError().message() << "\n";
+             << toString(std::move(E)) << "\n";
     } else {
       Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
     }
     return BasicBlockSection::List;
   }
 }
 
 // Common utility function tightly tied to the options listed here. Initializes

llvm/lib/CodeGen/MIRParser/MIRParser.cpp

 bool MIRParser::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
   return Impl->parseMachineFunctions(M, MMI);
 }
 
 std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(
     StringRef Filename, SMDiagnostic &Error, LLVMContext &Context,
     std::function<void(Function &)> ProcessIRFunction) {
   auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
-  if (std::error_code EC = FileOrErr.getError()) {
-    Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
-                         "Could not open input file: " + EC.message());
+  if (llvm::Error E = FileOrErr.takeError()) {
+    Error =
+        SMDiagnostic(Filename, SourceMgr::DK_Error,
+                     "Could not open input file: " + toString(std::move(E)));
     return nullptr;
   }
   return createMIRParser(std::move(FileOrErr.get()), Context,
                          ProcessIRFunction);
 }
 
 std::unique_ptr<MIRParser>
 llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents,

llvm/lib/DebugInfo/GSYM/GsymReader.cpp

GsymReader::GsymReader(std::unique_ptr<MemoryBuffer> Buffer) :
     Endian(support::endian::system_endianness()) {}
 
   GsymReader::GsymReader(GsymReader &&RHS) = default;
 
 GsymReader::~GsymReader() = default;
 
 llvm::Expected<GsymReader> GsymReader::openFile(StringRef Filename) {
   // Open the input file and return an appropriate error if needed.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BuffOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  auto Err = BuffOrErr.getError();
-  if (Err)
-    return llvm::errorCodeToError(Err);
+  if (Error E = BuffOrErr.takeError())
+    return E;
   return create(BuffOrErr.get());
 }
 
 llvm::Expected<GsymReader> GsymReader::copyBuffer(StringRef Bytes) {
   auto MemBuffer = MemoryBuffer::getMemBufferCopy(Bytes, "GSYM bytes");
   return create(MemBuffer);
 }
 

llvm/lib/DebugInfo/PDB/Native/NativeSession.cpp

Error NativeSession::createFromPdb(std::unique_ptr<MemoryBuffer> Buffer,
   Session =
       std::make_unique<NativeSession>(std::move(File), std::move(Allocator));
 
   return Error::success();
 }
 
 static Expected<std::unique_ptr<PDBFile>>
 loadPdbFile(StringRef PdbPath, std::unique_ptr<BumpPtrAllocator> &Allocator) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
+  Expected<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
       MemoryBuffer::getFile(PdbPath, /*IsText=*/false,
                             /*RequiresNullTerminator=*/false);
-  if (!ErrorOrBuffer)
-    return make_error<RawError>(ErrorOrBuffer.getError());
+  if (Error E = ErrorOrBuffer.takeError())
+    return E;
   std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
 
   PdbPath = Buffer->getBufferIdentifier();
-  file_magic Magic;
-  auto EC = identify_magic(PdbPath, Magic);
-  if (EC || Magic != file_magic::pdb)
-    return make_error<RawError>(EC);
+  Expected<file_magic> Magic = identify_magic_in_file(PdbPath);
+  if (Error E = Magic.takeError())
+    return E;
+  if (*Magic != file_magic::pdb)
+    return make_error<StringError>("Expected a pdb file in: " + PdbPath,
+                                   inconvertibleErrorCode());
 
   auto Stream = std::make_unique<MemoryBufferByteStream>(std::move(Buffer),
                                                          llvm::support::little);
 
   auto File = std::make_unique<PDBFile>(PdbPath, std::move(Stream), *Allocator);
   if (auto EC = File->parseFileHeaders())
     return std::move(EC);
 

 }
 
 Error NativeSession::createFromExe(StringRef ExePath,
                                    std::unique_ptr<IPDBSession> &Session) {
   Expected<std::string> PdbPath = getPdbPathFromExe(ExePath);
   if (!PdbPath)
     return PdbPath.takeError();
 
-  file_magic Magic;
-  auto EC = identify_magic(PdbPath.get(), Magic);
-  if (EC || Magic != file_magic::pdb)
-    return make_error<RawError>(EC);
+  Expected<file_magic> Magic = identify_magic_in_file(*PdbPath);
+  if (Error E = Magic.takeError())
+    return E;
+  if (*Magic != file_magic::pdb)
+    return make_error<StringError>("Expected a pdb file in: " + *PdbPath,
+                                   inconvertibleErrorCode());
 
   auto Allocator = std::make_unique<BumpPtrAllocator>();
   auto File = loadPdbFile(PdbPath.get(), Allocator);
   if (!File)
     return File.takeError();
 
   Session = std::make_unique<NativeSession>(std::move(File.get()),
                                             std::move(Allocator));

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

class SourceCode {
   const Optional<StringRef> load(StringRef FileName,
                                  const Optional<StringRef> &EmbeddedSource) {
     if (Lines <= 0)
       return None;
 
     if (EmbeddedSource)
       return EmbeddedSource;
     else {
-      ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+      Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
           MemoryBuffer::getFile(FileName);
-      if (!BufOrErr)
+      if (Error E = BufOrErr.takeError()) {
+        consumeError(std::move(E));
         return None;
+      }
       MemBuf = std::move(*BufOrErr);
       return MemBuf->getBuffer();
     }
   }
 
   const Optional<StringRef> pruneSource(const Optional<StringRef> &Source) {
     if (!Source)
       return None;
printError(Request,
              StringError("unable to parse arguments: " + Command,
                          std::make_error_code(std::errc::invalid_argument)),
              "");
 }
 
 bool JSONPrinter::printError(const Request &Request,
                              const ErrorInfoBase &ErrorInfo,
                              StringRef ErrorBanner) {
-  json::Object Json = toJSON(Request, ErrorInfo.message());
+  std::string Message;
+  if (ErrorInfo.isA<FileError>())
+    Message =
+        static_cast<const FileError &>(ErrorInfo).messageWithoutFileInfo();
+  else
+    Message = ErrorInfo.message();
+  json::Object Json = toJSON(Request, Message);
   if (ObjectList)
     ObjectList->push_back(std::move(Json));
   else
     printJSON(std::move(Json));
   return false;
 }
 
 void JSONPrinter::listBegin() {

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

if (sys::path::extension(Path) != ".dSYM") {
     ResourceName += ".dSYM";
   }
   sys::path::append(ResourceName, "Contents", "Resources", "DWARF");
   sys::path::append(ResourceName, Basename);
   return std::string(ResourceName.str());
 }
 
 bool checkFileCRC(StringRef Path, uint32_t CRCHash) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
+  Expected<std::unique_ptr<MemoryBuffer>> MB =
       MemoryBuffer::getFileOrSTDIN(Path);
-  if (!MB)
+  if (Error E = MB.takeError()) {
+    consumeError(std::move(E));
     return false;
+  }
   return CRCHash == llvm::crc32(arrayRefFromStringRef(MB.get()->getBuffer()));
 }
 
 bool findDebugBinary(const std::string &OrigPath,
                      const std::string &DebuglinkName, uint32_t CRCHash,
                      const std::string &FallbackDebugPath,
                      std::string &Result) {
   SmallString<16> OrigDir(OrigPath);

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

Error DynamicLibrarySearchGenerator::tryToGenerate(
   if (NewSymbols.empty())
     return Error::success();
 
   return JD.define(absoluteSymbols(std::move(NewSymbols)));
 }
 
 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
 StaticLibraryDefinitionGenerator::Load(ObjectLayer &L, const char *FileName) {
-  auto ArchiveBuffer = errorOrToExpected(MemoryBuffer::getFile(FileName));
+  auto ArchiveBuffer = MemoryBuffer::getFile(FileName);
 
   if (!ArchiveBuffer)
     return ArchiveBuffer.takeError();
 
   return Create(L, std::move(*ArchiveBuffer));
 }
 
 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
for (const auto &Obj : UB->objects()) {
       if (ObjTT.getArch() == TT.getArch() &&
           ObjTT.getSubArch() == TT.getSubArch() &&
           (TT.getVendor() == Triple::UnknownVendor ||
            ObjTT.getVendor() == TT.getVendor())) {
         // We found a match. Create an instance from a buffer covering this
         // slice.
         auto SliceBuffer = MemoryBuffer::getFileSlice(FileName, Obj.getSize(),
                                                       Obj.getOffset());
-        if (!SliceBuffer)
+        if (Error E = SliceBuffer.takeError())
           return make_error<StringError>(
               Twine("Could not create buffer for ") + TT.str() + " slice of " +
                   FileName + ": [ " + formatv("{0:x}", Obj.getOffset()) +
                   " .. " + formatv("{0:x}", Obj.getOffset() + Obj.getSize()) +
-                  ": " + SliceBuffer.getError().message(),
-              SliceBuffer.getError());
+                  ": " + toString(std::move(E)),
+              inconvertibleErrorCode());
         return Create(L, std::move(*SliceBuffer));
       }
     }
 
     return make_error<StringError>(Twine("Universal binary ") + FileName +
                                        " does not contain a slice for " +
                                        TT.str(),
                                    inconvertibleErrorCode());

llvm/lib/FuzzMutate/FuzzerCLI.cpp

for (int I = 1; I < ArgC; ++I) {
     if (Arg.startswith("-")) {
       if (Arg.equals("-ignore_remaining_args=1"))
         break;
       continue;
     }
 
     auto BufOrErr = MemoryBuffer::getFile(Arg, /*IsText=*/false,
                                           /*RequiresNullTerminator=*/false);
-    if (std::error_code EC = BufOrErr.getError()) {
-      errs() << "Error reading file: " << Arg << ": " << EC.message() << "\n";
+    if (Error E = BufOrErr.takeError()) {
+      errs() << "Error reading file: " << Arg << ": " << toString(std::move(E))
+             << "\n";
       return 1;
     }
     std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
     errs() << "Running: " << Arg << " (" << Buf->getBufferSize() << " bytes)\n";
     TestOne(reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),
             Buf->getBufferSize());
   }
   return 0;

llvm/lib/IR/Core.cpp

 
 /*===-- Memory buffers ----------------------------------------------------===*/
 
 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(
     const char *Path,
     LLVMMemoryBufferRef *OutMemBuf,
     char **OutMessage) {
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Path);
-  if (std::error_code EC = MBOrErr.getError()) {
-    *OutMessage = strdup(EC.message().c_str());
+  Expected<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Path);
+  if (Error E = MBOrErr.takeError()) {
+    *OutMessage = strdup(toString(std::move(E)).c_str());
     return 1;
   }
   *OutMemBuf = wrap(MBOrErr.get().release());
   return 0;
 }
 
 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
                                          char **OutMessage) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getSTDIN();
-  if (std::error_code EC = MBOrErr.getError()) {
-    *OutMessage = strdup(EC.message().c_str());
+  Expected<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getSTDIN();
+  if (Error E = MBOrErr.takeError()) {
+    *OutMessage = strdup(toString(std::move(E)).c_str());
     return 1;
   }
   *OutMemBuf = wrap(MBOrErr.get().release());
   return 0;
 }
 
 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(
     const char *InputData,

llvm/lib/IRReader/IRReader.cpp

llvm::getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer, SMDiagnostic &Err,
 
   return parseAssembly(Buffer->getMemBufferRef(), Err, Context);
 }
 
 std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,
                                                   SMDiagnostic &Err,
                                                   LLVMContext &Context,
                                                   bool ShouldLazyLoadMetadata) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  if (std::error_code EC = FileOrErr.getError()) {
+  if (Error E = FileOrErr.takeError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
-                       "Could not open input file: " + EC.message());
+                       "Could not open input file: " + toString(std::move(E)));
     return nullptr;
   }
 
   return getLazyIRModule(std::move(FileOrErr.get()), Err, Context,
                          ShouldLazyLoadMetadata);
 }
 
 std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
   }
 
   return parseAssembly(Buffer, Err, Context, nullptr, DataLayoutCallback);
 }
 
 std::unique_ptr<Module>
 llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
                   DataLayoutCallbackTy DataLayoutCallback) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
-  if (std::error_code EC = FileOrErr.getError()) {
+  if (Error E = FileOrErr.takeError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
-                       "Could not open input file: " + EC.message());
+                       "Could not open input file: " + toString(std::move(E)));
     return nullptr;
   }
 
   return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context,
                  DataLayoutCallback);
 }
 
 //===----------------------------------------------------------------------===//

llvm/lib/InterfaceStub/ELFObjHandler.cpp

 static Error writeELFBinaryToFile(StringRef FilePath, const IFSStub &Stub,
                                   bool WriteIfChanged) {
   ELFStubBuilder<ELFT> Builder{Stub};
   // Write Stub to memory first.
   std::vector<uint8_t> Buf(Builder.getSize());
   Builder.write(Buf.data());
 
   if (WriteIfChanged) {
-    if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
+    if (Expected<std::unique_ptr<MemoryBuffer>> BufOrError =
             MemoryBuffer::getFile(FilePath)) {
       // Compare Stub output with existing Stub file.
       // If Stub file unchanged, abort updating.
       if ((*BufOrError)->getBufferSize() == Builder.getSize() &&
           !memcmp((*BufOrError)->getBufferStart(), Buf.data(),
                   Builder.getSize()))
         return Error::success();
-    }
+    } else
+      consumeError(BufOrError.takeError());
   }
 
   Expected<std::unique_ptr<FileOutputBuffer>> BufOrError =
       FileOutputBuffer::create(FilePath, Builder.getSize());
   if (!BufOrError)
     return createStringError(errc::invalid_argument,
                              toString(BufOrError.takeError()) +
                                  " when trying to open `" + FilePath +

llvm/lib/LTO/Caching.cpp

return [=](unsigned Task, StringRef Key) -> AddStreamFn {
     SmallString<64> EntryPath;
     sys::path::append(EntryPath, CacheDirectoryPath, "llvmcache-" + Key);
     // First, see if we have a cache hit.
     SmallString<64> ResultPath;
     Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
         Twine(EntryPath), sys::fs::OF_UpdateAtime, &ResultPath);
     std::error_code EC;
     if (FDOrErr) {
-      ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+      Expected<std::unique_ptr<MemoryBuffer>> MBOrErr =
           MemoryBuffer::getOpenFile(*FDOrErr, EntryPath,
                                     /*FileSize=*/-1,
                                     /*RequiresNullTerminator=*/false);
       sys::fs::closeFile(*FDOrErr);
       if (MBOrErr) {
         AddBuffer(Task, std::move(*MBOrErr));
         return AddStreamFn();
       }
-      EC = MBOrErr.getError();
+      EC = errorToErrorCode(MBOrErr.takeError());
     } else {
       EC = errorToErrorCode(FDOrErr.takeError());
     }
 
     // On Windows we can fail to open a cache file with a permission denied
     // error. This generally means that another process has requested to delete
     // the file while it is still open, but it could also mean that another
     // process has opened the file without the sharing permissions we need.
struct CacheStream : NativeObjectStream {
             TempFile(std::move(TempFile)), EntryPath(std::move(EntryPath)),
             Task(Task) {}
 
       ~CacheStream() {
         // Make sure the stream is closed before committing it.
         OS.reset();
 
         // Open the file first to avoid racing with a cache pruner.
-        ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+        Expected<std::unique_ptr<MemoryBuffer>> MBOrErr =
             MemoryBuffer::getOpenFile(
                 sys::fs::convertFDToNativeFile(TempFile.FD), TempFile.TmpName,
                 /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
-        if (!MBOrErr)
+        if (Error E = MBOrErr.takeError())
           report_fatal_error(Twine("Failed to open new cache file ") +
-                             TempFile.TmpName + ": " +
-                             MBOrErr.getError().message() + "\n");
+                             TempFile.TmpName + ": " + toString(std::move(E)) +
+                             "\n");
 
         // On POSIX systems, this will atomically replace the destination if
         // it already exists. We try to emulate this on Windows, but this may
         // fail with a permission denied error (for example, if the destination
         // is currently opened by another process that does not give us the
         // sharing permissions we need). Since the existing file should be
         // semantically equivalent to the one we are trying to write, we give
         // AddBuffer a copy of the bytes we wrote in that case. We do this

llvm/lib/LTO/LTOBackend.cpp

auto ModuleLoader = [&](StringRef Identifier) {
     if (ModuleMap) {
       auto I = ModuleMap->find(Identifier);
       assert(I != ModuleMap->end());
       return I->second.getLazyModule(Mod.getContext(),
                                      /*ShouldLazyLoadMetadata=*/true,
                                      /*IsImporting*/ true);
     }
 
-    ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr =
+    Expected<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr =
         llvm::MemoryBuffer::getFile(Identifier);
-    if (!MBOrErr)
+    if (Error E = MBOrErr.takeError())
       return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
-          Twine("Error loading imported file ") + Identifier + " : ",
-          MBOrErr.getError()));
+          Twine("Error loading imported file ") + Identifier + " : " +
+              toString(std::move(E)),
+          inconvertibleErrorCode()));
 
     Expected<BitcodeModule> BMOrErr = findThinLTOModule(**MBOrErr);
     if (!BMOrErr)
       return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
           Twine("Error loading imported file ") + Identifier + " : " +
               toString(BMOrErr.takeError()),
           inconvertibleErrorCode()));
 

llvm/lib/LTO/LTOCodeGenerator.cpp

 
 std::unique_ptr<MemoryBuffer>
 LTOCodeGenerator::compileOptimized() {
   const char *name;
   if (!compileOptimizedToFile(&name))
     return nullptr;
 
   // read .o file into memory buffer
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = MemoryBuffer::getFile(
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr = MemoryBuffer::getFile(
       name, /*IsText=*/false, /*RequiresNullTerminator=*/false);
-  if (std::error_code EC = BufferOrErr.getError()) {
-    emitError(EC.message());
+  if (Error E = BufferOrErr.takeError()) {
+    emitError(toString(std::move(E)));
     sys::fs::remove(NativeObjectPath);
     return nullptr;
   }
 
   // remove temp files
   sys::fs::remove(NativeObjectPath);
 
   return std::move(*BufferOrErr);

llvm/lib/LTO/LTOModule.cpp

 /// bitcode.
 bool LTOModule::isBitcodeFile(const void *Mem, size_t Length) {
   Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
       MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>"));
   return !errorToBool(BCData.takeError());
 }
 
 bool LTOModule::isBitcodeFile(StringRef Path) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(Path);
-  if (!BufferOrErr)
+  if (Error E = BufferOrErr.takeError()) {
+    consumeError(std::move(E));
     return false;
+  }
 
   Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
       BufferOrErr.get()->getMemBufferRef());
   return !errorToBool(BCData.takeError());
 }
 
 bool LTOModule::isThinLTO() {
   Expected<BitcodeLTOInfo> Result = getBitcodeLTOInfo(MBRef);
std::string LTOModule::getProducerString(MemoryBuffer *Buffer) {
   if (!ProducerOrErr)
     return "";
   return *ProducerOrErr;
 }
 
 ErrorOr<std::unique_ptr<LTOModule>>
 LTOModule::createFromFile(LLVMContext &Context, StringRef path,
                           const TargetOptions &options) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(path);
-  if (std::error_code EC = BufferOrErr.getError()) {
+  if (std::error_code EC = errorToErrorCode(BufferOrErr.takeError())) {
     Context.emitError(EC.message());
     return EC;
   }
   std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
   return makeLTOModule(Buffer->getMemBufferRef(), options, Context,
                        /* ShouldBeLazy*/ false);
 }
 
 ErrorOr<std::unique_ptr<LTOModule>>
 LTOModule::createFromOpenFile(LLVMContext &Context, int fd, StringRef path,
                               size_t size, const TargetOptions &options) {
   return createFromOpenFileSlice(Context, fd, path, size, 0, options);
 }
 
 ErrorOr<std::unique_ptr<LTOModule>>
 LTOModule::createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path,
                                    size_t map_size, off_t offset,
                                    const TargetOptions &options) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getOpenFileSlice(sys::fs::convertFDToNativeFile(fd), path,
                                      map_size, offset);
-  if (std::error_code EC = BufferOrErr.getError()) {
+  if (std::error_code EC = errorToErrorCode(BufferOrErr.takeError())) {
     Context.emitError(EC.message());
     return EC;
   }
   std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
   return makeLTOModule(Buffer->getMemBufferRef(), options, Context,
                        /* ShouldBeLazy */ false);
 }
 

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

public:
   ErrorOr<std::unique_ptr<MemoryBuffer>> tryLoadingBuffer() {
     if (EntryPath.empty())
       return std::error_code();
     SmallString<64> ResultPath;
     Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
         Twine(EntryPath), sys::fs::OF_UpdateAtime, &ResultPath);
     if (!FDOrErr)
       return errorToErrorCode(FDOrErr.takeError());
-    ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getOpenFile(
+    Expected<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getOpenFile(
         *FDOrErr, EntryPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
     sys::fs::closeFile(*FDOrErr);
-    return MBOrErr;
+    return expectedToErrorOr(std::move(MBOrErr));
   }
 
   // Cache the Produced object file
   void write(const MemoryBuffer &OutputBuffer) {
     if (EntryPath.empty())
       return;
 
     // Write to a temporary to avoid race condition

llvm/lib/Object/Archive.cpp

if (!isThin) {
     if (!Size)
       return Size.takeError();
     return StringRef(Data.data() + StartOfFile, Size.get());
   }
   Expected<std::string> FullNameOrErr = getFullName();
   if (!FullNameOrErr)
     return FullNameOrErr.takeError();
   const std::string &FullName = *FullNameOrErr;
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(FullName);
-  if (std::error_code EC = Buf.getError())
-    return errorCodeToError(EC);
+  Expected<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(FullName);
+  if (Error E = Buf.takeError())
+    return E;
   Parent->ThinBuffers.push_back(std::move(*Buf));
   return Parent->ThinBuffers.back()->getBuffer();
 }
 
 Expected<Archive::Child> Archive::Child::getNext() const {
   size_t SpaceToSkip = Data.size();
   // If it's odd, add 1 to make it even.
   if (SpaceToSkip & 1)

 
 Expected<MemoryBufferRef> Archive::Child::getMemoryBufferRef() const {
   Expected<StringRef> NameOrErr = getName();
   if (!NameOrErr)
     return NameOrErr.takeError();
   StringRef Name = NameOrErr.get();
   Expected<StringRef> Buf = getBuffer();
   if (!Buf)
-    return createFileError(Name, Buf.takeError());
+    return Buf.takeError();
   return MemoryBufferRef(*Buf, Name);
 }
 
 Expected<std::unique_ptr<Binary>>
 Archive::Child::getAsBinary(LLVMContext *Context) const {
   Expected<MemoryBufferRef> BuffOrErr = getMemoryBufferRef();
   if (!BuffOrErr)
     return BuffOrErr.takeError();

llvm/lib/Object/ArchiveWriter.cpp

Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName,
   sys::fs::file_status Status;
   auto FDOrErr = sys::fs::openNativeFileForRead(FileName);
   if (!FDOrErr)
     return FDOrErr.takeError();
   sys::fs::file_t FD = *FDOrErr;
   assert(FD != sys::fs::kInvalidFile);
 
   if (auto EC = sys::fs::status(FD, Status))
-    return errorCodeToError(EC);
+    return createFileError(FileName, errorCodeToError(EC));
 
   // Opening a directory doesn't make sense. Let it fail.
   // Linux cannot open directories with open(2), although
   // cygwin and *bsd can.
   if (Status.type() == sys::fs::file_type::directory_file)
-    return errorCodeToError(make_error_code(errc::is_a_directory));
+    return createFileError(
+        FileName, errorCodeToError(make_error_code(errc::is_a_directory)));
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr =
       MemoryBuffer::getOpenFile(FD, FileName, Status.getSize(), false);
-  if (!MemberBufferOrErr)
-    return errorCodeToError(MemberBufferOrErr.getError());
+  if (Error E = MemberBufferOrErr.takeError())
+    return createFileError(FileName, std::move(E));
 
   if (auto EC = sys::fs::closeFile(FD))
-    return errorCodeToError(EC);
+    return createFileError(FileName, errorCodeToError(EC));
 
   NewArchiveMember M;
   M.Buf = std::move(*MemberBufferOrErr);
   M.MemberName = M.Buf->getBufferIdentifier();
   if (!Deterministic) {
     M.ModTime = std::chrono::time_point_cast<std::chrono::seconds>(
         Status.getLastModificationTime());
     M.UID = Status.getUser();

llvm/lib/Object/Binary.cpp

Expected<std::unique_ptr<Binary>> object::createBinary(MemoryBufferRef Buffer,
   case file_magic::tapi_file:
     return TapiUniversal::create(Buffer);
   }
   llvm_unreachable("Unexpected Binary File Type");
 }
 
 Expected<OwningBinary<Binary>>
 object::createBinary(StringRef Path, LLVMContext *Context, bool InitContent) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
-  if (std::error_code EC = FileOrErr.getError())
-    return errorCodeToError(EC);
+  if (Error E = FileOrErr.takeError())
+    return E;
   std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
 
   Expected<std::unique_ptr<Binary>> BinOrErr =
       createBinary(Buffer->getMemBufferRef(), Context, InitContent);
-  if (!BinOrErr)
-    return BinOrErr.takeError();
+  if (Error E = BinOrErr.takeError())
+    return createFileError(Path, std::move(E));
   std::unique_ptr<Binary> &Bin = BinOrErr.get();
 
   return OwningBinary<Binary>(std::move(Bin), std::move(Buffer));
 }

llvm/lib/Object/Error.cpp

 
 static ManagedStatic<_object_error_category> error_category;
 
 const std::error_category &object::object_category() {
   return *error_category;
 }
 
 llvm::Error llvm::object::isNotObjectErrorInvalidFileType(llvm::Error Err) {
-  return handleErrors(std::move(Err), [](std::unique_ptr<ECError> M) -> Error {
+  return handleErrors(
+      std::move(Err), [](std::unique_ptr<ErrorInfoBase> M) -> Error {
         // Try to handle 'M'. If successful, return a success value from
         // the handler.
         if (M->convertToErrorCode() == object_error::invalid_file_type)
           return Error::success();
 
         // We failed to handle 'M' - return it from the handler.
         // This value will be passed back from catchErrors and
         // wind up in Err2, where it will be returned from this function.
         return Error(std::move(M));
       });
 }

llvm/lib/Object/ObjectFile.cpp

ObjectFile::createObjectFile(MemoryBufferRef Object, file_magic Type,
   case file_magic::wasm_object:
     return createWasmObjectFile(Object);
   }
   llvm_unreachable("Unexpected Object File Type");
 }
 
 Expected<OwningBinary<ObjectFile>>
 ObjectFile::createObjectFile(StringRef ObjectPath) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFile(ObjectPath);
-  if (std::error_code EC = FileOrErr.getError())
-    return errorCodeToError(EC);
+  if (!FileOrErr)
+    return FileOrErr.takeError();
   std::unique_ptr<MemoryBuffer> Buffer = std::move(FileOrErr.get());
 
   Expected<std::unique_ptr<ObjectFile>> ObjOrErr =
       createObjectFile(Buffer->getMemBufferRef());
   if (Error Err = ObjOrErr.takeError())
     return std::move(Err);
   std::unique_ptr<ObjectFile> Obj = std::move(ObjOrErr.get());
 
   return OwningBinary<ObjectFile>(std::move(Obj), std::move(Buffer));
 }

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

if (Error E = ProfileReaderOrErr.takeError())
     return std::move(E);
   auto ProfileReader = std::move(ProfileReaderOrErr.get());
   auto Coverage = std::unique_ptr<CoverageMapping>(new CoverageMapping());
   bool DataFound = false;
 
   for (const auto &File : llvm::enumerate(ObjectFilenames)) {
     auto CovMappingBufOrErr = MemoryBuffer::getFileOrSTDIN(
         File.value(), /*IsText=*/false, /*RequiresNullTerminator=*/false);
-    if (std::error_code EC = CovMappingBufOrErr.getError())
-      return errorCodeToError(EC);
+    if (Error E = CovMappingBufOrErr.takeError())
+      return E;
     StringRef Arch = Arches.empty() ? StringRef() : Arches[File.index()];
     MemoryBufferRef CovMappingBufRef =
         CovMappingBufOrErr.get()->getMemBufferRef();
     SmallVector<std::unique_ptr<MemoryBuffer>, 4> Buffers;
     auto CoverageReadersOrErr = BinaryCoverageReader::create(
         CovMappingBufRef, Arch, Buffers, CompilationDir);
     if (Error E = CoverageReadersOrErr.takeError()) {
       E = handleMaybeNoDataFoundError(std::move(E));

llvm/lib/ProfileData/GCOV.cpp

class LineConsumer {
   std::unique_ptr<MemoryBuffer> Buffer;
   StringRef Remaining;
 
 public:
   LineConsumer() = default;
   LineConsumer(StringRef Filename) {
     // Open source files without requiring a NUL terminator. The concurrent
     // modification may nullify the NUL terminator condition.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
         MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/false,
                                      /*RequiresNullTerminator=*/false);
-    if (std::error_code EC = BufferOrErr.getError()) {
-      errs() << Filename << ": " << EC.message() << "\n";
+    if (Error E = BufferOrErr.takeError()) {
+      errs() << Filename << ": " << toString(std::move(E)) << "\n";
       Remaining = "";
     } else {
       Buffer = std::move(BufferOrErr.get());
       Remaining = Buffer->getBuffer();
     }
   }
   bool empty() { return Remaining.empty(); }
   void printNext(raw_ostream &OS, uint32_t LineNum) {

llvm/lib/ProfileData/InstrProfReader.cpp

 #include <system_error>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 static Expected<std::unique_ptr<MemoryBuffer>>
 setupMemoryBuffer(const Twine &Path) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
-      MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/true);
-  if (std::error_code EC = BufferOrErr.getError())
-    return errorCodeToError(EC);
-  return std::move(BufferOrErr.get());
+  return MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/true);
 }
 
 static Error initializeReader(InstrProfReader &Reader) {
   return Reader.readHeader();
 }
 
 Expected<std::unique_ptr<InstrProfReader>>
 InstrProfReader::create(const Twine &Path) {

llvm/lib/ProfileData/SampleProfReader.cpp

 }
 
 /// Prepare a memory buffer for the contents of \p Filename.
 ///
 /// \returns an error code indicating the status of the buffer.
 static ErrorOr<std::unique_ptr<MemoryBuffer>>
 setupMemoryBuffer(const Twine &Filename) {
   auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
-  if (std::error_code EC = BufferOrErr.getError())
-    return EC;
+  if (Error E = BufferOrErr.takeError())
+    return errorToErrorCode(std::move(E));
   auto Buffer = std::move(BufferOrErr.get());
 
   // Sanity check the file.
   if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<uint32_t>::max())
     return sampleprof_error::too_large;
 
   return std::move(Buffer);
 }

llvm/lib/Remarks/BitstreamRemarkParser.cpp

return createStringError(
         "Error while parsing BLOCK_META: missing external file path.");
 
   SmallString<80> FullPath(ExternalFilePrependPath);
   sys::path::append(FullPath, *ExternalFilePath);
 
   // External file: open the external file, parse it, check if its metadata
   // matches the one from the separate metadata, then replace the current parser
   // with the one parsing the remarks.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(FullPath);
-  if (std::error_code EC = BufferOrErr.getError())
-    return createFileError(FullPath, EC);
+  if (Error E = BufferOrErr.takeError())
+    return E;
 
   TmpRemarkBuffer = std::move(*BufferOrErr);
 
   // Don't try to parse the file if it's empty.
   if (TmpRemarkBuffer->getBufferSize() == 0)
     return make_error<EndOfFileError>();
 
   // Create a separate parser used for parsing the separate file.

llvm/lib/Remarks/YAMLRemarkParser.cpp

if (!Buf.startswith("---")) {
       // At this point, we expect Buf to contain the external file path.
       StringRef ExternalFilePath = Buf;
       SmallString<80> FullPath;
       if (ExternalFilePrependPath)
         FullPath = *ExternalFilePrependPath;
       sys::path::append(FullPath, ExternalFilePath);
 
       // Try to open the file and start parsing from there.
-      ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+      Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
           MemoryBuffer::getFile(FullPath);
-      if (std::error_code EC = BufferOrErr.getError())
-        return createFileError(FullPath, EC);
+      if (Error E = BufferOrErr.takeError())
+        return E;
 
       // Keep the buffer alive.
       SeparateBuf = std::move(*BufferOrErr);
       Buf = SeparateBuf->getBuffer();
     }
   }
 
   std::unique_ptr<YAMLRemarkParser> Result =

llvm/lib/Support/Error.cpp

 }
 
 std::error_code inconvertibleErrorCode() {
   return std::error_code(static_cast<int>(ErrorErrorCode::InconvertibleError),
                          *ErrorErrorCat);
 }
 
 std::error_code FileError::convertToErrorCode() const {
+  std::error_code NestedEC = Err->convertToErrorCode();
+  if (NestedEC == inconvertibleErrorCode())
     return std::error_code(static_cast<int>(ErrorErrorCode::FileError),
                            *ErrorErrorCat);
+  return NestedEC;
 }
 
 Error errorCodeToError(std::error_code EC) {
   if (!EC)
     return Error::success();
   return Error(std::make_unique<ECError>(ECError(EC)));
 }
 

llvm/lib/Support/FileUtilities.cpp

 /// DiffFilesWithTolerance - Compare the two files specified, returning 0 if the
 /// files match, 1 if they are different, and 2 if there is a file error.  This
 /// function differs from DiffFiles in that you can specify an absolete and
 /// relative FP error that is allowed to exist.  If you specify a string to fill
 /// in for the error option, it will set the string to an error message if an
 /// error occurs, allowing the caller to distinguish between a failed diff and a
 /// file system error.
 ///
-int llvm::DiffFilesWithTolerance(StringRef NameA,
-                                 StringRef NameB,
+int llvm::DiffFilesWithTolerance(StringRef NameA, StringRef NameB,
                                  double AbsTol, double RelTol,
-                                 std::string *Error) {
+                                 std::string *ErrString) {
   // Now its safe to mmap the files into memory because both files
   // have a non-zero size.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> F1OrErr = MemoryBuffer::getFile(NameA);
-  if (std::error_code EC = F1OrErr.getError()) {
-    if (Error)
-      *Error = EC.message();
+  Expected<std::unique_ptr<MemoryBuffer>> F1OrErr =
+      MemoryBuffer::getFile(NameA);
+  if (Error E = F1OrErr.takeError()) {
+    if (ErrString)
+      *ErrString = toString(std::move(E));
     return 2;
   }
   MemoryBuffer &F1 = *F1OrErr.get();
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> F2OrErr = MemoryBuffer::getFile(NameB);
-  if (std::error_code EC = F2OrErr.getError()) {
-    if (Error)
-      *Error = EC.message();
+  Expected<std::unique_ptr<MemoryBuffer>> F2OrErr =
+      MemoryBuffer::getFile(NameB);
+  if (Error E = F1OrErr.takeError()) {
+    if (ErrString)
+      *ErrString = toString(std::move(E));
     return 2;
   }
   MemoryBuffer &F2 = *F2OrErr.get();
 
   // Okay, now that we opened the files, scan them for the first difference.
   const char *File1Start = F1.getBufferStart();
   const char *File2Start = F2.getBufferStart();
   const char *File1End = F1.getBufferEnd();
   const char *File2End = F2.getBufferEnd();
   const char *F1P = File1Start;
   const char *F2P = File2Start;
   uint64_t A_size = F1.getBufferSize();
   uint64_t B_size = F2.getBufferSize();
 
   // Are the buffers identical?  Common case: Handle this efficiently.
   if (A_size == B_size &&
       std::memcmp(File1Start, File2Start, A_size) == 0)
     return 0;
 
   // Otherwise, we are done a tolerances are set.
   if (AbsTol == 0 && RelTol == 0) {
-    if (Error)
-      *Error = "Files differ without tolerance allowance";
+    if (ErrString)
+      *ErrString = "Files differ without tolerance allowance";
     return 1;   // Files different!
   }
 
   bool CompareFailed = false;
   while (true) {
     // Scan for the end of file or next difference.
     while (F1P < File1End && F2P < File2End && *F1P == *F2P) {
       ++F1P;
       ++F2P;
     }
 
     if (F1P >= File1End || F2P >= File2End) break;
 
     // Okay, we must have found a difference.  Backup to the start of the
     // current number each stream is at so that we can compare from the
     // beginning.
     F1P = BackupNumber(F1P, File1Start);
     F2P = BackupNumber(F2P, File2Start);
 
     // Now that we are at the start of the numbers, compare them, exiting if
     // they don't match.
-    if (CompareNumbers(F1P, F2P, File1End, File2End, AbsTol, RelTol, Error)) {
+    if (CompareNumbers(F1P, F2P, File1End, File2End, AbsTol, RelTol,
+                       ErrString)) {
       CompareFailed = true;
       break;
     }
   }
 
   // Okay, we reached the end of file.  If both files are at the end, we
   // succeeded.
   bool F1AtEnd = F1P >= File1End;
   bool F2AtEnd = F2P >= File2End;
   if (!CompareFailed && (!F1AtEnd || !F2AtEnd)) {
     // Else, we might have run off the end due to a number: backup and retry.
     if (F1AtEnd && isNumberChar(F1P[-1])) --F1P;
     if (F2AtEnd && isNumberChar(F2P[-1])) --F2P;
     F1P = BackupNumber(F1P, File1Start);
     F2P = BackupNumber(F2P, File2Start);
 
     // Now that we are at the start of the numbers, compare them, exiting if
     // they don't match.
-    if (CompareNumbers(F1P, F2P, File1End, File2End, AbsTol, RelTol, Error))
+    if (CompareNumbers(F1P, F2P, File1End, File2End, AbsTol, RelTol, ErrString))
       CompareFailed = true;
 
     // If we found the end, we succeeded.
     if (F1P < File1End || F2P < File2End)
       CompareFailed = true;
   }
 
   return CompareFailed;

llvm/lib/Support/Host.cpp

 //  Implementations of the CPU detection routines
 //
 //===----------------------------------------------------------------------===//
 
 using namespace llvm;
 
 static std::unique_ptr<llvm::MemoryBuffer>
     LLVM_ATTRIBUTE_UNUSED getProcCpuinfoContent() {
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
+  Expected<std::unique_ptr<llvm::MemoryBuffer>> Text =
       llvm::MemoryBuffer::getFileAsStream("/proc/cpuinfo");
-  if (std::error_code EC = Text.getError()) {
+  if (Error E = Text.takeError()) {
     llvm::errs() << "Can't read "
-                 << "/proc/cpuinfo: " << EC.message() << "\n";
+                 << "/proc/cpuinfo: " << toString(std::move(E)) << "\n";
     return nullptr;
   }
   return std::move(*Text);
 }
 
 StringRef sys::detail::getHostCPUNameForPowerPC(StringRef ProcCpuinfoContent) {
   // Access to the Processor Version Register (PVR) on PowerPC is privileged,
   // and so we must use an operating-system interface to determine the current
int computeHostNumPhysicalCores() {
   // one processor id enabled by the CPU affinity mask.
   cpu_set_t Affinity, Enabled;
   if (sched_getaffinity(0, sizeof(Affinity), &Affinity) != 0)
     return -1;
   CPU_ZERO(&Enabled);
 
   // Read /proc/cpuinfo as a stream (until EOF reached). It cannot be
   // mmapped because it appears to have 0 size.
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
+  Expected<std::unique_ptr<llvm::MemoryBuffer>> Text =
       llvm::MemoryBuffer::getFileAsStream("/proc/cpuinfo");
-  if (std::error_code EC = Text.getError()) {
+  if (Error E = Text.takeError()) {
     llvm::errs() << "Can't read "
-                 << "/proc/cpuinfo: " << EC.message() << "\n";
+                 << "/proc/cpuinfo: " << toString(std::move(E)) << "\n";
     return -1;
   }
   SmallVector<StringRef, 8> strs;
   (*Text)->getBuffer().split(strs, "\n", /*MaxSplit=*/-1,
                              /*KeepEmpty=*/false);
   int CurProcessor = -1;
   int CurPhysicalId = -1;
   int CurSiblings = -1;

llvm/lib/Support/LockFileManager.cpp

 ///
 /// \param LockFileName The name of the lock file to read.
 ///
 /// \returns The process ID of the process that owns this lock file
 Optional<std::pair<std::string, int> >
 LockFileManager::readLockFile(StringRef LockFileName) {
   // Read the owning host and PID out of the lock file. If it appears that the
   // owning process is dead, the lock file is invalid.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> MBOrErr =
       MemoryBuffer::getFile(LockFileName);
-  if (!MBOrErr) {
+  if (Error E = MBOrErr.takeError()) {
+    consumeError(std::move(E));
     sys::fs::remove(LockFileName);
     return None;
   }
   MemoryBuffer &MB = *MBOrErr.get();
 
   StringRef Hostname;
   StringRef PIDStr;
   std::tie(Hostname, PIDStr) = getToken(MB.getBuffer(), " ");

llvm/lib/Support/MemoryBuffer.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/AutoConvert.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Errno.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/SmallVectorMemoryBuffer.h"
 #include <cassert>
 #include <cerrno>
public:
 
   MemoryBuffer::BufferKind getBufferKind() const override {
     return MemoryBuffer::MemoryBuffer_Malloc;
   }
 };
 } // namespace
 
 template <typename MB>
-static ErrorOr<std::unique_ptr<MB>>
+static Expected<std::unique_ptr<MB>>
 getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
            bool IsText, bool RequiresNullTerminator, bool IsVolatile);
 
 std::unique_ptr<MemoryBuffer>
 MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName,
                            bool RequiresNullTerminator) {
   auto *Ret = new (NamedBufferAlloc(BufferName))
       MemoryBufferMem<MemoryBuffer>(InputData, RequiresNullTerminator);
   return std::unique_ptr<MemoryBuffer>(Ret);
 }
 
 std::unique_ptr<MemoryBuffer>
 MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) {
   return std::unique_ptr<MemoryBuffer>(getMemBuffer(
       Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator));
 }
 
-static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
+static Expected<std::unique_ptr<WritableMemoryBuffer>>
 getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName) {
   auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(InputData.size(), BufferName);
   if (!Buf)
-    return make_error_code(errc::not_enough_memory);
+    return errorCodeToError(errc::not_enough_memory);
   memcpy(Buf->getBufferStart(), InputData.data(), InputData.size());
   return std::move(Buf);
 }
 
 std::unique_ptr<MemoryBuffer>
 MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
   auto Buf = getMemBufferCopyImpl(InputData, BufferName);
   if (Buf)
     return std::move(*Buf);
   return nullptr;
 }
 
-ErrorOr<std::unique_ptr<MemoryBuffer>>
+Expected<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getFileOrSTDIN(const Twine &Filename, bool IsText,
                              bool RequiresNullTerminator) {
   SmallString<256> NameBuf;
   StringRef NameRef = Filename.toStringRef(NameBuf);
 
   if (NameRef == "-")
     return getSTDIN();
   return getFile(Filename, IsText, RequiresNullTerminator,
                  /*IsVolatile=*/false);
 }
 
-ErrorOr<std::unique_ptr<MemoryBuffer>>
+Expected<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize,
                            uint64_t Offset, bool IsVolatile) {
   return getFileAux<MemoryBuffer>(FilePath, MapSize, Offset, /*IsText=*/false,
                                   /*RequiresNullTerminator=*/false, IsVolatile);
 }
 
 //===----------------------------------------------------------------------===//
 // MemoryBuffer::getFile implementation.
public:
   }
 
   MemoryBuffer::BufferKind getBufferKind() const override {
     return MemoryBuffer::MemoryBuffer_MMap;
   }
 };
 } // namespace
 
-static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
+static Expected<std::unique_ptr<WritableMemoryBuffer>>
 getMemoryBufferForStream(sys::fs::file_t FD, const Twine &BufferName) {
   const ssize_t ChunkSize = 4096*4;
   SmallString<ChunkSize> Buffer;
   // Read into Buffer until we hit EOF.
   for (;;) {
     Buffer.reserve(Buffer.size() + ChunkSize);
     Expected<size_t> ReadBytes = sys::fs::readNativeFile(
         FD, makeMutableArrayRef(Buffer.end(), ChunkSize));
-    if (!ReadBytes)
-      return errorToErrorCode(ReadBytes.takeError());
+    if (Error E = ReadBytes.takeError())
+      return make_error<StringError>(BufferName + ": " + toString(std::move(E)),
+                                     inconvertibleErrorCode());
     if (*ReadBytes == 0)
       break;
     Buffer.set_size(Buffer.size() + *ReadBytes);
   }
 
   return getMemBufferCopyImpl(Buffer, BufferName);
 }
 
-ErrorOr<std::unique_ptr<MemoryBuffer>>
+Expected<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getFile(const Twine &Filename, bool IsText,
                       bool RequiresNullTerminator, bool IsVolatile) {
   return getFileAux<MemoryBuffer>(Filename, /*MapSize=*/-1, /*Offset=*/0,
                                   IsText, RequiresNullTerminator, IsVolatile);
 }
 
 template <typename MB>
-static ErrorOr<std::unique_ptr<MB>>
+static Expected<std::unique_ptr<MB>>
 getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
                 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
                 bool IsVolatile);
 
 template <typename MB>
-static ErrorOr<std::unique_ptr<MB>>
+static Expected<std::unique_ptr<MB>>
 getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
            bool IsText, bool RequiresNullTerminator, bool IsVolatile) {
   Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
       Filename, IsText ? sys::fs::OF_TextWithCRLF : sys::fs::OF_None);
   if (!FDOrErr)
-    return errorToErrorCode(FDOrErr.takeError());
+    return FDOrErr.takeError();
   sys::fs::file_t FD = *FDOrErr;
   auto Ret = getOpenFileImpl<MB>(FD, Filename, /*FileSize=*/-1, MapSize, Offset,
                                  RequiresNullTerminator, IsVolatile);
   sys::fs::closeFile(FD);
   return Ret;
 }
 
-ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
+Expected<std::unique_ptr<WritableMemoryBuffer>>
 WritableMemoryBuffer::getFile(const Twine &Filename, bool IsVolatile) {
   return getFileAux<WritableMemoryBuffer>(
       Filename, /*MapSize=*/-1, /*Offset=*/0, /*IsText=*/false,
       /*RequiresNullTerminator=*/false, IsVolatile);
 }
 
-ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
+Expected<std::unique_ptr<WritableMemoryBuffer>>
 WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
                                    uint64_t Offset, bool IsVolatile) {
   return getFileAux<WritableMemoryBuffer>(
       Filename, MapSize, Offset, /*IsText=*/false,
       /*RequiresNullTerminator=*/false, IsVolatile);
 }
 
 std::unique_ptr<WritableMemoryBuffer>
#if defined(__CYGWIN__)
   // FIXME: We should reorganize again getPageSize() on Win32.
   if ((FileSize & (4096 - 1)) == 0)
     return false;
 #endif
 
   return true;
 }
 
-static ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
+static Expected<std::unique_ptr<WriteThroughMemoryBuffer>>
 getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize,
                  uint64_t Offset) {
   Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForReadWrite(
       Filename, sys::fs::CD_OpenExisting, sys::fs::OF_None);
   if (!FDOrErr)
-    return errorToErrorCode(FDOrErr.takeError());
+    return FDOrErr.takeError();
   sys::fs::file_t FD = *FDOrErr;
 
   // Default is to map the full file.
   if (MapSize == uint64_t(-1)) {
     // If we don't know the file size, use fstat to find out.  fstat on an open
     // file descriptor is cheaper than stat on a random path.
     if (FileSize == uint64_t(-1)) {
       sys::fs::file_status Status;
       std::error_code EC = sys::fs::status(FD, Status);
       if (EC)
-        return EC;
+        return errorCodeToError(EC);
 
       // If this not a file or a block device (e.g. it's a named pipe
       // or character device), we can't mmap it, so error out.
       sys::fs::file_type Type = Status.type();
       if (Type != sys::fs::file_type::regular_file &&
           Type != sys::fs::file_type::block_file)
-        return make_error_code(errc::invalid_argument);
+        return errorCodeToError(errc::invalid_argument);
 
       FileSize = Status.getSize();
     }
     MapSize = FileSize;
   }
 
   std::error_code EC;
   std::unique_ptr<WriteThroughMemoryBuffer> Result(
       new (NamedBufferAlloc(Filename))
           MemoryBufferMMapFile<WriteThroughMemoryBuffer>(false, FD, MapSize,
                                                          Offset, EC));
   if (EC)
-    return EC;
+    return errorCodeToError(EC);
   return std::move(Result);
 }
 
-ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
+Expected<std::unique_ptr<WriteThroughMemoryBuffer>>
 WriteThroughMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize) {
   return getReadWriteFile(Filename, FileSize, FileSize, 0);
 }
 
 /// Map a subrange of the specified file as a WritableMemoryBuffer.
-ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
+Expected<std::unique_ptr<WriteThroughMemoryBuffer>>
 WriteThroughMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
                                        uint64_t Offset) {
   return getReadWriteFile(Filename, -1, MapSize, Offset);
 }
 
 template <typename MB>
-static ErrorOr<std::unique_ptr<MB>>
+static Expected<std::unique_ptr<MB>>
 getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
                 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
                 bool IsVolatile) {
   static int PageSize = sys::Process::getPageSizeEstimate();
 
   // Default is to map the full file.
   if (MapSize == uint64_t(-1)) {
     // If we don't know the file size, use fstat to find out.  fstat on an open
     // file descriptor is cheaper than stat on a random path.
     if (FileSize == uint64_t(-1)) {
       sys::fs::file_status Status;
       std::error_code EC = sys::fs::status(FD, Status);
       if (EC)
-        return EC;
+        return make_error<StringError>(Filename + ": " + EC.message(), EC);
 
       // If this not a file or a block device (e.g. it's a named pipe
       // or character device), we can't trust the size. Create the memory
       // buffer by copying off the stream.
       sys::fs::file_type Type = Status.type();
       if (Type != sys::fs::file_type::regular_file &&
           Type != sys::fs::file_type::block_file)
         return getMemoryBufferForStream(FD, Filename);
#ifdef __MVS__
   if (auto EC = llvm::enableAutoConversion(FD))
     return EC;
 #endif
 
   auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(MapSize, Filename);
   if (!Buf) {
     // Failed to create a buffer. The only way it can fail is if
     // new(std::nothrow) returns 0.
-    return make_error_code(errc::not_enough_memory);
+    return errorCodeToError(errc::not_enough_memory);
   }
 
   // Read until EOF, zero-initialize the rest.
   MutableArrayRef<char> ToRead = Buf->getBuffer();
   while (!ToRead.empty()) {
     Expected<size_t> ReadBytes =
         sys::fs::readNativeFileSlice(FD, ToRead, Offset);
     if (!ReadBytes)
-      return errorToErrorCode(ReadBytes.takeError());
+      return ReadBytes.takeError();
     if (*ReadBytes == 0) {
       std::memset(ToRead.data(), 0, ToRead.size());
       break;
     }
     ToRead = ToRead.drop_front(*ReadBytes);
     Offset += *ReadBytes;
   }
 
   return std::move(Buf);
 }
 
-ErrorOr<std::unique_ptr<MemoryBuffer>>
-MemoryBuffer::getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
-                          bool RequiresNullTerminator, bool IsVolatile) {
+Expected<std::unique_ptr<MemoryBuffer>>
+MemoryBuffer::getOpenFile(sys::fs::file_t FD, const Twine &Filename,
+                          uint64_t FileSize, bool RequiresNullTerminator,
+                          bool IsVolatile) {
   return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, FileSize, 0,
                          RequiresNullTerminator, IsVolatile);
 }
 
-ErrorOr<std::unique_ptr<MemoryBuffer>>
-MemoryBuffer::getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize,
-                               int64_t Offset, bool IsVolatile) {
+Expected<std::unique_ptr<MemoryBuffer>>
+MemoryBuffer::getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename,
+                               uint64_t MapSize, int64_t Offset,
+                               bool IsVolatile) {
   assert(MapSize != uint64_t(-1));
   return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false,
                                        IsVolatile);
 }
 
-ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getSTDIN() {
+Expected<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getSTDIN() {
   // Read in all of the data from stdin, we cannot mmap stdin.
   //
   // FIXME: That isn't necessarily true, we should try to mmap stdin and
   // fallback if it fails.
   sys::ChangeStdinMode(sys::fs::OF_Text);
 
   return getMemoryBufferForStream(sys::fs::getStdinHandle(), "<stdin>");
 }
 
-ErrorOr<std::unique_ptr<MemoryBuffer>>
+Expected<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getFileAsStream(const Twine &Filename) {
   Expected<sys::fs::file_t> FDOrErr =
       sys::fs::openNativeFileForRead(Filename, sys::fs::OF_None);
   if (!FDOrErr)
-    return errorToErrorCode(FDOrErr.takeError());
+    return FDOrErr.takeError();
   sys::fs::file_t FD = *FDOrErr;
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Ret =
+  Expected<std::unique_ptr<MemoryBuffer>> Ret =
       getMemoryBufferForStream(FD, Filename);
   sys::fs::closeFile(FD);
   return Ret;
 }
 
 MemoryBufferRef MemoryBuffer::getMemBufferRef() const {
   StringRef Data = getBuffer();
   StringRef Identifier = getBufferIdentifier();
   return MemoryBufferRef(Data, Identifier);
 }
 
 SmallVectorMemoryBuffer::~SmallVectorMemoryBuffer() {}

llvm/lib/Support/SourceMgr.cpp

 using namespace llvm;
 
 static const size_t TabStop = 8;
 
 unsigned SourceMgr::AddIncludeFile(const std::string &Filename,
                                    SMLoc IncludeLoc,
                                    std::string &IncludedFile) {
   IncludedFile = Filename;
-  ErrorOr<std::unique_ptr<MemoryBuffer>> NewBufOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> NewBufOrErr =
       MemoryBuffer::getFile(IncludedFile);
 
   // If the file didn't exist directly, see if it's in an include path.
   for (unsigned i = 0, e = IncludeDirectories.size(); i != e && !NewBufOrErr;
        ++i) {
+    consumeError(NewBufOrErr.takeError());
     IncludedFile =
         IncludeDirectories[i] + sys::path::get_separator().data() + Filename;
     NewBufOrErr = MemoryBuffer::getFile(IncludedFile);
   }
 
-  if (!NewBufOrErr)
+  if (!NewBufOrErr) {
+    consumeError(NewBufOrErr.takeError());
     return 0;
+  }
 
   return AddNewSourceBuffer(std::move(*NewBufOrErr), IncludeLoc);
 }
 
 unsigned SourceMgr::FindBufferContainingLoc(SMLoc Loc) const {
   for (unsigned i = 0, e = Buffers.size(); i != e; ++i)
     if (Loc.getPointer() >= Buffers[i].Buffer->getBufferStart() &&
         // Use <= here so that a pointer to the null at the end of the buffer

llvm/lib/Support/Unix/Path.inc

 
 Expected<int> openNativeFile(const Twine &Name, CreationDisposition Disp,
                              FileAccess Access, OpenFlags Flags,
                              unsigned Mode) {
 
   int FD;
   std::error_code EC = openFile(Name, FD, Disp, Access, Flags, Mode);
   if (EC)
-    return errorCodeToError(EC);
+    return createFileError(Name, EC);
   return FD;
 }
 
 std::error_code openFileForRead(const Twine &Name, int &ResultFD,
                                 OpenFlags Flags,
                                 SmallVectorImpl<char> *RealPath) {
   std::error_code EC =
       openFile(Name, ResultFD, CD_OpenExisting, FA_Read, Flags, 0666);
#endif
   return std::error_code();
 }
 
 Expected<file_t> openNativeFileForRead(const Twine &Name, OpenFlags Flags,
                                        SmallVectorImpl<char> *RealPath) {
   file_t ResultFD;
   std::error_code EC = openFileForRead(Name, ResultFD, Flags, RealPath);
   if (EC)
-    return errorCodeToError(EC);
+    return createFileError(Name, EC);
   return ResultFD;
 }
 
 file_t getStdinHandle() { return 0; }
 file_t getStdoutHandle() { return 1; }
 file_t getStderrHandle() { return 2; }
 
 Expected<size_t> readNativeFile(file_t FD, MutableArrayRef<char> Buf) {

llvm/lib/Support/VirtualFileSystem.cpp

 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"

 ErrorOr<std::string> RealFile::getName() {
   return RealName.empty() ? S.getName().str() : RealName;
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 RealFile::getBuffer(const Twine &Name, int64_t FileSize,
                     bool RequiresNullTerminator, bool IsVolatile) {
   assert(FD != kInvalidFile && "cannot get buffer for closed file");
-  return MemoryBuffer::getOpenFile(FD, Name, FileSize, RequiresNullTerminator,
-                                   IsVolatile);
+  return expectedToErrorOr(MemoryBuffer::getOpenFile(
+      FD, Name, FileSize, RequiresNullTerminator, IsVolatile));
 }
 
 std::error_code RealFile::close() {
   std::error_code EC = sys::fs::closeFile(FD);
   FD = kInvalidFile;
   return EC;
 }
 

llvm/lib/Support/Windows/Path.inc

Expected<file_t> openNativeFile(const Twine &Name, CreationDisposition Disp,
   bool Inherit = false;
   if (Flags & OF_ChildInherit)
     Inherit = true;
 
   file_t Result;
   std::error_code EC = openNativeFileInternal(
       Name, Result, NativeDisp, NativeAccess, FILE_ATTRIBUTE_NORMAL, Inherit);
   if (EC)
-    return errorCodeToError(EC);
+    return createFileError(Name, EC);
 
   if (Flags & OF_UpdateAtime) {
     FILETIME FileTime;
     SYSTEMTIME SystemTime;
     GetSystemTime(&SystemTime);
     if (SystemTimeToFileTime(&SystemTime, &FileTime) == 0 ||
         SetFileTime(Result, NULL, &FileTime, NULL) == 0) {
       DWORD LastError = ::GetLastError();
       ::CloseHandle(Result);
-      return errorCodeToError(mapWindowsError(LastError));
+      return createFileError(Name, mapWindowsError(LastError));
     }
   }
 
   if (Flags & OF_Delete) {
     if ((EC = setDeleteDisposition(Result, true))) {
       ::CloseHandle(Result);
-      return errorCodeToError(EC);
+      return createFileError(Name, EC);
     }
   }
   return Result;
 }
 
 std::error_code openFile(const Twine &Name, int &ResultFD,
                          CreationDisposition Disp, FileAccess Access,
                          OpenFlags Flags, unsigned int Mode) {

llvm/lib/TableGen/Main.cpp

int llvm::TableGenMain(const char *argv0, TableGenMainFn *MainFn) {
   RecordKeeper Records;
 
   if (TimePhases)
     Records.startPhaseTiming();
 
   // Parse the input file.
 
   Records.startTimer("Parse, build records");
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(InputFilename, /*IsText=*/true);
-  if (std::error_code EC = FileOrErr.getError())
+  if (Error E = FileOrErr.takeError())
     return reportError(argv0, "Could not open input file '" + InputFilename +
-                                  "': " + EC.message() + "\n");
+                                  "': " + toString(std::move(E)) + "\n");
 
   Records.saveInputFilename(InputFilename);
 
   // Tell SrcMgr about this buffer, which is what TGParser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
 
   // Record the location of the include directory so that the lexer can find
   // it later.

llvm/lib/Target/BPF/BTFDebug.cpp

std::string BTFDebug::populateFileContent(const DISubprogram *SP) {
   std::vector<std::string> Content;
   std::string Line;
   Content.push_back(Line); // Line 0 for empty string
 
   std::unique_ptr<MemoryBuffer> Buf;
   auto Source = File->getSource();
   if (Source)
     Buf = MemoryBuffer::getMemBufferCopy(*Source);
-  else if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+  else if (Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
                MemoryBuffer::getFile(FileName))
     Buf = std::move(*BufOrErr);
+  else {
+    consumeError(BufOrErr.takeError());
+  }
   if (Buf)
     for (line_iterator I(*Buf, false), E; I != E; ++I)
       Content.push_back(std::string(*I));
 
   FileContent[FileName] = Content;
   return FileName;
 }
 

llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp

 
 class DllOptTable : public llvm::opt::OptTable {
 public:
   DllOptTable() : OptTable(InfoTable, false) {}
 };
 
 // Opens a file. Path has to be resolved already.
 std::unique_ptr<MemoryBuffer> openFile(const Twine &Path) {
-  ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB = MemoryBuffer::getFile(Path);
+  Expected<std::unique_ptr<llvm::MemoryBuffer>> MB =
+      MemoryBuffer::getFile(Path);
 
-  if (std::error_code EC = MB.getError()) {
-    llvm::errs() << "cannot open file " << Path << ": " << EC.message() << "\n";
+  if (Error E = MB.takeError()) {
+    llvm::errs() << "cannot open file " << Path << ": "
+                 << toString(std::move(E)) << "\n";
     return nullptr;
   }
 
   return std::move(*MB);
 }
 
 MachineTypes getEmulation(StringRef S) {
   return StringSwitch<MachineTypes>(S)

llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp

static void fatalOpenError(llvm::Error E, Twine File) {
   });
 }
 
 static void doList(opt::InputArgList& Args) {
   // lib.exe prints the contents of the first archive file.
   std::unique_ptr<MemoryBuffer> B;
   for (auto *Arg : Args.filtered(OPT_INPUT)) {
     // Create or open the archive object.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> MaybeBuf = MemoryBuffer::getFile(
+    Expected<std::unique_ptr<MemoryBuffer>> MaybeBuf = MemoryBuffer::getFile(
         Arg->getValue(), /*IsText=*/false, /*RequiresNullTerminator=*/false);
-    fatalOpenError(errorCodeToError(MaybeBuf.getError()), Arg->getValue());
+    fatalOpenError(MaybeBuf.takeError(), Arg->getValue());
 
     if (identify_magic(MaybeBuf.get()->getBuffer()) == file_magic::archive) {
       B = std::move(MaybeBuf.get());
       break;
     }
   }
 
   // lib.exe doesn't print an error if no .lib files are passed.
for (auto *Arg : Args.filtered(OPT_INPUT)) {
     // Note that there's a loophole in the rule; you can prepend `.\` or
     // something like that to a path to make it look different, and they are
     // handled as if they were different files. This behavior is compatible with
     // Microsoft lib.exe.
     if (!Seen.insert(Path).second)
       continue;
 
     // Open a file.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> MOrErr = MemoryBuffer::getFile(
+    Expected<std::unique_ptr<MemoryBuffer>> MOrErr = MemoryBuffer::getFile(
         Path, /*IsText=*/false, /*RequiresNullTerminator=*/false);
-    fatalOpenError(errorCodeToError(MOrErr.getError()), Path);
+    fatalOpenError(MOrErr.takeError(), Path);
     MemoryBufferRef MBRef = (*MOrErr)->getMemBufferRef();
 
     // Append a file.
     appendFile(Members, LibMachine, LibMachineSource, MBRef);
 
     // Take the ownership of the file buffer to keep the file open.
     MBs.push_back(std::move(*MOrErr));
   }

llvm/lib/Transforms/IPO/BlockExtractor.cpp

const SmallVectorImpl<SmallVector<BasicBlock *, 16>>
         &GroupsOfBlocksToExtract,
     bool EraseFunctions) {
   return new BlockExtractorLegacyPass(GroupsOfBlocksToExtract, EraseFunctions);
 }
 
 /// Gets all of the blocks specified in the input file.
 void BlockExtractor::loadFile() {
   auto ErrOrBuf = MemoryBuffer::getFile(BlockExtractorFile);
-  if (ErrOrBuf.getError())
-    report_fatal_error("BlockExtractor couldn't load the file.");
+  if (Error E = ErrOrBuf.takeError())
+    report_fatal_error("BlockExtractor couldn't load the file: " +
+                       toString(std::move(E)));
   // Read the file.
   auto &Buf = *ErrOrBuf;
   SmallVector<StringRef, 16> Lines;
   Buf->getBuffer().split(Lines, '\n', /*MaxSplit=*/-1,
                          /*KeepEmpty=*/false);
   for (const auto &Line : Lines) {
     SmallVector<StringRef, 4> LineSplit;
     Line.split(LineSplit, ' ', /*MaxSplit=*/-1,

llvm/lib/Transforms/IPO/Internalize.cpp

public:
   }
 
 private:
   // Contains the set of symbols loaded from file
   StringSet<> ExternalNames;
 
   void LoadFile(StringRef Filename) {
     // Load the APIFile...
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
+    Expected<std::unique_ptr<MemoryBuffer>> Buf =
         MemoryBuffer::getFile(Filename);
-    if (!Buf) {
-      errs() << "WARNING: Internalize couldn't load file '" << Filename
-             << "'! Continuing as if it's empty.\n";
+    if (Error E = Buf.takeError()) {
+      errs() << "WARNING: Internalize couldn't load file '" << Filename << "' ("
+             << toString(std::move(E)) << ")! Continuing as if it's empty.\n";
       return; // Just continue as if the file were empty
     }
     for (line_iterator I(*Buf->get(), true), E; I != E; ++I)
       ExternalNames.insert(*I);
   }
 };
 } // end anonymous namespace
 

llvm/lib/Transforms/IPO/LowerTypeTests.cpp

 bool LowerTypeTestsModule::runForTesting(Module &M) {
   ModuleSummaryIndex Summary(/*HaveGVs=*/false);
 
   // Handle the command-line summary arguments. This code is for testing
   // purposes only, so we handle errors directly.
   if (!ClReadSummary.empty()) {
     ExitOnError ExitOnErr("-lowertypetests-read-summary: " + ClReadSummary +
                           ": ");
-    auto ReadSummaryFile =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ClReadSummary)));
+    auto ReadSummaryFile = ExitOnErr(MemoryBuffer::getFile(ClReadSummary));
 
     yaml::Input In(ReadSummaryFile->getBuffer());
     In >> Summary;
     ExitOnErr(errorCodeToError(In.error()));
   }
 
   bool Changed =
       LowerTypeTestsModule(

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

bool DevirtModule::runForTesting(
   std::unique_ptr<ModuleSummaryIndex> Summary =
       std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
 
   // Handle the command-line summary arguments. This code is for testing
   // purposes only, so we handle errors directly.
   if (!ClReadSummary.empty()) {
     ExitOnError ExitOnErr("-wholeprogramdevirt-read-summary: " + ClReadSummary +
                           ": ");
-    auto ReadSummaryFile =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ClReadSummary)));
+    auto ReadSummaryFile = ExitOnErr(MemoryBuffer::getFile(ClReadSummary));
     if (Expected<std::unique_ptr<ModuleSummaryIndex>> SummaryOrErr =
             getModuleSummaryIndex(*ReadSummaryFile)) {
       Summary = std::move(*SummaryOrErr);
       ExitOnErr(checkCombinedSummaryForTesting(Summary.get()));
     } else {
       // Try YAML if we've failed with bitcode.
       consumeError(SummaryOrErr.takeError());
       yaml::Input In(ReadSummaryFile->getBuffer());

llvm/lib/Transforms/Utils/SymbolRewriter.cpp

 using PatternRewriteNamedAliasDescriptor =
     PatternRewriteDescriptor<RewriteDescriptor::Type::NamedAlias, GlobalAlias,
                              &Module::getNamedAlias, &Module::aliases>;
 
 } // end anonymous namespace
 
 bool RewriteMapParser::parse(const std::string &MapFile,
                              RewriteDescriptorList *DL) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Mapping =
+  Expected<std::unique_ptr<MemoryBuffer>> Mapping =
       MemoryBuffer::getFile(MapFile);
 
-  if (!Mapping)
-    report_fatal_error("unable to read rewrite map '" + MapFile + "': " +
-                       Mapping.getError().message());
+  if (Error E = Mapping.takeError())
+    report_fatal_error("unable to read rewrite map '" + MapFile +
+                       "': " + toString(std::move(E)));
 
   if (!parse(*Mapping, DL))
     report_fatal_error("unable to parse rewrite map '" + MapFile + "'");
 
   return true;
 }
 
 bool RewriteMapParser::parse(std::unique_ptr<MemoryBuffer> &MapFile,

llvm/test/DebugInfo/symbolize-missing-file.test

 RUN: llvm-symbolizer --obj=unexisting-file 0x1234 2>&1 | FileCheck -DMSG=%errc_ENOENT %s
 
-CHECK: LLVMSymbolizer: error reading file: [[MSG]]
+CHECK: LLVMSymbolizer: error reading file: 'unexisting-file': [[MSG]]

llvm/test/MC/Hexagon/not_found.s

 # RUN: not llvm-mc -arch=hexagon -filetype=asm junk123.s 2>%t ; FileCheck -DMSG=%errc_ENOENT %s < %t
 #
 
-# CHECK: junk123.s: [[MSG]]
+# CHECK: 'junk123.s': [[MSG]]

llvm/test/Object/ar-create.test

 Test which operations create an archive and which don't.
 
 RUN: touch %t
 RUN: rm -f %t.foo.a
 RUN: not llvm-ar p %t.foo.a %t 2>&1 | FileCheck %s
 RUN: not llvm-ar d %t.foo.a %t 2>&1 | FileCheck %s
 RUN: not llvm-ar m %t.foo.a %t 2>&1 | FileCheck %s
 RUN: not llvm-ar t %t.foo.a %t 2>&1 | FileCheck %s
 RUN: not llvm-ar x %t.foo.a %t 2>&1 | FileCheck %s
 
 RUN: llvm-ar q %t.foo.a %t 2>&1 | FileCheck --check-prefix=CREATE %s
 RUN: rm -f %t.foo.a
 RUN: llvm-ar r %t.foo.a %t 2>&1 | FileCheck --check-prefix=CREATE %s
 RUN: rm -f %t.foo.a
 
-CHECK: llvm-ar{{(.exe|.EXE)?}}: error: unable to load '{{[^']+}}.foo.a':
+CHECK: llvm-ar{{(.exe|.EXE)?}}: error: unable to load: '{{[^']+}}.foo.a':
 CREATE: creating {{.*}}.foo.a

llvm/test/Object/ar-error.test

 Test if we get a proper error with a filename that doesn't exist
 
 RUN: not llvm-ar r %t.out.a sparkle.o %t 2>&1 | FileCheck %s
 
 # Don't check the message "No such file or directory".
-CHECK: llvm-ar{{(.exe|.EXE)?}}: error: sparkle.o:
+CHECK: llvm-ar{{(.exe|.EXE)?}}: error: 'sparkle.o':

llvm/test/Object/archive-extract.test

 
 RUN: not llvm-ar x %p/Inputs/thin.a foo.o 2>&1 | FileCheck %s --check-prefix=THINEXTRACT
 THINEXTRACT: extracting from a thin archive is not supported
 
 RUN: llvm-ar p %p/Inputs/thin.a evenlen | FileCheck %s --check-prefix=EVENLEN
 EVENLEN: evenlen
 
 RUN: not llvm-ar p %p/Inputs/thin-path.a t/test2.o 2>&1 | FileCheck %s --DMSG=%errc_ENOENT --check-prefix=MISSING
-MISSING: error: [[MSG]]
+MISSING: error: '{{.*}}test2.o': [[MSG]]

llvm/test/Object/directory.ll

 ;RUN: rm -rf %t && mkdir -p %t
 ;RUN: not llvm-ar r %t/test.a . 2>&1 | FileCheck -DMSG=%errc_EISDIR %s
-;CHECK: .: [[MSG]]
+;CHECK: '.': [[MSG]]
 
 ;RUN: rm -f %t/test.a
 ;RUN: touch %t/a-very-long-file-name
 ;RUN: llvm-ar r %t/test.a %s %t/a-very-long-file-name
 ;RUN: llvm-ar r %t/test.a %t/a-very-long-file-name
 ;RUN: llvm-ar t %t/test.a | FileCheck -check-prefix=MEMBERS %s
 ;MEMBERS-NOT: /
 ;MEMBERS: directory.ll
 ;MEMBERS: a-very-long-file-name
 ;MEMBERS-NOT: a-very-long-file-name

llvm/test/Object/invalid.test

ProgramHeaders:
   - Type:     PT_DYNAMIC
     FileSize: 0xffff0000
     FirstSec: .dynamic
     LastSec:  .dynamic
 
 # RUN: yaml2obj --docnum=24 %s -o %t24
 # RUN: not obj2yaml 2>&1 %t24 | FileCheck %s -DFILE=%t24 --check-prefix=INVALID-SHSTRNDX
 
-# INVALID-SHSTRNDX: Error reading file: [[FILE]]: section header string table index 255 does not exist
+# INVALID-SHSTRNDX: error: '[[FILE]]': section header string table index 255 does not exist
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
   EShStrNdx: 0xFF

llvm/test/ObjectYAML/wasm/header_invalid_version.yaml

 # RUN: yaml2obj %s | not obj2yaml 2>&1 | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000002
 ...
-# CHECK: Error reading file: <stdin>: invalid version number: 2
+# CHECK: error: '<stdin>': invalid version number: 2

llvm/test/ObjectYAML/wasm/invalid_export.yaml

 # RUN: yaml2obj < %s | not obj2yaml 2>&1 | FileCheck %s
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            EXPORT
     Exports:
       - Name:            invalid_function_index
         Kind:            FUNCTION
         Index:           0x00000001
 
-# CHECK: Error reading file: <stdin>: invalid function export
+# CHECK: error: '<stdin>': invalid function export

llvm/test/ObjectYAML/wasm/invalid_global_weak.yaml

- Type:            CUSTOM
     SymbolTable:
       - Index:           0
         Kind:            GLOBAL
         Name:            imported_global
         Flags:           [ BINDING_WEAK, UNDEFINED ]
         Global:          0
 ...
 
-# CHECK: Error reading file: <stdin>: undefined weak global symbol
+# CHECK: error: '<stdin>': undefined weak global symbol

llvm/test/tools/llvm-ar/error-opening-directory.test

 ## Unsupported on AIX and FreeBSD as AIX and FreeBSD 12 and earlier allow
 ## reading directories by default.
 # UNSUPPORTED: system-freebsd, system-aix
 
 # RUN: rm -rf %t && mkdir -p %t
 
 ## Passing in a directory:
 # RUN: mkdir -p %t/tmpDir
 # RUN: not llvm-ar p %t/tmpDir 2>&1 | \
 # RUN:    FileCheck %s --check-prefix=IS-DIR -DARCHIVE=%t/tmpDir -DMSG=%errc_EISDIR
 
-# IS-DIR: error: unable to open '[[ARCHIVE]]': [[MSG]]
+# IS-DIR: error: [[ARCHIVE]]: [[MSG]]

llvm/test/tools/llvm-ar/error-opening-permission.test

 ## Unsupported on windows as marking files "unreadable"
 ## is non-trivial on windows.
 # UNSUPPORTED: system-windows
 
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: echo file1 > %t/1.txt
 
 ## No Permission:
 # RUN: llvm-ar rc %t/permission.b %t/1.txt
 # RUN: chmod 100 %t/permission.b
 # RUN: not llvm-ar p %t/permission.b 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NO-PERMISSION -DARCHIVE=%t/permission.b -DMSG=%errc_EACCES
 
-# NO-PERMISSION: error: unable to open '[[ARCHIVE]]': [[MSG]]
+# NO-PERMISSION: error: '[[ARCHIVE]]': [[MSG]]

llvm/test/tools/llvm-ar/missing-thin-archive-member.test

 ## Test llvm-ar errors when thin archive members are missing.
 
 # RUN: rm -rf %t-archive.a
 # RUN: echo contents > %t-temp.txt
 
 ## File is not in archive.
 # RUN: llvm-ar qT %t-archive.a
 # RUN: not llvm-ar p %t-archive.a %t-temp.txt 2>&1 | FileCheck %s -DPATH=%t-temp.txt --check-prefix=MISSING
 
 # MISSING: error: '[[PATH]]' was not found
 
 ## File has been deleted.
 # RUN: llvm-ar qT %t-archive.a %t-temp.txt
 # RUN: rm %t-temp.txt
-# RUN: not llvm-ar p %t-archive.a 2>&1 | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=DELETED
+# RUN: not llvm-ar p %t-archive.a 2>&1 | FileCheck -DMSG=%errc_ENOENT -DFILE=%t-temp.txt %s --check-prefix=DELETED
 
-# DELETED: error: [[MSG]]
+# DELETED: error: '[[FILE]]': [[MSG]]

llvm/test/tools/llvm-ar/move.test

 
 # NO-ARCHIVE: error: an archive name must be specified
 
 ## Member does not exist:
 # RUN: llvm-ar rc %t/missing.a %t/1.o %t/2.o %t/3.o
 # RUN: not llvm-ar m %t/missing.a %t/missing.txt 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=MISSING-FILE -DFILE=%t/missing.txt -DMSG=%errc_ENOENT
 
-# MISSING-FILE: error: [[FILE]]: [[MSG]]
+# MISSING-FILE: error: '[[FILE]]': [[MSG]]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

llvm/test/tools/llvm-ar/print.test

 # RUN:   | FileCheck %s --check-prefix=NO-ARCHIVE
 # 
 # NO-ARCHIVE: error: an archive name must be specified
 
 ## Archive does not exist:
 # RUN: not llvm-ar p %t/missing.a 2>&1 \
 # RUN:   | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=MISSING-ARCHIVE -DARCHIVE=%t/missing.a
 
-# MISSING-ARCHIVE: error: unable to load '[[ARCHIVE]]': [[MSG]]
+# MISSING-ARCHIVE: error: unable to load: '[[ARCHIVE]]': [[MSG]]
 
 ## Member does not exist:
 # RUN: not llvm-ar p %t/archive.a %t-missing.txt 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=MISSING-FILE -DFILE=%t-missing.txt
 
 # MISSING-FILE: error: '[[FILE]]' was not found
 
 ## Print empty thin archive:
 # RUN: llvm-ar Trc %t/thin-archive-empty.a
 # RUN: llvm-ar p %t/thin-archive-empty.a 2>&1 | count 0
 # RUN: llvm-ar pv %t/thin-archive-empty.a 2>&1 | count 0
 
 ## Print thin archive:
 # RUN: llvm-ar Trc %t/thin-archive.a %t/1.txt %t/2.txt %t/3.txt
 # RUN: llvm-ar p %t/archive.a %t/2.txt \
 # RUN:   | FileCheck %s --check-prefix=SINGLE --match-full-lines --implicit-check-not {{.}}

llvm/test/tools/llvm-ar/quick-append.test

 # RUN:   | FileCheck %s --check-prefix=NO-ARCHIVE
 
 # NO-ARCHIVE: error: an archive name must be specified
 
 ## Member does not exist:
 # RUN: not llvm-ar qc %t/missing.a %t/missing.txt 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=MISSING-FILE -DFILE=%t/missing.txt -DMSG=%errc_ENOENT
 
-# MISSING-FILE: error: [[FILE]]: [[MSG]]
+# MISSING-FILE: error: '[[FILE]]': [[MSG]]
 
 ## Create and append members to a thin archive:
 # RUN: llvm-ar qcT %t/thin-multiple.a %t/1.o
 # RUN: llvm-ar qcT %t/thin-multiple.a %t/2.o
 # RUN: llvm-ar t %t/thin-multiple.a \
 # RUN:   | FileCheck %s --check-prefix=MULTIPLE
 
 # RUN: llvm-ar qcT %t/thin-same.a %t/1.o %t/1.o

llvm/test/tools/llvm-ar/replace.test

 
 # NO-ARCHIVE: error: an archive name must be specified
 
 ## Member does not exist:
 # RUN: llvm-ar rc %t/missing.a %t/1.o %t/2.o %t/3.o
 # RUN: not llvm-ar r %t/missing.a %t/missing.txt 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=MISSING-FILE -DFILE=%t/missing.txt -DMSG=%errc_ENOENT
 
-# MISSING-FILE: error: [[FILE]]: [[MSG]]
+# MISSING-FILE: error: '[[FILE]]': [[MSG]]
 
 ## Create and Replace member of thin archive:
 # RUN: llvm-ar rcT %t/thin.a %t/1.o %t/2.o %t/3.o
 # RUN: yaml2obj %s -o %t/1.o --docnum=4
 # RUN: llvm-ar rT %t/thin.a %t/1.o
 # RUN: llvm-ar t %t/thin.a | FileCheck %s --check-prefix=SINGLE
 
 # RUN: llvm-nm --print-armap %t/thin.a \

llvm/test/tools/llvm-ar/response.test

 ## rsp-quoting
 # RUN: not llvm-ar --rsp-quoting=foobar @%t.response1.txt 2>&1 | \
 # RUN:   FileCheck  %s --check-prefix=ERROR
 # ERROR: Invalid response file quoting style foobar
 
 # RUN: echo -e 'rc %/t.a blah\\foo' > %t-rsp.txt
 # RUN: not llvm-ar --rsp-quoting=windows @%t-rsp.txt 2>&1 | \
 # RUN:   FileCheck -DMSG=%errc_ENOENT %s --check-prefix=WIN
-# WIN: error: blah\foo: [[MSG]]
+# WIN: error: 'blah\foo': [[MSG]]
 
 # RUN: not llvm-ar -rsp-quoting posix @%t-rsp.txt 2>&1 | \
 # RUN:   FileCheck -DMSG=%errc_ENOENT %s --check-prefix=POSIX
-# POSIX: error: blahfoo: [[MSG]]
+# POSIX: error: 'blahfoo': [[MSG]]

llvm/test/tools/llvm-ifs/fail-file-open.test

-# RUN: not llvm-ifs --output-format=IFS --output=%t.tbe %s.NotAFileInTestingDir 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --output-format=IFS --output=%t.tbe %s.NotAFileInTestingDir 2>&1 | FileCheck -DMSG=%errc_ENOENT %s
 
 This file will not be read. An invalid file path is fed to llvm-ifs.
 
-# CHECK: error: Could not open `{{.*}}.NotAFileInTestingDir`
+# CHECK: error: '{{.*}}.NotAFileInTestingDir': [[MSG]]

llvm/test/tools/llvm-libtool-darwin/L-and-l.test

-## This test checks that -l and -L options work correctly.
+g# This test checks that -l and -L options work correctly.
 
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 
 ## Check that the library is recognised when it ends with '.o':
 # RUN: llvm-libtool-darwin -static -o %t.lib -l%basename_t.tmp-input1.o -l%basename_t.tmp-input2.o -L%T
 # RUN: llvm-ar t %t.lib | \
 # RUN:   FileCheck %s --check-prefix=CHECK-NAMES --implicit-check-not={{.}} -DPREFIX=%basename_t.tmp

llvm/test/tools/llvm-libtool-darwin/archive-flattening.test

 
 ## Archive member not a Mach-O object file:
 # RUN: rm -f %t.not-macho.ar
 # RUN: yaml2obj %s -o %t.elf
 # RUN: llvm-ar cr %t.not-macho.ar %t.elf
 # RUN: not llvm-libtool-darwin -static -o %t.lib %t.not-macho.ar 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NOT-MACHO -DARCHIVE=%t.not-macho.ar -DFILE=%basename_t.tmp.elf
 
-# NOT-MACHO: error: '[[ARCHIVE]]': '[[FILE]]': format not supported
+# NOT-MACHO: error: '[[ARCHIVE]]': [[FILE]]: format not supported
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64

llvm/test/tools/llvm-libtool-darwin/filelist.test

-## This test checks that the -filelist option works correctly.
+g# This test checks that the -filelist option works correctly.
 
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 # RUN: llvm-as %S/Inputs/x86_64-osx.ll -o %t-x86_64.bc
 
 ## Passing files in a listfile:
 # RUN: echo %t-input1.o >  %t.files.txt
 # RUN: echo %t-input2.o >> %t.files.txt

llvm/test/tools/llvm-libtool-darwin/invalid-input-output-args.test

 
 # NOT-OBJECT: error: '[[FILE]]': The file was not recognized as a valid object file
 
 ## Input file is not a Mach-O object file:
 # RUN: yaml2obj %s -o %t.elf
 # RUN: not llvm-libtool-darwin -static -o %t.lib %t.elf 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NOT-MACHO -DFILE=%basename_t.tmp.elf
 
-# NOT-MACHO: error: '[[FILE]]': format not supported
+# NOT-MACHO: error: [[FILE]]: format not supported
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64

llvm/test/tools/llvm-mc/basic.test

 # RUN: not llvm-mc %t.blah -o /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT --check-prefix=ENOENT %s
 
-# ENOENT: {{.*}}.blah: [[MSG]]
+# ENOENT: error: '{{.*}}.blah': [[MSG]]

llvm/test/tools/llvm-mca/invalid_input_file_name.test

 # RUN: not llvm-mca %t.blah -o /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT --check-prefix=ENOENT %s
 
-# ENOENT: {{.*}}.blah: [[MSG]]
+# ENOENT: error: '{{.*}}.blah': [[MSG]]

llvm/test/tools/llvm-ml/basic.test

 # RUN: not llvm-ml %t.blah.asm /Fo /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT --check-prefix=ENOENT %s
 
-# ENOENT: {{.*}}.blah.asm: [[MSG]]
+# ENOENT: error: '{{.*}}.blah.asm': [[MSG]]

llvm/test/tools/llvm-readobj/ELF/thin-archive-paths.test

 # RUN: llvm-readobj --file-headers a/relative.a | FileCheck %s -DARFILE="a/relative.a" --check-prefix=REL
 # REL: File: [[ARFILE]](b/1.o)
 
 # Show that relative paths in an error message for both archive and member look
 # sensible.
 # RUN: rm a/b/1.o
 # RUN: not llvm-readobj --file-headers a/relative.a 2>&1 | FileCheck %s --check-prefix=ERR1 -DMSG=%errc_ENOENT
 # RUN: not llvm-readelf --file-headers a/relative.a 2>&1 | FileCheck %s --check-prefix=ERR1 -DMSG=%errc_ENOENT
-# ERR1: error: 'a/relative.a': 'b/1.o': [[MSG]]
+# ERR1: error: 'a/relative.a': 'a/b/1.o': [[MSG]]
 
 # RUN: mkdir -p %t/c
 # RUN: yaml2obj %s -o a/b/1.o
 # RUN: llvm-ar rcT c/absolute.a %t/a/b/1.o
 
 # Show that absolute paths in the file header printing are correct.
 # RUN: llvm-readobj --file-headers c/absolute.a | FileCheck %s --check-prefix=ABS -DARFILE="c/absolute.a" -DDIR=%/t
 # ABS: File: [[ARFILE]]([[DIR]]/a/b/1.o)

llvm/test/tools/llvm-sim/fail-cases.test

 # RUN: not llvm-sim %s 2>&1 | FileCheck %s
-# RUN: not llvm-sim %s.2 2>&1 | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=EXIST
+# RUN: not llvm-sim %s.2 2>&1 | FileCheck -DMSG=%errc_ENOENT -DFILE=%s.2 %s --check-prefix=EXIST
 
 # File reading error messaging tests.
 
 # CHECK: error: expected top-level entity
 
-# EXIST: error: Could not open input file: [[MSG]]
+# EXIST: error: Could not open input file: '[[FILE]]': [[MSG]]

llvm/test/tools/llvm-symbolizer/output-style-inlined.test

 
 LLVM: main
 GNU: inctwo
 
 ## Check that we are able to produce an output properly when the --no-inlines option
 ## is specified, but a file doesn't exist. Check we report an error.
 
 RUN: llvm-symbolizer --output-style=GNU --obj=%p/Inputs/not.exist 0x1 0x2 --no-inlines 2>&1 \
-RUN:   | FileCheck %s --check-prefix=NOT-EXIST-GNU -DMSG=%errc_ENOENT
+RUN:   | FileCheck %s --check-prefix=NOT-EXIST-GNU -DMSG=%errc_ENOENT -DFILE=%p/Inputs/not.exist
 RUN: llvm-symbolizer --output-style=LLVM --obj=%p/Inputs/not.exist 0x1 0x2 --no-inlines 2>&1 \
-RUN:   | FileCheck %s --check-prefix=NOT-EXIST-LLVM -DMSG=%errc_ENOENT
+RUN:   | FileCheck %s --check-prefix=NOT-EXIST-LLVM -DMSG=%errc_ENOENT -DFILE=%p/Inputs/not.exist
 
-# NOT-EXIST-GNU:      LLVMSymbolizer: error reading file: [[MSG]]
+# NOT-EXIST-GNU:      LLVMSymbolizer: error reading file: '[[FILE]]': [[MSG]]
 # NOT-EXIST-GNU-NEXT: ??
 # NOT-EXIST-GNU-NEXT: ??:0
 # NOT-EXIST-GNU-NEXT: ??
 # NOT-EXIST-GNU-NEXT: ??:0
 
-# NOT-EXIST-LLVM:       LLVMSymbolizer: error reading file: [[MSG]]
+# NOT-EXIST-LLVM:       LLVMSymbolizer: error reading file: '[[FILE]]': [[MSG]]
 # NOT-EXIST-LLVM-NEXT:  ??
 # NOT-EXIST-LLVM-NEXT:  ??:0:0
 # NOT-EXIST-LLVM-EMPTY:
 # NOT-EXIST-LLVM-NEXT:  ??
 # NOT-EXIST-LLVM-NEXT:  ??:0:0

llvm/test/tools/llvm-tapi-diff/tapi-diff-misspelled-tbd.test

-; RUN: not llvm-tapi-diff %S/Inputs/v4A.tbd %S/Inputs/v4.tbd 2>&1 | FileCheck %s
+; RUN: not llvm-tapi-diff %S/Inputs/v4A.tbd %S/Inputs/v4.tbd 2>&1 | FileCheck -DMSG=%errc_ENOENT %s
 
-; CHECK: {{.*}}: error: {{.*}}v4.tbd: {{[Nn]}}o such file or directory
+; CHECK: {{.*}}: error: '{{.*}}v4.tbd': [[MSG]]
 ; CHECK-NOT: error:
 ; CHECK-NOT: warning:

llvm/test/tools/obj2yaml/Archives/regular.yaml

 ...
 
 ## Check we report an error for non-regular archives.
 
 # RUN: yaml2obj %s --docnum=3 -o %t.not.regular.a
 # RUN: not obj2yaml %t.not.regular.a 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.not.regular.a --check-prefix=NOT-REGULAR-ERR
 
-# NOT-REGULAR-ERR: Error reading file: [[FILE]]: only regular archives are supported
+# NOT-REGULAR-ERR: error: '[[FILE]]': only regular archives are supported
 
 --- !Arch
 Magic: "!<thin>\n"
 Members:
   - {}
 
 ## Check we report an error when unable to read the header of an archive member.
 
 # RUN: yaml2obj %s --docnum=4 -o %t.truncated.a
 # RUN: not obj2yaml %t.truncated.a 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.truncated.a --check-prefix=TRUNCATED-ERR
 
-# TRUNCATED-ERR: Error reading file: [[FILE]]: unable to read the header of a child at offset 0x8
+# TRUNCATED-ERR: error: '[[FILE]]': unable to read the header of a child at offset 0x8
 
 --- !Arch
 Content: "00"
 
 ## Check we report an error when unable to read the data of an archive member.
 
 # RUN: yaml2obj %s --docnum=5 -o %t.entdata.a
 # RUN: not obj2yaml %t.entdata.a 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.entdata.a --check-prefix=ENTDATA-ERR
 
-# ENTDATA-ERR: Error reading file: [[FILE]]: unable to read the data of a child at offset 0x8 of size 1: the remaining archive size is 0
+# ENTDATA-ERR: error: '[[FILE]]': unable to read the data of a child at offset 0x8 of size 1: the remaining archive size is 0
 
 --- !Arch
 Members:
   - Size: [[SIZE='1']]
 
 ## Check we report an error when unable to read the size of an archive member.
 
 # RUN: yaml2obj %s --docnum=5 -DSIZE='x' -o %t.entsize.a
 # RUN: not obj2yaml %t.entsize.a 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.entsize.a --check-prefix=ENTSIZE-ERR
 
-# ENTSIZE-ERR: Error reading file: [[FILE]]: unable to read the size of a child at offset 0x8 as integer: "x"
+# ENTSIZE-ERR: error: '[[FILE]]': unable to read the size of a child at offset 0x8 as integer: "x"
 
 ## Check we don't try to dump the padding byte when the size of the content is odd and
 ## the content ends at the end of a file.
 
 # RUN: yaml2obj %s --docnum=6 -DCONTENT="61" -o %t.no.padding.byte.a
 # RUN: obj2yaml %t.no.padding.byte.a | FileCheck %s --check-prefix=NO-PADDING-BYTE
 
 #      NO-PADDING-BYTE: --- !Arch

llvm/test/tools/obj2yaml/ELF/entsize.yaml

- Name:    .mydynsym
     EntSize: [[DYNSYMES=0x18]]
 
 ## Document that we are unable to dump a SHT_SYMTAB section when its entry size
 ## is not equal to sizeof(ELF_Sym).
 
 # RUN: yaml2obj %s -DSYMTABES=0x19 -o %t2
 # RUN: not obj2yaml %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=ERR1
 
-# ERR1: Error reading file: [[FILE]]: section [index 2] has invalid sh_entsize: expected 24, but got 25
+# ERR1: error: '[[FILE]]': section [index 2] has invalid sh_entsize: expected 24, but got 25
 
 ## Document that we are unable to dump a SHT_DYNSYM section when its entry size
 ## is not equal to sizeof(ELF_Sym).
 
 # RUN: yaml2obj %s -DDYNSYMES=0x19 -o %t3
 # RUN: not obj2yaml %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=ERR2
 
-# ERR2: Error reading file: [[FILE]]: section [index 3] has invalid sh_entsize: expected 24, but got 25
+# ERR2: error: '[[FILE]]': section [index 3] has invalid sh_entsize: expected 24, but got 25

llvm/test/tools/obj2yaml/ELF/section-group.yaml

- Name:    signature
     Section: .rodata
 
 ## Document that yaml2obj can't dump the SHT_GROUP section when its sh_entsize != 4.
 
 # RUN: yaml2obj %s -DENTSIZE=0xfe -o %t1.entsize.o
 # RUN: not obj2yaml %t1.entsize.o 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t1.entsize.o --check-prefix=ENTSIZE
 
-# ENTSIZE: Error reading file: [[FILE]]: section [index 1] has invalid sh_entsize: expected 4, but got 254
+# ENTSIZE: error: '[[FILE]]': section [index 1] has invalid sh_entsize: expected 4, but got 254
 
 ## Check we are able to dump members of the SHT_GROUP section even when
 ## one of them has section index 0.
 
 # RUN: yaml2obj -DSEC=0 %s -o %tnull.o
 # RUN: obj2yaml %tnull.o | FileCheck %s -DSEC="''"
 
 ## Check obj2yaml report an error when sh_info field of
 ## group section contains invalid (too large) signature symbol index.
 
 # RUN: yaml2obj -DINFO=0xFF %s -o %t2.o
 # RUN: not obj2yaml %t2.o 2>&1 | FileCheck %s -DFILE=%t2.o --check-prefix=ERR
 
-# ERR: Error reading file: [[FILE]]: unable to get symbol from section [index 3]: invalid symbol index (255)
+# ERR: error: '[[FILE]]': unable to get symbol from section [index 3]: invalid symbol index (255)

llvm/test/tools/obj2yaml/ELF/shlink.yaml

 ## Check obj2yaml reports a proper error when unable to resolve
 ## a sh_link reference in a regular section.
 ## (We had a bug: the error was silently ignored).
 
 # RUN: yaml2obj --docnum=1 %s -o %t1.o
 # RUN: not obj2yaml %t1.o 2>&1 | FileCheck %s -DFILE=%t1.o --check-prefix=ERR1
 
-## ERR1: Error reading file: [[FILE]]: unable to resolve sh_link reference in section '.test': invalid section index: 100
+## ERR1: error: '[[FILE]]': unable to resolve sh_link reference in section '.test': invalid section index: 100
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .test

llvm/test/tools/obj2yaml/ELF/sht-symtab-shndx.yaml

- Type:  STT_SECTION
     Index: SHN_XINDEX
 
 ## Check that yaml2obj is unable to dump an object, which has
 ## symbols with section index == SHN_XINDEX, but no SHT_SYMTAB_SHNDX section.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: not obj2yaml %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=CASE2
 
-# CASE2: Error reading file: [[FILE]]: found an extended symbol index (1), but unable to locate the extended symbol index table
+# CASE2: error: '[[FILE]]': found an extended symbol index (1), but unable to locate the extended symbol index table
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Symbols:
   - Type:  STT_SECTION
     Index: SHN_XINDEX
 
 ## Check that yaml2obj is unable to dump an object, which has symbols with
 ## section index == SHN_XINDEX, but SHT_SYMTAB_SHNDX table contains invalid indices
 ## that are larger than total number of the sections.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: not obj2yaml %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=CASE3
 
-# CASE3: Error reading file: [[FILE]]: invalid section index: 254
+# CASE3: error: '[[FILE]]': invalid section index: 254
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: bar
     Type: SHT_PROGBITS
   - Name:    .symtab_shndx
     Type:    SHT_SYMTAB_SHNDX
     Entries: [ 0, 254 ]
     Link:    .symtab
 Symbols:
   - Type:  STT_SECTION
     Index: SHN_XINDEX
 
 ## Check that yaml2obj is unable to dump an object, which has symbols with
 ## section index == SHN_XINDEX, but SHT_SYMTAB_SHNDX table contains more
 ## entries than the number of symbols in .symtab.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: not obj2yaml %t4 2>&1 | FileCheck %s -DFILE=%t4 --check-prefix=CASE4
 
-## CASE4: Error reading file: [[FILE]]: unable to read extended section indexes: SHT_SYMTAB_SHNDX has 3 entries, but the symbol table associated has 2
+## CASE4: error: '[[FILE]]': unable to read extended section indexes: SHT_SYMTAB_SHNDX has 3 entries, but the symbol table associated has 2
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: bar

 ## ELF gABI allows having multiple SHT_SYMTAB_SHNDX sections.
 ## Only one is allowed to be linked with a corresponding symbol table section though.
 ## Check we report an error when multiple SHT_SYMTAB_SHNDX sections are linked
 ## to the same symbol table.
 
 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: not obj2yaml %t5 2>&1 | FileCheck %s -DFILE=%t5 --check-prefix=CASE5
 
-# CASE5: Error reading file: [[FILE]]: multiple SHT_SYMTAB_SHNDX sections are linked to the same symbol table with index 5
+# CASE5: error: '[[FILE]]': multiple SHT_SYMTAB_SHNDX sections are linked to the same symbol table with index 5
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:    .symtab_shndx1

 # MULTIPLE-SYMTAB-NEXT:     Index:  SHN_XINDEX
 
 ## Check that yaml2obj can't dump the object if SHT_SYMTAB_SHNDX is
 ## not associated with a SHT_SYMTAB section (this case is illegal).
 
 # RUN: yaml2obj --docnum=6 %s -o %t6
 # RUN: not obj2yaml %t6 2>&1 | FileCheck %s -DFILE=%t6 --check-prefix=CASE6
 
-# CASE6: Error reading file: [[FILE]]: unable to read extended section indexes: SHT_SYMTAB_SHNDX section is linked with SHT_PROGBITS section (expected SHT_SYMTAB/SHT_DYNSYM)
+# CASE6: error: '[[FILE]]': unable to read extended section indexes: SHT_SYMTAB_SHNDX section is linked with SHT_PROGBITS section (expected SHT_SYMTAB/SHT_DYNSYM)
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:    .symtab_shndx
     Type:    SHT_SYMTAB_SHNDX
     Entries: [ 0 ]
     Link:    .foo
   - Name:    .foo
     Type:    SHT_PROGBITS
 
 ## Check that we are unable to dump the SHT_SYMTAB_SHNDX section when its
 ## sh_entsize has an unexpected value (not equal to 4).
 
 # RUN: yaml2obj -DENTSIZE=0xff --docnum=7 %s -o %t7.entsize.bad
 # RUN: not obj2yaml %t7.entsize.bad 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t7.entsize.bad --check-prefix=CASE7-BAD
 
-# CASE7-BAD: Error reading file: [[FILE]]: unable to read extended section indexes: section [index 1] has invalid sh_entsize: expected 4, but got 255
+# CASE7-BAD: error: '[[FILE]]': unable to read extended section indexes: section [index 1] has invalid sh_entsize: expected 4, but got 255
 
 ## Check we don't print the "EntSize" field when the "sh_entsize" field has the default value.
 
 # RUN: yaml2obj -DENTSIZE=4 --docnum=7 %s -o %t7.entsize.ok
 # RUN: obj2yaml %t7.entsize.ok | FileCheck %s -DFILE=%t7.entsize.ok --check-prefix=CASE7
 
 # CASE7:      - Name:    .symtab_shndx
 # CASE7-NEXT:   Type:    SHT_SYMTAB_SHNDX

llvm/test/tools/obj2yaml/ELF/verdef-section.yaml

 
 ## Document that we are not able to dump a version definition which
 ## has a version revision (vd_version) that is not equal to 1.
 
 # RUN: yaml2obj %s -DVERSION=2 -o %t.version
 # RUN: not obj2yaml %t.version 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.version --check-prefix=VERSION-ERR
 
-# VERSION-ERR: Error reading file: [[FILE]]: invalid SHT_GNU_verdef section version: 2
+# VERSION-ERR: error: '[[FILE]]': invalid SHT_GNU_verdef section version: 2

llvm/test/tools/obj2yaml/invalid_input_file.test

 # RUN: not obj2yaml  %p/path/does/not/exist 2>&1 | FileCheck -DMSG=%errc_ENOENT %s
 
-# CHECK: Error reading file: {{.*}}/path/does/not/exist: [[MSG]]
+# CHECK: error: '{{.*}}/path/does/not/exist': [[MSG]]

llvm/tools/dsymutil/BinaryHolder.cpp

 //===-- BinaryHolder.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This program is a utility that aims to be a dropin replacement for
 // Darwin's dsymutil.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BinaryHolder.h"
 #include "llvm/Object/MachO.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace dsymutil {
 
 static std::pair<StringRef, StringRef>
 getArchiveAndObjectName(StringRef Filename) {

 Error BinaryHolder::ArchiveEntry::load(IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                                        StringRef Filename,
                                        TimestampTy Timestamp, bool Verbose) {
   StringRef ArchiveFilename = getArchiveAndObjectName(Filename).first;
 
   // Try to load archive and force it to be memory mapped.
   auto ErrOrBuff = (ArchiveFilename == "-")
                        ? MemoryBuffer::getSTDIN()
-                       : VFS->getBufferForFile(ArchiveFilename, -1, false);
-  if (auto Err = ErrOrBuff.getError())
-    return errorCodeToError(Err);
+                       : errorOrToExpected(
+                             VFS->getBufferForFile(ArchiveFilename, -1, false));
+  if (Error E = ErrOrBuff.takeError())
+    return E;
 
   MemBuffer = std::move(*ErrOrBuff);
 
   if (Verbose)
     WithColor::note() << "loaded archive '" << ArchiveFilename << "'\n";
 
   // Load one or more archive buffers, depending on whether we're dealing with
   // a fat binary.
Error BinaryHolder::ArchiveEntry::load(IntrusiveRefCntPtr<vfs::FileSystem> VFS,
 
   return Error::success();
 }
 
 Error BinaryHolder::ObjectEntry::load(IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                                       StringRef Filename, TimestampTy Timestamp,
                                       bool Verbose) {
   // Try to load regular binary and force it to be memory mapped.
-  auto ErrOrBuff = (Filename == "-")
-                       ? MemoryBuffer::getSTDIN()
-                       : VFS->getBufferForFile(Filename, -1, false);
-  if (auto Err = ErrOrBuff.getError())
-    return errorCodeToError(Err);
+  auto ErrOrBuff =
+      (Filename == "-")
+          : errorOrToExpected(VFS->getBufferForFile(Filename, -1, false));
+  if (Error E = ErrOrBuff.takeError())
+    return E;
 
   if (Filename != "-" && Timestamp != sys::TimePoint<>()) {
     llvm::ErrorOr<vfs::Status> Stat = VFS->status(Filename);
     if (!Stat)
       return errorCodeToError(Stat.getError());
     if (Timestamp != std::chrono::time_point_cast<std::chrono::seconds>(
                          Stat->getLastModificationTime()))
       WithColor::warning() << Filename

llvm/tools/dsymutil/DebugMap.cpp

 };
 
 } // end anonymous namespace
 
 ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
 DebugMap::parseYAMLDebugMap(StringRef InputFile, StringRef PrependPath,
                             bool Verbose) {
   auto ErrOrFile = MemoryBuffer::getFileOrSTDIN(InputFile);
-  if (auto Err = ErrOrFile.getError())
-    return Err;
+  if (Error E = ErrOrFile.takeError())
+    return errorToErrorCode(std::move(E));
 
   YAMLContext Ctxt;
 
   Ctxt.PrependPath = PrependPath;
 
   std::unique_ptr<DebugMap> Res;
   yaml::Input yin((*ErrOrFile)->getBuffer(), &Ctxt);
   yin >> Res;

llvm/tools/dsymutil/SymbolMap.cpp

#endif
   if (sys::fs::is_directory(SymbolMapPath)) {
     SymbolMapPath += (Twine("/") + sys::path::filename(InputFile) + "-" +
                       MachOUtils::getArchName(Map.getTriple().getArchName()) +
                       ".bcsymbolmap")
                          .str();
   }
 
   auto ErrOrMemBuffer = MemoryBuffer::getFile(SymbolMapPath);
-  if (auto EC = ErrOrMemBuffer.getError()) {
-    WithColor::warning() << SymbolMapPath << ": " << EC.message()
+  if (Error E = ErrOrMemBuffer.takeError()) {
+    WithColor::warning() << SymbolMapPath << ": " << toString(std::move(E))
                          << ": not unobfuscating.\n";
     return {};
   }
 
   std::vector<std::string> UnobfuscatedStrings;
   auto &MemBuf = **ErrOrMemBuffer;
   StringRef Data(MemBuf.getBufferStart(),
                  MemBuf.getBufferEnd() - MemBuf.getBufferStart());

llvm/tools/lli/lli.cpp

public:
   }
 
   std::unique_ptr<MemoryBuffer> getObject(const Module* M) override {
     const std::string &ModuleID = M->getModuleIdentifier();
     std::string CacheName;
     if (!getCacheFilename(ModuleID, CacheName))
       return nullptr;
     // Load the object from the cache filename
-    ErrorOr<std::unique_ptr<MemoryBuffer>> IRObjectBuffer =
+    Expected<std::unique_ptr<MemoryBuffer>> IRObjectBuffer =
         MemoryBuffer::getFile(CacheName, /*IsText=*/false,
                               /*RequiresNullTerminator=*/false);
     // If the file isn't there, that's OK.
-    if (!IRObjectBuffer)
+    if (Error E = IRObjectBuffer.takeError()) {
+      consumeError(std::move(E));
       return nullptr;
+    }
     // MCJIT will want to write into this buffer, and we don't want that
     // because the file has probably just been mmapped.  Instead we make
     // a copy.  The filed-based buffer will be released when it goes
     // out of scope.
     return MemoryBuffer::getMemBufferCopy(IRObjectBuffer.get()->getBuffer());
   }
 
 private:
if (!Obj) {
       consumeError(Obj.takeError());
       reportError(Err, argv[0]);
     }
     object::OwningBinary<object::ObjectFile> &O = Obj.get();
     EE->addObjectFile(std::move(O));
   }
 
   for (unsigned i = 0, e = ExtraArchives.size(); i != e; ++i) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> ArBufOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> ArBufOrErr =
         MemoryBuffer::getFileOrSTDIN(ExtraArchives[i]);
-    if (!ArBufOrErr)
+    if (Error E = ArBufOrErr.takeError()) {
+      consumeError(std::move(E));
       reportError(Err, argv[0]);
+    }
     std::unique_ptr<MemoryBuffer> &ArBuf = ArBufOrErr.get();
 
     Expected<std::unique_ptr<object::Archive>> ArOrErr =
         object::Archive::create(ArBuf->getMemBufferRef());
     if (!ArOrErr) {
       std::string Buf;
       raw_string_ostream OS(Buf);
       logAllUnhandledErrors(ArOrErr.takeError(), OS);
for (auto EAItr = ExtraArchives.begin(), EAEnd = ExtraArchives.end();
       auto &JD = *JDItr->second;
       JD.addGenerator(ExitOnErr(orc::StaticLibraryDefinitionGenerator::Load(
           J->getObjLinkingLayer(), EAItr->c_str(), *TT)));
     }
   }
 
   // Add the objects.
   for (auto &ObjPath : ExtraObjects) {
-    auto Obj = ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ObjPath)));
+    auto Obj = ExitOnErr(MemoryBuffer::getFile(ObjPath));
     ExitOnErr(J->addObjectFile(std::move(Obj)));
   }
 
   // Run any static constructors.
   ExitOnErr(J->initialize(J->getMainJITDylib()));
 
   // Run any -thread-entry points.
   std::vector<std::thread> AltEntryThreads;

llvm/tools/llvm-ar/llvm-ar.cpp

if (PositionalArgs.empty())
     badUsage("an archive name must be specified");
   ArchiveName = PositionalArgs[0];
   PositionalArgs.erase(PositionalArgs.begin());
 }
 
 static object::Archive &readLibrary(const Twine &Library) {
   auto BufOrErr = MemoryBuffer::getFile(Library, /*IsText=*/false,
                                         /*RequiresNullTerminator=*/false);
-  failIfError(BufOrErr.getError(), "could not open library " + Library);
+  failIfError(BufOrErr.takeError(), "could not open library " + Library);
   ArchiveBuffers.push_back(std::move(*BufOrErr));
   auto LibOrErr =
       object::Archive::create(ArchiveBuffers.back()->getMemBufferRef());
   failIfError(errorToErrorCode(LibOrErr.takeError()),
               "could not parse library");
   Archives.push_back(std::move(*LibOrErr));
   return *Archives.back();
 }
static void addChildMember(std::vector<NewArchiveMember> &Members,
   }
   Members.push_back(std::move(*NMOrErr));
 }
 
 static void addMember(std::vector<NewArchiveMember> &Members,
                       StringRef FileName, bool FlattenArchive = false) {
   Expected<NewArchiveMember> NMOrErr =
       NewArchiveMember::getFile(FileName, Deterministic);
-  failIfError(NMOrErr.takeError(), FileName);
+  failIfError(NMOrErr.takeError());
   StringSaver Saver(Alloc);
   // For regular archives, use the basename of the object path for the member
   // name. For thin archives, use the full relative paths so the file resolves
   // correctly.
   if (!Thin) {
     NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);
   } else {
     if (sys::path::is_absolute(FileName))
case ReplaceOrInsert:
     return;
   case CreateSymTab:
     createSymbolTable(OldArchive);
     return;
   }
   llvm_unreachable("Unknown operation.");
 }
 
+static std::pair<Error, bool> hasErrorCode(Error E, std::error_code EC) {
+  bool HasErrorCode = false;
+  E = handleErrors(std::move(E), [&](std::unique_ptr<ErrorInfoBase> E) {
+    if (EC == E->convertToErrorCode())
+      HasErrorCode = true;
+    return Error(std::move(E));
+  });
+  return std::make_pair(std::move(E), HasErrorCode);
+}
+
 static int performOperation(ArchiveOperation Operation,
                             std::vector<NewArchiveMember> *NewMembers) {
   // Create or open the archive object.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(
+  Expected<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(
       ArchiveName, /*IsText=*/false, /*RequiresNullTerminator=*/false);
-  std::error_code EC = Buf.getError();
-  if (EC && EC != errc::no_such_file_or_directory)
-    fail("unable to open '" + ArchiveName + "': " + EC.message());
+  std::pair<Error, bool> E =
+      hasErrorCode(Buf.takeError(), errc::no_such_file_or_directory);
+  if (E.first && !E.second)
+    fail(toString(std::move(E.first)));
 
-  if (!EC) {
+  if (!E.first) {
     Error Err = Error::success();
     object::Archive Archive(Buf.get()->getMemBufferRef(), Err);
     failIfError(std::move(Err), "unable to load '" + ArchiveName + "'");
     if (Archive.isThin())
       CompareFullPath = true;
     performOperation(Operation, &Archive, std::move(Buf.get()), NewMembers);
     return 0;
   }
 
-  assert(EC == errc::no_such_file_or_directory);
+  assert(E.second);
 
   if (!shouldCreateArchive(Operation)) {
-    failIfError(EC, Twine("unable to load '") + ArchiveName + "'");
+    failIfError(std::move(E.first), "unable to load");
   } else {
+    consumeError(std::move(E.first));
     if (!Create) {
       // Produce a warning if we should and we're creating the archive
       WithColor::warning(errs(), ToolName)
           << "creating " << ArchiveName << "\n";
     }
   }
 
   performOperation(Operation, nullptr, nullptr, NewMembers);
   return 0;
 }
 
 static void runMRIScript() {
   enum class MRICommand { AddLib, AddMod, Create, CreateThin, Delete, Save, End, Invalid };
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getSTDIN();
-  failIfError(Buf.getError());
+  Expected<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getSTDIN();
+  failIfError(Buf.takeError());
   const MemoryBuffer &Ref = *Buf.get();
   bool Saved = false;
   std::vector<NewArchiveMember> NewMembers;
   ParsingMRIScript = true;
 
   for (line_iterator I(Ref, /*SkipBlanks*/ false), E; I != E; ++I) {
     ++MRILineNumber;
     StringRef Line = *I;

llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

 
 static Error reportError(StringRef Message) {
   return createStringError(std::errc::illegal_byte_sequence, Message.data());
 }
 
 static Expected<std::unique_ptr<MemoryBuffer>> openBitcodeFile(StringRef Path) {
   // Read the input file.
   Expected<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
-      errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Path));
+      MemoryBuffer::getFileOrSTDIN(Path);
   if (Error E = MemBufOrErr.takeError())
     return std::move(E);
 
   std::unique_ptr<MemoryBuffer> MemBuf = std::move(*MemBufOrErr);
 
   if (MemBuf->getBufferSize() & 3)
     return reportError(
         "Bitcode stream should be a multiple of 4 bytes in length");

llvm/tools/llvm-cat/llvm-cat.cpp

int main(int argc, char **argv) {
 
   ExitOnError ExitOnErr("llvm-cat: ");
   LLVMContext Context;
 
   SmallVector<char, 0> Buffer;
   BitcodeWriter Writer(Buffer);
   if (BinaryCat) {
     for (const auto &InputFilename : InputFilenames) {
-      std::unique_ptr<MemoryBuffer> MB = ExitOnErr(
-          errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename)));
+      std::unique_ptr<MemoryBuffer> MB =
+          ExitOnErr(MemoryBuffer::getFileOrSTDIN(InputFilename));
       std::vector<BitcodeModule> Mods = ExitOnErr(getBitcodeModuleList(*MB));
       for (auto &BitcodeMod : Mods) {
         llvm::append_range(Buffer, BitcodeMod.getBuffer());
         Writer.copyStrtab(BitcodeMod.getStrtab());
       }
     }
   } else {
     // The string table does not own strings added to it, some of which are

llvm/tools/llvm-cov/CodeCoverage.cpp

if (!RemappedFilenames.empty()) {
     auto Loc = RemappedFilenames.find(SourceFile);
     if (Loc != RemappedFilenames.end())
       SourceFile = Loc->second;
   }
   for (const auto &Files : LoadedSourceFiles)
     if (isEquivalentFile(SourceFile, Files.first))
       return *Files.second;
   auto Buffer = MemoryBuffer::getFile(SourceFile);
-  if (auto EC = Buffer.getError()) {
+  if (auto EC = errorToErrorCode(Buffer.takeError())) {
     error(EC.message(), SourceFile);
     return EC;
   }
   LoadedSourceFiles.emplace_back(std::string(SourceFile),
                                  std::move(Buffer.get()));
   return *LoadedSourceFiles.back().second;
 }
 
int RC = sys::ExecuteAndWait(ViewOpts.DemanglerOpts[0], ArgsV,
                                /*memoryLimit=*/0, &ErrMsg);
   if (RC) {
     error(ErrMsg, ViewOpts.DemanglerOpts[0]);
     return;
   }
 
   // Parse the demangler's output.
   auto BufOrError = MemoryBuffer::getFile(OutputPath);
-  if (!BufOrError) {
-    error(OutputPath, BufOrError.getError().message());
+  if (Error E = BufOrError.takeError()) {
+    error(OutputPath, toString(std::move(E)));
     return;
   }
 
   std::unique_ptr<MemoryBuffer> DemanglerBuf = std::move(*BufOrError);
 
   SmallVector<StringRef, 8> Symbols;
   StringRef DemanglerData = DemanglerBuf->getBuffer();
   DemanglerData.split(Symbols, '\n', /*MaxSplit=*/NumSymbols,

llvm/tools/llvm-cov/gcov.cpp

 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include <system_error>
 using namespace llvm;
 
+static Error removeErrorCode(Error E, std::error_code EC) {
+  return handleErrors(std::move(E),
+                      [&](std::unique_ptr<ErrorInfoBase> E) -> Error {
+                        if (EC == E->convertToErrorCode())
+                          return Error::success();
+                        return Error(std::move(E));
+                      });
+}
 static void reportCoverage(StringRef SourceFile, StringRef ObjectDir,
                            const std::string &InputGCNO,
                            const std::string &InputGCDA, bool DumpGCOV,
                            const GCOV::Options &Options) {
   SmallString<128> CoverageFileStem(ObjectDir);
   if (CoverageFileStem.empty()) {
     // If no directory was specified with -o, look next to the source file.
     CoverageFileStem = sys::path::parent_path(SourceFile);
std::string GCNO = InputGCNO.empty()
                          : InputGCNO;
   std::string GCDA = InputGCDA.empty()
                          ? std::string(CoverageFileStem.str()) + ".gcda"
                          : InputGCDA;
   GCOVFile GF;
 
   // Open .gcda and .gcda without requiring a NUL terminator. The concurrent
   // modification may nullify the NUL terminator condition.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> GCNO_Buff =
+  Expected<std::unique_ptr<MemoryBuffer>> GCNO_Buff =
       MemoryBuffer::getFileOrSTDIN(GCNO, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
-  if (std::error_code EC = GCNO_Buff.getError()) {
-    errs() << GCNO << ": " << EC.message() << "\n";
+  if (Error E = GCNO_Buff.takeError()) {
+    errs() << GCNO << ": " << toString(std::move(E)) << "\n";
     return;
   }
   GCOVBuffer GCNO_GB(GCNO_Buff.get().get());
   if (!GF.readGCNO(GCNO_GB)) {
     errs() << "Invalid .gcno File!\n";
     return;
   }
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> GCDA_Buff =
+  Expected<std::unique_ptr<MemoryBuffer>> GCDA_Buff =
       MemoryBuffer::getFileOrSTDIN(GCDA, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
-  if (std::error_code EC = GCDA_Buff.getError()) {
-    if (EC != errc::no_such_file_or_directory) {
-      errs() << GCDA << ": " << EC.message() << "\n";
+  if (Error E = GCDA_Buff.takeError()) {
+    if ((E = removeErrorCode(
+             std::move(E),
+             std::make_error_code(std::errc::no_such_file_or_directory)))) {
+      errs() << GCDA << ": " << toString(std::move(E)) << "\n";
       return;
     }
     // Clear the filename to make it clear we didn't read anything.
     GCDA = "-";
   } else {
     GCOVBuffer gcda_buf(GCDA_Buff.get().get());
     if (!gcda_buf.readGCDAFormat())
       errs() << GCDA << ":not a gcov data file\n";

llvm/tools/llvm-cxxmap/llvm-cxxmap.cpp

 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
   cl::HideUnrelatedOptions({&CXXMapCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "LLVM C++ mangled name remapper\n");
 
   auto OldSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(OldSymbolFile);
-  if (!OldSymbolBufOrError)
-    exitWithErrorCode(OldSymbolBufOrError.getError(), OldSymbolFile);
+  if (Error E = OldSymbolBufOrError.takeError())
+    exitWithError(std::move(E), OldSymbolFile);
 
   auto NewSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(NewSymbolFile);
-  if (!NewSymbolBufOrError)
-    exitWithErrorCode(NewSymbolBufOrError.getError(), NewSymbolFile);
+  if (Error E = NewSymbolBufOrError.takeError())
+    exitWithError(std::move(E), NewSymbolFile);
 
   auto RemappingBufOrError = MemoryBuffer::getFileOrSTDIN(RemappingFile);
-  if (!RemappingBufOrError)
-    exitWithErrorCode(RemappingBufOrError.getError(), RemappingFile);
+  if (Error E = RemappingBufOrError.takeError())
+    exitWithError(std::move(E), RemappingFile);
 
   std::error_code EC;
   raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_TextWithCRLF);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   remapSymbols(*OldSymbolBufOrError.get(), *NewSymbolBufOrError.get(),
                *RemappingBufOrError.get(), OS);
 }

llvm/tools/llvm-dis/llvm-dis.cpp

if (InputFilenames.size() < 1) {
     InputFilenames.push_back("-");
   } else if (InputFilenames.size() > 1 && !OutputFilename.empty()) {
     errs()
         << "error: output file name cannot be set for multiple input files\n";
     return 1;
   }
 
   for (std::string InputFilename : InputFilenames) {
-    std::unique_ptr<MemoryBuffer> MB = ExitOnErr(
-        errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename)));
+    std::unique_ptr<MemoryBuffer> MB =
+        ExitOnErr(MemoryBuffer::getFileOrSTDIN(InputFilename));
 
     BitcodeFileContents IF = ExitOnErr(llvm::getBitcodeFileContents(*MB));
 
     const size_t N = IF.Mods.size();
 
     if (OutputFilename == "-" && N > 1)
       errs() << "only single module bitcode files can be written to stdout\n";
 

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

if (auto *Obj = dyn_cast<ObjectFile>(BinOrErr->get())) {
     }
   else if (auto *Arch = dyn_cast<Archive>(BinOrErr->get()))
     Result = handleArchive(Filename, *Arch, HandleObj, OS);
   return Result;
 }
 
 static bool handleFile(StringRef Filename, HandlerFn HandleObj,
                        raw_ostream &OS) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BuffOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  error(Filename, BuffOrErr.getError());
+  error(Filename, BuffOrErr.takeError());
   std::unique_ptr<MemoryBuffer> Buffer = std::move(BuffOrErr.get());
   return handleBuffer(Filename, *Buffer, HandleObj, OS);
 }
 
 /// If the input path is a .dSYM bundle (as created by the dsymutil tool),
 /// replace it with individual entries for each of the object files inside the
 /// bundle otherwise return the input path.
 static std::vector<std::string> expandBundle(const std::string &InputPath) {

llvm/tools/llvm-exegesis/lib/BenchmarkResult.cpp

 
 } // namespace yaml
 
 namespace exegesis {
 
 Expected<InstructionBenchmark>
 InstructionBenchmark::readYaml(const LLVMState &State, StringRef Filename) {
   if (auto ExpectedMemoryBuffer =
-          errorOrToExpected(MemoryBuffer::getFile(Filename, /*IsText=*/true))) {
+          MemoryBuffer::getFile(Filename, /*IsText=*/true)) {
     yaml::Input Yin(*ExpectedMemoryBuffer.get());
     YamlContext Context(State);
     InstructionBenchmark Benchmark;
     if (Yin.setCurrentDocument())
       yaml::yamlize(Yin, Benchmark, /*unused*/ true, Context);
     if (!Context.getLastError().empty())
       return make_error<Failure>(Context.getLastError());
     return Benchmark;
   } else {
     return ExpectedMemoryBuffer.takeError();
   }
 }
 
 Expected<std::vector<InstructionBenchmark>>
 InstructionBenchmark::readYamls(const LLVMState &State, StringRef Filename) {
   if (auto ExpectedMemoryBuffer =
-          errorOrToExpected(MemoryBuffer::getFile(Filename, /*IsText=*/true))) {
+          MemoryBuffer::getFile(Filename, /*IsText=*/true)) {
     yaml::Input Yin(*ExpectedMemoryBuffer.get());
     YamlContext Context(State);
     std::vector<InstructionBenchmark> Benchmarks;
     while (Yin.setCurrentDocument()) {
       Benchmarks.emplace_back();
       yamlize(Yin, Benchmarks.back(), /*unused*/ true, Context);
       if (Yin.error())
         return errorCodeToError(Yin.error());

llvm/tools/llvm-exegesis/lib/SnippetFile.cpp

private:
   unsigned InvalidComments = 0;
 };
 
 } // namespace
 
 // Reads code snippets from file `Filename`.
 Expected<std::vector<BenchmarkCode>> readSnippets(const LLVMState &State,
                                                   StringRef Filename) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  if (std::error_code EC = BufferPtr.getError()) {
+  if (Error E = BufferPtr.takeError()) {
     return make_error<Failure>("cannot read snippet: " + Filename + ": " +
-                               EC.message());
+                               toString(std::move(E)));
   }
   SourceMgr SM;
   SM.AddNewSourceBuffer(std::move(BufferPtr.get()), SMLoc());
 
   BenchmarkCode Result;
 
   const TargetMachine &TM = State.getTargetMachine();
   MCContext Context(TM.getTargetTriple(), TM.getMCAsmInfo(),

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

for (auto &Obj : FilterObjs) {
         return Err;
     }
   }
   return Error::success();
 }
 
 static llvm::Error handleFileConversionToGSYM(StringRef Filename,
                                               const std::string &OutFile) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BuffOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  error(Filename, BuffOrErr.getError());
+  error(Filename, BuffOrErr.takeError());
   std::unique_ptr<MemoryBuffer> Buffer = std::move(BuffOrErr.get());
   return handleBuffer(Filename, *Buffer, OutFile);
 }
 
 static llvm::Error convertFileToGSYM(raw_ostream &OS) {
   // Expand any .dSYM bundles to the individual object files contained therein.
   std::vector<std::string> Objects;
   std::string OutFile = OutputFilename;

llvm/tools/llvm-ifs/llvm-ifs.cpp

static std::string getTypeName(IFSSymbolType Type) {
   case IFSSymbolType::Unknown:
     return "Unknown";
   }
   llvm_unreachable("Unexpected ifs symbol type.");
 }
 
 static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) {
   // Read in file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
+  Expected<std::unique_ptr<MemoryBuffer>> BufOrError =
       MemoryBuffer::getFileOrSTDIN(FilePath, /*IsText=*/true);
-  if (!BufOrError)
-    return createStringError(BufOrError.getError(), "Could not open `%s`",
-                             FilePath.data());
+  if (Error E = BufOrError.takeError())
+    return E;
 
   std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
   ErrorCollector EC(/*UseFatalErrors=*/false);
 
   // First try to read as a binary (fails fast if not binary).
   if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::ELF) {
     Expected<std::unique_ptr<IFSStub>> StubFromELF =
         readELFFile(FileReadBuffer->getMemBufferRef());
static Error writeIFS(StringRef FilePath, IFSStub &Stub) {
   std::string IFSStr;
   raw_string_ostream OutStr(IFSStr);
   Error YAMLErr = writeIFSToOutputStream(OutStr, Stub);
   if (YAMLErr)
     return YAMLErr;
   OutStr.flush();
 
   if (WriteIfChanged) {
-    if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
+    if (Expected<std::unique_ptr<MemoryBuffer>> BufOrError =
             MemoryBuffer::getFile(FilePath)) {
       // Compare IFS output with the existing IFS file. If unchanged, avoid changing the file.
       if ((*BufOrError)->getBuffer() == IFSStr)
         return Error::success();
-    }
+    } else
+      consumeError(BufOrError.takeError());
   }
   // Open IFS file for writing.
   std::error_code SysErr;
   raw_fd_ostream Out(FilePath, SysErr);
   if (SysErr)
     return createStringError(SysErr, "Couldn't open `%s` for writing",
                              FilePath.data());
   Out << IFSStr;

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

Session::Session(std::unique_ptr<ExecutorProcessControl> EPC, Error &Err)
   }
 
   ObjLayer.addPlugin(std::make_unique<JITLinkSessionPlugin>(*this));
 
   // Process any harness files.
   for (auto &HarnessFile : TestHarnesses) {
     HarnessFiles.insert(HarnessFile);
 
-    auto ObjBuffer =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(HarnessFile)));
+    auto ObjBuffer = ExitOnErr(MemoryBuffer::getFile(HarnessFile));
 
     auto ObjSymbolInfo =
         ExitOnErr(getObjectSymbolInfo(ES, ObjBuffer->getMemBufferRef()));
 
     for (auto &KV : ObjSymbolInfo.first)
       HarnessDefinitions.insert(*KV.first);
 
     auto Obj = ExitOnErr(

 }
 
 } // end namespace llvm
 
 static Triple getFirstFileTriple() {
   static Triple FirstTT = []() {
     assert(!InputFiles.empty() && "InputFiles can not be empty");
     for (auto InputFile : InputFiles) {
-      auto ObjBuffer =
-          ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(InputFile)));
+      auto ObjBuffer = ExitOnErr(MemoryBuffer::getFile(InputFile));
       switch (identify_magic(ObjBuffer->getBuffer())) {
       case file_magic::elf_relocatable:
       case file_magic::macho_object:
       case file_magic::coff_object: {
         auto Obj = ExitOnErr(
             object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef()));
         return Obj->makeTriple();
       }
for (auto *JD : S.JDSearchOrder) {
       }
       JD->setLinkOrder(std::move(LinkOrder));
     }
   }
 
   LLVM_DEBUG(dbgs() << "Adding test harness objects...\n");
   for (auto HarnessFile : TestHarnesses) {
     LLVM_DEBUG(dbgs() << "  " << HarnessFile << "\n");
-    auto ObjBuffer =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(HarnessFile)));
+    auto ObjBuffer = ExitOnErr(MemoryBuffer::getFile(HarnessFile));
     ExitOnErr(S.ObjLayer.add(*S.MainJD, std::move(ObjBuffer)));
   }
 
   // Load each object into the corresponding JITDylib..
   LLVM_DEBUG(dbgs() << "Adding objects...\n");
   for (auto InputFileItr = InputFiles.begin(), InputFileEnd = InputFiles.end();
        InputFileItr != InputFileEnd; ++InputFileItr) {
     unsigned InputFileArgIdx =
         InputFiles.getPosition(InputFileItr - InputFiles.begin());
     const std::string &InputFile = *InputFileItr;
     auto &JD = *std::prev(IdxToJLD.lower_bound(InputFileArgIdx))->second;
     LLVM_DEBUG(dbgs() << "  " << InputFileArgIdx << ": \"" << InputFile
                       << "\" to " << JD.getName() << "\n";);
-    auto ObjBuffer =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(InputFile)));
+    auto ObjBuffer = ExitOnErr(MemoryBuffer::getFile(InputFile));
 
     auto Magic = identify_magic(ObjBuffer->getBuffer());
     if (Magic == file_magic::archive ||
         Magic == file_magic::macho_universal_binary)
       JD.addGenerator(ExitOnErr(StaticLibraryDefinitionGenerator::Load(
           S.ObjLayer, InputFile.c_str(),
           S.ES.getExecutorProcessControl().getTargetTriple())));
     else
static Error runChecks(Session &S) {
 
   RuntimeDyldChecker Checker(
       IsSymbolValid, GetSymbolInfo, GetSectionInfo, GetStubInfo, GetGOTInfo,
       TT.isLittleEndian() ? support::little : support::big, Disassembler.get(),
       InstPrinter.get(), dbgs());
 
   std::string CheckLineStart = "# " + CheckName + ":";
   for (auto &CheckFile : CheckFiles) {
-    auto CheckerFileBuf =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(CheckFile)));
+    auto CheckerFileBuf = ExitOnErr(MemoryBuffer::getFile(CheckFile));
     if (!Checker.checkAllRulesInBuffer(CheckLineStart, &*CheckerFileBuf))
       ExitOnErr(make_error<StringError>(
           "Some checks in " + CheckFile + " failed", inconvertibleErrorCode()));
   }
 
   return Error::success();
 }
 

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

static Error processCommandLineLibraries() {
 
   return Error::success();
 }
 
 static Error processFileList() {
   StringRef FileName, DirName;
   std::tie(FileName, DirName) = StringRef(FileList).rsplit(",");
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(FileName, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
-  if (std::error_code EC = FileOrErr.getError())
-    return createFileError(FileName, errorCodeToError(EC));
+  if (Error E = FileOrErr.takeError())
+    return E;
   const MemoryBuffer &Ref = *FileOrErr.get();
 
   line_iterator I(Ref, /*SkipBlanks=*/false);
   if (I.is_at_eof())
     return createStringError(std::errc::invalid_argument,
                              "file list file: '%s' is empty",
                              FileName.str().c_str());
   for (; !I.is_at_eof(); ++I) {
static Error verifyAndAddMachOObject(MembersPerArchitectureMap &Members,
 
   // Throw error if not a valid object file.
   if (!ObjOrErr)
     return createFileError(Member.MemberName, ObjOrErr.takeError());
 
   // Throw error if not in Mach-O format.
   if (!isa<object::MachOObjectFile>(**ObjOrErr))
     return createStringError(std::errc::invalid_argument,
-                             "'%s': format not supported",
+                             "%s: format not supported",
                              Member.MemberName.data());
 
   auto *O = dyn_cast<MachOObjectFile>(ObjOrErr->get());
   uint32_t FileCPUType, FileCPUSubtype;
   std::tie(FileCPUType, FileCPUSubtype) = MachO::getCPUTypeFromArchitecture(
       MachO::getArchitectureFromName(O->getArchTriple().getArchName()));
 
   // If -arch_only is specified then skip this file if it doesn't match
static Error addUniversalMembers(
   return Error::success();
 }
 
 static Error addMember(MembersPerArchitectureMap &Members,
                        std::vector<std::unique_ptr<MemoryBuffer>> &FileBuffers,
                        StringRef FileName, const Config &C) {
   Expected<NewArchiveMember> NMOrErr =
       NewArchiveMember::getFile(FileName, C.Deterministic);
-  if (!NMOrErr)
-    return createFileError(FileName, NMOrErr.takeError());
+  if (Error E = NMOrErr.takeError())
+    return E;
 
   // For regular archives, use the basename of the object path for the member
   // name.
   NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);
   file_magic Magic = identify_magic(NMOrErr->Buf->getBuffer());
 
   // Flatten archives.
   if (Magic == file_magic::archive)

llvm/tools/llvm-link/llvm-link.cpp

std::unique_ptr<ModuleSummaryIndex> Index =
       ExitOnErr(llvm::getModuleSummaryIndexForFile(SummaryIndex));
 
   // Map of Module -> List of globals to import from the Module
   FunctionImporter::ImportMapTy ImportList;
 
   auto ModuleLoader = [&DestModule](const char *argv0,
                                     const std::string &Identifier) {
     std::unique_ptr<MemoryBuffer> Buffer =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Identifier)));
+        ExitOnErr(MemoryBuffer::getFileOrSTDIN(Identifier));
     return loadFile(argv0, std::move(Buffer), DestModule.getContext(), false);
   };
 
   ModuleLazyLoaderCache ModuleLoaderCache(ModuleLoader);
   for (const auto &Import : Imports) {
     // Identify the requested function and its bitcode source file.
     size_t Idx = Import.find(':');
     if (Idx == std::string::npos) {

 static bool linkFiles(const char *argv0, LLVMContext &Context, Linker &L,
                       const cl::list<std::string> &Files, unsigned Flags) {
   // Filter out flags that don't apply to the first file we load.
   unsigned ApplicableFlags = Flags & Linker::Flags::OverrideFromSrc;
   // Similar to some flags, internalization doesn't apply to the first file.
   bool InternalizeLinkedSymbols = false;
   for (const auto &File : Files) {
     std::unique_ptr<MemoryBuffer> Buffer =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(File)));
+        ExitOnErr(MemoryBuffer::getFileOrSTDIN(File));
 
     std::unique_ptr<Module> M =
         identify_magic(Buffer->getBuffer()) == file_magic::archive
             ? loadArFile(argv0, std::move(Buffer), Context)
             : loadFile(argv0, std::move(Buffer), Context);
     if (!M.get()) {
       errs() << argv0 << ": ";
       WithColor::error() << " loading file '" << File << "'\n";

llvm/tools/llvm-lto/llvm-lto.cpp

namespace {
   };
   }
 
 static void error(const Twine &Msg) {
   errs() << "llvm-lto: " << Msg << '\n';
   exit(1);
 }
 
+static void error(Error E, const Twine &Prefix) {
+  if (E)
+    error(Prefix + ": " + toString(std::move(E)));
+}
+
 static void error(std::error_code EC, const Twine &Prefix) {
   if (EC)
     error(Prefix + ": " + EC.message());
 }
 
 template <typename T>
 static void error(const ErrorOr<T> &V, const Twine &Prefix) {
   error(V.getError(), Prefix);
 }
 
 static void maybeVerifyModule(const Module &Mod) {
   if (!DisableVerify && verifyModule(Mod, &errs()))
     error("Broken Module");
 }
 
 static std::unique_ptr<LTOModule>
 getLocalLTOModule(StringRef Path, std::unique_ptr<MemoryBuffer> &Buffer,
                   const TargetOptions &Options) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(Path);
-  error(BufferOrErr, "error loading file '" + Path + "'");
+  error(errorToErrorCode(BufferOrErr.takeError()),
+        "error loading file '" + Path + "'");
   Buffer = std::move(BufferOrErr.get());
   CurrentActivity = ("loading file '" + Path + "'").str();
   std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
   Context->setDiagnosticHandler(std::make_unique<LLVMLTODiagnosticHandler>(),
                                 true);
   ErrorOr<std::unique_ptr<LTOModule>> Ret = LTOModule::createInLocalContext(
       std::move(Context), Buffer->getBufferStart(), Buffer->getBufferSize(),
       Options, Path);
if (QueryHasCtorDtor)
              << ": hasCtorDtor = " << (Module->hasCtorDtor() ? "true" : "false")
              << "\n";
   }
 }
 
 static std::unique_ptr<MemoryBuffer> loadFile(StringRef Filename) {
     ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename.str() +
         "': ");
-    return ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Filename)));
+    return ExitOnErr(MemoryBuffer::getFileOrSTDIN(Filename));
 }
 
 static void listDependentLibraries() {
   for (auto &Filename : InputFilenames) {
     auto Buffer = loadFile(Filename);
     std::string E;
     std::unique_ptr<lto::InputFile> Input(LTOModule::createInputFile(
         Buffer->getBufferStart(), Buffer->getBufferSize(), Filename.c_str(),

 /// This is meant to enable testing of ThinLTO combined index generation,
 /// currently available via the gold plugin via -thinlto.
 static void createCombinedModuleSummaryIndex() {
   ModuleSummaryIndex CombinedIndex(/*HaveGVs=*/false);
   uint64_t NextModuleId = 0;
   for (auto &Filename : InputFilenames) {
     ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename + "': ");
     std::unique_ptr<MemoryBuffer> MB =
-        ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Filename)));
+        ExitOnErr(MemoryBuffer::getFileOrSTDIN(Filename));
     ExitOnErr(readModuleSummaryIndex(*MB, CombinedIndex, NextModuleId++));
   }
   std::error_code EC;
   assert(!OutputFilename.empty());
   raw_fd_ostream OS(OutputFilename + ".thinlto.bc", EC,
                     sys::fs::OpenFlags::OF_None);
   error(EC, "error opening the file '" + OutputFilename + ".thinlto.bc'");
   WriteIndexToFile(CombinedIndex, OS);

 std::vector<std::unique_ptr<MemoryBuffer>>
 loadAllFilesForIndex(const ModuleSummaryIndex &Index) {
   std::vector<std::unique_ptr<MemoryBuffer>> InputBuffers;
 
   for (auto &ModPath : Index.modulePaths()) {
     const auto &Filename = ModPath.first();
     std::string CurrentActivity = ("loading file '" + Filename + "'").str();
     auto InputOrErr = MemoryBuffer::getFile(Filename);
-    error(InputOrErr, "error " + CurrentActivity);
+    error(InputOrErr.takeError(), "error " + CurrentActivity);
     InputBuffers.push_back(std::move(*InputOrErr));
   }
   return InputBuffers;
 }
 
 std::unique_ptr<ModuleSummaryIndex> loadCombinedIndex() {
   if (ThinLTOIndex.empty())
     report_fatal_error("Missing -thinlto-index for ThinLTO promotion stage");
if (OutputFilename.empty())
           "OutputFilename is necessary to store the combined index.\n");
 
     LLVMContext Ctx;
     std::vector<std::unique_ptr<MemoryBuffer>> InputBuffers;
     for (unsigned i = 0; i < InputFilenames.size(); ++i) {
       auto &Filename = InputFilenames[i];
       std::string CurrentActivity = "loading file '" + Filename + "'";
       auto InputOrErr = MemoryBuffer::getFile(Filename);
-      error(InputOrErr, "error " + CurrentActivity);
+      error(InputOrErr.takeError(), "error " + CurrentActivity);
       InputBuffers.push_back(std::move(*InputOrErr));
       ThinGenerator.addModule(Filename, InputBuffers.back()->getBuffer());
     }
 
     auto CombinedIndex = ThinGenerator.linkCombinedIndex();
     if (!CombinedIndex)
       report_fatal_error("ThinLink didn't create an index");
     std::error_code EC;
if (InputFilenames.size() != 1 && !OutputFilename.empty())
                          "ones.");
     if (!ThinLTOIndex.empty())
       errs() << "Warning: -thinlto-index ignored for codegen stage";
 
     std::vector<std::unique_ptr<MemoryBuffer>> InputBuffers;
     for (auto &Filename : InputFilenames) {
       LLVMContext Ctx;
       auto InputOrErr = MemoryBuffer::getFile(Filename);
-      error(InputOrErr, "error " + CurrentActivity);
+      error(InputOrErr.takeError(), "error " + CurrentActivity);
       InputBuffers.push_back(std::move(*InputOrErr));
       ThinGenerator.addModule(Filename, InputBuffers.back()->getBuffer());
     }
     ThinGenerator.setCodeGenOnly(true);
     ThinGenerator.run();
     for (auto BinName :
          zip(ThinGenerator.getProducedBinaries(), InputFilenames)) {
       std::string OutputName = OutputFilename;
if (!ThinLTOIndex.empty())
       errs() << "Warning: -thinlto-index ignored for full ThinLTO process";
 
     LLVMContext Ctx;
     std::vector<std::unique_ptr<MemoryBuffer>> InputBuffers;
     for (unsigned i = 0; i < InputFilenames.size(); ++i) {
       auto &Filename = InputFilenames[i];
       std::string CurrentActivity = "loading file '" + Filename + "'";
       auto InputOrErr = MemoryBuffer::getFile(Filename);
-      error(InputOrErr, "error " + CurrentActivity);
+      error(InputOrErr.takeError(), "error " + CurrentActivity);
       InputBuffers.push_back(std::move(*InputOrErr));
       ThinGenerator.addModule(Filename, InputBuffers.back()->getBuffer());
     }
 
     if (!ThinLTOSaveTempsPrefix.empty())
       ThinGenerator.setSaveTempsDir(ThinLTOSaveTempsPrefix);
 
     if (!ThinLTOGeneratedObjectsDir.empty()) {
if (IndexStats) {
     return 0;
   }
 
   if (CheckHasObjC) {
     for (auto &Filename : InputFilenames) {
       ExitOnError ExitOnErr(std::string(*argv) + ": error loading file '" +
                             Filename + "': ");
       std::unique_ptr<MemoryBuffer> BufferOrErr =
-          ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(Filename)));
-      auto Buffer = std::move(BufferOrErr.get());
-      if (ExitOnErr(isBitcodeContainingObjCCategory(*Buffer)))
+          ExitOnErr(MemoryBuffer::getFile(Filename));
+      if (ExitOnErr(isBitcodeContainingObjCCategory(*BufferOrErr)))
         outs() << "Bitcode " << Filename << " contains ObjC\n";
       else
         outs() << "Bitcode " << Filename << " does not contain ObjC\n";
     }
     return 0;
   }
 
   if (PrintMachOCPUOnly) {

llvm/tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
   const char *ProgName = argv[0];
   const Target *TheTarget = GetTarget(ProgName);
   if (!TheTarget)
     return 1;
   // Now that GetTarget() has (potentially) replaced TripleName, it's safe to
   // construct the Triple object.
   Triple TheTriple(TripleName);
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(InputFilename, /*IsText=*/true);
-  if (std::error_code EC = BufferPtr.getError()) {
-    WithColor::error(errs(), ProgName)
-        << InputFilename << ": " << EC.message() << '\n';
+  if (Error E = BufferPtr.takeError()) {
+    WithColor::error(errs(), ProgName) << toString(std::move(E)) << '\n';
     return 1;
   }
   MemoryBuffer *Buffer = BufferPtr->get();
 
   SourceMgr SrcMgr;
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());

llvm/tools/llvm-mca/llvm-mca.cpp

int main(int argc, char **argv) {
   const Target *TheTarget = getTarget(ProgName);
   if (!TheTarget)
     return 1;
 
   // GetTarget() may replaced TripleName with a default triple.
   // For safety, reconstruct the Triple object.
   Triple TheTriple(TripleName);
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(InputFilename);
-  if (std::error_code EC = BufferPtr.getError()) {
-    WithColor::error() << InputFilename << ": " << EC.message() << '\n';
+  if (Error E = BufferPtr.takeError()) {
+    WithColor::error() << toString(std::move(E)) << '\n';
     return 1;
   }
 
   if (MCPU == "native")
     MCPU = std::string(llvm::sys::getHostCPUName());
 
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MCPU, MATTR));

llvm/tools/llvm-ml/llvm-ml.cpp

int main(int Argc, char **Argv) {
 
   bool SafeSEH = InputArgs.hasArg(OPT_safeseh);
   if (SafeSEH && !(TheTriple.isArch32Bit() && TheTriple.isX86())) {
     WithColor::warning()
         << "/safeseh applies only to 32-bit X86 platforms; ignoring.\n";
     SafeSEH = false;
   }
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(InputFilename);
-  if (std::error_code EC = BufferPtr.getError()) {
-    WithColor::error(errs(), ProgName)
-        << InputFilename << ": " << EC.message() << '\n';
+  if (llvm::Error E = BufferPtr.takeError()) {
+    WithColor::error(errs(), ProgName) << toString(std::move(E)) << '\n';
     return 1;
   }
 
   SourceMgr SrcMgr;
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
 

llvm/tools/llvm-modextract/llvm-modextract.cpp

 
 int main(int argc, char **argv) {
   cl::HideUnrelatedOptions({&ModextractCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "Module extractor");
 
   ExitOnError ExitOnErr("llvm-modextract: error: ");
 
   std::unique_ptr<MemoryBuffer> MB =
-      ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename)));
+      ExitOnErr(MemoryBuffer::getFileOrSTDIN(InputFilename));
   std::vector<BitcodeModule> Ms = ExitOnErr(getBitcodeModuleList(*MB));
 
   LLVMContext Context;
   if (ModuleIndex >= Ms.size()) {
     errs() << "llvm-modextract: error: module index out of range; bitcode file "
               "contains "
            << Ms.size() << " module(s)\n";
     return 1;

llvm/tools/llvm-mt/llvm-mt.cpp

if (InputArgs.hasArg(OPT_out)) {
     OutputFile = InputFiles[0];
   } else {
     reportError("no output file specified");
   }
 
   windows_manifest::WindowsManifestMerger Merger;
 
   for (const auto &File : InputFiles) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> ManifestOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> ManifestOrErr =
         MemoryBuffer::getFile(File);
-    if (!ManifestOrErr)
-      reportError(File, ManifestOrErr.getError());
+    error(ManifestOrErr.takeError());
     error(Merger.merge(*ManifestOrErr.get()));
   }
 
   std::unique_ptr<MemoryBuffer> OutputBuffer = Merger.getMergedManifest();
   if (!OutputBuffer)
     reportError("empty manifest not written");
   Expected<std::unique_ptr<FileOutputBuffer>> FileOrErr =
       FileOutputBuffer::create(OutputFile, OutputBuffer->getBufferSize());
   if (!FileOrErr)
     reportError(OutputFile, errorToErrorCode(FileOrErr.takeError()));
   std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
   std::copy(OutputBuffer->getBufferStart(), OutputBuffer->getBufferEnd(),
             FileBuffer->getBufferStart());
   error(FileBuffer->commit());
   return 0;
 }

llvm/tools/llvm-nm/llvm-nm.cpp

 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/TapiFile.h"
 #include "llvm/Object/TapiUniversal.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
static bool checkMachOAndArchFlags(SymbolicFile *O, std::string &Filename) {
   if (!llvm::is_contained(ArchFlags, ArchFlagName)) {
     error("No architecture specified", Filename);
     return false;
   }
   return true;
 }
 
 static void dumpSymbolNamesFromFile(std::string &Filename) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  if (error(BufferOrErr.getError(), Filename))
+  if (error(errorToErrorCode(BufferOrErr.takeError()), Filename))
     return;
 
   LLVMContext Context;
   LLVMContext *ContextPtr = NoLLVMBitcode ? nullptr : &Context;
   Expected<std::unique_ptr<Binary>> BinaryOrErr =
       createBinary(BufferOrErr.get()->getMemBufferRef(), ContextPtr);
   if (!BinaryOrErr) {
     error(BinaryOrErr.takeError(), Filename);

llvm/tools/llvm-objcopy/COFF/COFFObjcopy.cpp

if (Obj.getSections().empty())
     return 0;
   const Section &Last = Obj.getSections().back();
   return alignTo(Last.Header.VirtualAddress + Last.Header.VirtualSize,
                  Obj.IsPE ? Obj.PeHeader.SectionAlignment : 1);
 }
 
 static Expected<std::vector<uint8_t>>
 createGnuDebugLinkSectionContents(StringRef File) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> LinkTargetOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> LinkTargetOrErr =
       MemoryBuffer::getFile(File);
-  if (!LinkTargetOrErr)
-    return createFileError(File, LinkTargetOrErr.getError());
+  if (Error E = LinkTargetOrErr.takeError())
+    return E;
   auto LinkTarget = std::move(*LinkTargetOrErr);
   uint32_t CRC32 = llvm::crc32(arrayRefFromStringRef(LinkTarget->getBuffer()));
 
   StringRef FileName = sys::path::filename(File);
   size_t CRCPos = alignTo(FileName.size() + 1, 4);
   std::vector<uint8_t> Data(CRCPos + 4);
   memcpy(Data.data(), FileName.data(), FileName.size());
   support::endian::write32le(Data.data() + CRCPos, CRC32);
for (Section &Sec : Obj.getMutableSections()) {
             It->second.NewFlags, Sec.Header.Characteristics);
     }
 
   for (const auto &Flag : Config.AddSection) {
     StringRef SecName, FileName;
     std::tie(SecName, FileName) = Flag.split("=");
 
     auto BufOrErr = MemoryBuffer::getFile(FileName);
-    if (!BufOrErr)
-      return createFileError(FileName, errorCodeToError(BufOrErr.getError()));
+    if (Error E = BufOrErr.takeError())
+      return E;
     auto Buf = std::move(*BufOrErr);
 
     uint32_t Characteristics;
     const auto It = Config.SetSectionFlags.find(SecName);
     if (It != Config.SetSectionFlags.end())
       Characteristics = flagsToCharacteristics(It->second.NewFlags, 0);
     else
       Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_1BYTES;

llvm/tools/llvm-objcopy/ConfigManager.cpp

 }
 
 static Error addSymbolsFromFile(NameMatcher &Symbols, BumpPtrAllocator &Alloc,
                                 StringRef Filename, MatchStyle MS,
                                 function_ref<Error(Error)> ErrorCallback) {
   StringSaver Saver(Alloc);
   SmallVector<StringRef, 16> Lines;
   auto BufOrErr = MemoryBuffer::getFile(Filename);
-  if (!BufOrErr)
-    return createFileError(Filename, BufOrErr.getError());
+  if (Error E = BufOrErr.takeError())
+    return E;
 
   BufOrErr.get()->getBuffer().split(Lines, '\n');
   for (StringRef Line : Lines) {
     // Ignore everything after '#', trim whitespace, and only add the symbol if
     // it's not empty.
     auto TrimmedLine = Line.split('#').first.trim();
     if (!TrimmedLine.empty())
       if (Error E = Symbols.addMatcher(NameOrPattern::create(

 }
 
 static Error addSymbolsToRenameFromFile(StringMap<StringRef> &SymbolsToRename,
                                         BumpPtrAllocator &Alloc,
                                         StringRef Filename) {
   StringSaver Saver(Alloc);
   SmallVector<StringRef, 16> Lines;
   auto BufOrErr = MemoryBuffer::getFile(Filename);
-  if (!BufOrErr)
-    return createFileError(Filename, BufOrErr.getError());
+  if (Error E = BufOrErr.takeError())
+    return E;
 
   BufOrErr.get()->getBuffer().split(Lines, '\n');
   size_t NumLines = Lines.size();
   for (size_t LineNo = 0; LineNo < NumLines; ++LineNo) {
     StringRef TrimmedLine = Lines[LineNo].split('#').first.trim();
     if (TrimmedLine.empty())
       continue;
 
objcopy::parseObjcopyOptions(ArrayRef<const char *> RawArgsArr,
 
   Config.AddGnuDebugLink = InputArgs.getLastArgValue(OBJCOPY_add_gnu_debuglink);
   // The gnu_debuglink's target is expected to not change or else its CRC would
   // become invalidated and get rejected. We can avoid recalculating the
   // checksum for every target file inside an archive by precomputing the CRC
   // here. This prevents a significant amount of I/O.
   if (!Config.AddGnuDebugLink.empty()) {
     auto DebugOrErr = MemoryBuffer::getFile(Config.AddGnuDebugLink);
-    if (!DebugOrErr)
-      return createFileError(Config.AddGnuDebugLink, DebugOrErr.getError());
+    if (Error E = DebugOrErr.takeError())
+      return E;
     auto Debug = std::move(*DebugOrErr);
     Config.GnuDebugLinkCRC32 =
         llvm::crc32(arrayRefFromStringRef(Debug->getBuffer()));
   }
   Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo);
   Config.SymbolsPrefix = InputArgs.getLastArgValue(OBJCOPY_prefix_symbols);
   Config.AllocSectionsPrefix =
       InputArgs.getLastArgValue(OBJCOPY_prefix_alloc_sections);

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

if (Config.OnlyKeepDebug)
     for (auto &Sec : Obj.sections())
       if (Sec.Flags & SHF_ALLOC && Sec.Type != SHT_NOTE)
         Sec.Type = SHT_NOBITS;
 
   for (const auto &Flag : Config.AddSection) {
     std::pair<StringRef, StringRef> SecPair = Flag.split("=");
     StringRef SecName = SecPair.first;
     StringRef File = SecPair.second;
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
         MemoryBuffer::getFile(File);
-    if (!BufOrErr)
-      return createFileError(File, errorCodeToError(BufOrErr.getError()));
+    if (Error E = BufOrErr.takeError())
+      return E;
     std::unique_ptr<MemoryBuffer> Buf = std::move(*BufOrErr);
     ArrayRef<uint8_t> Data(
         reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),
         Buf->getBufferSize());
     OwnedDataSection &NewSection =
         Obj.addSection<OwnedDataSection>(SecName, Data);
     if (SecName.startswith(".note") && SecName != ".note.GNU-stack")
       NewSection.Type = SHT_NOTE;

llvm/tools/llvm-objcopy/MachO/MachOObjcopy.cpp

for (const std::unique_ptr<Section> &Sec : LC.Sections) {
       }
     }
 
   return createStringError(object_error::parse_failed, "section '%s' not found",
                            SecName.str().c_str());
 }
 
 static Error addSection(StringRef SecName, StringRef Filename, Object &Obj) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFile(Filename);
-  if (!BufOrErr)
-    return createFileError(Filename, errorCodeToError(BufOrErr.getError()));
+  if (Error E = BufOrErr.takeError())
+    return E;
   std::unique_ptr<MemoryBuffer> Buf = std::move(*BufOrErr);
 
   std::pair<StringRef, StringRef> Pair = SecName.split(',');
   StringRef TargetSegName = Pair.first;
   Section Sec(TargetSegName, Pair.second);
   Sec.Content = Obj.NewSectionsContents.save(Buf->getBuffer());
   Sec.Size = Sec.Content.size();
 

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

static Error executeObjcopy(ConfigManager &ConfigMgr) {
 
   std::function<Error(raw_ostream & OutFile)> ObjcopyFunc;
 
   OwningBinary<llvm::object::Binary> BinaryHolder;
   std::unique_ptr<MemoryBuffer> MemoryBufferHolder;
 
   if (Config.InputFormat == FileFormat::Binary ||
       Config.InputFormat == FileFormat::IHex) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
         MemoryBuffer::getFileOrSTDIN(Config.InputFilename);
-    if (!BufOrErr)
-      return createFileError(Config.InputFilename, BufOrErr.getError());
+    if (Error E = BufOrErr.takeError())
+      return E;
     MemoryBufferHolder = std::move(*BufOrErr);
 
     if (Config.InputFormat == FileFormat::Binary)
       ObjcopyFunc = [&](raw_ostream &OutFile) -> Error {
         // Handle FileFormat::Binary.
         return executeObjcopyOnRawBinary(ConfigMgr, *MemoryBufferHolder,
                                          OutFile);
       };
     else
       ObjcopyFunc = [&](raw_ostream &OutFile) -> Error {
         // Handle FileFormat::IHex.
         return executeObjcopyOnIHex(ConfigMgr, *MemoryBufferHolder, OutFile);
       };
   } else {
     Expected<OwningBinary<llvm::object::Binary>> BinaryOrErr =
         createBinary(Config.InputFilename);
     if (!BinaryOrErr)
-      return createFileError(Config.InputFilename, BinaryOrErr.takeError());
+      return BinaryOrErr.takeError();
     BinaryHolder = std::move(*BinaryOrErr);
 
     if (Archive *Ar = dyn_cast<Archive>(BinaryHolder.getBinary())) {
       // Handle Archive.
       if (Error E = executeObjcopyOnArchive(ConfigMgr, *Ar))
         return E;
     } else {
       // Handle llvm::object::Binary.

llvm/tools/llvm-objcopy/wasm/WasmObjcopy.cpp

if (Error E = dumpSectionToFile(SecName, FileName, Obj))
       return createFileError(FileName, std::move(E));
   }
 
   removeSections(Config, Obj);
 
   for (StringRef Flag : Config.AddSection) {
     StringRef SecName, FileName;
     std::tie(SecName, FileName) = Flag.split("=");
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
         MemoryBuffer::getFile(FileName);
-    if (!BufOrErr)
-      return createFileError(FileName, errorCodeToError(BufOrErr.getError()));
+    if (Error E = BufOrErr.takeError())
+      return E;
     Section Sec;
     Sec.SectionType = llvm::wasm::WASM_SEC_CUSTOM;
     Sec.Name = SecName;
     std::unique_ptr<MemoryBuffer> Buf = std::move(*BufOrErr);
     Sec.Contents = makeArrayRef<uint8_t>(
         reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),
         Buf->getBufferSize());
     Obj.addSectionWithOwnedContents(Sec, std::move(Buf));

llvm/tools/llvm-objdump/MachODump.cpp

if (!DSYMFile.empty()) {
         llvm::sys::path::replace_extension(ShortName, "");
         SmallString<1024> FullPath(DSYMPath);
         llvm::sys::path::append(FullPath, "Contents", "Resources", "DWARF",
                                 ShortName);
         DSYMPath = std::string(FullPath.str());
       }
 
       // Load the file.
-      ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+      Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
           MemoryBuffer::getFileOrSTDIN(DSYMPath);
-      if (std::error_code EC = BufOrErr.getError()) {
-        reportError(errorCodeToError(EC), DSYMPath);
+      if (Error E = BufOrErr.takeError()) {
+        reportError(std::move(E), DSYMPath);
         return;
       }
 
       // We need to keep the file alive, because we're replacing DbgObj with it.
       DSYMBuf = std::move(BufOrErr.get());
 
       Expected<std::unique_ptr<Binary>> BinaryOrErr =
       createBinary(DSYMBuf.get()->getMemBufferRef());

llvm/tools/llvm-objdump/SourcePrinter.cpp

 }
 
 bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
   std::unique_ptr<MemoryBuffer> Buffer;
   if (LineInfo.Source) {
     Buffer = MemoryBuffer::getMemBuffer(*LineInfo.Source);
   } else {
     auto BufferOrError = MemoryBuffer::getFile(LineInfo.FileName);
-    if (!BufferOrError) {
+    if (Error E = BufferOrError.takeError()) {
+      consumeError(std::move(E));
       if (MissingSources.insert(LineInfo.FileName).second)
         reportWarning("failed to find source " + LineInfo.FileName,
                       Obj->getFileName());
       return false;
     }
     Buffer = std::move(*BufferOrError);
   }
   // Chomp the file to get lines

llvm/tools/llvm-opt-report/OptReport.cpp

struct OptReportLocationInfo {
   }
 };
 
 typedef std::map<std::string, std::map<int, std::map<std::string, std::map<int,
           OptReportLocationInfo>>>> LocationInfoTy;
 } // anonymous namespace
 
 static bool readLocationInfo(LocationInfoTy &LocationInfo) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
+  Expected<std::unique_ptr<MemoryBuffer>> Buf =
       MemoryBuffer::getFile(InputFileName.c_str());
-  if (std::error_code EC = Buf.getError()) {
+  if (Error E = Buf.takeError()) {
     WithColor::error() << "Can't open file " << InputFileName << ": "
-                       << EC.message() << "\n";
+                       << toString(std::move(E)) << "\n";
     return false;
   }
 
   Expected<remarks::Format> Format = remarks::parseFormat(ParserFormat);
   if (!Format) {
     handleAllErrors(Format.takeError(), [&](const ErrorInfoBase &PE) {
       PE.log(WithColor::error());
       errs() << '\n';
static bool writeReport(LocationInfoTy &LocationInfo) {
   bool FirstFile = true;
   for (auto &FI : LocationInfo) {
     SmallString<128> FileName(FI.first);
     if (!InputRelDir.empty())
       sys::fs::make_absolute(InputRelDir, FileName);
 
     const auto &FileInfo = FI.second;
 
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
+    Expected<std::unique_ptr<MemoryBuffer>> Buf =
         MemoryBuffer::getFile(FileName);
-    if (std::error_code EC = Buf.getError()) {
+    if (Error E = Buf.takeError()) {
       WithColor::error() << "Can't open file " << FileName << ": "
-                         << EC.message() << "\n";
+                         << toString(std::move(E)) << "\n";
       return false;
     }
 
     if (FirstFile)
       FirstFile = false;
     else
       OS << "\n";
 

llvm/tools/llvm-pdbutil/InputFile.cpp

 }
 
 Expected<InputFile> InputFile::open(StringRef Path, bool AllowUnknownFile) {
   InputFile IF;
   if (!llvm::sys::fs::exists(Path))
     return make_error<StringError>(formatv("File {0} not found", Path),
                                    inconvertibleErrorCode());
 
-  file_magic Magic;
-  if (auto EC = identify_magic(Path, Magic))
-    return make_error<StringError>(
-        formatv("Unable to identify file type for file {0}", Path), EC);
+  auto Magic = identify_magic_in_file(Path);
+  if (Error E = Magic.takeError())
+    return E;
 
-  if (Magic == file_magic::coff_object) {
+  if (*Magic == file_magic::coff_object) {
     Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(Path);
     if (!BinaryOrErr)
       return BinaryOrErr.takeError();
 
     IF.CoffObject = std::move(*BinaryOrErr);
     IF.PdbOrObj = llvm::cast<COFFObjectFile>(IF.CoffObject.getBinary());
     return std::move(IF);
   }
 
-  if (Magic == file_magic::pdb) {
+  if (*Magic == file_magic::pdb) {
     std::unique_ptr<IPDBSession> Session;
     if (auto Err = loadDataForPDB(PDB_ReaderType::Native, Path, Session))
       return std::move(Err);
 
     IF.PdbSession.reset(static_cast<NativeSession *>(Session.release()));
     IF.PdbOrObj = &IF.PdbSession->getPDBFile();
 
     return std::move(IF);
   }
 
   if (!AllowUnknownFile)
     return make_error<StringError>(
         formatv("File {0} is not a supported file type", Path),
         inconvertibleErrorCode());
 
   auto Result = MemoryBuffer::getFile(Path, /*IsText=*/false,
                                       /*RequiresNullTerminator=*/false);
-  if (!Result)
-    return make_error<StringError>(
-        formatv("File {0} could not be opened", Path), Result.getError());
+  if (Error E = Result.takeError())
+    return E;
 
   IF.UnknownFile = std::move(*Result);
   IF.PdbOrObj = IF.UnknownFile.get();
   return std::move(IF);
 }
 
 PDBFile &InputFile::pdb() {
   assert(isPdb());

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

cl::opt<bool> ForceName("name",
                         cl::init(false));
 } // namespace exportstream
 }
 
 static ExitOnError ExitOnErr;
 
 static void yamlToPdb(StringRef Path) {
   BumpPtrAllocator Allocator;
-  ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
+  Expected<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
       MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
 
-  if (ErrorOrBuffer.getError()) {
-    ExitOnErr(createFileError(Path, errorCodeToError(ErrorOrBuffer.getError())));
+  if (Error E = ErrorOrBuffer.takeError()) {
+    ExitOnErr(std::move(E));
   }
 
   std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
 
   llvm::yaml::Input In(Buffer->getBuffer());
   pdb::yaml::PdbObject YamlObj(Allocator);
   In >> YamlObj;
 

llvm/tools/llvm-profdata/llvm-profdata.cpp

class SymbolRemapper {
   std::unique_ptr<MemoryBuffer> File;
   DenseMap<StringRef, StringRef> RemappingTable;
 
 public:
   /// Build a SymbolRemapper from a file containing a list of old/new symbols.
   static std::unique_ptr<SymbolRemapper> create(StringRef InputFile) {
     auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFile);
     if (!BufOrError)
-      exitWithErrorCode(BufOrError.getError(), InputFile);
+      exitWithError(BufOrError.takeError(), InputFile);
 
     auto Remapper = std::make_unique<SymbolRemapper>();
     Remapper->File = std::move(BufOrError.get());
 
     for (line_iterator LineIt(*Remapper->File, /*SkipBlanks=*/true, '#');
          !LineIt.is_at_eof(); ++LineIt) {
       std::pair<StringRef, StringRef> Parts = LineIt->split(' ');
       if (Parts.first.empty() || Parts.second.empty() ||
static sampleprof::SampleProfileFormat FormatMap[] = {
     sampleprof::SPF_Binary};
 
 static std::unique_ptr<MemoryBuffer>
 getInputFileBuf(const StringRef &InputFile) {
   if (InputFile == "")
     return {};
 
   auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFile);
-  if (!BufOrError)
-    exitWithErrorCode(BufOrError.getError(), InputFile);
+  if (Error E = BufOrError.takeError())
+    exitWithError(std::move(E), InputFile);
 
   return std::move(*BufOrError);
 }
 
 static void populateProfileSymbolList(MemoryBuffer *Buffer,
                                       sampleprof::ProfileSymbolList &PSL) {
   if (!Buffer)
     return;

llvm/tools/llvm-rc/ResourceFileWriter.cpp

ResourceFileWriter::loadFile(StringRef File) const {
   // must have a root directory, but e.g. the path "\dir\file" on windows
   // isn't considered absolute, but it does have a root directory. As long as
   // sys::path::append doesn't handle appending an absolute path or a path
   // starting with a root directory on top of a base, we must handle this
   // case separately at the top. C++17's path::append handles that case
   // properly though, so if using that to append paths below, this early
   // exception case could be removed.)
   if (sys::path::has_root_directory(File))
-    return errorOrToExpected(MemoryBuffer::getFile(
-        File, /*IsText=*/false, /*RequiresNullTerminator=*/false));
+    return MemoryBuffer::getFile(File, /*IsText=*/false,
+                                 /*RequiresNullTerminator=*/false);
 
   // 1. The current working directory.
   sys::fs::current_path(Cwd);
   Path.assign(Cwd.begin(), Cwd.end());
   sys::path::append(Path, File);
   if (sys::fs::exists(Path))
-    return errorOrToExpected(MemoryBuffer::getFile(
-        Path, /*IsText=*/false, /*RequiresNullTerminator=*/false));
+    return MemoryBuffer::getFile(Path, /*IsText=*/false,
+                                 /*RequiresNullTerminator=*/false);
 
   // 2. The directory of the input resource file, if it is different from the
   // current working directory.
   StringRef InputFileDir = sys::path::parent_path(Params.InputFilePath);
   Path.assign(InputFileDir.begin(), InputFileDir.end());
   sys::path::append(Path, File);
   if (sys::fs::exists(Path))
-    return errorOrToExpected(MemoryBuffer::getFile(
-        Path, /*IsText=*/false, /*RequiresNullTerminator=*/false));
+    return MemoryBuffer::getFile(Path, /*IsText=*/false,
+                                 /*RequiresNullTerminator=*/false);
 
   // 3. All of the include directories specified on the command line.
   for (StringRef ForceInclude : Params.Include) {
     Path.assign(ForceInclude.begin(), ForceInclude.end());
     sys::path::append(Path, File);
     if (sys::fs::exists(Path))
-      return errorOrToExpected(MemoryBuffer::getFile(
-          Path, /*IsText=*/false, /*RequiresNullTerminator=*/false));
+      return MemoryBuffer::getFile(Path, /*IsText=*/false,
+                                   /*RequiresNullTerminator=*/false);
   }
 
   if (!Params.NoInclude) {
     if (auto Result = llvm::sys::Process::FindInEnvPath("INCLUDE", File))
-      return errorOrToExpected(MemoryBuffer::getFile(
-          *Result, /*IsText=*/false, /*RequiresNullTerminator=*/false));
+      return MemoryBuffer::getFile(*Result, /*IsText=*/false,
+                                   /*RequiresNullTerminator=*/false);
   }
 
   return make_error<StringError>("error : file not found : " + Twine(File),
                                  inconvertibleErrorCode());
 }
 
 } // namespace rc
 } // namespace llvm

llvm/tools/llvm-rc/llvm-rc.cpp

void doRc(std::string Src, std::string Dest, RcOptions &Opts,
   if (Opts.Preprocess) {
     std::string OutFile = createTempFile("preproc", "rc");
     TempPreprocFile.setFile(OutFile);
     if (preprocess(Src, OutFile, Opts, Argv0))
       PreprocessedFile = OutFile;
   }
 
   // Read and tokenize the input file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> File =
+  Expected<std::unique_ptr<MemoryBuffer>> File =
       MemoryBuffer::getFile(PreprocessedFile);
-  if (!File) {
+  if (Error E = File.takeError()) {
     fatalError("Error opening file '" + Twine(PreprocessedFile) +
-               "': " + File.getError().message());
+               "': " + toString(std::move(E)));
   }
 
   std::unique_ptr<MemoryBuffer> FileContents = std::move(*File);
   StringRef Contents = FileContents->getBuffer();
 
   std::string FilteredContents = filterCppOutput(Contents);
   std::vector<RCToken> Tokens = ExitOnErr(tokenizeRC(FilteredContents));
 
#include "ResourceScriptTokenList.def"
   // STRINGTABLE resources come at the very end.
   if (!Opts.IsDryRun)
     ExitOnErr(Visitor->dumpAllStringTables());
 }
 
 void doCvtres(std::string Src, std::string Dest, std::string TargetTriple) {
   object::WindowsResourceParser Parser;
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(Src);
-  if (!BufferOrErr)
+  if (Error E = BufferOrErr.takeError())
     fatalError("Error opening file '" + Twine(Src) +
-               "': " + BufferOrErr.getError().message());
+               "': " + toString(std::move(E)));
   std::unique_ptr<MemoryBuffer> &Buffer = BufferOrErr.get();
   std::unique_ptr<object::WindowsResource> Binary =
       ExitOnErr(object::WindowsResource::createWindowsResource(
           Buffer->getMemBufferRef()));
 
   std::vector<std::string> Duplicates;
   ExitOnErr(Parser.parse(Binary.get(), Duplicates));
   for (const auto &DupeDiag : Duplicates)

llvm/tools/llvm-readobj/llvm-readobj.cpp

static void dumpWindowsResourceFile(WindowsResource *WinRes,
   WindowsRes::Dumper Dumper(WinRes, Printer);
   if (auto Err = Dumper.printData())
     reportError(std::move(Err), WinRes->getFileName());
 }
 
 
 /// Opens \a File and dumps it.
 static void dumpInput(StringRef File, ScopedPrinter &Writer) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
-  if (std::error_code EC = FileOrErr.getError())
-    return reportError(errorCodeToError(EC), File);
+  if (Error E = FileOrErr.takeError())
+    return reportError(std::move(E), File);
 
   std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
   file_magic Type = identify_magic(Buffer->getBuffer());
   if (Type == file_magic::bitcode) {
     reportWarning(createStringError(errc::invalid_argument,
                                     "bitcode files are not supported"),
                   File);
     return;

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

if (!InputFileList.size())
     InputFileList.push_back("-");
   for (auto &File : InputFileList) {
     // Instantiate a dynamic linker.
     TrivialMemoryManager MemMgr;
     RuntimeDyld Dyld(MemMgr, MemMgr);
 
     // Load the input memory buffer.
 
-    ErrorOr<std::unique_ptr<MemoryBuffer>> InputBuffer =
+    Expected<std::unique_ptr<MemoryBuffer>> InputBuffer =
         MemoryBuffer::getFileOrSTDIN(File);
-    if (std::error_code EC = InputBuffer.getError())
-      ErrorAndExit("unable to read input: '" + EC.message() + "'");
+    if (Error E = InputBuffer.takeError())
+      ErrorAndExit("unable to read input: '" + toString(std::move(E)) + "'");
 
     Expected<std::unique_ptr<ObjectFile>> MaybeObj(
       ObjectFile::createObjectFile((*InputBuffer)->getMemBufferRef()));
 
     if (!MaybeObj) {
       std::string Buf;
       raw_string_ostream OS(Buf);
       logAllUnhandledErrors(MaybeObj.takeError(), OS);
static int executeInput() {
 
   // If we don't have any input files, read from stdin.
   if (!InputFileList.size())
     InputFileList.push_back("-");
   {
     TimeRegion TR(Timers ? &Timers->LoadObjectsTimer : nullptr);
     for (auto &File : InputFileList) {
       // Load the input memory buffer.
-      ErrorOr<std::unique_ptr<MemoryBuffer>> InputBuffer =
+      Expected<std::unique_ptr<MemoryBuffer>> InputBuffer =
           MemoryBuffer::getFileOrSTDIN(File);
-      if (std::error_code EC = InputBuffer.getError())
-        ErrorAndExit("unable to read input: '" + EC.message() + "'");
+      if (Error E = InputBuffer.takeError())
+        ErrorAndExit("unable to read input: '" + toString(std::move(E)) + "'");
       Expected<std::unique_ptr<ObjectFile>> MaybeObj(
           ObjectFile::createObjectFile((*InputBuffer)->getMemBufferRef()));
 
       if (!MaybeObj) {
         std::string Buf;
         raw_string_ostream OS(Buf);
         logAllUnhandledErrors(MaybeObj.takeError(), OS);
         OS.flush();
int Result = 0;
     Result = Main(Argv.size() - 1, Argv.data());
   }
 
   return Result;
 }
 
 static int checkAllExpressions(RuntimeDyldChecker &Checker) {
   for (const auto& CheckerFileName : CheckFiles) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> CheckerFileBuf =
+    Expected<std::unique_ptr<MemoryBuffer>> CheckerFileBuf =
         MemoryBuffer::getFileOrSTDIN(CheckerFileName);
-    if (std::error_code EC = CheckerFileBuf.getError())
-      ErrorAndExit("unable to read input '" + CheckerFileName + "': " +
-                   EC.message());
+    if (Error E = CheckerFileBuf.takeError())
+      ErrorAndExit("unable to read input '" + CheckerFileName +
+                   "': " + toString(std::move(E)));
 
     if (!Checker.checkAllRulesInBuffer("# rtdyld-check:",
                                        CheckerFileBuf.get().get()))
       ErrorAndExit("some checks in '" + CheckerFileName + "' failed");
   }
   return 0;
 }
 
#endif
   // know the endianness.
   std::unique_ptr<RuntimeDyldChecker> Checker;
 
   // If we don't have any input files, read from stdin.
   if (!InputFileList.size())
     InputFileList.push_back("-");
   for (auto &InputFile : InputFileList) {
     // Load the input memory buffer.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> InputBuffer =
+    Expected<std::unique_ptr<MemoryBuffer>> InputBuffer =
         MemoryBuffer::getFileOrSTDIN(InputFile);
 
-    if (std::error_code EC = InputBuffer.getError())
-      ErrorAndExit("unable to read input: '" + EC.message() + "'");
+    if (Error E = InputBuffer.takeError())
+      ErrorAndExit("unable to read input: '" + toString(std::move(E)) + "'");
 
     Expected<std::unique_ptr<ObjectFile>> MaybeObj(
       ObjectFile::createObjectFile((*InputBuffer)->getMemBufferRef()));
 
     if (!MaybeObj) {
       std::string Buf;
       raw_string_ostream OS(Buf);
       logAllUnhandledErrors(MaybeObj.takeError(), OS);

llvm/tools/llvm-size/llvm-size.cpp

static void error(const Twine &Message, StringRef File = "") {
   HadError = true;
   if (File.empty())
     WithColor::error(errs(), ToolName) << Message << '\n';
   else
     WithColor::error(errs(), ToolName)
         << "'" << File << "': " << Message << '\n';
 }
 
+static void error(llvm::Error E) {
+  HadError = true;
+  WithColor::error(errs(), ToolName);
+  std::string Buf;
+  raw_string_ostream OS(Buf);
+  logAllUnhandledErrors(std::move(E), OS);
+  OS.flush();
+  errs() << Buf << "\n";
+}
+
 // This version of error() prints the archive name and member name, for example:
 // "libx.a(foo.o)" after the ToolName before the error message.  It sets
 // HadError but returns allowing the code to move on to other archive members.
 static void error(llvm::Error E, StringRef FileName, const Archive::Child &C,
                   StringRef ArchitectureName = StringRef()) {
   HadError = true;
   WithColor::error(errs(), ToolName) << "'" << FileName << "'";
 

 
 /// Print the section sizes for @p file. If @p file is an archive, print the
 /// section sizes for each archive member.
 static void printFileSectionSizes(StringRef file) {
 
   // Attempt to open the binary.
   Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(file);
   if (!BinaryOrErr) {
-    error(BinaryOrErr.takeError(), file);
+    error(BinaryOrErr.takeError());
     return;
   }
   Binary &Bin = *BinaryOrErr.get().getBinary();
 
   if (Archive *a = dyn_cast<Archive>(&Bin)) {
     // This is an archive. Iterate over each member and display its sizes.
     Error Err = Error::success();
     for (auto &C : a->children(Err)) {

llvm/tools/llvm-strings/llvm-strings.cpp

if (MinLength == 0) {
     return EXIT_FAILURE;
   }
 
   std::vector<std::string> InputFileNames = Args.getAllArgValues(OPT_INPUT);
   if (InputFileNames.empty())
     InputFileNames.push_back("-");
 
   for (const auto &File : InputFileNames) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
+    Expected<std::unique_ptr<MemoryBuffer>> Buffer =
         MemoryBuffer::getFileOrSTDIN(File);
-    if (std::error_code EC = Buffer.getError())
-      errs() << File << ": " << EC.message() << '\n';
+    if (Error E = Buffer.takeError())
+      errs() << File << ": " << toString(std::move(E)) << '\n';
     else
       strings(llvm::outs(), File == "-" ? "{standard input}" : File,
               Buffer.get()->getMemBufferRef().getBuffer());
   }
 
   return EXIT_SUCCESS;
 }

llvm/tools/llvm-tapi-diff/llvm-tapi-diff.cpp

 cl::opt<std::string> InputFileNameRHS(cl::Positional, cl::desc("<second file>"),
                                       cl::cat(NMCat));
 
 std::string ToolName;
 } // anonymous namespace
 
 ExitOnError ExitOnErr;
 
-void setErrorBanner(ExitOnError &ExitOnErr, std::string InputFile) {
-  ExitOnErr.setBanner(ToolName + ": error: " + InputFile + ": ");
-}
-
-Expected<std::unique_ptr<Binary>> convertFileToBinary(std::string &Filename) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+Expected<std::unique_ptr<Binary>> convertFileToBinary(StringRef Filename) {
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
-  if (BufferOrErr.getError())
-    return errorCodeToError(BufferOrErr.getError());
-  return createBinary(BufferOrErr.get()->getMemBufferRef());
+  if (Error E = BufferOrErr.takeError())
+    return E;
+  Expected<std::unique_ptr<Binary>> B =
+      createBinary(BufferOrErr.get()->getMemBufferRef());
+  if (Error E = B.takeError())
+    return createFileError(Filename, std::move(E));
+  return B;
 }
 
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
   cl::HideUnrelatedOptions(NMCat);
   cl::ParseCommandLineOptions(
       Argc, Argv,
       "This tool will compare two tbd files and return the "
       "differences in those files.");
   if (InputFileNameLHS.empty() || InputFileNameRHS.empty()) {
     cl::PrintHelpMessage();
     return EXIT_FAILURE;
   }
 
   ToolName = Argv[0];
 
-  setErrorBanner(ExitOnErr, InputFileNameLHS);
+  ExitOnErr.setBanner(ToolName + ": error: ");
   auto BinLHS = ExitOnErr(convertFileToBinary(InputFileNameLHS));
 
   TapiUniversal *FileLHS = dyn_cast<TapiUniversal>(BinLHS.get());
   if (!FileLHS) {
-    ExitOnErr(
-        createStringError(std::errc::executable_format_error,
-                          "Error when parsing file, unsupported file format"));
+    ExitOnErr(createStringError(
+        std::errc::executable_format_error,
+        "%s: Error when parsing file, unsupported file format",
+        InputFileNameLHS.c_str()));
   }
 
-  setErrorBanner(ExitOnErr, InputFileNameRHS);
   auto BinRHS = ExitOnErr(convertFileToBinary(InputFileNameRHS));
 
   TapiUniversal *FileRHS = dyn_cast<TapiUniversal>(BinRHS.get());
   if (!FileRHS) {
-    ExitOnErr(
-        createStringError(std::errc::executable_format_error,
-                          "Error when parsing file, unsupported file format"));
+    ExitOnErr(createStringError(
+        std::errc::executable_format_error,
+        "%s: Error when parsing file, unsupported file format",
+        InputFileNameRHS.c_str()));
   }
 
   raw_ostream &OS = outs();
 
   return DiffEngine(FileLHS, FileRHS).compareFiles(OS);
 }

llvm/tools/llvm-undname/llvm-undname.cpp

 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
   cl::HideUnrelatedOptions({&UndNameCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "llvm-undname\n");
 
   if (!RawFile.empty()) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
         MemoryBuffer::getFileOrSTDIN(RawFile);
-    if (std::error_code EC = FileOrErr.getError()) {
+    if (Error E = FileOrErr.takeError()) {
       WithColor::error() << "Could not open input file \'" << RawFile
-                         << "\': " << EC.message() << '\n';
+                         << "\': " << toString(std::move(E)) << '\n';
       return 1;
     }
     return msDemangle(std::string(FileOrErr->get()->getBuffer())) ? 0 : 1;
   }
 
   bool Success = true;
   if (Symbols.empty()) {
     while (true) {

llvm/tools/lto/lto.cpp

 }
 
 bool lto_module_is_object_file(const char* path) {
   return LTOModule::isBitcodeFile(StringRef(path));
 }
 
 bool lto_module_is_object_file_for_target(const char* path,
                                           const char* target_triplet_prefix) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer = MemoryBuffer::getFile(path);
-  if (!Buffer)
+  Expected<std::unique_ptr<MemoryBuffer>> Buffer = MemoryBuffer::getFile(path);
+  if (Error E = Buffer.takeError()) {
+    consumeError(std::move(E));
     return false;
+  }
   return LTOModule::isBitcodeForTarget(Buffer->get(),
                                        StringRef(target_triplet_prefix));
 }
 
 bool lto_module_has_objc_category(const void *mem, size_t length) {
   std::unique_ptr<MemoryBuffer> Buffer(LTOModule::makeBuffer(mem, length));
   if (!Buffer)
     return false;

llvm/tools/obj2yaml/obj2yaml.cpp

 //===------ utils/obj2yaml.cpp - obj2yaml conversion tool -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "obj2yaml.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/Minidump.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/WithColor.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 static Error dumpObject(const ObjectFile &Obj) {
   if (Obj.isCOFF())
     return errorCodeToError(coff2yaml(outs(), cast<COFFObjectFile>(Obj)));
 
   if (Obj.isXCOFF())
     return errorCodeToError(xcoff2yaml(outs(), cast<XCOFFObjectFile>(Obj)));
 
   if (Obj.isELF())
     return elf2yaml(outs(), Obj);
 
   if (Obj.isWasm())
     return errorCodeToError(wasm2yaml(outs(), cast<WasmObjectFile>(Obj)));
 
   llvm_unreachable("unexpected object file format");
 }
 
-static Error dumpInput(StringRef File) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false,
-                                   /*RequiresNullTerminator=*/false);
-  if (std::error_code EC = FileOrErr.getError())
-    return errorCodeToError(EC);
-  std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
+static Error dumpInputImpl(std::unique_ptr<MemoryBuffer> Buffer) {
   MemoryBufferRef MemBuf = Buffer->getMemBufferRef();
   if (file_magic::archive == identify_magic(MemBuf.getBuffer()))
     return archive2yaml(outs(), MemBuf);
 
   Expected<std::unique_ptr<Binary>> BinOrErr =
       createBinary(MemBuf, /*Context=*/nullptr);
   if (!BinOrErr)
     return BinOrErr.takeError();
 
   Binary &Binary = *BinOrErr->get();
   // Universal MachO is not a subclass of ObjectFile, so it needs to be handled
   // here with the other binary types.
   if (Binary.isMachO() || Binary.isMachOUniversalBinary())
     return macho2yaml(outs(), Binary);
   if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary))
     return dumpObject(*Obj);
   if (MinidumpFile *Minidump = dyn_cast<MinidumpFile>(&Binary))
     return minidump2yaml(outs(), *Minidump);
 
   return Error::success();
 }
 
-static void reportError(StringRef Input, Error Err) {
-  if (Input == "-")
-    Input = "<stdin>";
+static Error dumpInput(StringRef File) {
+  Expected<std::unique_ptr<MemoryBuffer>> FileOrErr =
+      MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false,
+                                   /*RequiresNullTerminator=*/false);
+  if (Error E = FileOrErr.takeError())
+    return E;
+  // Get the Buffer's identifier, since it'll do the '-' -> '<stdin>' mapping
+  // for us.
+  SmallString<32> Identifier = (*FileOrErr)->getBufferIdentifier();
+  if (Error E = dumpInputImpl(std::move(*FileOrErr)))
+    return createFileError(Identifier, std::move(E));
+  return Error::success();
+}
+
+static void reportError(const char *ProgName, Error Err) {
   std::string ErrMsg;
   raw_string_ostream OS(ErrMsg);
   logAllUnhandledErrors(std::move(Err), OS);
   OS.flush();
-  errs() << "Error reading file: " << Input << ": " << ErrMsg;
-  errs().flush();
+  WithColor::error(errs(), ProgName) << ErrMsg;
 }
 
 cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input file>"),
                                    cl::init("-"));
 
 int main(int argc, char *argv[]) {
   InitLLVM X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv);
+  const char *ProgName = argv[0];
 
   if (Error Err = dumpInput(InputFilename)) {
-    reportError(InputFilename, std::move(Err));
+    reportError(ProgName, std::move(Err));
     return 1;
   }
 
   return 0;
 }

llvm/tools/sancov/sancov.cpp

static void readInts(const char *Start, const char *End,
                      std::set<uint64_t> *Ints) {
   const T *S = reinterpret_cast<const T *>(Start);
   const T *E = reinterpret_cast<const T *>(End);
   std::copy(S, E, std::inserter(*Ints, Ints->end()));
 }
 
 ErrorOr<std::unique_ptr<RawCoverage>>
 RawCoverage::read(const std::string &FileName) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFile(FileName);
   if (!BufOrErr)
-    return BufOrErr.getError();
+    return errorToErrorCode(BufOrErr.takeError());
   std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
   if (Buf->getBufferSize() < 8) {
     errs() << "File too small (<8): " << Buf->getBufferSize() << '\n';
     return make_error_code(errc::illegal_byte_sequence);
   }
   const FileHeader *Header =
       reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
 

 }
 
 std::unique_ptr<SymbolizedCoverage>
 SymbolizedCoverage::read(const std::string &InputFile) {
   auto Coverage(std::make_unique<SymbolizedCoverage>());
 
   std::map<std::string, CoveragePoint> Points;
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-      MemoryBuffer::getFile(InputFile);
+      expectedToErrorOr(MemoryBuffer::getFile(InputFile));
   failIfError(BufOrErr);
 
   SourceMgr SM;
   yaml::Stream S(**BufOrErr, SM);
 
   yaml::document_iterator DI = S.begin();
   failIf(DI == S.end(), "empty document: " + InputFile);
   yaml::Node *Root = DI->getRoot();

 }
 
 static ErrorOr<bool> isCoverageFile(const std::string &FileName) {
   auto ShortFileName = llvm::sys::path::filename(FileName);
   if (!SancovFileRegex.match(ShortFileName))
     return false;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-      MemoryBuffer::getFile(FileName);
+      expectedToErrorOr(MemoryBuffer::getFile(FileName));
   if (!BufOrErr) {
     errs() << "Warning: " << BufOrErr.getError().message() << "("
            << BufOrErr.getError().value()
            << "), filename: " << llvm::sys::path::filename(FileName) << "\n";
     return BufOrErr.getError();
   }
   std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
   if (Buf->getBufferSize() < 8) {
static bool isSymbolizedCoverageFile(const std::string &FileName) {
   return SymcovFileRegex.match(ShortFileName);
 }
 
 static std::unique_ptr<SymbolizedCoverage>
 symbolize(const RawCoverage &Data, const std::string ObjectFile) {
   auto Coverage = std::make_unique<SymbolizedCoverage>();
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-      MemoryBuffer::getFile(ObjectFile);
+      expectedToErrorOr(MemoryBuffer::getFile(ObjectFile));
   failIfError(BufOrErr);
   SHA1 Hasher;
   Hasher.update((*BufOrErr)->getBuffer());
   Coverage->BinaryHash = toHex(Hasher.final());
 
   Blacklists B;
   auto Symbolizer(createSymbolizer());
 

llvm/tools/sanstats/sanstats.cpp

while (1) {
     llvm::outs() << " " << CountFromData(Data, SizeofPtr) << '\n';
   }
 }
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv,
                               "Sanitizer Statistics Processing Tool");
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
+  Expected<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
       ClInputFile, /*IsText=*/false, /*RequiresNullTerminator=*/false);
-  if (!MBOrErr) {
-    errs() << argv[0] << ": " << ClInputFile << ": "
-           << MBOrErr.getError().message() << '\n';
+  if (Error E = MBOrErr.takeError()) {
+    errs() << argv[0] << ": " << ClInputFile << ": " << toString(std::move(E))
+           << '\n';
     return 1;
   }
   std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
   const char *Begin = MB->getBufferStart(), *End = MB->getBufferEnd();
   if (Begin == End) {
     errs() << argv[0] << ": " << ClInputFile << ": short read\n";
     return 1;
   }

llvm/tools/split-file/split-file.cpp

cl::ParseCommandLineOptions(
       nullptr,
       /*EnvVar=*/nullptr,
       /*LongOptionsUseDoubleDash=*/true);
 
   if (input.empty())
     fatal("", "input filename is not specified");
   if (output.empty())
     fatal("", "output directory is not specified");
-  ErrorOr<std::unique_ptr<MemoryBuffer>> bufferOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> bufferOrErr =
       MemoryBuffer::getFileOrSTDIN(input);
-  if (std::error_code ec = bufferOrErr.getError())
-    fatal(input, ec.message());
+  if (Error E = bufferOrErr.takeError())
+    fatal(input, toString(std::move(E)));
 
   // Delete output if it is a file or an empty directory, so that we can create
   // a directory.
   sys::fs::file_status status;
   if (std::error_code ec = sys::fs::status(output, status))
     if (ec.value() != static_cast<int>(std::errc::no_such_file_or_directory))
       fatal(output, ec.message());
   if (status.type() != sys::fs::file_type::file_not_found &&

llvm/tools/verify-uselistorder/verify-uselistorder.cpp

bool TempFile::writeAssembly(const Module &M) const {
   }
 
   M.print(OS, nullptr, /* ShouldPreserveUseListOrder */ true);
   return false;
 }
 
 std::unique_ptr<Module> TempFile::readBitcode(LLVMContext &Context) const {
   LLVM_DEBUG(dbgs() << " - read bitcode\n");
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufferOr =
       MemoryBuffer::getFile(Filename);
-  if (!BufferOr) {
-    errs() << "verify-uselistorder: error: " << BufferOr.getError().message()
-           << "\n";
+  if (Error E = BufferOr.takeError()) {
+    errs() << "verify-uselistorder: error: " << toString(std::move(E)) << "\n";
     return nullptr;
   }
 
   MemoryBuffer *Buffer = BufferOr.get().get();
   Expected<std::unique_ptr<Module>> ModuleOr =
       parseBitcodeFile(Buffer->getMemBufferRef(), Context);
   if (!ModuleOr) {
     logAllUnhandledErrors(ModuleOr.takeError(), errs(),

llvm/tools/yaml2obj/yaml2obj.cpp

int main(int argc, char **argv) {
   std::error_code EC;
   std::unique_ptr<ToolOutputFile> Out(
       new ToolOutputFile(OutputFilename, EC, sys::fs::OF_None));
   if (EC) {
     ErrHandler("failed to open '" + OutputFilename + "': " + EC.message());
     return 1;
   }
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
+  Expected<std::unique_ptr<MemoryBuffer>> Buf =
       MemoryBuffer::getFileOrSTDIN(Input);
-  if (!Buf)
+  if (Error E = Buf.takeError()) {
+    consumeError(std::move(E));
     return 1;
+  }
 
   Optional<std::string> Buffer = preprocess(Buf.get()->getBuffer(), ErrHandler);
   if (!Buffer)
     return 1;
   yaml::Input YIn(*Buffer);
 
   if (!convertYAML(YIn, Out->os(), ErrHandler, DocNum,
                    MaxSize == 0 ? UINT64_MAX : MaxSize))
     return 1;
 
   Out->keep();
   Out->os().flush();
   return 0;
 }

llvm/unittests/Support/MemoryBufferTest.cpp

TEST_F(MemoryBufferTest, getOpenFile) {
   OF << "12345678";
   OF.close();
 
   {
     Expected<sys::fs::file_t> File = sys::fs::openNativeFileForRead(TestPath);
     ASSERT_THAT_EXPECTED(File, Succeeded());
     auto OnExit =
         make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
-    ErrorOr<OwningBuffer> MB = MemoryBuffer::getOpenFile(*File, TestPath, 6);
-    ASSERT_NO_ERROR(MB.getError());
+    Expected<OwningBuffer> MB = MemoryBuffer::getOpenFile(*File, TestPath, 6);
+    ASSERT_FALSE(!MB);
     EXPECT_EQ("123456", MB.get()->getBuffer());
   }
   {
     Expected<sys::fs::file_t> File = sys::fs::openNativeFileForWrite(
         TestPath, sys::fs::CD_OpenExisting, sys::fs::OF_None);
     ASSERT_THAT_EXPECTED(File, Succeeded());
     auto OnExit =
         make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
-    ASSERT_ERROR(MemoryBuffer::getOpenFile(*File, TestPath, 6).getError());
+    Expected<std::unique_ptr<MemoryBuffer>> MB =
+        MemoryBuffer::getOpenFile(*File, TestPath, 6);
+    ASSERT_FALSE(MB);
+    consumeError(MB.takeError());
   }
 }
 
 TEST_F(MemoryBufferTest, NullTerminator4K) {
   // Test that a file with size that is a multiple of the page size can be null
   // terminated correctly by MemoryBuffer.
   int TestFD;
   SmallString<64> TestPath;
   sys::fs::createTemporaryFile("MemoryBufferTest_NullTerminator4K", "temp",
                                TestFD, TestPath);
   FileRemover Cleanup(TestPath);
   raw_fd_ostream OF(TestFD, true, /*unbuffered=*/true);
   for (unsigned i = 0; i < 4096 / 16; ++i) {
     OF << "0123456789abcdef";
   }
   OF.close();
 
-  ErrorOr<OwningBuffer> MB = MemoryBuffer::getFile(TestPath.c_str());
-  std::error_code EC = MB.getError();
-  ASSERT_FALSE(EC);
+  Expected<OwningBuffer> MB = MemoryBuffer::getFile(TestPath.c_str());
+  ASSERT_TRUE((bool)MB);
 
   const char *BufData = MB.get()->getBufferStart();
   EXPECT_EQ('f', BufData[4095]);
   EXPECT_EQ('\0', BufData[4096]);
 }
 
 TEST_F(MemoryBufferTest, copy) {
   // copy with no name

 #else
       DWORD Written;
       ASSERT_TRUE(::WriteFile(pipes[1], "foo", 3, &Written, nullptr))
           << ::GetLastError();
       ASSERT_EQ(Written, 3u);
 #endif
     }
   });
-  ErrorOr<OwningBuffer> MB =
+  Expected<OwningBuffer> MB =
       MemoryBuffer::getOpenFile(pipes[0], "pipe", /*FileSize*/ -1);
   Writer.join();
-  ASSERT_NO_ERROR(MB.getError());
+  ASSERT_TRUE((bool)MB);
   EXPECT_EQ(MB.get()->getBuffer(), "foofoofoofoofoo");
 }
 #endif
 
 TEST_F(MemoryBufferTest, make_new) {
   // 0-sized buffer
   OwningBuffer Zero(WritableMemoryBuffer::getNewUninitMemBuffer(0));
   EXPECT_TRUE(nullptr != Zero.get());
for (int i = 0; i < 60000; ++i) {
     OF << "0123456789";
   }
 
   if (Reopen) {
     OF.close();
     EXPECT_FALSE(sys::fs::openFileForRead(TestPath.c_str(), TestFD));
   }
 
-  ErrorOr<OwningBuffer> Buf = MemoryBuffer::getOpenFileSlice(
+  Expected<OwningBuffer> Buf = MemoryBuffer::getOpenFileSlice(
       sys::fs::convertFDToNativeFile(TestFD), TestPath.c_str(),
       40000, // Size
       80000  // Offset
   );
 
-  std::error_code EC = Buf.getError();
-  EXPECT_FALSE(EC);
+  Error E = Buf.takeError();
+  EXPECT_FALSE(E);
 
   StringRef BufData = Buf.get()->getBuffer();
   EXPECT_EQ(BufData.size(), 40000U);
   EXPECT_EQ(BufData[0], '0');
   EXPECT_EQ(BufData[9], '9');
 }
 
 TEST_F(MemoryBufferTest, getOpenFileNoReopen) {
for (unsigned i = 0; i < 0x2000 / 8; ++i) {
     OF << "abcdefgh";
   }
   for (unsigned i = 0; i < 0x2000 / 8; ++i) {
     OF << "ABCDEFGH";
   }
   OF.close();
 
   // Try offset of one page.
-  ErrorOr<OwningBuffer> MB = MemoryBuffer::getFileSlice(TestPath.str(),
-                                                        0x4000, 0x1000);
-  std::error_code EC = MB.getError();
-  ASSERT_FALSE(EC);
+  Expected<OwningBuffer> MB =
+      MemoryBuffer::getFileSlice(TestPath.str(), 0x4000, 0x1000);
+  ASSERT_TRUE((bool)MB);
   EXPECT_EQ(0x4000UL, MB.get()->getBufferSize());
  
   StringRef BufData = MB.get()->getBuffer();
   EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678"));
   EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678"));
   EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh"));
   EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh"));
   EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH"));
   EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH"));
    
   // Try non-page aligned.
-  ErrorOr<OwningBuffer> MB2 = MemoryBuffer::getFileSlice(TestPath.str(),
-                                                         0x3000, 0x0800);
-  EC = MB2.getError();
-  ASSERT_FALSE(EC);
+  Expected<OwningBuffer> MB2 =
+      MemoryBuffer::getFileSlice(TestPath.str(), 0x3000, 0x0800);
+  ASSERT_TRUE((bool)MB2);
   EXPECT_EQ(0x3000UL, MB2.get()->getBufferSize());
   
   StringRef BufData2 = MB2.get()->getBuffer();
   EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678"));
   EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678"));
   EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh"));
   EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh"));
 }
 
 TEST_F(MemoryBufferTest, writableSlice) {
   // Create a file initialized with some data
   int FD;
   SmallString<64> TestPath;
   sys::fs::createTemporaryFile("MemoryBufferTest_WritableSlice", "temp", FD,
                                TestPath);
   FileRemover Cleanup(TestPath);
   raw_fd_ostream OF(FD, true);
   for (unsigned i = 0; i < 0x1000; ++i)
     OF << "0123456789abcdef";
   OF.close();
 
   {
     auto MBOrError =
         WritableMemoryBuffer::getFileSlice(TestPath.str(), 0x6000, 0x2000);
-    ASSERT_FALSE(MBOrError.getError());
+    ASSERT_TRUE((bool)MBOrError);
     // Write some data.  It should be mapped private, so that upon completion
     // the original file contents are not modified.
     WritableMemoryBuffer &MB = **MBOrError;
     ASSERT_EQ(0x6000u, MB.getBufferSize());
     char *Start = MB.getBufferStart();
     ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize());
     ::memset(Start, 'x', MB.getBufferSize());
   }
 
   auto MBOrError = MemoryBuffer::getFile(TestPath);
-  ASSERT_FALSE(MBOrError.getError());
+  ASSERT_TRUE((bool)MBOrError);
   auto &MB = **MBOrError;
   ASSERT_EQ(0x10000u, MB.getBufferSize());
   for (size_t i = 0; i < MB.getBufferSize(); i += 0x10)
     EXPECT_EQ("0123456789abcdef", MB.getBuffer().substr(i, 0x10)) << "i: " << i;
 }
 
 TEST_F(MemoryBufferTest, writeThroughFile) {
   // Create a file initialized with some data
   int FD;
   SmallString<64> TestPath;
   sys::fs::createTemporaryFile("MemoryBufferTest_WriteThrough", "temp", FD,
                                TestPath);
   FileRemover Cleanup(TestPath);
   raw_fd_ostream OF(FD, true);
   OF << "0123456789abcdef";
   OF.close();
   {
     auto MBOrError = WriteThroughMemoryBuffer::getFile(TestPath);
-    ASSERT_FALSE(MBOrError.getError());
+    ASSERT_TRUE((bool)MBOrError);
     // Write some data.  It should be mapped readwrite, so that upon completion
     // the original file contents are modified.
     WriteThroughMemoryBuffer &MB = **MBOrError;
     ASSERT_EQ(16u, MB.getBufferSize());
     char *Start = MB.getBufferStart();
     ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize());
     ::memset(Start, 'x', MB.getBufferSize());
   }
 
   auto MBOrError = MemoryBuffer::getFile(TestPath);
-  ASSERT_FALSE(MBOrError.getError());
+  ASSERT_TRUE((bool)MBOrError);
   auto &MB = **MBOrError;
   ASSERT_EQ(16u, MB.getBufferSize());
   EXPECT_EQ("xxxxxxxxxxxxxxxx", MB.getBuffer());
 }
 
 TEST_F(MemoryBufferTest, mmapVolatileNoNull) {
   // Verify that `MemoryBuffer::getOpenFile` will use mmap when
   // `RequiresNullTerminator = false`, `IsVolatile = true`, and the file is
TEST_F(MemoryBufferTest, mmapVolatileNoNull) {
 
   Expected<sys::fs::file_t> File = sys::fs::openNativeFileForRead(TestPath);
   ASSERT_THAT_EXPECTED(File, Succeeded());
   auto OnExit =
       make_scope_exit([&] { ASSERT_NO_ERROR(sys::fs::closeFile(*File)); });
 
   auto MBOrError = MemoryBuffer::getOpenFile(*File, TestPath,
       /*FileSize=*/-1, /*RequiresNullTerminator=*/false, /*IsVolatile=*/true);
-  ASSERT_NO_ERROR(MBOrError.getError())
+  ASSERT_TRUE((bool)MBOrError);
   OwningBuffer MB = std::move(*MBOrError);
   EXPECT_EQ(MB->getBufferKind(), MemoryBuffer::MemoryBuffer_MMap);
   EXPECT_EQ(MB->getBufferSize(), std::size_t(FileWrites * 8));
   EXPECT_TRUE(MB->getBuffer().startswith("01234567"));
 }
 }

llvm/unittests/Support/TarWriterTest.cpp

static std::vector<uint8_t> createTar(StringRef Base, StringRef Filename) {
   Expected<std::unique_ptr<TarWriter>> TarOrErr =
       TarWriter::create(TarWriterTest.path(), Base);
   EXPECT_TRUE((bool)TarOrErr);
   std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
   Tar->append(Filename, "contents");
   Tar.reset();
 
   // Read the tar file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> MBOrErr =
       MemoryBuffer::getFile(TarWriterTest.path());
   EXPECT_TRUE((bool)MBOrErr);
   std::unique_ptr<MemoryBuffer> MB = std::move(*MBOrErr);
   std::vector<uint8_t> Buf((const uint8_t *)MB->getBufferStart(),
                            (const uint8_t *)MB->getBufferEnd());
 
   // Windows does not allow us to remove a mmap'ed files, so
   // unmap first and then remove the temporary file.

llvm/unittests/Support/raw_ostream_test.cpp

TEST(raw_ostreamTest, reserve_stream) {
   OS << "hello";
   OS << 1;
   OS << 'w' << 'o' << 'r' << 'l' << 'd';
   OS.flush();
   EXPECT_EQ("11111111111111111111hello1world", Str);
 }
 
 static void checkFileData(StringRef FileName, StringRef GoldenData) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFileOrSTDIN(FileName);
-  EXPECT_FALSE(BufOrErr.getError());
+  EXPECT_TRUE((bool)BufOrErr);
 
   EXPECT_EQ((*BufOrErr)->getBufferSize(), GoldenData.size());
   EXPECT_EQ(memcmp((*BufOrErr)->getBufferStart(), GoldenData.data(),
                    GoldenData.size()),
             0);
 }
 
 TEST(raw_ostreamTest, writeToOutputFile) {

llvm/utils/FileCheck/FileCheck.cpp

errs() << "Unable to combine check-prefix strings into a prefix regular "
               "with the following error: "
            << REError << "\n";
     return 2;
   }
 
   SourceMgr SM;
 
   // Read the expected strings from the check file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> CheckFileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> CheckFileOrErr =
       MemoryBuffer::getFileOrSTDIN(CheckFilename, /*IsText=*/true);
-  if (std::error_code EC = CheckFileOrErr.getError()) {
+  if (Error E = CheckFileOrErr.takeError()) {
     errs() << "Could not open check file '" << CheckFilename
-           << "': " << EC.message() << '\n';
+           << "': " << toString(std::move(E)) << '\n';
     return 2;
   }
   MemoryBuffer &CheckFile = *CheckFileOrErr.get();
 
   SmallString<4096> CheckFileBuffer;
   StringRef CheckFileText = FC.CanonicalizeFile(CheckFile, CheckFileBuffer);
 
   unsigned CheckFileBufferID =
       SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(
                                 CheckFileText, CheckFile.getBufferIdentifier()),
                             SMLoc());
 
   std::pair<unsigned, unsigned> ImpPatBufferIDRange;
   if (FC.readCheckFile(SM, CheckFileText, PrefixRE, &ImpPatBufferIDRange))
     return 2;
 
   // Open the file to check and add it to SourceMgr.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> InputFileOrErr =
+  Expected<std::unique_ptr<MemoryBuffer>> InputFileOrErr =
       MemoryBuffer::getFileOrSTDIN(InputFilename, /*IsText=*/true);
   if (InputFilename == "-")
     InputFilename = "<stdin>"; // Overwrite for improved diagnostic messages
-  if (std::error_code EC = InputFileOrErr.getError()) {
+  if (Error E = InputFileOrErr.takeError()) {
     errs() << "Could not open input file '" << InputFilename
-           << "': " << EC.message() << '\n';
+           << "': " << toString(std::move(E)) << '\n';
     return 2;
   }
   MemoryBuffer &InputFile = *InputFileOrErr.get();
 
   if (InputFile.getBufferSize() == 0 && !AllowEmptyInput) {
     errs() << "FileCheck error: '" << InputFilename << "' is empty.\n";
     DumpCommandLine(argc, argv);
     return 2;

llvm/utils/yaml-bench/YAMLBench.cpp

 }
 
 int main(int argc, char **argv) {
   llvm::cl::ParseCommandLineOptions(argc, argv);
   bool ShowColors = UseColor == cl::BOU_UNSET
                         ? sys::Process::StandardOutHasColors()
                         : UseColor == cl::BOU_TRUE;
   if (Input.getNumOccurrences()) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+    Expected<std::unique_ptr<MemoryBuffer>> BufOrErr =
         MemoryBuffer::getFileOrSTDIN(Input);
-    if (!BufOrErr)
+    if (Error E = BufOrErr.takeError()) {
+      consumeError(std::move(E));
       return 1;
-    MemoryBuffer &Buf = *BufOrErr.get();
+    }
+    MemoryBuffer &Buf = **BufOrErr;
 
     llvm::SourceMgr sm;
     if (DumpTokens) {
       yaml::dumpTokens(Buf.getBuffer(), outs());
     }
 
     if (DumpCanonical) {
       yaml::Stream stream(Buf.getBuffer(), sm, ShowColors);