Removing redundant-move warnings generated by gcc9x.

[thopre]

llvm/lib/Support/FileCheck.cpp

345

I fixed a build failure with -Werror where GCC was the host compiler by doing the reverse change. So this change would most likely result on build failure when host compiler is GCC <9.x

[alexander-shaposhnikov]

llvm/tools/llvm-objcopy/CopyConfig.cpp

573

khm, wouldn't it break the builds using MSVC ? https://gcc.godbolt.org/z/esJH6J

[mehdi_amini]

Isn't clang warning in the other direction? (incompatible with GCC)

[mehdi_amini]

In D65774#1616200, @mehdi_amini wrote:

Isn't clang warning in the other direction? (incompatible with GCC)

Some past reference: http://lists.llvm.org/pipermail/llvm-dev/2018-September/126471.html

[rupprecht]

Agree with all these comments -- I'm no expert on when and when not to std::move, but this is undoing changes I've made to fix buildbots on different compilers.

[zahiraam]

In D65774#1619537, @rupprecht wrote:

Agree with all these comments -- I'm no expert on when and when not to std::move, but this is undoing changes I've made to fix buildbots on different compilers.

I agree. This is probably more aggressive than I anticipated. I am looking at them and trying to figure out which and if some of them can stay.

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

public:
   }
 
   Optional<std::string> generateMessage(BugReporterContext &BRC,
                                         BugReport &R) const {
     std::string Msg = Cb(BRC, R);
     if (Msg.empty())
       return None;
 
-    return std::move(Msg);
+    return Msg;
   }
 
   StringRef getTagDescription() const override {
     // TODO: Remember a few examples of generated messages
     // and display them in the ExplodedGraph dump by
     // returning them from this function.
     return "Note Tag";
   }

clang/lib/AST/ASTImporter.cpp

ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
     FunctionDecl *FromFD) {
   assert(FromFD->getTemplatedKind() ==
       FunctionDecl::TK_FunctionTemplateSpecialization);
 
   FunctionTemplateAndArgsTy Result;
 
   auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
   if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
-    return std::move(Err);
+    return Err;
 
   // Import template arguments.
   auto TemplArgs = FTSInfo->TemplateArguments->asArray();
   if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
       std::get<1>(Result)))
-    return std::move(Err);
+    return Err;
 
   return Result;
 }
 
 template <>
 Expected<TemplateParameterList *>
 ASTNodeImporter::import(TemplateParameterList *From) {
   SmallVector<NamedDecl *, 4> To(From->size());
   if (Error Err = ImportContainerChecked(*From, To))
-    return std::move(Err);
+    return Err;
 
   ExpectedExpr ToRequiresClause = import(From->getRequiresClause());
   if (!ToRequiresClause)
     return ToRequiresClause.takeError();
 
   auto ToTemplateLocOrErr = import(From->getTemplateLoc());
   if (!ToTemplateLocOrErr)
     return ToTemplateLocOrErr.takeError();
case TemplateArgument::Expression:
     else
       return ToExpr.takeError();
 
   case TemplateArgument::Pack: {
     SmallVector<TemplateArgument, 2> ToPack;
     ToPack.reserve(From.pack_size());
     if (Error Err = ImportTemplateArguments(
         From.pack_begin(), From.pack_size(), ToPack))
-      return std::move(Err);
+      return Err;
 
     return TemplateArgument(
         llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
   }
   }
 
   llvm_unreachable("Invalid template argument kind");
 }
Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
 
   auto LocationOrErr = import(From.getLocation());
   if (!LocationOrErr)
     return LocationOrErr.takeError();
 
   SourceLocation EllipsisLoc;
   if (From.isPackExpansion())
     if (Error Err = importInto(EllipsisLoc, From.getEllipsisLoc()))
-      return std::move(Err);
+      return Err;
 
   return LambdaCapture(
       *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var,
       EllipsisLoc);
 }
 
 } // namespace clang
 
ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
                                        const TemplateSpecializationType *T) {
   auto ToTemplateOrErr = import(T->getTemplateName());
   if (!ToTemplateOrErr)
     return ToTemplateOrErr.takeError();
 
   SmallVector<TemplateArgument, 2> ToTemplateArgs;
   if (Error Err = ImportTemplateArguments(
       T->getArgs(), T->getNumArgs(), ToTemplateArgs))
-    return std::move(Err);
+    return Err;
 
   QualType ToCanonType;
   if (!QualType(T, 0).isCanonical()) {
     QualType FromCanonType
       = Importer.getFromContext().getCanonicalType(QualType(T, 0));
     if (ExpectedType TyOrErr = import(FromCanonType))
       ToCanonType = *TyOrErr;
     else
if (!ToQualifierOrErr)
     return ToQualifierOrErr.takeError();
 
   IdentifierInfo *ToName = Importer.Import(T->getIdentifier());
 
   SmallVector<TemplateArgument, 2> ToPack;
   ToPack.reserve(T->getNumArgs());
   if (Error Err = ImportTemplateArguments(
       T->getArgs(), T->getNumArgs(), ToPack))
-    return std::move(Err);
+    return Err;
 
   return Importer.getToContext().getDependentTemplateSpecializationType(
       T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
 }
 
 ExpectedType
 ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
   auto ToQualifierOrErr = import(T->getQualifier());
Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
       << D->getDeclKindName();
   return make_error<ImportError>(ImportError::UnsupportedConstruct);
 }
 
 ExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
   // Import the context of this declaration.
   DeclContext *DC, *LexicalDC;
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
-    return std::move(Err);
+    return Err;
 
   // Import the location of this declaration.
   ExpectedSLoc LocOrErr = import(D->getLocation());
   if (!LocOrErr)
     return LocOrErr.takeError();
 
   EmptyDecl *ToD;
   if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, *LocOrErr))

 
 ExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
   // Import the major distinguishing characteristics of this namespace.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   NamespaceDecl *MergeWithNamespace = nullptr;
   if (!Name) {
     // This is an anonymous namespace. Adopt an existing anonymous
     // namespace if we can.
     // FIXME: Not testable.
if (!Name) {
         TU->setAnonymousNamespace(ToNamespace);
       else
         cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
     }
   }
   Importer.MapImported(D, ToNamespace);
 
   if (Error Err = ImportDeclContext(D))
-    return std::move(Err);
+    return Err;
 
   return ToNamespace;
 }
 
 ExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
   // Import the major distinguishing characteristics of this namespace.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *LookupD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
-    return std::move(Err);
+    return Err;
   if (LookupD)
     return LookupD;
 
   // NOTE: No conflict resolution is done for namespace aliases now.
 
   SourceLocation ToNamespaceLoc, ToAliasLoc, ToTargetNameLoc;
   NestedNameSpecifierLoc ToQualifierLoc;
   NamespaceDecl *ToNamespace;

 ExpectedDecl
 ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
   // Import the major distinguishing characteristics of this typedef.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // If this typedef is not in block scope, determine whether we've
   // seen a typedef with the same name (that we can merge with) or any
   // other entity by that name (which name lookup could conflict with).
   if (!DC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;

 ExpectedDecl
 ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
   // Import the major distinguishing characteristics of this typedef.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *FoundD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
-    return std::move(Err);
+    return Err;
   if (FoundD)
     return FoundD;
 
   // If this typedef is not in block scope, determine whether we've
   // seen a typedef with the same name (that we can merge with) or any
   // other entity by that name (which name lookup could conflict with).
   if (!DC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;

 
 ExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
   // Import the major distinguishing characteristics of this label.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   assert(LexicalDC->isFunctionOrMethod());
 
   LabelDecl *ToLabel;
   if (D->isGnuLocal()) {
     ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());

 
 ExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
   // Import the major distinguishing characteristics of this enum.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Figure out what enum name we're looking for.
   unsigned IDNS = Decl::IDNS_Tag;
   DeclarationName SearchName = Name;
   if (!SearchName && D->getTypedefNameForAnonDecl()) {
     if (Error Err = importInto(
         SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
-      return std::move(Err);
+      return Err;
     IDNS = Decl::IDNS_Ordinary;
   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
     IDNS |= Decl::IDNS_Ordinary;
 
   // We may already have an enum of the same name; try to find and match it.
   if (!DC->isFunctionOrMethod() && SearchName) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
     auto FoundDecls =
ExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
   D2->setIntegerType(ToIntegerType);
   D2->setAccess(D->getAccess());
   D2->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(D2);
 
   // Import the definition
   if (D->isCompleteDefinition())
     if (Error Err = ImportDefinition(D, D2))
-      return std::move(Err);
+      return Err;
 
   return D2;
 }
 
 ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
   bool IsFriendTemplate = false;
   if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
     IsFriendTemplate =
         DCXX->getDescribedClassTemplate() &&
         DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
             Decl::FOK_None;
   }
 
   // Import the major distinguishing characteristics of this record.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Figure out what structure name we're looking for.
   unsigned IDNS = Decl::IDNS_Tag;
   DeclarationName SearchName = Name;
   if (!SearchName && D->getTypedefNameForAnonDecl()) {
     if (Error Err = importInto(
         SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
-      return std::move(Err);
+      return Err;
     IDNS = Decl::IDNS_Ordinary;
   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
     IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend;
 
   // We may already have a record of the same name; try to find and match it.
   RecordDecl *PrevDecl = nullptr;
   if (!DC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
for (auto *FoundDecl : FoundDecls) {
             if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
               auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
               assert(FoundCXX && "Record type mismatch");
 
               if (!Importer.isMinimalImport())
                 // FoundDef may not have every implicit method that D has
                 // because implicit methods are created only if they are used.
                 if (Error Err = ImportImplicitMethods(DCXX, FoundCXX))
-                  return std::move(Err);
+                  return Err;
             }
           }
           PrevDecl = FoundRecord->getMostRecentDecl();
           break;
         }
       }
 
       ConflictingDecls.push_back(FoundDecl);
if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
 
     if (LexicalDC != DC && D->isInIdentifierNamespace(Decl::IDNS_TagFriend))
       DC->makeDeclVisibleInContext(D2);
 
     if (ClassTemplateDecl *FromDescribed =
         DCXX->getDescribedClassTemplate()) {
       ClassTemplateDecl *ToDescribed;
       if (Error Err = importInto(ToDescribed, FromDescribed))
-        return std::move(Err);
+        return Err;
       D2CXX->setDescribedClassTemplate(ToDescribed);
       if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
         // In a record describing a template the type should be an
         // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
         // previously set type to the correct value here (ToDescribed is not
         // available at record create).
         // FIXME: The previous type is cleared but not removed from
         // ASTContext's internal storage.
ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
   else
     return QualifierLocOrErr.takeError();
 
   if (D->isAnonymousStructOrUnion())
     D2->setAnonymousStructOrUnion(true);
 
   if (D->isCompleteDefinition())
     if (Error Err = ImportDefinition(D, D2, IDK_Default))
-      return std::move(Err);
+      return Err;
 
   return D2;
 }
 
 ExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
   // Import the major distinguishing characteristics of this enumerator.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Determine whether there are any other declarations with the same name and
   // in the same context.
   if (!LexicalDC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
     unsigned IDNS = Decl::IDNS_Ordinary;
ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   assert(*RedeclIt == D);
 
   // Import the major distinguishing characteristics of this function.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   FunctionDecl *FoundByLookup = nullptr;
   FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
 
   // If this is a function template specialization, then try to find the same
   // existing specialization in the "to" context. The lookup below will not
if (isa<CXXMethodDecl>(FoundByLookup)) {
         }
       }
     }
   }
 
   DeclarationNameInfo NameInfo(Name, Loc);
   // Import additional name location/type info.
   if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
-    return std::move(Err);
+    return Err;
 
   QualType FromTy = D->getType();
   bool usedDifferentExceptionSpec = false;
 
   if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) {
     FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
     // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
     // FunctionDecl that we are importing the FunctionProtoType for.
ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
 
   // Import Ctor initializers.
   if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
     if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
       SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
       // Import first, then allocate memory and copy if there was no error.
       if (Error Err = ImportContainerChecked(
           FromConstructor->inits(), CtorInitializers))
-        return std::move(Err);
+        return Err;
       auto **Memory =
           new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
       std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
       auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
       ToCtor->setCtorInitializers(Memory);
       ToCtor->setNumCtorInitializers(NumInitializers);
     }
   }
if (FromFT) {
     if (!ToFTOrErr)
       return ToFTOrErr.takeError();
   }
 
   if (D->doesThisDeclarationHaveABody()) {
     Error Err = ImportFunctionDeclBody(D, ToFunction);
 
     if (Err)
-      return std::move(Err);
+      return Err;
   }
 
   // FIXME: Other bits to merge?
 
   // If it is a template, import all related things.
   if (Error Err = ImportTemplateInformation(D, ToFunction))
-    return std::move(Err);
+    return Err;
 
   bool IsFriend = D->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend);
 
   // TODO Can we generalize this approach to other AST nodes as well?
   if (D->getDeclContext()->containsDeclAndLoad(D))
     DC->addDeclInternal(ToFunction);
   if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D))
     LexicalDC->addDeclInternal(ToFunction);

 
 ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
   // Import the major distinguishing characteristics of a variable.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Determine whether we've already imported this field.
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
   for (auto *FoundDecl : FoundDecls) {
     if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
       // For anonymous fields, match up by index.

 
 ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
   // Import the major distinguishing characteristics of a variable.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Determine whether we've already imported this field.
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
     if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
       // For anonymous indirect fields, match up by index.
ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
   LexicalDC->addDeclInternal(ToIndirectField);
   return ToIndirectField;
 }
 
 ExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
   // Import the major distinguishing characteristics of a declaration.
   DeclContext *DC, *LexicalDC;
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
-    return std::move(Err);
+    return Err;
 
   // Determine whether we've already imported this decl.
   // FriendDecl is not a NamedDecl so we cannot use lookup.
   auto *RD = cast<CXXRecordDecl>(DC);
   FriendDecl *ImportedFriend = RD->getFirstFriend();
 
   while (ImportedFriend) {
     if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
while (ImportedFriend) {
     ImportedFriend = ImportedFriend->getNextFriend();
   }
 
   // Not found. Create it.
   FriendDecl::FriendUnion ToFU;
   if (NamedDecl *FriendD = D->getFriendDecl()) {
     NamedDecl *ToFriendD;
     if (Error Err = importInto(ToFriendD, FriendD))
-      return std::move(Err);
+      return Err;
 
     if (FriendD->getFriendObjectKind() != Decl::FOK_None &&
         !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
       ToFriendD->setObjectOfFriendDecl(false);
 
     ToFU = ToFriendD;
   } else { // The friend is a type, not a decl.
     if (auto TSIOrErr = import(D->getFriendType()))

 
 ExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
   // Import the major distinguishing characteristics of an ivar.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Determine whether we've already imported this ivar
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
   for (auto *FoundDecl : FoundDecls) {
     if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
       if (Importer.IsStructurallyEquivalent(D->getType(),
ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
   assert(*RedeclIt == D);
 
   // Import the major distinguishing characteristics of a variable.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Try to find a variable in our own ("to") context with the same name and
   // in the same context as the variable we're importing.
   VarDecl *FoundByLookup = nullptr;
   if (D->isFileVarDecl()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
   ToVar->setLexicalDeclContext(LexicalDC);
 
   if (FoundByLookup) {
     auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl());
     ToVar->setPreviousDecl(Recent);
   }
 
   if (Error Err = ImportInitializer(D, ToVar))
-    return std::move(Err);
+    return Err;
 
   if (D->isConstexpr())
     ToVar->setConstexpr(true);
 
   if (D->getDeclContext()->containsDeclAndLoad(D))
     DC->addDeclInternal(ToVar);
   if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D))
     LexicalDC->addDeclInternal(ToVar);

 
 ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
   // Import the major distinguishing characteristics of a method.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
   for (auto *FoundDecl : FoundDecls) {
     if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
       if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
         continue;
for (auto *ToParam : ToParams) {
     ToParam->setOwningFunction(ToMethod);
     ToMethod->addDeclInternal(ToParam);
   }
 
   SmallVector<SourceLocation, 12> FromSelLocs;
   D->getSelectorLocs(FromSelLocs);
   SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size());
   if (Error Err = ImportContainerChecked(FromSelLocs, ToSelLocs))
-    return std::move(Err);
+    return Err;
 
   ToMethod->setMethodParams(Importer.getToContext(), ToParams, ToSelLocs);
 
   ToMethod->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToMethod);
   return ToMethod;
 }
 
 ExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
   // Import the major distinguishing characteristics of a category.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   SourceLocation ToVarianceLoc, ToLocation, ToColonLoc;
   TypeSourceInfo *ToTypeSourceInfo;
   if (auto Imp = importSeq(
       D->getVarianceLoc(), D->getLocation(), D->getColonLoc(),
       D->getTypeSourceInfo()))

 
 ExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
   // Import the major distinguishing characteristics of a category.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   ObjCInterfaceDecl *ToInterface;
   if (Error Err = importInto(ToInterface, D->getClassInterface()))
-    return std::move(Err);
+    return Err;
 
   // Determine if we've already encountered this category.
   ObjCCategoryDecl *MergeWithCategory
     = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
   ObjCCategoryDecl *ToCategory = MergeWithCategory;
   if (!ToCategory) {
     SourceLocation ToAtStartLoc, ToCategoryNameLoc;
     SourceLocation ToIvarLBraceLoc, ToIvarRBraceLoc;
ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
                                 ProtocolLocs.data(), Importer.getToContext());
 
   } else {
     Importer.MapImported(D, ToCategory);
   }
 
   // Import all of the members of this category.
   if (Error Err = ImportDeclContext(D))
-    return std::move(Err);
+    return Err;
 
   // If we have an implementation, import it as well.
   if (D->getImplementation()) {
     if (Expected<ObjCCategoryImplDecl *> ToImplOrErr =
         import(D->getImplementation()))
       ToCategory->setImplementation(*ToImplOrErr);
     else
       return ToImplOrErr.takeError();
ExpectedDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
   }
 
   // Import the major distinguishing characteristics of a protocol.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   ObjCProtocolDecl *MergeWithProtocol = nullptr;
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
   for (auto *FoundDecl : FoundDecls) {
     if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
       continue;
if (!ToProto) {
     ToProto->setLexicalDeclContext(LexicalDC);
     LexicalDC->addDeclInternal(ToProto);
   }
 
   Importer.MapImported(D, ToProto);
 
   if (D->isThisDeclarationADefinition())
     if (Error Err = ImportDefinition(D, ToProto))
-      return std::move(Err);
+      return Err;
 
   return ToProto;
 }
 
 ExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
   DeclContext *DC, *LexicalDC;
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
-    return std::move(Err);
+    return Err;
 
   ExpectedSLoc ExternLocOrErr = import(D->getExternLoc());
   if (!ExternLocOrErr)
     return ExternLocOrErr.takeError();
 
   ExpectedSLoc LangLocOrErr = import(D->getLocation());
   if (!LangLocOrErr)
     return LangLocOrErr.takeError();

 }
 
 ExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   SourceLocation ToLoc, ToUsingLoc;
   NestedNameSpecifierLoc ToQualifierLoc;
   if (auto Imp = importSeq(
       D->getNameInfo().getLoc(), D->getUsingLoc(), D->getQualifierLoc()))
     std::tie(ToLoc, ToUsingLoc, ToQualifierLoc) = *Imp;
   else
     return Imp.takeError();
 
   DeclarationNameInfo NameInfo(Name, ToLoc);
   if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
-    return std::move(Err);
+    return Err;
 
   UsingDecl *ToUsing;
   if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
                               ToUsingLoc, ToQualifierLoc, NameInfo,
                               D->hasTypename()))
     return ToUsing;
 
   ToUsing->setLexicalDeclContext(LexicalDC);

 }
 
 ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   Expected<UsingDecl *> ToUsingOrErr = import(D->getUsingDecl());
   if (!ToUsingOrErr)
     return ToUsingOrErr.takeError();
 
   Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());

 }
 
 ExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   auto ToComAncestorOrErr = Importer.ImportContext(D->getCommonAncestor());
   if (!ToComAncestorOrErr)
     return ToComAncestorOrErr.takeError();
 
   NamespaceDecl *ToNominatedNamespace;

 
 ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl(
     UnresolvedUsingValueDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   SourceLocation ToLoc, ToUsingLoc, ToEllipsisLoc;
   NestedNameSpecifierLoc ToQualifierLoc;
   if (auto Imp = importSeq(
       D->getNameInfo().getLoc(), D->getUsingLoc(), D->getQualifierLoc(),
       D->getEllipsisLoc()))
     std::tie(ToLoc, ToUsingLoc, ToQualifierLoc, ToEllipsisLoc) = *Imp;
   else
     return Imp.takeError();
 
   DeclarationNameInfo NameInfo(Name, ToLoc);
   if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
-    return std::move(Err);
+    return Err;
 
   UnresolvedUsingValueDecl *ToUsingValue;
   if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
                               ToUsingLoc, ToQualifierLoc, NameInfo,
                               ToEllipsisLoc))
     return ToUsingValue;
 
   ToUsingValue->setAccess(D->getAccess());
   ToUsingValue->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToUsingValue);
 
   return ToUsingValue;
 }
 
 ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
     UnresolvedUsingTypenameDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   SourceLocation ToUsingLoc, ToTypenameLoc, ToEllipsisLoc;
   NestedNameSpecifierLoc ToQualifierLoc;
   if (auto Imp = importSeq(
       D->getUsingLoc(), D->getTypenameLoc(), D->getQualifierLoc(),
       D->getEllipsisLoc()))
ExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
   }
 
   // Import the major distinguishing characteristics of an @interface.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Look for an existing interface with the same name.
   ObjCInterfaceDecl *MergeWithIface = nullptr;
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
   for (auto *FoundDecl : FoundDecls) {
     if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
ExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
   if (auto ToPListOrErr =
       ImportObjCTypeParamList(D->getTypeParamListAsWritten()))
     ToIface->setTypeParamList(*ToPListOrErr);
   else
     return ToPListOrErr.takeError();
 
   if (D->isThisDeclarationADefinition())
     if (Error Err = ImportDefinition(D, ToIface))
-      return std::move(Err);
+      return Err;
 
   return ToIface;
 }
 
 ExpectedDecl
 ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
   ObjCCategoryDecl *Category;
   if (Error Err = importInto(Category, D->getCategoryDecl()))
-    return std::move(Err);
+    return Err;
 
   ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
   if (!ToImpl) {
     DeclContext *DC, *LexicalDC;
     if (Error Err = ImportDeclContext(D, DC, LexicalDC))
-      return std::move(Err);
+      return Err;
 
     SourceLocation ToLocation, ToAtStartLoc, ToCategoryNameLoc;
     if (auto Imp = importSeq(
         D->getLocation(), D->getAtStartLoc(), D->getCategoryNameLoc()))
       std::tie(ToLocation, ToAtStartLoc, ToCategoryNameLoc) = *Imp;
     else
       return Imp.takeError();
 
     if (GetImportedOrCreateDecl(
             ToImpl, D, Importer.getToContext(), DC,
             Importer.Import(D->getIdentifier()), Category->getClassInterface(),
             ToLocation, ToAtStartLoc, ToCategoryNameLoc))
       return ToImpl;
 
     ToImpl->setLexicalDeclContext(LexicalDC);
     LexicalDC->addDeclInternal(ToImpl);
     Category->setImplementation(ToImpl);
   }
 
   Importer.MapImported(D, ToImpl);
   if (Error Err = ImportDeclContext(D))
-    return std::move(Err);
+    return Err;
 
   return ToImpl;
 }
 
 ExpectedDecl
 ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
   // Find the corresponding interface.
   ObjCInterfaceDecl *Iface;
   if (Error Err = importInto(Iface, D->getClassInterface()))
-    return std::move(Err);
+    return Err;
 
   // Import the superclass, if any.
   ObjCInterfaceDecl *Super;
   if (Error Err = importInto(Super, D->getSuperClass()))
-    return std::move(Err);
+    return Err;
 
   ObjCImplementationDecl *Impl = Iface->getImplementation();
   if (!Impl) {
     // We haven't imported an implementation yet. Create a new @implementation
     // now.
     DeclContext *DC, *LexicalDC;
     if (Error Err = ImportDeclContext(D, DC, LexicalDC))
-      return std::move(Err);
+      return Err;
 
     SourceLocation ToLocation, ToAtStartLoc, ToSuperClassLoc;
     SourceLocation ToIvarLBraceLoc, ToIvarRBraceLoc;
     if (auto Imp = importSeq(
         D->getLocation(), D->getAtStartLoc(), D->getSuperClassLoc(),
         D->getIvarLBraceLoc(), D->getIvarRBraceLoc()))
       std::tie(
           ToLocation, ToAtStartLoc, ToSuperClassLoc,
if ((Super && !Impl->getSuperClass()) ||
                           diag::note_odr_objc_missing_superclass);
 
       return make_error<ImportError>(ImportError::NameConflict);
     }
   }
 
   // Import all of the members of this @implementation.
   if (Error Err = ImportDeclContext(D))
-    return std::move(Err);
+    return Err;
 
   return Impl;
 }
 
 ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
   // Import the major distinguishing characteristics of an @property.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // Check whether we have already imported this property.
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
   for (auto *FoundDecl : FoundDecls) {
     if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
       // Check property types.
ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
   ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl);
   return ToProperty;
 }
 
 ExpectedDecl
 ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
   ObjCPropertyDecl *Property;
   if (Error Err = importInto(Property, D->getPropertyDecl()))
-    return std::move(Err);
+    return Err;
 
   DeclContext *DC, *LexicalDC;
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
-    return std::move(Err);
+    return Err;
 
   auto *InImpl = cast<ObjCImplDecl>(LexicalDC);
 
   // Import the ivar (for an @synthesize).
   ObjCIvarDecl *Ivar = nullptr;
   if (Error Err = importInto(Ivar, D->getPropertyIvarDecl()))
-    return std::move(Err);
+    return Err;
 
   ObjCPropertyImplDecl *ToImpl
     = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
                                    Property->getQueryKind());
   if (!ToImpl) {
     SourceLocation ToBeginLoc, ToLocation, ToPropertyIvarDeclLoc;
     if (auto Imp = importSeq(
         D->getBeginLoc(), D->getLocation(), D->getPropertyIvarDeclLoc()))
ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
   bool IsFriend = D->getFriendObjectKind() != Decl::FOK_None;
 
   // Import the major distinguishing characteristics of this class template.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   ClassTemplateDecl *FoundByLookup = nullptr;
 
   // We may already have a template of the same name; try to find and match it.
   if (!DC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
if (!Name)
       return make_error<ImportError>(ImportError::NameConflict);
   }
 
   CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
 
   // Create the declaration that is being templated.
   CXXRecordDecl *ToTemplated;
   if (Error Err = importInto(ToTemplated, FromTemplated))
-    return std::move(Err);
+    return Err;
 
   // Create the class template declaration itself.
   auto TemplateParamsOrErr = import(D->getTemplateParameters());
   if (!TemplateParamsOrErr)
     return TemplateParamsOrErr.takeError();
 
   ClassTemplateDecl *D2;
   if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
 
   return D2;
 }
 
 ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
                                           ClassTemplateSpecializationDecl *D) {
   ClassTemplateDecl *ClassTemplate;
   if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate()))
-    return std::move(Err);
+    return Err;
 
   // Import the context of this declaration.
   DeclContext *DC, *LexicalDC;
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
-    return std::move(Err);
+    return Err;
 
   // Import template arguments.
   SmallVector<TemplateArgument, 2> TemplateArgs;
   if (Error Err = ImportTemplateArguments(
       D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
-    return std::move(Err);
+    return Err;
 
   // Try to find an existing specialization with these template arguments.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *PrevDecl = nullptr;
   ClassTemplatePartialSpecializationDecl *PartialSpec =
             dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
   if (PartialSpec)
     PrevDecl =
ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
 
   // Create the specialization.
   ClassTemplateSpecializationDecl *D2 = nullptr;
   if (PartialSpec) {
     // Import TemplateArgumentListInfo.
     TemplateArgumentListInfo ToTAInfo;
     const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
     if (Error Err = ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
-      return std::move(Err);
+      return Err;
 
     QualType CanonInjType;
     if (Error Err = importInto(
         CanonInjType, PartialSpec->getInjectedSpecializationType()))
-      return std::move(Err);
+      return Err;
     CanonInjType = CanonInjType.getCanonicalType();
 
     auto ToTPListOrErr = import(PartialSpec->getTemplateParameters());
     if (!ToTPListOrErr)
       return ToTPListOrErr.takeError();
 
     if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
             D2, D, Importer.getToContext(), D->getTagKind(), DC,
if (D->getPointOfInstantiation().isValid()) {
     else
       return POIOrErr.takeError();
   }
 
   D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
 
   if (D->isCompleteDefinition())
     if (Error Err = ImportDefinition(D, D2))
-      return std::move(Err);
+      return Err;
 
   return D2;
 }
 
 ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   // If this variable has a definition in the translation unit we're coming
   // from,
   // but this particular declaration is not that definition, import the
ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   }
 
   // Import the major distinguishing characteristics of this variable template.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
   if (ToD)
     return ToD;
 
   // We may already have a template of the same name; try to find and match it.
   assert(!DC->isFunctionOrMethod() &&
          "Variable templates cannot be declared at function scope");
   SmallVector<NamedDecl *, 4> ConflictingDecls;
   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   // FIXME: Value not used?
   ExpectedType TypeOrErr = import(DTemplated->getType());
   if (!TypeOrErr)
     return TypeOrErr.takeError();
 
   // Create the declaration that is being templated.
   VarDecl *ToTemplated;
   if (Error Err = importInto(ToTemplated, DTemplated))
-    return std::move(Err);
+    return Err;
 
   // Create the variable template declaration itself.
   auto TemplateParamsOrErr = import(D->getTemplateParameters());
   if (!TemplateParamsOrErr)
     return TemplateParamsOrErr.takeError();
 
   VarTemplateDecl *ToVarTD;
   if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
if (Definition && Definition != D) {
     if (ExpectedDecl ImportedDefOrErr = import(Definition))
       return Importer.MapImported(D, *ImportedDefOrErr);
     else
       return ImportedDefOrErr.takeError();
   }
 
   VarTemplateDecl *VarTemplate = nullptr;
   if (Error Err = importInto(VarTemplate, D->getSpecializedTemplate()))
-    return std::move(Err);
+    return Err;
 
   // Import the context of this declaration.
   DeclContext *DC, *LexicalDC;
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
-    return std::move(Err);
+    return Err;
 
   // Import the location of this declaration.
   ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
   if (!BeginLocOrErr)
     return BeginLocOrErr.takeError();
 
   auto IdLocOrErr = import(D->getLocation());
   if (!IdLocOrErr)
     return IdLocOrErr.takeError();
 
   // Import template arguments.
   SmallVector<TemplateArgument, 2> TemplateArgs;
   if (Error Err = ImportTemplateArguments(
       D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
-    return std::move(Err);
+    return Err;
 
   // Try to find an existing specialization with these template arguments.
   void *InsertPos = nullptr;
   VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
       TemplateArgs, InsertPos);
   if (D2) {
     // We already have a variable template specialization with these template
     // arguments.
 
     // FIXME: Check for specialization vs. instantiation errors.
 
     if (VarDecl *FoundDef = D2->getDefinition()) {
       if (!D->isThisDeclarationADefinition() ||
           IsStructuralMatch(D, FoundDef)) {
         // The record types structurally match, or the "from" translation
         // unit only had a forward declaration anyway; call it the same
         // variable.
         return Importer.MapImported(D, FoundDef);
       }
     }
   } else {
     // Import the type.
     QualType T;
     if (Error Err = importInto(T, D->getType()))
-      return std::move(Err);
+      return Err;
 
     auto TInfoOrErr = import(D->getTypeSourceInfo());
     if (!TInfoOrErr)
       return TInfoOrErr.takeError();
 
     TemplateArgumentListInfo ToTAInfo;
     if (Error Err = ImportTemplateArgumentListInfo(
         D->getTemplateArgsInfo(), ToTAInfo))
-      return std::move(Err);
+      return Err;
 
     using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
     // Create a new specialization.
     if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
       // Import TemplateArgumentListInfo
       TemplateArgumentListInfo ArgInfos;
       const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
       // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
       if (Error Err = ImportTemplateArgumentListInfo(
           *FromTAArgsAsWritten, ArgInfos))
-        return std::move(Err);
+        return Err;
 
       auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
       if (!ToTPListOrErr)
         return ToTPListOrErr.takeError();
 
       PartVarSpecDecl *ToPartial;
       if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
                                   *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
if (D2) {
     // Add the specialization to this context.
     D2->setLexicalDeclContext(LexicalDC);
     LexicalDC->addDeclInternal(D2);
 
     D2->setAccess(D->getAccess());
   }
 
   if (Error Err = ImportInitializer(D, D2))
-    return std::move(Err);
+    return Err;
 
   return D2;
 }
 
 ExpectedDecl
 ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
 
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return std::move(Err);
+    return Err;
 
   if (ToD)
     return ToD;
 
   const FunctionTemplateDecl *FoundByLookup = nullptr;
 
   // Try to find a function in our own ("to") context with the same name, same
   // type, and in the same context as the function we're importing.
ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   }
 
   auto ParamsOrErr = import(D->getTemplateParameters());
   if (!ParamsOrErr)
     return ParamsOrErr.takeError();
 
   FunctionDecl *TemplatedFD;
   if (Error Err = importInto(TemplatedFD, D->getTemplatedDecl()))
-    return std::move(Err);
+    return Err;
 
   FunctionTemplateDecl *ToFunc;
   if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
                               *ParamsOrErr, TemplatedFD))
     return ToFunc;
 
   TemplatedFD->setDescribedFunctionTemplate(ToFunc);
 
if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
       Constraints.push_back(*InputOrErr);
     else
       return InputOrErr.takeError();
   }
 
   SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
                                S->getNumLabels());
   if (Error Err = ImportContainerChecked(S->outputs(), Exprs))
-    return std::move(Err);
+    return Err;
 
   if (Error Err =
           ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
-    return std::move(Err);
+    return Err;
 
   if (Error Err = ImportArrayChecked(
           S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
-    return std::move(Err);
+    return Err;
 
   ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
   if (!AsmLocOrErr)
     return AsmLocOrErr.takeError();
   auto AsmStrOrErr = import(S->getAsmString());
   if (!AsmStrOrErr)
     return AsmStrOrErr.takeError();
   ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc());
ExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) {
   return new (Importer.getToContext()) NullStmt(
       *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
 }
 
 ExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
   SmallVector<Stmt *, 8> ToStmts(S->size());
 
   if (Error Err = ImportContainerChecked(S->body(), ToStmts))
-    return std::move(Err);
+    return Err;
 
   ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc());
   if (!ToLBracLocOrErr)
     return ToLBracLocOrErr.takeError();
 
   ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc());
   if (!ToRBracLocOrErr)
     return ToRBracLocOrErr.takeError();

 
 ExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
   ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
   if (!ToAttrLocOrErr)
     return ToAttrLocOrErr.takeError();
   ArrayRef<const Attr*> FromAttrs(S->getAttrs());
   SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
   if (Error Err = ImportContainerChecked(FromAttrs, ToAttrs))
-    return std::move(Err);
+    return Err;
   ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
   if (!ToSubStmtOrErr)
     return ToSubStmtOrErr.takeError();
 
   return AttributedStmt::Create(
       Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
 }
 
if (E->getDecl() != E->getFoundDecl()) {
     ToFoundD = *FoundDOrErr;
   }
 
   TemplateArgumentListInfo ToTAInfo;
   TemplateArgumentListInfo *ToResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (Error Err =
         ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
-      return std::move(Err);
+      return Err;
     ToResInfo = &ToTAInfo;
   }
 
   auto *ToE = DeclRefExpr::Create(
       Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
       E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
       E->getValueKind(), ToFoundD, ToResInfo, E->isNonOdrUse());
   if (E->hadMultipleCandidates())
for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) {
     if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I)))
       ToIndexExprs[I - 1] = *ToArgOrErr;
     else
       return ToArgOrErr.takeError();
   }
 
   SmallVector<Designator, 4> ToDesignators(E->size());
   if (Error Err = ImportContainerChecked(E->designators(), ToDesignators))
-    return std::move(Err);
+    return Err;
 
   return DesignatedInitExpr::Create(
         Importer.getToContext(), ToDesignators,
         ToIndexExprs, *ToEqualOrColonLocOrErr,
         E->usesGNUSyntax(), *ToInitOrErr);
 }
 
 ExpectedStmt

 ExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
   ExpectedType ToTypeOrErr = import(E->getType());
   if (!ToTypeOrErr)
     return ToTypeOrErr.takeError();
 
   SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
   if (Error Err = ImportArrayChecked(
       E->tokloc_begin(), E->tokloc_end(), ToLocations.begin()))
-    return std::move(Err);
+    return Err;
 
   return StringLiteral::Create(
       Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(),
       *ToTypeOrErr, ToLocations.data(), ToLocations.size());
 }
 
 ExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   auto Imp = importSeq(
ExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
   SourceLocation ToBuiltinLoc, ToRParenLoc;
   QualType ToType;
   std::tie(ToBuiltinLoc, ToType, ToRParenLoc) = *Imp;
 
   SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
   if (Error Err = ImportArrayChecked(
       E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
       ToExprs.begin()))
-    return std::move(Err);
+    return Err;
 
   return new (Importer.getToContext()) AtomicExpr(
       ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
   auto Imp = importSeq(
       E->getAmpAmpLoc(), E->getLabelLoc(), E->getLabel(), E->getType());
ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
 
   return new (Importer.getToContext())
       ParenExpr(ToLParen, ToRParen, ToSubExpr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
   SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
   if (Error Err = ImportContainerChecked(E->exprs(), ToExprs))
-    return std::move(Err);
+    return Err;
 
   ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc());
   if (!ToLParenLocOrErr)
     return ToLParenLocOrErr.takeError();
 
   ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc());
   if (!ToRParenLocOrErr)
     return ToRParenLocOrErr.takeError();
ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
   CXXConstructorDecl *ToConstructor;
   QualType ToType;
   TypeSourceInfo *ToTypeSourceInfo;
   SourceRange ToParenOrBraceRange;
   std::tie(ToConstructor, ToType, ToTypeSourceInfo, ToParenOrBraceRange) = *Imp;
 
   SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
-    return std::move(Err);
+    return Err;
 
   return CXXTemporaryObjectExpr::Create(
       Importer.getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
       ToParenOrBraceRange, E->hadMultipleCandidates(),
       E->isListInitialization(), E->isStdInitListInitialization(),
       E->requiresZeroInitialization());
 }
 
if (!E->isValueDependent())
     Length = E->getPackLength();
 
   SmallVector<TemplateArgument, 8> ToPartialArguments;
   if (E->isPartiallySubstituted()) {
     if (Error Err = ImportTemplateArguments(
         E->getPartialArguments().data(),
         E->getPartialArguments().size(),
         ToPartialArguments))
-      return std::move(Err);
+      return Err;
   }
 
   return SizeOfPackExpr::Create(
       Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
       Length, ToPartialArguments);
 }
 
 
ExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
   TypeSourceInfo *ToAllocatedTypeSourceInfo;
   std::tie(
     ToOperatorNew, ToOperatorDelete, ToTypeIdParens, ToArraySize, ToInitializer,
     ToType, ToAllocatedTypeSourceInfo, ToSourceRange, ToDirectInitRange) = *Imp;
 
   SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
   if (Error Err =
       ImportContainerChecked(E->placement_arguments(), ToPlacementArgs))
-    return std::move(Err);
+    return Err;
 
   return CXXNewExpr::Create(
       Importer.getToContext(), E->isGlobalNew(), ToOperatorNew,
       ToOperatorDelete, E->passAlignment(), E->doesUsualArrayDeleteWantSize(),
       ToPlacementArgs, ToTypeIdParens, ToArraySize, E->getInitializationStyle(),
       ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
       ToDirectInitRange);
 }
ExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
   QualType ToType;
   SourceLocation ToLocation;
   CXXConstructorDecl *ToConstructor;
   SourceRange ToParenOrBraceRange;
   std::tie(ToType, ToLocation, ToConstructor, ToParenOrBraceRange) = *Imp;
 
   SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
-    return std::move(Err);
+    return Err;
 
   return CXXConstructExpr::Create(
       Importer.getToContext(), ToType, ToLocation, ToConstructor,
       E->isElidable(), ToArgs, E->hadMultipleCandidates(),
       E->isListInitialization(), E->isStdInitListInitialization(),
       E->requiresZeroInitialization(), E->getConstructionKind(),
       ToParenOrBraceRange);
 }
 
 ExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) {
   ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
   if (!ToSubExprOrErr)
     return ToSubExprOrErr.takeError();
 
   SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects());
   if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects))
-    return std::move(Err);
+    return Err;
 
   return ExprWithCleanups::Create(
       Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(),
       ToObjects);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
   auto Imp = importSeq(
       E->getCallee(), E->getType(), E->getRParenLoc());
   if (!Imp)
     return Imp.takeError();
 
   Expr *ToCallee;
   QualType ToType;
   SourceLocation ToRParenLoc;
   std::tie(ToCallee, ToType, ToRParenLoc) = *Imp;
 
   SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
-    return std::move(Err);
+    return Err;
 
   return CXXMemberCallExpr::Create(Importer.getToContext(), ToCallee, ToArgs,
                                    ToType, E->getValueKind(), ToRParenLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
   ExpectedType ToTypeOrErr = import(E->getType());
   if (!ToTypeOrErr)
ExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
 
   DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc);
 
   TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (Error Err =
             ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
                                            E->template_arguments(), ToTAInfo))
-      return std::move(Err);
+      return Err;
     ResInfo = &ToTAInfo;
   }
 
   return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(),
                             ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
                             ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
                             ResInfo, ToType, E->getValueKind(),
                             E->getObjectKind(), E->isNonOdrUse());
else
       return ToBaseOrErr.takeError();
   }
 
   TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (Error Err = ImportTemplateArgumentListInfo(
         E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(),
         ToTAInfo))
-      return std::move(Err);
+      return Err;
     ResInfo = &ToTAInfo;
   }
 
   auto ToMemberNameInfoOrErr = importSeq(E->getMember(), E->getMemberLoc());
   if (!ToMemberNameInfoOrErr)
     return ToMemberNameInfoOrErr.takeError();
   DeclarationNameInfo ToMemberNameInfo(
       std::get<0>(*ToMemberNameInfoOrErr), std::get<1>(*ToMemberNameInfoOrErr));
   // Import additional name location/type info.
   if (Error Err = ImportDeclarationNameLoc(
       E->getMemberNameInfo(), ToMemberNameInfo))
-    return std::move(Err);
+    return Err;
 
   return CXXDependentScopeMemberExpr::Create(
       Importer.getToContext(), ToBase, ToType, E->isArrow(), ToOperatorLoc,
       ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
       ToMemberNameInfo, ResInfo);
 }
 
 ExpectedStmt
 ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
   auto Imp = importSeq(
       E->getQualifierLoc(), E->getTemplateKeywordLoc(), E->getDeclName(),
       E->getExprLoc(), E->getLAngleLoc(), E->getRAngleLoc());
   if (!Imp)
     return Imp.takeError();
 
   NestedNameSpecifierLoc ToQualifierLoc;
   SourceLocation ToTemplateKeywordLoc, ToExprLoc, ToLAngleLoc, ToRAngleLoc;
   DeclarationName ToDeclName;
   std::tie(
       ToQualifierLoc, ToTemplateKeywordLoc, ToDeclName, ToExprLoc,
       ToLAngleLoc, ToRAngleLoc) = *Imp;
 
   DeclarationNameInfo ToNameInfo(ToDeclName, ToExprLoc);
   if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
-    return std::move(Err);
+    return Err;
 
   TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc);
   TemplateArgumentListInfo *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (Error Err =
         ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
-      return std::move(Err);
+      return Err;
     ResInfo = &ToTAInfo;
   }
 
   return DependentScopeDeclRefExpr::Create(
       Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
       ToNameInfo, ResInfo);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
     CXXUnresolvedConstructExpr *E) {
   auto Imp = importSeq(
       E->getLParenLoc(), E->getRParenLoc(), E->getTypeSourceInfo());
   if (!Imp)
     return Imp.takeError();
 
   SourceLocation ToLParenLoc, ToRParenLoc;
   TypeSourceInfo *ToTypeSourceInfo;
   std::tie(ToLParenLoc, ToRParenLoc, ToTypeSourceInfo) = *Imp;
 
   SmallVector<Expr *, 8> ToArgs(E->arg_size());
   if (Error Err =
       ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
-    return std::move(Err);
+    return Err;
 
   return CXXUnresolvedConstructExpr::Create(
       Importer.getToContext(), ToTypeSourceInfo, ToLParenLoc,
       llvm::makeArrayRef(ToArgs), ToRParenLoc);
 }
 
 ExpectedStmt
 ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
   Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass());
   if (!ToNamingClassOrErr)
     return ToNamingClassOrErr.takeError();
 
   auto ToQualifierLocOrErr = import(E->getQualifierLoc());
   if (!ToQualifierLocOrErr)
     return ToQualifierLocOrErr.takeError();
 
   auto ToNameInfoOrErr = importSeq(E->getName(), E->getNameLoc());
   if (!ToNameInfoOrErr)
     return ToNameInfoOrErr.takeError();
   DeclarationNameInfo ToNameInfo(
       std::get<0>(*ToNameInfoOrErr), std::get<1>(*ToNameInfoOrErr));
   // Import additional name location/type info.
   if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
-    return std::move(Err);
+    return Err;
 
   UnresolvedSet<8> ToDecls;
   for (auto *D : E->decls())
     if (auto ToDOrErr = import(D))
       ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
     else
       return ToDOrErr.takeError();
 
   if (E->hasExplicitTemplateArgs() && E->getTemplateKeywordLoc().isValid()) {
     TemplateArgumentListInfo ToTAInfo;
     if (Error Err = ImportTemplateArgumentListInfo(
         E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(),
         ToTAInfo))
-      return std::move(Err);
+      return Err;
 
     ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
     if (!ToTemplateKeywordLocOrErr)
       return ToTemplateKeywordLocOrErr.takeError();
 
     return UnresolvedLookupExpr::Create(
         Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
         *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo,
ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
   std::tie(ToType, ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc) = *Imp1;
 
   auto Imp2 = importSeq(E->getName(), E->getNameLoc());
   if (!Imp2)
     return Imp2.takeError();
   DeclarationNameInfo ToNameInfo(std::get<0>(*Imp2), std::get<1>(*Imp2));
   // Import additional name location/type info.
   if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
-    return std::move(Err);
+    return Err;
 
   UnresolvedSet<8> ToDecls;
   for (Decl *D : E->decls())
     if (auto ToDOrErr = import(D))
       ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
     else
       return ToDOrErr.takeError();
 
   TemplateArgumentListInfo ToTAInfo;
   TemplateArgumentListInfo *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (Error Err =
         ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
-      return std::move(Err);
+      return Err;
     ResInfo = &ToTAInfo;
   }
 
   Expr *ToBase = nullptr;
   if (!E->isImplicitAccess()) {
     if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
       ToBase = *ToBaseOrErr;
     else
ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
   Expr *ToCallee;
   QualType ToType;
   SourceLocation ToRParenLoc;
   std::tie(ToCallee, ToType, ToRParenLoc) = *Imp;
 
   unsigned NumArgs = E->getNumArgs();
   llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
-     return std::move(Err);
+     return Err;
 
   if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
     return CXXOperatorCallExpr::Create(
         Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
         OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
         OCE->getADLCallKind());
   }
 
for (const auto &FromCapture : E->captures()) {
     if (auto ToCaptureOrErr = import(FromCapture))
       ToCaptures.push_back(*ToCaptureOrErr);
     else
       return ToCaptureOrErr.takeError();
   }
 
   SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
   if (Error Err = ImportContainerChecked(E->capture_inits(), ToCaptureInits))
-    return std::move(Err);
+    return Err;
 
   auto Imp = importSeq(
       E->getIntroducerRange(), E->getCaptureDefaultLoc(), E->getEndLoc());
   if (!Imp)
     return Imp.takeError();
 
   SourceRange ToIntroducerRange;
   SourceLocation ToCaptureDefaultLoc, ToEndLoc;
if (!Imp)
     return Imp.takeError();
 
   SourceLocation ToLBraceLoc, ToRBraceLoc;
   QualType ToType;
   std::tie(ToLBraceLoc, ToRBraceLoc, ToType) = *Imp;
 
   SmallVector<Expr *, 4> ToExprs(E->getNumInits());
   if (Error Err = ImportContainerChecked(E->inits(), ToExprs))
-    return std::move(Err);
+    return Err;
 
   ASTContext &ToCtx = Importer.getToContext();
   InitListExpr *To = new (ToCtx) InitListExpr(
       ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
   To->setType(ToType);
 
   if (E->hasArrayFiller()) {
     if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller()))
if (!Imp)
     return Imp.takeError();
 
   QualType ToType;
   SourceLocation ToBeginLoc, ToEndLoc;
   std::tie(ToType, ToBeginLoc, ToEndLoc) = *Imp;
 
   SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
   if (Error Err = ImportContainerChecked(E->getArgs(), ToArgs))
-    return std::move(Err);
+    return Err;
 
   // According to Sema::BuildTypeTrait(), if E is value-dependent,
   // Value is always false.
   bool ToValue = (E->isValueDependent() ? false : E->getValue());
 
   return TypeTraitExpr::Create(
       Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs,
       ToEndLoc, ToValue);
Expected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) {
   // need it to have a definition.
   if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
     auto *FromRecord = cast<RecordDecl>(FromDC);
     if (ToRecord->isCompleteDefinition()) {
       // Do nothing.
     } else if (FromRecord->isCompleteDefinition()) {
       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
           FromRecord, ToRecord, ASTNodeImporter::IDK_Basic))
-        return std::move(Err);
+        return Err;
     } else {
       CompleteDecl(ToRecord);
     }
   } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
     auto *FromEnum = cast<EnumDecl>(FromDC);
     if (ToEnum->isCompleteDefinition()) {
       // Do nothing.
     } else if (FromEnum->isCompleteDefinition()) {
       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
           FromEnum, ToEnum, ASTNodeImporter::IDK_Basic))
-        return std::move(Err);
+        return Err;
     } else {
       CompleteDecl(ToEnum);
     }
   } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
     auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
     if (ToClass->getDefinition()) {
       // Do nothing.
     } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
           FromDef, ToClass, ASTNodeImporter::IDK_Basic))
-        return std::move(Err);
+        return Err;
     } else {
       CompleteDecl(ToClass);
     }
   } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
     auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
     if (ToProto->getDefinition()) {
       // Do nothing.
     } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
           FromDef, ToProto, ASTNodeImporter::IDK_Basic))
-        return std::move(Err);
+        return Err;
     } else {
       CompleteDecl(ToProto);
     }
   }
 
   return ToDC;
 }
 

 
 Expected<NestedNameSpecifier *>
 ASTImporter::Import(NestedNameSpecifier *FromNNS) {
   if (!FromNNS)
     return nullptr;
 
   NestedNameSpecifier *Prefix = nullptr;
   if (Error Err = importInto(Prefix, FromNNS->getPrefix()))
-    return std::move(Err);
+    return Err;
 
   switch (FromNNS->getKind()) {
   case NestedNameSpecifier::Identifier:
     assert(FromNNS->getAsIdentifier() && "NNS should contain identifier.");
     return NestedNameSpecifier::Create(ToContext, Prefix,
                                        Import(FromNNS->getAsIdentifier()));
 
   case NestedNameSpecifier::Namespace:
ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
   }
 
   NestedNameSpecifierLocBuilder Builder;
 
   while (!NestedNames.empty()) {
     NNS = NestedNames.pop_back_val();
     NestedNameSpecifier *Spec = nullptr;
     if (Error Err = importInto(Spec, NNS.getNestedNameSpecifier()))
-      return std::move(Err);
+      return Err;
 
     NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
 
     SourceLocation ToLocalBeginLoc, ToLocalEndLoc;
     if (Kind != NestedNameSpecifier::Super) {
       if (Error Err = importInto(ToLocalBeginLoc, NNS.getLocalBeginLoc()))
-        return std::move(Err);
+        return Err;
 
       if (Kind != NestedNameSpecifier::Global)
         if (Error Err = importInto(ToLocalEndLoc, NNS.getLocalEndLoc()))
-          return std::move(Err);
+          return Err;
     }
 
     switch (Kind) {
     case NestedNameSpecifier::Identifier:
       Builder.Extend(getToContext(), Spec->getAsIdentifier(), ToLocalBeginLoc,
                      ToLocalEndLoc);
       break;
 
     case NestedNameSpecifier::Namespace:
       Builder.Extend(getToContext(), Spec->getAsNamespace(), ToLocalBeginLoc,
                      ToLocalEndLoc);
       break;
 
     case NestedNameSpecifier::NamespaceAlias:
       Builder.Extend(getToContext(), Spec->getAsNamespaceAlias(),
                      ToLocalBeginLoc, ToLocalEndLoc);
       break;
 
     case NestedNameSpecifier::TypeSpec:
     case NestedNameSpecifier::TypeSpecWithTemplate: {
       SourceLocation ToTLoc;
       if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc()))
-        return std::move(Err);
+        return Err;
       TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
             QualType(Spec->getAsType(), 0), ToTLoc);
       Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(),
                      ToLocalEndLoc);
       break;
     }
 
     case NestedNameSpecifier::Global:
if (!ToFileIDOrErr)
     return ToFileIDOrErr.takeError();
   SourceManager &ToSM = ToContext.getSourceManager();
   return ToSM.getComposedLoc(*ToFileIDOrErr, Decomposed.second);
 }
 
 Expected<SourceRange> ASTImporter::Import(SourceRange FromRange) {
   SourceLocation ToBegin, ToEnd;
   if (Error Err = importInto(ToBegin, FromRange.getBegin()))
-    return std::move(Err);
+    return Err;
   if (Error Err = importInto(ToEnd, FromRange.getEnd()))
-    return std::move(Err);
+    return Err;
 
   return SourceRange(ToBegin, ToEnd);
 }
 
 Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
   llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
   if (Pos != ImportedFileIDs.end())
     return Pos->second;
Expected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) {
   if (From->isBaseInitializer()) {
     auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
     if (!ToTInfoOrErr)
       return ToTInfoOrErr.takeError();
 
     SourceLocation EllipsisLoc;
     if (From->isPackExpansion())
       if (Error Err = importInto(EllipsisLoc, From->getEllipsisLoc()))
-        return std::move(Err);
+        return Err;
 
     return new (ToContext) CXXCtorInitializer(
         ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
         *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
   } else if (From->isMemberInitializer()) {
     ExpectedDecl ToFieldOrErr = Import(From->getMember());
     if (!ToFieldOrErr)
       return ToFieldOrErr.takeError();

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

bool DynTypedMatcher::matchesNoKindCheck(
   return false;
 }
 
 llvm::Optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
   if (!AllowBind) return llvm::None;
   auto Result = *this;
   Result.Implementation =
       new IdDynMatcher(ID, std::move(Result.Implementation));
-  return std::move(Result);
+  return Result;
 }
 
 bool DynTypedMatcher::canConvertTo(ast_type_traits::ASTNodeKind To) const {
   const auto From = getSupportedKind();
   auto QualKind = ast_type_traits::ASTNodeKind::getFromNodeKind<QualType>();
   auto TypeKind = ast_type_traits::ASTNodeKind::getFromNodeKind<Type>();
   /// Mimic the implicit conversions of Matcher<>.
   /// - From Matcher<Type> to Matcher<QualType>

clang/lib/CodeGen/CodeGenAction.cpp

CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   if (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo &&
       CI.getCodeGenOpts().MacroDebugInfo) {
     std::unique_ptr<PPCallbacks> Callbacks =
         llvm::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(),
                                             CI.getPreprocessor());
     CI.getPreprocessor().addPPCallbacks(std::move(Callbacks));
   }
 
-  return std::move(Result);
+  return Result;
 }
 
 static void BitcodeInlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
                                          void *Context,
                                          unsigned LocCookie) {
   SM.print(nullptr, llvm::errs());
 
   auto Diags = static_cast<DiagnosticsEngine *>(Context);

clang/lib/CrossTU/CrossTranslationUnit.cpp

CrossTranslationUnitContext::ASTUnitStorage::getASTUnitForFunction(
   // Try the cache first.
   auto ASTCacheEntry = NameASTUnitMap.find(FunctionName);
   if (ASTCacheEntry == NameASTUnitMap.end()) {
     // Load the ASTUnit from the pre-dumped AST file specified by ASTFileName.
 
     // Ensure that the Index is loaded, as we need to search in it.
     if (llvm::Error IndexLoadError =
             ensureCTUIndexLoaded(CrossTUDir, IndexName))
-      return std::move(IndexLoadError);
+      return IndexLoadError;
 
     // Check if there is and entry in the index for the function.
     if (!NameFileMap.count(FunctionName)) {
       ++NumNotInOtherTU;
       return llvm::make_error<IndexError>(index_error_code::missing_definition);
     }
 
     // Search in the index for the filename where the definition of FuncitonName
if (ASTCacheEntry == NameASTUnitMap.end()) {
     return ASTCacheEntry->second;
   }
 }
 
 llvm::Expected<std::string>
 CrossTranslationUnitContext::ASTUnitStorage::getFileForFunction(
     StringRef FunctionName, StringRef CrossTUDir, StringRef IndexName) {
   if (llvm::Error IndexLoadError = ensureCTUIndexLoaded(CrossTUDir, IndexName))
-    return std::move(IndexLoadError);
+    return IndexLoadError;
   return NameFileMap[FunctionName];
 }
 
 llvm::Error CrossTranslationUnitContext::ASTUnitStorage::ensureCTUIndexLoaded(
     StringRef CrossTUDir, StringRef IndexName) {
   // Dont initialize if the map is filled.
   if (!NameFileMap.empty())
     return llvm::Error::success();

clang/lib/Driver/DriverOptions.cpp

std::unique_ptr<OptTable> clang::driver::createDriverOptTable() {
   auto Result = llvm::make_unique<DriverOptTable>();
   // Options.inc is included in DriverOptions.cpp, and calls OptTable's
   // addValues function.
   // Opt is a variable used in the code fragment in Options.inc.
   OptTable &Opt = *Result;
 #define OPTTABLE_ARG_INIT
 #include "clang/Driver/Options.inc"
 #undef OPTTABLE_ARG_INIT
-  return std::move(Result);
+  return Result;
 }

clang/lib/Frontend/CompilerInstance.cpp

if (RemoveFileOnSignal)
     llvm::sys::RemoveFileOnSignal(OSFile);
 
   if (ResultPathName)
     *ResultPathName = OutFile;
   if (TempPathName)
     *TempPathName = TempFile;
 
   if (!Binary || OS->supportsSeeking())
-    return std::move(OS);
+    return OS;
 
   auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
   assert(!NonSeekStream);
   NonSeekStream = std::move(OS);
-  return std::move(B);
+  return B;
 }
 
 // Initialization Utilities
 
 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
   return InitializeSourceManager(
       Input, getDiagnostics(), getFileManager(), getSourceManager(),
       hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,

clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

for (FrontendPluginRegistry::iterator it =
            FrontendPluginRegistry::begin(), ie = FrontendPluginRegistry::end();
          it != ie; ++it) {
       if (it->getName() == CI.getFrontendOpts().ActionName) {
         std::unique_ptr<PluginASTAction> P(it->instantiate());
         if ((P->getActionType() != PluginASTAction::ReplaceAction &&
              P->getActionType() != PluginASTAction::Cmdline) ||
             !P->ParseArgs(CI, CI.getFrontendOpts().PluginArgs[it->getName()]))
           return nullptr;
-        return std::move(P);
+        return P;
       }
     }
 
     CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name)
       << CI.getFrontendOpts().ActionName;
     return nullptr;
   }
 

clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

NonLocalizedStringBRVisitor::VisitNode(const ExplodedNode *Succ,
 
   if (!L.isValid() || !L.asLocation().isValid())
     return nullptr;
 
   auto Piece = std::make_shared<PathDiagnosticEventPiece>(
       L, "Non-localized string literal here");
   Piece->addRange(LiteralExpr->getSourceRange());
 
-  return std::move(Piece);
+  return Piece;
 }
 
 namespace {
 class EmptyLocalizationContextChecker
     : public Checker<check::ASTDecl<ObjCImplementationDecl>> {
 
   // A helper class, which walks the AST
   class MethodCrawler : public ConstStmtVisitor<MethodCrawler> {

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

RefCountReportVisitor::VisitNode(const ExplodedNode *N,
   // to Sym.
   for (const Stmt *Child : S->children())
     if (const Expr *Exp = dyn_cast_or_null<Expr>(Child))
       if (CurrSt->getSValAsScalarOrLoc(Exp, LCtx).getAsLocSymbol() == Sym) {
         P->addRange(Exp->getSourceRange());
         break;
       }
 
-  return std::move(P);
+  return P;
 }
 
 static Optional<std::string> describeRegion(const MemRegion *MR) {
   if (const auto *VR = dyn_cast_or_null<VarRegion>(MR))
     return std::string(VR->getDecl()->getName());
   // Once we support more storage locations for bindings,
   // this would need to be improved.
   return None;

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

if (isUnderconstrained(PrevN)) {
     ProgramPoint P = N->getLocation();
     PathDiagnosticLocation L =
       PathDiagnosticLocation::create(P, BRC.getSourceManager());
     if (!L.isValid())
       return nullptr;
 
     auto X = std::make_shared<PathDiagnosticEventPiece>(L, os.str());
     X->setTag(getTag());
-    return std::move(X);
+    return X;
   }
 
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Implementation of SuppressInlineDefensiveChecksVisitor.
 //===----------------------------------------------------------------------===//
if (const MemRegion *R = state->getLValue(VD, LCtx).getAsRegion()) {
     if (report.isInteresting(R))
       event->setPrunable(false);
     else {
       SVal V = state->getSVal(R);
       if (report.isInteresting(V))
         event->setPrunable(false);
     }
   }
-  return std::move(event);
+  return event;
 }
 
 std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTrueTest(
     const Expr *Cond, const MemberExpr *ME, BugReporterContext &BRC,
     BugReport &report, const ExplodedNode *N, bool TookTrue, bool IsAssuming) {
   SmallString<256> Buf;
   llvm::raw_svector_ostream Out(Buf);
 

clang/lib/Tooling/CommonOptionsParser.cpp

 
 llvm::Expected<CommonOptionsParser> CommonOptionsParser::create(
     int &argc, const char **argv, llvm::cl::OptionCategory &Category,
     llvm::cl::NumOccurrencesFlag OccurrencesFlag, const char *Overview) {
   CommonOptionsParser Parser;
   llvm::Error Err =
       Parser.init(argc, argv, Category, OccurrencesFlag, Overview);
   if (Err)
-    return std::move(Err);
-  return std::move(Parser);
+    return Err;
+  return Parser;
 }
 
 CommonOptionsParser::CommonOptionsParser(
     int &argc, const char **argv, cl::OptionCategory &Category,
     llvm::cl::NumOccurrencesFlag OccurrencesFlag, const char *Overview) {
   llvm::Error Err = init(argc, argv, Category, OccurrencesFlag, Overview);
   if (Err) {
     llvm::report_fatal_error(
         "CommonOptionsParser: failed to parse command-line arguments. " +
         llvm::toString(std::move(Err)));
   }
 }

clang/lib/Tooling/Refactoring/ASTSelection.cpp

public:
   }
 
   Optional<SelectedASTNode> getSelectedASTNode() {
     assert(SelectionStack.size() == 1 && "stack was not popped");
     SelectedASTNode Result = std::move(SelectionStack.back());
     SelectionStack.pop_back();
     if (Result.Children.empty())
       return None;
-    return std::move(Result);
+    return Result;
   }
 
   bool TraversePseudoObjectExpr(PseudoObjectExpr *E) {
     // Avoid traversing the semantic expressions. They should be handled by
     // looking through the appropriate opaque expressions in order to build
     // a meaningful selection tree.
     llvm::SaveAndRestore<bool> LookThrough(LookThroughOpaqueValueExprs, true);
     return TraverseStmt(E->getSyntacticForm());

clang/lib/Tooling/Refactoring/AtomicChange.cpp

for (llvm::StringRef Header : Change.getInsertedHeaders()) {
               ? Header.str()
               : ("\"" + Header + "\"").str();
       std::string ReplacementText = "#include " + EscapedHeader;
       // Offset UINT_MAX and length 0 indicate that the replacement is a header
       // insertion.
       llvm::Error Err = HeaderReplacements.add(
           tooling::Replacement(FilePath, UINT_MAX, 0, ReplacementText));
       if (Err)
-        return std::move(Err);
+        return Err;
     }
     for (const std::string &Header : Change.getRemovedHeaders()) {
       // Offset UINT_MAX and length 1 indicate that the replacement is a header
       // deletion.
       llvm::Error Err =
           HeaderReplacements.add(Replacement(FilePath, UINT_MAX, 1, Header));
       if (Err)
-        return std::move(Err);
+        return Err;
     }
   }
 
   // cleanupAroundReplacements() converts header insertions/deletions into
   // actual replacements that add/remove headers at the right location.
   return clang::format::cleanupAroundReplacements(Code, HeaderReplacements,
                                                   Style);
 }
 
 // Combine replacements in all Changes as a `Replacements`. This ignores the
 // file path in all replacements and replaces them with \p FilePath.
 llvm::Expected<Replacements>
 combineReplacementsInChanges(llvm::StringRef FilePath,
                              llvm::ArrayRef<AtomicChange> Changes) {
   Replacements Replaces;
   for (const auto &Change : Changes)
     for (const auto &R : Change.getReplacements())
       if (auto Err = Replaces.add(Replacement(
               FilePath, R.getOffset(), R.getLength(), R.getReplacementText())))
-        return std::move(Err);
+        return Err;
   return Replaces;
 }
 
 } // end namespace
 
 AtomicChange::AtomicChange(const SourceManager &SM,
                            SourceLocation KeyPosition) {
   const FullSourceLoc FullKeyPosition(KeyPosition, SM);

clang/lib/Tooling/Refactoring/Extract/Extract.cpp

// Create the replacement for the extracted declaration.
     if (IsExpr && !ReturnType->isVoidType())
       OS << "return ";
     OS << ExtractedCodeRewriter.getRewrittenText(ExtractedRange);
     if (Semicolons.isNeededInExtractedFunction())
       OS << ';';
     OS << "\n}\n\n";
     auto Err = Change.insert(SM, ExtractedDeclLocation, OS.str());
     if (Err)
-      return std::move(Err);
+      return Err;
   }
 
   // Create the replacement for the call to the extracted declaration.
   {
     std::string ReplacedCode;
     llvm::raw_string_ostream OS(ReplacedCode);
 
     OS << DeclName << '(';
     // FIXME: Forward arguments.
     OS << ')';
     if (Semicolons.isNeededInOriginalFunction())
       OS << ';';
 
     auto Err = Change.replace(
         SM, CharSourceRange::getTokenRange(ExtractedRange), OS.str());
     if (Err)
-      return std::move(Err);
+      return Err;
   }
 
   // FIXME: Add support for assocciated symbol location to AtomicChange to mark
   // the ranges of the name of the extracted declaration.
   return AtomicChanges{std::move(Change)};
 }
 
 } // end namespace tooling
 } // end namespace clang

clang/lib/Tooling/Refactoring/Rename/RenamingAction.cpp

for (const auto &Occurrence : Occurrences) {
     assert(NewName.getNamePieces().size() == Ranges.size() &&
            "Mismatching number of ranges and name pieces");
     AtomicChange Change(SM, Ranges[0].getBegin());
     for (const auto &Range : llvm::enumerate(Ranges)) {
       auto Error =
           Change.replace(SM, CharSourceRange::getCharRange(Range.value()),
                          NewName.getNamePieces()[Range.index()]);
       if (Error)
-        return std::move(Error);
+        return Error;
     }
     Changes.push_back(std::move(Change));
   }
-  return std::move(Changes);
+  return Changes;
 }
 
 /// Takes each atomic change and inserts its replacements into the set of
 /// replacements that belong to the appropriate file.
 static void convertChangesToFileReplacements(
     ArrayRef<AtomicChange> AtomicChanges,
     std::map<std::string, tooling::Replacements> *FileToReplaces) {
   for (const auto &AtomicChange : AtomicChanges) {

clang/lib/Tooling/Refactoring/Stencil.cpp

for (auto &Part : OtherStencil.Parts)
     Parts.push_back(std::move(Part));
 }
 
 llvm::Expected<std::string>
 Stencil::eval(const MatchFinder::MatchResult &Match) const {
   std::string Result;
   for (const auto &Part : Parts)
     if (auto Err = Part.eval(Match, &Result))
-      return std::move(Err);
+      return Err;
   return Result;
 }
 
 StencilPart stencil::text(StringRef Text) {
   return StencilPart(std::make_shared<RawText>(Text));
 }
 
 StencilPart stencil::selection(RangeSelector Selector) {
   return StencilPart(std::make_shared<SelectorOp>(std::move(Selector)));
 }
 
 StencilPart stencil::dPrint(StringRef Id) {
   return StencilPart(std::make_shared<DebugPrintNodeOp>(Id));
 }

clang/tools/clang-import-test/clang-import-test.cpp

llvm::Expected<CIAndOrigins> Parse(const std::string &Path,
 
   CI.getDiagnosticClient().BeginSourceFile(
       CI.getCompilerInstance().getLangOpts(),
       &CI.getCompilerInstance().getPreprocessor());
   MultiplexConsumer Consumers(std::move(ASTConsumers));
   Consumers.Initialize(CI.getASTContext());
 
   if (llvm::Error PE = ParseSource(Path, CI.getCompilerInstance(), Consumers))
-    return std::move(PE);
+    return PE;
   CI.getDiagnosticClient().EndSourceFile();
   if (ShouldDumpIR)
     CG.GetModule()->print(llvm::outs(), nullptr);
   if (CI.getDiagnosticClient().getNumErrors())
     return llvm::make_error<llvm::StringError>(
         "Errors occurred while parsing the expression.", std::error_code());
-  return std::move(CI);
+  return CI;
 }
 
 void Forget(CIAndOrigins &CI, llvm::MutableArrayRef<CIAndOrigins> Imports) {
   llvm::SmallVector<ExternalASTMerger::ImporterSource, 3> Sources;
   for (CIAndOrigins &Import : Imports)
     Sources.push_back({Import.getASTContext(), Import.getFileManager(),
                        Import.getOriginMap()});
   ExternalASTSource *Source = CI.CI->getASTContext().getExternalSource();

clang/tools/clang-refactor/TestSupport.cpp

if (GroupedRanges.empty()) {
     llvm::errs() << "error: -selection=test:" << Filename
                  << ": no 'range' commands";
     return None;
   }
 
   TestSelectionRangesInFile TestRanges = {Filename.str(), {}};
   for (auto &Group : GroupedRanges)
     TestRanges.GroupedRanges.push_back({Group.first, std::move(Group.second)});
-  return std::move(TestRanges);
+  return TestRanges;
 }
 
 } // end namespace refactor
 } // end namespace clang

llvm/include/llvm/Bitstream/BitstreamReader.h

if (BitsInCurWord >= NumBits) {
       BitsInCurWord -= NumBits;
       return R;
     }
 
     word_t R = BitsInCurWord ? CurWord : 0;
     unsigned BitsLeft = NumBits - BitsInCurWord;
 
     if (Error fillResult = fillCurWord())
-      return std::move(fillResult);
+      return fillResult;
 
     // If we run out of data, abort.
     if (BitsLeft > BitsInCurWord)
       return createStringError(std::errc::io_error,
                                "Unexpected end of file reading %u of %u bits",
                                BitsInCurWord, BitsLeft);
 
     word_t R2 = CurWord & (~word_t(0) >> (BitsInWord - BitsLeft));
while (true) {
           return MaybeSubBlock.takeError();
       }
 
       if (Code == bitc::DEFINE_ABBREV &&
           !(Flags & AF_DontAutoprocessAbbrevs)) {
         // We read and accumulate abbrev's, the client can't do anything with
         // them anyway.
         if (Error Err = ReadAbbrevRecord())
-          return std::move(Err);
+          return Err;
         continue;
       }
 
       return BitstreamEntry::getRecord(Code);
     }
   }
 
   /// This is a convenience function for clients that don't expect any
   /// subblocks. This just skips over them automatically.
   Expected<BitstreamEntry> advanceSkippingSubblocks(unsigned Flags = 0) {
     while (true) {
       // If we found a normal entry, return it.
       Expected<BitstreamEntry> MaybeEntry = advance(Flags);
       if (!MaybeEntry)
         return MaybeEntry;
       BitstreamEntry Entry = MaybeEntry.get();
 
       if (Entry.Kind != BitstreamEntry::SubBlock)
         return Entry;
 
       // If we found a sub-block, just skip over it and check the next entry.
       if (Error Err = SkipBlock())
-        return std::move(Err);
+        return Err;
     }
   }
 
   Expected<unsigned> ReadCode() { return Read(CurCodeSize); }
 
   // Block header:
   //    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
 

llvm/include/llvm/DebugInfo/CodeView/CVRecord.h

 template <typename Kind>
 inline Expected<CVRecord<Kind>> readCVRecordFromStream(BinaryStreamRef Stream,
                                                        uint32_t Offset) {
   const RecordPrefix *Prefix = nullptr;
   BinaryStreamReader Reader(Stream);
   Reader.setOffset(Offset);
 
   if (auto EC = Reader.readObject(Prefix))
-    return std::move(EC);
+    return EC;
   if (Prefix->RecordLen < 2)
     return make_error<CodeViewError>(cv_error_code::corrupt_record);
 
   Reader.setOffset(Offset);
   ArrayRef<uint8_t> RawData;
   if (auto EC = Reader.readBytes(RawData, Prefix->RecordLen + sizeof(uint16_t)))
-    return std::move(EC);
+    return EC;
   return codeview::CVRecord<Kind>(RawData);
 }
 
 } // end namespace codeview
 
 template <typename Kind>
 struct VarStreamArrayExtractor<codeview::CVRecord<Kind>> {
   Error operator()(BinaryStreamRef Stream, uint32_t &Len,

llvm/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h

if (auto EC = S.visitKnownRecord(Symbol, Record))
       return EC;
     if (auto EC = S.visitSymbolEnd(Symbol))
       return EC;
     return Error::success();
   }
   template <typename T> static Expected<T> deserializeAs(CVSymbol Symbol) {
     T Record(static_cast<SymbolRecordKind>(Symbol.kind()));
     if (auto EC = deserializeAs<T>(Symbol, Record))
-      return std::move(EC);
+      return EC;
     return Record;
   }
 
   explicit SymbolDeserializer(SymbolVisitorDelegate *Delegate,
                               CodeViewContainer Container)
       : Delegate(Delegate), Container(Container) {}
 
   Error visitSymbolBegin(CVSymbol &Record, uint32_t Offset) override {

llvm/include/llvm/DebugInfo/DWARF/DWARFListTable.h

DWARFListTableBase<DWARFListType>::findList(DWARFDataExtractor Data,
 
   // Extract the list from the section and enter it into the list map.
   DWARFListType List;
   uint32_t End = getHeaderOffset() + Header.length();
   uint32_t StartingOffset = Offset;
   if (Error E =
           List.extract(Data, getHeaderOffset(), End, &Offset,
                        Header.getSectionName(), Header.getListTypeString()))
-    return std::move(E);
+    return E;
   ListMap[StartingOffset] = List;
   return List;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFLISTTABLE_H

llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

struct LogicalDylib {
     JITSymbol findSymbol(BaseLayerT &BaseLayer, const std::string &Name,
                          bool ExportedSymbolsOnly) {
       if (auto Sym = StubsMgr->findStub(Name, ExportedSymbolsOnly))
         return Sym;
       for (auto BLK : BaseLayerVModuleKeys)
         if (auto Sym = BaseLayer.findSymbolIn(BLK, Name, ExportedSymbolsOnly))
           return Sym;
         else if (auto Err = Sym.takeError())
-          return std::move(Err);
+          return Err;
       return nullptr;
     }
 
     Error removeModulesFromBaseLayer(BaseLayerT &BaseLayer) {
       for (auto &BLK : BaseLayerVModuleKeys)
         if (auto Err = BaseLayer.removeModule(BLK))
           return Err;
       return Error::success();
public:
   /// @return A handle for the given named symbol, if it exists.
   JITSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) {
     for (auto &KV : LogicalDylibs) {
       if (auto Sym = KV.second.StubsMgr->findStub(Name, ExportedSymbolsOnly))
         return Sym;
       if (auto Sym = findSymbolIn(KV.first, Name, ExportedSymbolsOnly))
         return Sym;
       else if (auto Err = Sym.takeError())
-        return std::move(Err);
+        return Err;
     }
     return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
   }
 
   /// Get the address of a symbol provided by this layer, or some layer
   ///        below this one.
   JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
                          bool ExportedSymbolsOnly) {
const DataLayout &DL = SrcM.getDataLayout();
           continue;
 
         // Skip weak functions for which we already have definitions.
         auto MangledName = mangle(F.getName(), DL);
         if (F.hasWeakLinkage() || F.hasLinkOnceLinkage()) {
           if (auto Sym = LD.findSymbol(BaseLayer, MangledName, false))
             continue;
           else if (auto Err = Sym.takeError())
-            return std::move(Err);
+            return Err;
         }
 
         // Record all functions defined by this module.
         if (CloneStubsIntoPartitions)
           LD.getStubsToClone(LMId).insert(&F);
 
         // Create a callback, associate it with the stub for the function,
         // and set the compile action to compile the partition containing the
Error addLogicalModule(LogicalDylib &LD, std::unique_ptr<Module> SrcMPtr) {
     // Build a resolver for the globals module and add it to the base layer.
     auto LegacyLookup = [this, &LD](const std::string &Name) -> JITSymbol {
       if (auto Sym = LD.StubsMgr->findStub(Name, false))
         return Sym;
 
       if (auto Sym = LD.findSymbol(BaseLayer, Name, false))
         return Sym;
       else if (auto Err = Sym.takeError())
-        return std::move(Err);
+        return Err;
 
       return nullptr;
     };
 
     auto GVsResolver = createSymbolResolver(
         [&LD, LegacyLookup](const SymbolNameSet &Symbols) {
           auto RS = getResponsibilitySetWithLegacyFn(Symbols, LegacyLookup);
 
if (auto PartKeyOrErr = emitPartition(LD, LMId, Part)) {
 
             // Update the function body pointer for the stub.
             if (auto EC = LD.StubsMgr->updatePointer(FnName, FnBodyAddr))
               return 0;
 
           } else
             return FnBodyAddrOrErr.takeError();
         } else if (auto Err = FnBodySym.takeError())
-          return std::move(Err);
+          return Err;
         else
           llvm_unreachable("Function not emitted for partition");
       }
 
       LD.BaseLayerVModuleKeys.push_back(PartKey);
     } else
       return PartKeyOrErr.takeError();
 
auto Resolver = createSymbolResolver(
           auto NotFoundViaLegacyLookup =
               lookupWithLegacyFn(ES, *Q, Symbols, LegacyLookup);
           return LD.BackingResolver->lookup(Q,
                                             std::move(NotFoundViaLegacyLookup));
         });
     SetSymbolResolver(K, std::move(Resolver));
 
     if (auto Err = BaseLayer.addModule(std::move(K), std::move(M)))
-      return std::move(Err);
+      return Err;
 
     return K;
   }
 
   ExecutionSession &ES;
   BaseLayerT &BaseLayer;
   SymbolResolverGetter GetSymbolResolver;
   SymbolResolverSetter SetSymbolResolver;

llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h

public:
   static Expected<std::unique_ptr<LocalTrampolinePool>>
   Create(GetTrampolineLandingFunction GetTrampolineLanding) {
     Error Err = Error::success();
 
     auto LTP = std::unique_ptr<LocalTrampolinePool>(
         new LocalTrampolinePool(std::move(GetTrampolineLanding), Err));
 
     if (Err)
-      return std::move(Err);
-    return std::move(LTP);
+      return Err;
+    return LTP;
   }
 
   /// Get a free trampoline. Returns an error if one can not be provide (e.g.
   /// because the pool is empty and can not be grown).
   Expected<JITTargetAddress> getTrampoline() override {
     std::lock_guard<std::mutex> Lock(LTPMutex);
     if (AvailableTrampolines.empty()) {
       if (auto Err = grow())
-        return std::move(Err);
+        return Err;
     }
     assert(!AvailableTrampolines.empty() && "Failed to grow trampoline pool");
     auto TrampolineAddr = AvailableTrampolines.back();
     AvailableTrampolines.pop_back();
     return TrampolineAddr;
   }
 
   /// Returns the given trampoline to the pool for re-use.

 public:
   /// Create a new LocalJITCompileCallbackManager.
   static Expected<std::unique_ptr<LocalJITCompileCallbackManager>>
   Create(ExecutionSession &ES, JITTargetAddress ErrorHandlerAddress) {
     Error Err = Error::success();
     auto CCMgr = std::unique_ptr<LocalJITCompileCallbackManager>(
         new LocalJITCompileCallbackManager(ES, ErrorHandlerAddress, Err));
     if (Err)
-      return std::move(Err);
-    return std::move(CCMgr);
+      return Err;
+    return CCMgr;
   }
 
 private:
   /// Construct a InProcessJITCompileCallbackManager.
   /// @param ErrorHandlerAddress The address of an error handler in the target
   ///                            process to be used if a compile callback fails.
   LocalJITCompileCallbackManager(ExecutionSession &ES,
                                  JITTargetAddress ErrorHandlerAddress,

llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h

public:
   SetterImpl &setNumCompileThreads(unsigned NumCompileThreads) {
     impl().NumCompileThreads = NumCompileThreads;
     return impl();
   }
 
   /// Create an instance of the JIT.
   Expected<std::unique_ptr<JITType>> create() {
     if (auto Err = impl().prepareForConstruction())
-      return std::move(Err);
+      return Err;
 
     Error Err = Error::success();
     std::unique_ptr<JITType> J(new JITType(impl(), Err));
     if (Err)
-      return std::move(Err);
-    return std::move(J);
+      return Err;
+    return J;
   }
 
 protected:
   SetterImpl &impl() { return static_cast<SetterImpl &>(*this); }
 };
 
 /// Constructs LLJIT instances.
 class LLJITBuilder

llvm/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h

JITSymbol find(StringRef Name, bool ExportedSymbolsOnly, BaseLayerT &B) {
           JITSymbolFlags Flags = JITSymbolFlags::fromGlobalValue(*GV);
           auto GetAddress =
             [this, ExportedSymbolsOnly, PName, &B]() -> Expected<JITTargetAddress> {
               if (this->EmitState == Emitting)
                 return 0;
               else if (this->EmitState == NotEmitted) {
                 this->EmitState = Emitting;
                 if (auto Err = this->emitToBaseLayer(B))
-                  return std::move(Err);
+                  return Err;
                 this->EmitState = Emitted;
               }
               if (auto Sym = B.findSymbolIn(K, PName, ExportedSymbolsOnly))
                 return Sym.getAddress();
               else if (auto Err = Sym.takeError())
-                return std::move(Err);
+                return Err;
               else
                 llvm_unreachable("Successful symbol lookup should return "
                                  "definition address here");
           };
           return JITSymbol(std::move(GetAddress), Flags);
         } else
           return nullptr;
       case Emitting:

llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h

public:
   /// createLocalLazyCallThroughManager.
   template <typename ORCABI>
   static Expected<std::unique_ptr<LocalLazyCallThroughManager>>
   Create(ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr) {
     auto LLCTM = std::unique_ptr<LocalLazyCallThroughManager>(
         new LocalLazyCallThroughManager(ES, ErrorHandlerAddr));
 
     if (auto Err = LLCTM->init<ORCABI>())
-      return std::move(Err);
+      return Err;
 
-    return std::move(LLCTM);
+    return LLCTM;
   }
 };
 
 /// Create a LocalLazyCallThroughManager from the given triple and execution
 /// session.
 Expected<std::unique_ptr<LazyCallThroughManager>>
 createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES,
                                   JITTargetAddress ErrorHandlerAddr);

llvm/include/llvm/ExecutionEngine/Orc/Legacy.h

getResponsibilitySetWithLegacyFn(const SymbolNameSet &Symbols,
                                  FindSymbolFn FindSymbol) {
   SymbolNameSet Result;
 
   for (auto &S : Symbols) {
     if (JITSymbol Sym = FindSymbol(*S)) {
       if (!Sym.getFlags().isStrong())
         Result.insert(S);
     } else if (auto Err = Sym.takeError())
-      return std::move(Err);
+      return Err;
   }
 
   return Result;
 }
 
 /// Use the given legacy-style FindSymbol function (i.e. a function that
 ///        takes a const std::string& or StringRef and returns a JITSymbol) to
 ///        find the address and flags for each symbol in Symbols and store the

llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h

public:
   class RemoteTrampolinePool : public TrampolinePool {
   public:
     RemoteTrampolinePool(OrcRemoteTargetClient &Client) : Client(Client) {}
 
     Expected<JITTargetAddress> getTrampoline() override {
       std::lock_guard<std::mutex> Lock(RTPMutex);
       if (AvailableTrampolines.empty()) {
         if (auto Err = grow())
-          return std::move(Err);
+          return Err;
       }
       assert(!AvailableTrampolines.empty() && "Failed to grow trampoline pool");
       auto TrampolineAddr = AvailableTrampolines.back();
       AvailableTrampolines.pop_back();
       return TrampolineAddr;
     }
 
   private:
public:
   /// Channel is the ChannelT instance to communicate on. It is assumed that
   /// the channel is ready to be read from and written to.
   static Expected<std::unique_ptr<OrcRemoteTargetClient>>
   Create(rpc::RawByteChannel &Channel, ExecutionSession &ES) {
     Error Err = Error::success();
     auto Client = std::unique_ptr<OrcRemoteTargetClient>(
         new OrcRemoteTargetClient(Channel, ES, Err));
     if (Err)
-      return std::move(Err);
-    return std::move(Client);
+      return Err;
+    return Client;
   }
 
   /// Call the int(void) function at the given address in the target and return
   /// its result.
   Expected<int> callIntVoid(JITTargetAddress Addr) {
     LLVM_DEBUG(dbgs() << "Calling int(*)(void) "
                       << format("0x%016" PRIx64, Addr) << "\n");
     return callB<exec::CallIntVoid>(Addr);
public:
   }
 
   /// Create an RCMemoryManager which will allocate its memory on the remote
   /// target.
   Expected<std::unique_ptr<RemoteRTDyldMemoryManager>>
   createRemoteMemoryManager() {
     auto Id = AllocatorIds.getNext();
     if (auto Err = callB<mem::CreateRemoteAllocator>(Id))
-      return std::move(Err);
+      return Err;
     return std::unique_ptr<RemoteRTDyldMemoryManager>(
         new RemoteRTDyldMemoryManager(*this, Id));
   }
 
   /// Create an RCIndirectStubsManager that will allocate stubs on the remote
   /// target.
   Expected<std::unique_ptr<RemoteIndirectStubsManager>>
   createIndirectStubsManager() {
     auto Id = IndirectStubOwnerIds.getNext();
     if (auto Err = callB<stubs::CreateIndirectStubsOwner>(Id))
-      return std::move(Err);
+      return Err;
     return llvm::make_unique<RemoteIndirectStubsManager>(*this, Id);
   }
 
   Expected<RemoteCompileCallbackManager &>
   enableCompileCallbacks(JITTargetAddress ErrorHandlerAddress) {
     assert(!CallbackManager && "CallbackManager already obtained");
 
     // Emit the resolver block on the JIT server.
     if (auto Err = callB<stubs::EmitResolverBlock>())
-      return std::move(Err);
+      return Err;
 
     // Create the callback manager.
     CallbackManager.emplace(*this, ES, ErrorHandlerAddress);
     RemoteCompileCallbackManager &Mgr = *CallbackManager;
     return Mgr;
   }
 
   /// Search for symbols in the remote process. Note: This should be used by

llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h

handleEmitIndirectStubs(ResourceIdMgr::ResourceId Id,
     auto StubOwnerItr = IndirectStubsOwners.find(Id);
     if (StubOwnerItr == IndirectStubsOwners.end())
       return errorCodeToError(
                orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist));
 
     typename TargetT::IndirectStubsInfo IS;
     if (auto Err =
             TargetT::emitIndirectStubsBlock(IS, NumStubsRequired, nullptr))
-      return std::move(Err);
+      return Err;
 
     JITTargetAddress StubsBase = static_cast<JITTargetAddress>(
         reinterpret_cast<uintptr_t>(IS.getStub(0)));
     JITTargetAddress PtrsBase = static_cast<JITTargetAddress>(
         reinterpret_cast<uintptr_t>(IS.getPtr(0)));
     uint32_t NumStubsEmitted = IS.getNumStubs();
 
     auto &BlockList = StubOwnerItr->second;
Expected<JITTargetAddress> handleReserveMem(ResourceIdMgr::ResourceId Id,
                                               uint64_t Size, uint32_t Align) {
     auto I = Allocators.find(Id);
     if (I == Allocators.end())
       return errorCodeToError(
                orcError(OrcErrorCode::RemoteAllocatorDoesNotExist));
     auto &Allocator = I->second;
     void *LocalAllocAddr = nullptr;
     if (auto Err = Allocator.allocate(LocalAllocAddr, Size, Align))
-      return std::move(Err);
+      return Err;
 
     LLVM_DEBUG(dbgs() << "  Allocator " << Id << " reserved " << LocalAllocAddr
                       << " (" << Size << " bytes, alignment " << Align
                       << ")\n");
 
     JITTargetAddress AllocAddr = static_cast<JITTargetAddress>(
         reinterpret_cast<uintptr_t>(LocalAllocAddr));
 

llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h

Expected<NonBlockingCallResult<Func>> appendCallNB(const ArgTs &... Args) {
 
     if (auto Err = this->template appendCallAsync<Func>(
             [Promise](ErrorReturn RetOrErr) {
               Promise->set_value(std::move(RetOrErr));
               return Error::success();
             },
             Args...)) {
       RTraits::consumeAbandoned(FutureResult.get());
-      return std::move(Err);
+      return Err;
     }
-    return std::move(FutureResult);
+    return FutureResult;
   }
 
   /// The same as appendCallNBWithSeq, except that it calls C.send() to
   /// flush the channel after serializing the call.
   template <typename Func, typename... ArgTs>
   Expected<NonBlockingCallResult<Func>> callNB(const ArgTs &... Args) {
     auto Result = appendCallNB<Func>(Args...);
     if (!Result)
       return Result;
     if (auto Err = this->C.send()) {
       this->abandonPendingResponses();
       detail::ResultTraits<typename Func::ReturnType>::consumeAbandoned(
           std::move(Result->get()));
-      return std::move(Err);
+      return Err;
     }
     return Result;
   }
 
   /// Call Func on Channel C. Blocks waiting for a result. Returns an Error
   /// for void functions or an Expected<T> for functions returning a T.
   ///
   /// This function is for use in threaded code where another thread is
if (auto Err = this->template appendCallAsync<Func>(
             [&](ResultType R) {
               Result = std::move(R);
               ReceivedResponse = true;
               return Error::success();
             },
             Args...)) {
       detail::ResultTraits<typename Func::ReturnType>::consumeAbandoned(
           std::move(Result));
-      return std::move(Err);
+      return Err;
     }
 
     while (!ReceivedResponse) {
       if (auto Err = this->handleOne()) {
         detail::ResultTraits<typename Func::ReturnType>::consumeAbandoned(
             std::move(Result));
-        return std::move(Err);
+        return Err;
       }
     }
 
     return Result;
   }
 };
 
 /// Asynchronous dispatch for a function on an RPC endpoint.

llvm/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h

public:
     }
 
     JITSymbol::GetAddressFtor getSymbolMaterializer(std::string Name) override {
       return [this, Name]() -> Expected<JITTargetAddress> {
         // The symbol may be materialized between the creation of this lambda
         // and its execution, so we need to double check.
         if (!this->Finalized)
           if (auto Err = this->finalize())
-            return std::move(Err);
+            return Err;
         return this->getSymbol(Name, false).getAddress();
       };
     }
 
     void mapSectionAddress(const void *LocalAddress,
                            JITTargetAddress TargetAddr) const override {
       assert(PFC && "mapSectionAddress called on finalized LinkedObject");
       assert(PFC->RTDyld && "mapSectionAddress called on raw LinkedObject");
public:
   /// @param Name The name of the symbol to search for.
   /// @param ExportedSymbolsOnly If true, search only for exported symbols.
   /// @return A handle for the given named symbol, if it exists.
   JITSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) {
     for (auto &KV : LinkedObjects)
       if (auto Sym = KV.second->getSymbol(Name, ExportedSymbolsOnly))
         return Sym;
       else if (auto Err = Sym.takeError())
-        return std::move(Err);
+        return Err;
 
     return nullptr;
   }
 
   /// Search for the given named symbol in the context of the loaded
   ///        object represented by the VModuleKey K.
   /// @param K The VModuleKey for the object to search in.
   /// @param Name The name of the symbol to search for.

llvm/include/llvm/Object/ELFObjectFile.h

ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const {
   return *Ret;
 }
 
 template <class ELFT>
 Expected<ELFObjectFile<ELFT>>
 ELFObjectFile<ELFT>::create(MemoryBufferRef Object) {
   auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer());
   if (Error E = EFOrErr.takeError())
-    return std::move(E);
+    return E;
   auto EF = std::move(*EFOrErr);
 
   auto SectionsOrErr = EF.sections();
   if (!SectionsOrErr)
     return SectionsOrErr.takeError();
 
   const Elf_Shdr *DotDynSymSec = nullptr;
   const Elf_Shdr *DotSymtabSec = nullptr;

llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h

public:
   }
   bool operator!=(const CoverageMappingIterator &RHS) {
     return Reader != RHS.Reader;
   }
   Expected<CoverageMappingRecord &> operator*() {
     if (ReadErr != coveragemap_error::success) {
       auto E = make_error<CoverageMapError>(ReadErr);
       ReadErr = coveragemap_error::success;
-      return std::move(E);
+      return E;
     }
     return Record;
   }
   Expected<CoverageMappingRecord *> operator->() {
     if (ReadErr != coveragemap_error::success) {
       auto E = make_error<CoverageMapError>(ReadErr);
       ReadErr = coveragemap_error::success;
-      return std::move(E);
+      return E;
     }
     return &Record;
   }
 };
 
 class CoverageMappingReader {
 public:
   virtual ~CoverageMappingReader() = default;

llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp

if (Expected<SimpleBitstreamCursor::word_t> MaybeWord = Stream.Read(size))
       Dest = MaybeWord.get();
     else
       return MaybeWord.takeError();
     return Error::success();
   };
 
   char Signature[6];
   if (Error Err = tryRead(Signature[0], 8))
-    return std::move(Err);
+    return Err;
   if (Error Err = tryRead(Signature[1], 8))
-    return std::move(Err);
+    return Err;
 
   // Autodetect the file contents, if it is one we know.
   if (Signature[0] == 'C' && Signature[1] == 'P') {
     if (Error Err = tryRead(Signature[2], 8))
-      return std::move(Err);
+      return Err;
     if (Error Err = tryRead(Signature[3], 8))
-      return std::move(Err);
+      return Err;
     if (Signature[2] == 'C' && Signature[3] == 'H')
       return ClangSerializedASTBitstream;
   } else if (Signature[0] == 'D' && Signature[1] == 'I') {
     if (Error Err = tryRead(Signature[2], 8))
-      return std::move(Err);
+      return Err;
     if (Error Err = tryRead(Signature[3], 8))
-      return std::move(Err);
+      return Err;
     if (Signature[2] == 'A' && Signature[3] == 'G')
       return ClangSerializedDiagnosticsBitstream;
   } else if (Signature[0] == 'R' && Signature[1] == 'M') {
     if (Error Err = tryRead(Signature[2], 8))
-      return std::move(Err);
+      return Err;
     if (Error Err = tryRead(Signature[3], 8))
-      return std::move(Err);
+      return Err;
     if (Signature[2] == 'R' && Signature[3] == 'K')
       return LLVMBitstreamRemarks;
   } else {
     if (Error Err = tryRead(Signature[2], 4))
-      return std::move(Err);
+      return Err;
     if (Error Err = tryRead(Signature[3], 4))
-      return std::move(Err);
+      return Err;
     if (Error Err = tryRead(Signature[4], 4))
-      return std::move(Err);
+      return Err;
     if (Error Err = tryRead(Signature[5], 4))
-      return std::move(Err);
+      return Err;
     if (Signature[0] == 'B' && Signature[1] == 'C' && Signature[2] == 0x0 &&
         Signature[3] == 0xC && Signature[4] == 0xE && Signature[5] == 0xD)
       return LLVMIRBitstream;
   }
   return UnknownBitstream;
 }
 
 static Expected<CurStreamTypeType> analyzeHeader(Optional<BCDumpOptions> O,

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

static Expected<BitstreamCursor> initStream(MemoryBufferRef Buffer) {
   // If we have a wrapper header, parse it and ignore the non-bc file contents.
   // The magic number is 0x0B17C0DE stored in little endian.
   if (isBitcodeWrapper(BufPtr, BufEnd))
     if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
       return error("Invalid bitcode wrapper header");
 
   BitstreamCursor Stream(ArrayRef<uint8_t>(BufPtr, BufEnd));
   if (Error Err = hasInvalidBitcodeHeader(Stream))
-    return std::move(Err);
+    return Err;
 
-  return std::move(Stream);
+  return Stream;
 }
 
 /// Convert a string from a record into an std::string, return true on failure.
 template <typename StrTy>
 static bool convertToString(ArrayRef<uint64_t> Record, unsigned Idx,
                             StrTy &Result) {
   if (Idx > Record.size())
     return true;
for (auto &I : instructions(F))
       I.setMetadata(LLVMContext::MD_tbaa, nullptr);
   }
 }
 
 /// Read the "IDENTIFICATION_BLOCK_ID" block, do some basic enforcement on the
 /// "epoch" encoded in the bitcode, and return the producer name if any.
 static Expected<std::string> readIdentificationBlock(BitstreamCursor &Stream) {
   if (Error Err = Stream.EnterSubBlock(bitc::IDENTIFICATION_BLOCK_ID))
-    return std::move(Err);
+    return Err;
 
   // Read all the records.
   SmallVector<uint64_t, 64> Record;
 
   std::string ProducerIdentification;
 
   while (true) {
     BitstreamEntry Entry;
case BitstreamEntry::Error:
       return error("Malformed block");
 
     case BitstreamEntry::SubBlock:
       if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID)
         return readIdentificationBlock(Stream);
 
       // Ignore other sub-blocks.
       if (Error Err = Stream.SkipBlock())
-        return std::move(Err);
+        return Err;
       continue;
     case BitstreamEntry::Record:
       if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
         continue;
       else
         return Skipped.takeError();
     }
   }
 }
 
 static Expected<bool> hasObjCCategoryInModule(BitstreamCursor &Stream) {
   if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
-    return std::move(Err);
+    return Err;
 
   SmallVector<uint64_t, 64> Record;
   // Read all the records for this module.
 
   while (true) {
     Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
     if (!MaybeEntry)
       return MaybeEntry.takeError();
case BitstreamEntry::EndBlock:
       return false;
 
     case BitstreamEntry::SubBlock:
       if (Entry.ID == bitc::MODULE_BLOCK_ID)
         return hasObjCCategoryInModule(Stream);
 
       // Ignore other sub-blocks.
       if (Error Err = Stream.SkipBlock())
-        return std::move(Err);
+        return Err;
       continue;
 
     case BitstreamEntry::Record:
       if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
         continue;
       else
         return Skipped.takeError();
     }
   }
 }
 
 static Expected<std::string> readModuleTriple(BitstreamCursor &Stream) {
   if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
-    return std::move(Err);
+    return Err;
 
   SmallVector<uint64_t, 64> Record;
 
   std::string Triple;
 
   // Read all the records for this module.
   while (true) {
     Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
case BitstreamEntry::EndBlock:
       return "";
 
     case BitstreamEntry::SubBlock:
       if (Entry.ID == bitc::MODULE_BLOCK_ID)
         return readModuleTriple(Stream);
 
       // Ignore other sub-blocks.
       if (Error Err = Stream.SkipBlock())
-        return std::move(Err);
+        return Err;
       continue;
 
     case BitstreamEntry::Record:
       if (llvm::Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
         continue;
       else
         return Skipped.takeError();
     }

 /// Helper to note and return the current location, and jump to the given
 /// offset.
 static Expected<uint64_t> jumpToValueSymbolTable(uint64_t Offset,
                                                  BitstreamCursor &Stream) {
   // Save the current parsing location so we can jump back at the end
   // of the VST read.
   uint64_t CurrentBit = Stream.GetCurrentBitNo();
   if (Error JumpFailed = Stream.JumpToBit(Offset * 32))
-    return std::move(JumpFailed);
+    return JumpFailed;
   Expected<BitstreamEntry> MaybeEntry = Stream.advance();
   if (!MaybeEntry)
     return MaybeEntry.takeError();
   assert(MaybeEntry.get().Kind == BitstreamEntry::SubBlock);
   assert(MaybeEntry.get().ID == bitc::VALUE_SYMTAB_BLOCK_ID);
   return CurrentBit;
 }
 

 
 const std::error_category &llvm::BitcodeErrorCategory() {
   return *ErrorCategory;
 }
 
 static Expected<StringRef> readBlobInRecord(BitstreamCursor &Stream,
                                             unsigned Block, unsigned RecordID) {
   if (Error Err = Stream.EnterSubBlock(Block))
-    return std::move(Err);
+    return Err;
 
   StringRef Strtab;
   while (true) {
     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
     if (!MaybeEntry)
       return MaybeEntry.takeError();
     llvm::BitstreamEntry Entry = MaybeEntry.get();
 
     switch (Entry.Kind) {
     case BitstreamEntry::EndBlock:
       return Strtab;
 
     case BitstreamEntry::Error:
       return error("Malformed block");
 
     case BitstreamEntry::SubBlock:
       if (Error Err = Stream.SkipBlock())
-        return std::move(Err);
+        return Err;
       break;
 
     case BitstreamEntry::Record:
       StringRef Blob;
       SmallVector<uint64_t, 1> Record;
       Expected<unsigned> MaybeRecord =
           Stream.readRecord(Entry.ID, Record, &Blob);
       if (!MaybeRecord)
while (true) {
     case BitstreamEntry::Error:
       return error("Malformed block");
 
     case BitstreamEntry::SubBlock: {
       uint64_t IdentificationBit = -1ull;
       if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID) {
         IdentificationBit = Stream.GetCurrentBitNo() - BCBegin * 8;
         if (Error Err = Stream.SkipBlock())
-          return std::move(Err);
+          return Err;
 
         {
           Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
           if (!MaybeEntry)
             return MaybeEntry.takeError();
           Entry = MaybeEntry.get();
         }
 
         if (Entry.Kind != BitstreamEntry::SubBlock ||
             Entry.ID != bitc::MODULE_BLOCK_ID)
           return error("Malformed block");
       }
 
       if (Entry.ID == bitc::MODULE_BLOCK_ID) {
         uint64_t ModuleBit = Stream.GetCurrentBitNo() - BCBegin * 8;
         if (Error Err = Stream.SkipBlock())
-          return std::move(Err);
+          return Err;
 
         F.Mods.push_back({Stream.getBitcodeBytes().slice(
                               BCBegin, Stream.getCurrentByteNo() - BCBegin),
                           Buffer.getBufferIdentifier(), IdentificationBit,
                           ModuleBit});
         continue;
       }
 
case BitstreamEntry::SubBlock: {
         // of modules in the symbol table does not match the number of modules
         // in the input file and regenerate the symbol table.
         if (F.Symtab.empty())
           F.Symtab = *SymtabOrErr;
         continue;
       }
 
       if (Error Err = Stream.SkipBlock())
-        return std::move(Err);
+        return Err;
       continue;
     }
     case BitstreamEntry::Record:
       if (Expected<unsigned> StreamFailed = Stream.skipRecord(Entry.ID))
         continue;
       else
         return StreamFailed.takeError();
     }

 Expected<std::unique_ptr<Module>>
 BitcodeModule::getModuleImpl(LLVMContext &Context, bool MaterializeAll,
                              bool ShouldLazyLoadMetadata, bool IsImporting) {
   BitstreamCursor Stream(Buffer);
 
   std::string ProducerIdentification;
   if (IdentificationBit != -1ull) {
     if (Error JumpFailed = Stream.JumpToBit(IdentificationBit))
-      return std::move(JumpFailed);
+      return JumpFailed;
     Expected<std::string> ProducerIdentificationOrErr =
         readIdentificationBlock(Stream);
     if (!ProducerIdentificationOrErr)
       return ProducerIdentificationOrErr.takeError();
 
     ProducerIdentification = *ProducerIdentificationOrErr;
   }
 
   if (Error JumpFailed = Stream.JumpToBit(ModuleBit))
-    return std::move(JumpFailed);
+    return JumpFailed;
   auto *R = new BitcodeReader(std::move(Stream), Strtab, ProducerIdentification,
                               Context);
 
   std::unique_ptr<Module> M =
       llvm::make_unique<Module>(ModuleIdentifier, Context);
   M->setMaterializer(R);
 
   // Delay parsing Metadata if ShouldLazyLoadMetadata is true.
   if (Error Err =
           R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata, IsImporting))
-    return std::move(Err);
+    return Err;
 
   if (MaterializeAll) {
     // Read in the entire module, and destroy the BitcodeReader.
     if (Error Err = M->materializeAll())
-      return std::move(Err);
+      return Err;
   } else {
     // Resolve forward references from blockaddresses.
     if (Error Err = R->materializeForwardReferencedFunctions())
-      return std::move(Err);
+      return Err;
   }
-  return std::move(M);
+  return M;
 }
 
 Expected<std::unique_ptr<Module>>
 BitcodeModule::getLazyModule(LLVMContext &Context, bool ShouldLazyLoadMetadata,
                              bool IsImporting) {
   return getModuleImpl(Context, false, ShouldLazyLoadMetadata, IsImporting);
 }
 
ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, CombinedIndex,
                                     ModulePath, ModuleId);
   return R.parseModule();
 }
 
 // Parse the specified bitcode buffer, returning the function info index.
 Expected<std::unique_ptr<ModuleSummaryIndex>> BitcodeModule::getSummary() {
   BitstreamCursor Stream(Buffer);
   if (Error JumpFailed = Stream.JumpToBit(ModuleBit))
-    return std::move(JumpFailed);
+    return JumpFailed;
 
   auto Index = llvm::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
   ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, *Index,
                                     ModuleIdentifier, 0);
 
   if (Error Err = R.parseModule())
-    return std::move(Err);
+    return Err;
 
-  return std::move(Index);
+  return Index;
 }
 
 static Expected<bool> getEnableSplitLTOUnitFlag(BitstreamCursor &Stream,
                                                 unsigned ID) {
   if (Error Err = Stream.EnterSubBlock(ID))
-    return std::move(Err);
+    return Err;
   SmallVector<uint64_t, 64> Record;
 
   while (true) {
     Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
     if (!MaybeEntry)
       return MaybeEntry.takeError();
     BitstreamEntry Entry = MaybeEntry.get();
 
static Expected<bool> getEnableSplitLTOUnitFlag(BitstreamCursor &Stream,
   }
   llvm_unreachable("Exit infinite loop");
 }
 
 // Check if the given bitcode buffer contains a global value summary block.
 Expected<BitcodeLTOInfo> BitcodeModule::getLTOInfo() {
   BitstreamCursor Stream(Buffer);
   if (Error JumpFailed = Stream.JumpToBit(ModuleBit))
-    return std::move(JumpFailed);
+    return JumpFailed;
 
   if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
-    return std::move(Err);
+    return Err;
 
   while (true) {
     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
     if (!MaybeEntry)
       return MaybeEntry.takeError();
     llvm::BitstreamEntry Entry = MaybeEntry.get();
 
     switch (Entry.Kind) {
case BitstreamEntry::SubBlock:
         if (!EnableSplitLTOUnit)
           return EnableSplitLTOUnit.takeError();
         return BitcodeLTOInfo{/*IsThinLTO=*/false, /*HasSummary=*/true,
                               *EnableSplitLTOUnit};
       }
 
       // Ignore other sub-blocks.
       if (Error Err = Stream.SkipBlock())
-        return std::move(Err);
+        return Err;
       continue;
 
     case BitstreamEntry::Record:
       if (Expected<unsigned> StreamFailed = Stream.skipRecord(Entry.ID))
         continue;
       else
         return StreamFailed.takeError();
     }

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

case BitstreamEntry::Record: {
       Expected<unsigned> MaybeCode = IndexCursor.skipRecord(Entry.ID);
       if (!MaybeCode)
         return MaybeCode.takeError();
       unsigned Code = MaybeCode.get();
       switch (Code) {
       case bitc::METADATA_STRINGS: {
         // Rewind and parse the strings.
         if (Error Err = IndexCursor.JumpToBit(CurrentPos))
-          return std::move(Err);
+          return Err;
         StringRef Blob;
         Record.clear();
         if (Expected<unsigned> MaybeRecord =
                 IndexCursor.readRecord(Entry.ID, Record, &Blob))
           ;
         else
           return MaybeRecord.takeError();
         unsigned NumStrings = Record[0];
         MDStringRef.reserve(NumStrings);
         auto IndexNextMDString = [&](StringRef Str) {
           MDStringRef.push_back(Str);
         };
         if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
-          return std::move(Err);
+          return Err;
         break;
       }
       case bitc::METADATA_INDEX_OFFSET: {
         // This is the offset to the index, when we see this we skip all the
         // records and load only an index to these.
         if (Error Err = IndexCursor.JumpToBit(CurrentPos))
-          return std::move(Err);
+          return Err;
         Record.clear();
         if (Expected<unsigned> MaybeRecord =
                 IndexCursor.readRecord(Entry.ID, Record))
           ;
         else
           return MaybeRecord.takeError();
         if (Record.size() != 2)
           return error("Invalid record");
         auto Offset = Record[0] + (Record[1] << 32);
         auto BeginPos = IndexCursor.GetCurrentBitNo();
         if (Error Err = IndexCursor.JumpToBit(BeginPos + Offset))
-          return std::move(Err);
+          return Err;
         Expected<BitstreamEntry> MaybeEntry =
             IndexCursor.advanceSkippingSubblocks(
                 BitstreamCursor::AF_DontPopBlockAtEnd);
         if (!MaybeEntry)
           return MaybeEntry.takeError();
         Entry = MaybeEntry.get();
         assert(Entry.Kind == BitstreamEntry::Record &&
                "Corrupted bitcode: Expected `Record` when trying to find the "
case BitstreamEntry::Record: {
       }
       case bitc::METADATA_INDEX:
         // We don't expect to get there, the Index is loaded when we encounter
         // the offset.
         return error("Corrupted Metadata block");
       case bitc::METADATA_NAME: {
         // Named metadata need to be materialized now and aren't deferred.
         if (Error Err = IndexCursor.JumpToBit(CurrentPos))
-          return std::move(Err);
+          return Err;
         Record.clear();
 
         unsigned Code;
         if (Expected<unsigned> MaybeCode =
                 IndexCursor.readRecord(Entry.ID, Record)) {
           Code = MaybeCode.get();
           assert(Code == bitc::METADATA_NAME);
         } else
case BitstreamEntry::Record: {
           NMD->addOperand(MD);
         }
         break;
       }
       case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
         // FIXME: we need to do this early because we don't materialize global
         // value explicitly.
         if (Error Err = IndexCursor.JumpToBit(CurrentPos))
-          return std::move(Err);
+          return Err;
         Record.clear();
         if (Expected<unsigned> MaybeRecord =
                 IndexCursor.readRecord(Entry.ID, Record))
           ;
         else
           return MaybeRecord.takeError();
         if (Record.size() % 2 == 0)
           return error("Invalid record");
         unsigned ValueID = Record[0];
         if (ValueID >= ValueList.size())
           return error("Invalid record");
         if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
           if (Error Err = parseGlobalObjectAttachment(
                   *GO, ArrayRef<uint64_t>(Record).slice(1)))
-            return std::move(Err);
+            return Err;
         break;
       }
       case bitc::METADATA_KIND:
       case bitc::METADATA_STRING_OLD:
       case bitc::METADATA_OLD_FN_NODE:
       case bitc::METADATA_OLD_NODE:
       case bitc::METADATA_VALUE:
       case bitc::METADATA_DISTINCT_NODE:

llvm/lib/Bitstream/Reader/BitstreamReader.cpp

Expected<unsigned> BitstreamCursor::skipRecord(unsigned AbbrevID) {
   for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i < e; ++i) {
     const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
     if (Op.isLiteral())
       continue;
 
     if (Op.getEncoding() != BitCodeAbbrevOp::Array &&
         Op.getEncoding() != BitCodeAbbrevOp::Blob) {
       if (Error Err = skipAbbreviatedField(*this, Op))
-        return std::move(Err);
+        return Err;
       continue;
     }
 
     if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
       // Array case.  Read the number of elements as a vbr6.
       Expected<uint32_t> MaybeNum = ReadVBR(6);
       if (!MaybeNum)
         return MaybeNum.takeError();
       unsigned NumElts = MaybeNum.get();
 
       // Get the element encoding.
       assert(i+2 == e && "array op not second to last?");
       const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
 
       // Read all the elements.
       // Decode the value as we are commanded.
       switch (EltEnc.getEncoding()) {
       default:
         report_fatal_error("Array element type can't be an Array or a Blob");
       case BitCodeAbbrevOp::Fixed:
         assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize);
         if (Error Err = JumpToBit(GetCurrentBitNo() +
                                   NumElts * EltEnc.getEncodingData()))
-          return std::move(Err);
+          return Err;
         break;
       case BitCodeAbbrevOp::VBR:
         assert((unsigned)EltEnc.getEncodingData() <= MaxChunkSize);
         for (; NumElts; --NumElts)
           if (Expected<uint64_t> Res =
                   ReadVBR64((unsigned)EltEnc.getEncodingData()))
             ; // Skip!
           else
             return Res.takeError();
         break;
       case BitCodeAbbrevOp::Char6:
         if (Error Err = JumpToBit(GetCurrentBitNo() + NumElts * 6))
-          return std::move(Err);
+          return Err;
         break;
       }
       continue;
     }
 
     assert(Op.getEncoding() == BitCodeAbbrevOp::Blob);
     // Blob case.  Read the number of bytes as a vbr6.
     Expected<uint32_t> MaybeNum = ReadVBR(6);
for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i < e; ++i) {
     // record to empty and return.
     if (!canSkipToPos(NewEnd/8)) {
       skipToEnd();
       break;
     }
 
     // Skip over the blob.
     if (Error Err = JumpToBit(NewEnd))
-      return std::move(Err);
+      return Err;
   }
   return Code;
 }
 
 Expected<unsigned> BitstreamCursor::readRecord(unsigned AbbrevID,
                                                SmallVectorImpl<uint64_t> &Vals,
                                                StringRef *Blob) {
   if (AbbrevID == bitc::UNABBREV_RECORD) {
if (!canSkipToPos(NewEnd/8)) {
       skipToEnd();
       break;
     }
 
     // Otherwise, inform the streamer that we need these bytes in memory.  Skip
     // over tail padding first, in case jumping to NewEnd invalidates the Blob
     // pointer.
     if (Error Err = JumpToBit(NewEnd))
-      return std::move(Err);
+      return Err;
     const char *Ptr = (const char *)getPointerToBit(CurBitPos, NumElts);
 
     // If we can return a reference to the data, do so to avoid copying it.
     if (Blob) {
       *Blob = StringRef(Ptr, NumElts);
     } else {
       // Otherwise, unpack into Vals with zero extension.
       for (; NumElts; --NumElts)
Error BitstreamCursor::ReadAbbrevRecord() {
   CurAbbrevs.push_back(std::move(Abbv));
 
   return Error::success();
 }
 
 Expected<Optional<BitstreamBlockInfo>>
 BitstreamCursor::ReadBlockInfoBlock(bool ReadBlockInfoNames) {
   if (llvm::Error Err = EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID))
-    return std::move(Err);
+    return Err;
 
   BitstreamBlockInfo NewBlockInfo;
 
   SmallVector<uint64_t, 64> Record;
   BitstreamBlockInfo::BlockInfo *CurBlockInfo = nullptr;
 
   // Read all the records for this module.
   while (true) {
     Expected<BitstreamEntry> MaybeEntry =
         advanceSkippingSubblocks(AF_DontAutoprocessAbbrevs);
     if (!MaybeEntry)
       return MaybeEntry.takeError();
     BitstreamEntry Entry = MaybeEntry.get();
 
     switch (Entry.Kind) {
     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
     case llvm::BitstreamEntry::Error:
       return None;
     case llvm::BitstreamEntry::EndBlock:
-      return std::move(NewBlockInfo);
+      return NewBlockInfo;
     case llvm::BitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read abbrev records, associate them with CurBID.
     if (Entry.ID == bitc::DEFINE_ABBREV) {
       if (!CurBlockInfo) return None;
       if (Error Err = ReadAbbrevRecord())
-        return std::move(Err);
+        return Err;
 
       // ReadAbbrevRecord installs the abbrev in CurAbbrevs.  Move it to the
       // appropriate BlockInfo.
       CurBlockInfo->Abbrevs.push_back(std::move(CurAbbrevs.back()));
       CurAbbrevs.pop_back();
       continue;
     }
 

llvm/lib/DebugInfo/CodeView/DebugStringTableSubsection.cpp

 }
 
 Expected<StringRef>
 DebugStringTableSubsectionRef::getString(uint32_t Offset) const {
   BinaryStreamReader Reader(Stream);
   Reader.setOffset(Offset);
   StringRef Result;
   if (auto EC = Reader.readCString(Result))
-    return std::move(EC);
+    return EC;
   return Result;
 }
 
 DebugStringTableSubsection::DebugStringTableSubsection()
     : DebugSubsection(DebugSubsectionKind::StringTable) {}
 
 uint32_t DebugStringTableSubsection::insert(StringRef S) {
   auto P = StringToId.insert({S, StringSize});

llvm/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

 Expected<std::vector<DWARFDebugNames::AttributeEncoding>>
 DWARFDebugNames::NameIndex::extractAttributeEncodings(uint32_t *Offset) {
   std::vector<AttributeEncoding> Result;
   for (;;) {
     auto AttrEncOr = extractAttributeEncoding(Offset);
     if (!AttrEncOr)
       return AttrEncOr.takeError();
     if (isSentinel(*AttrEncOr))
-      return std::move(Result);
+      return Result;
 
     Result.emplace_back(*AttrEncOr);
   }
 }
 
 Expected<DWARFDebugNames::Abbrev>
 DWARFDebugNames::NameIndex::extractAbbrev(uint32_t *Offset) {
   if (*Offset >= EntriesBase) {
DWARFDebugNames::NameIndex::getEntry(uint32_t *Offset) const {
   Entry E(*this, *AbbrevIt);
 
   dwarf::FormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
   for (auto &Value : E.Values) {
     if (!Value.extractValue(AS, Offset, FormParams))
       return createStringError(errc::io_error,
                                "Error extracting index attribute values.");
   }
-  return std::move(E);
+  return E;
 }
 
 DWARFDebugNames::NameTableEntry
 DWARFDebugNames::NameIndex::getNameTableEntry(uint32_t Index) const {
   assert(0 < Index && Index <= Hdr.NameCount);
   uint32_t StringOffsetOffset = StringOffsetsBase + 4 * (Index - 1);
   uint32_t EntryOffsetOffset = EntryOffsetsBase + 4 * (Index - 1);
   const DWARFDataExtractor &AS = Section.AccelSection;

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

return createStringError(errc::invalid_argument, "offset 0x%8.8" PRIx32
                        Offset);
 
   std::pair<LineTableIter, bool> Pos =
       LineTableMap.insert(LineTableMapTy::value_type(Offset, LineTable()));
   LineTable *LT = &Pos.first->second;
   if (Pos.second) {
     if (Error Err =
             LT->parse(DebugLineData, &Offset, Ctx, U, RecoverableErrorCallback))
-      return std::move(Err);
+      return Err;
     return LT;
   }
   return LT;
 }
 
 Error DWARFDebugLine::LineTable::parse(
     DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
     const DWARFContext &Ctx, const DWARFUnit *U,

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

if (Offset > 0) {
     if (Offset < 12U)
       return createStringError(errc::invalid_argument, "Did not detect a valid"
                                " range list table with base = 0x%" PRIu32,
                                Offset);
     Offset -= 12U;
   }
   llvm::DWARFDebugRnglistTable Table;
   if (Error E = Table.extractHeaderAndOffsets(DA, &Offset))
-    return std::move(E);
+    return E;
   return Table;
 }
 
 Error DWARFUnit::extractRangeList(uint32_t RangeListOffset,
                                   DWARFDebugRangeList &RangeList) const {
   // Require that compile unit is extracted.
   assert(!DieArray.empty());
   DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
void DWARFUnit::clearDIEs(bool KeepCUDie) {
   }
 }
 
 Expected<DWARFAddressRangesVector>
 DWARFUnit::findRnglistFromOffset(uint32_t Offset) {
   if (getVersion() <= 4) {
     DWARFDebugRangeList RangeList;
     if (Error E = extractRangeList(Offset, RangeList))
-      return std::move(E);
+      return E;
     return RangeList.getAbsoluteRanges(getBaseAddress());
   }
   if (RngListTable) {
     DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
                                   isLittleEndian, RngListTable->getAddrSize());
     auto RangeListOrError = RngListTable->findList(RangesData, Offset);
     if (RangeListOrError)
       return RangeListOrError.get().getAbsoluteRanges(getBaseAddress(), *this);

llvm/lib/DebugInfo/MSF/MSFBuilder.cpp

Expected<uint32_t> MSFBuilder::addStream(uint32_t Size,
   return StreamData.size() - 1;
 }
 
 Expected<uint32_t> MSFBuilder::addStream(uint32_t Size) {
   uint32_t ReqBlocks = bytesToBlocks(Size, BlockSize);
   std::vector<uint32_t> NewBlocks;
   NewBlocks.resize(ReqBlocks);
   if (auto EC = allocateBlocks(ReqBlocks, NewBlocks))
-    return std::move(EC);
+    return EC;
   StreamData.push_back(std::make_pair(Size, NewBlocks));
   return StreamData.size() - 1;
 }
 
 Error MSFBuilder::setStreamSize(uint32_t Idx, uint32_t Size) {
   uint32_t OldSize = getStreamSize(Idx);
   if (OldSize == Size)
     return Error::success();
Expected<MSFLayout> MSFBuilder::generateLayout() {
   uint32_t NumDirectoryBlocks = bytesToBlocks(SB->NumDirectoryBytes, BlockSize);
   if (NumDirectoryBlocks > DirectoryBlocks.size()) {
     // Our hint wasn't enough to satisfy the entire directory.  Allocate
     // remaining pages.
     std::vector<uint32_t> ExtraBlocks;
     uint32_t NumExtraBlocks = NumDirectoryBlocks - DirectoryBlocks.size();
     ExtraBlocks.resize(NumExtraBlocks);
     if (auto EC = allocateBlocks(NumExtraBlocks, ExtraBlocks))
-      return std::move(EC);
+      return EC;
     DirectoryBlocks.insert(DirectoryBlocks.end(), ExtraBlocks.begin(),
                            ExtraBlocks.end());
   } else if (NumDirectoryBlocks < DirectoryBlocks.size()) {
     uint32_t NumUnnecessaryBlocks = DirectoryBlocks.size() - NumDirectoryBlocks;
     for (auto B :
          ArrayRef<uint32_t>(DirectoryBlocks).drop_back(NumUnnecessaryBlocks))
       FreeBlocks[B] = true;
     DirectoryBlocks.resize(NumDirectoryBlocks);
Expected<FileBufferByteStream> MSFBuilder::commit(StringRef Path,
   if (!L)
     return L.takeError();
 
   Layout = std::move(*L);
 
   uint64_t FileSize = Layout.SB->BlockSize * Layout.SB->NumBlocks;
   auto OutFileOrError = FileOutputBuffer::create(Path, FileSize);
   if (auto EC = OutFileOrError.takeError())
-    return std::move(EC);
+    return EC;
 
   FileBufferByteStream Buffer(std::move(*OutFileOrError),
                               llvm::support::little);
   BinaryStreamWriter Writer(Buffer);
 
   if (auto EC = Writer.writeObject(*Layout.SB))
-    return std::move(EC);
+    return EC;
 
   commitFpm(Buffer, Layout, Allocator);
 
   uint32_t BlockMapOffset =
       msf::blockToOffset(Layout.SB->BlockMapAddr, Layout.SB->BlockSize);
   Writer.setOffset(BlockMapOffset);
   if (auto EC = Writer.writeArray(Layout.DirectoryBlocks))
-    return std::move(EC);
+    return EC;
 
   auto DirStream = WritableMappedBlockStream::createDirectoryStream(
       Layout, Buffer, Allocator);
   BinaryStreamWriter DW(*DirStream);
   if (auto EC = DW.writeInteger<uint32_t>(Layout.StreamSizes.size()))
-    return std::move(EC);
+    return EC;
 
   if (auto EC = DW.writeArray(Layout.StreamSizes))
-    return std::move(EC);
+    return EC;
 
   for (const auto &Blocks : Layout.StreamMap) {
     if (auto EC = DW.writeArray(Blocks))
-      return std::move(EC);
+      return EC;
   }
 
-  return std::move(Buffer);
+  return Buffer;
 }

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

Expected<StringRef> DbiModuleList::getFileName(uint32_t Index) const {
   BinaryStreamReader Names(NamesBuffer);
   if (Index >= getSourceFileCount())
     return make_error<RawError>(raw_error_code::index_out_of_bounds);
 
   uint32_t FileOffset = FileNameOffsets[Index];
   Names.setOffset(FileOffset);
   StringRef Name;
   if (auto EC = Names.readCString(Name))
-    return std::move(EC);
+    return EC;
   return Name;
 }

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

 Expected<codeview::DebugChecksumsSubsectionRef>
 ModuleDebugStreamRef::findChecksumsSubsection() const {
   codeview::DebugChecksumsSubsectionRef Result;
   for (const auto &SS : subsections()) {
     if (SS.kind() != DebugSubsectionKind::FileChecksums)
       continue;
 
     if (auto EC = Result.initialize(SS.getRecordData()))
-      return std::move(EC);
+      return EC;
     return Result;
   }
   return Result;
 }

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

 
 Expected<std::string> readStreamData(BinaryStream &Stream, uint32_t Limit) {
   uint32_t Offset = 0, DataLength = std::min(Limit, Stream.getLength());
   std::string Result;
   Result.reserve(DataLength);
   while (Offset < DataLength) {
     ArrayRef<uint8_t> Data;
     if (auto E = Stream.readLongestContiguousChunk(Offset, Data))
-      return std::move(E);
+      return E;
     Data = Data.take_front(DataLength - Offset);
     Offset += Data.size();
     Result += toStringRef(Data);
   }
   return Result;
 }
 
 class NativeInjectedSource final : public IPDBInjectedSource {

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

 uint32_t PDBFile::getFileSize() const { return Buffer->getLength(); }
 
 Expected<ArrayRef<uint8_t>> PDBFile::getBlockData(uint32_t BlockIndex,
                                                   uint32_t NumBytes) const {
   uint64_t StreamBlockOffset = msf::blockToOffset(BlockIndex, getBlockSize());
 
   ArrayRef<uint8_t> Result;
   if (auto EC = Buffer->readBytes(StreamBlockOffset, NumBytes, Result))
-    return std::move(EC);
+    return EC;
   return Result;
 }
 
 Error PDBFile::setBlockData(uint32_t BlockIndex, uint32_t Offset,
                             ArrayRef<uint8_t> Data) const {
   return make_error<RawError>(raw_error_code::not_writable,
                               "PDBFile is immutable");
 }
if (!DbiS)
       return DbiS.takeError();
 
     auto GlobalS =
         safelyCreateIndexedStream(DbiS->getGlobalSymbolStreamIndex());
     if (!GlobalS)
       return GlobalS.takeError();
     auto TempGlobals = llvm::make_unique<GlobalsStream>(std::move(*GlobalS));
     if (auto EC = TempGlobals->reload())
-      return std::move(EC);
+      return EC;
     Globals = std::move(TempGlobals);
   }
   return *Globals;
 }
 
 Expected<InfoStream &> PDBFile::getPDBInfoStream() {
   if (!Info) {
     auto InfoS = safelyCreateIndexedStream(StreamPDB);
     if (!InfoS)
       return InfoS.takeError();
     auto TempInfo = llvm::make_unique<InfoStream>(std::move(*InfoS));
     if (auto EC = TempInfo->reload())
-      return std::move(EC);
+      return EC;
     Info = std::move(TempInfo);
   }
   return *Info;
 }
 
 Expected<DbiStream &> PDBFile::getPDBDbiStream() {
   if (!Dbi) {
     auto DbiS = safelyCreateIndexedStream(StreamDBI);
     if (!DbiS)
       return DbiS.takeError();
     auto TempDbi = llvm::make_unique<DbiStream>(std::move(*DbiS));
     if (auto EC = TempDbi->reload(this))
-      return std::move(EC);
+      return EC;
     Dbi = std::move(TempDbi);
   }
   return *Dbi;
 }
 
 Expected<TpiStream &> PDBFile::getPDBTpiStream() {
   if (!Tpi) {
     auto TpiS = safelyCreateIndexedStream(StreamTPI);
     if (!TpiS)
       return TpiS.takeError();
     auto TempTpi = llvm::make_unique<TpiStream>(*this, std::move(*TpiS));
     if (auto EC = TempTpi->reload())
-      return std::move(EC);
+      return EC;
     Tpi = std::move(TempTpi);
   }
   return *Tpi;
 }
 
 Expected<TpiStream &> PDBFile::getPDBIpiStream() {
   if (!Ipi) {
     if (!hasPDBIpiStream())
       return make_error<RawError>(raw_error_code::no_stream);
 
     auto IpiS = safelyCreateIndexedStream(StreamIPI);
     if (!IpiS)
       return IpiS.takeError();
     auto TempIpi = llvm::make_unique<TpiStream>(*this, std::move(*IpiS));
     if (auto EC = TempIpi->reload())
-      return std::move(EC);
+      return EC;
     Ipi = std::move(TempIpi);
   }
   return *Ipi;
 }
 
 Expected<PublicsStream &> PDBFile::getPDBPublicsStream() {
   if (!Publics) {
     auto DbiS = getPDBDbiStream();
     if (!DbiS)
       return DbiS.takeError();
 
     auto PublicS =
         safelyCreateIndexedStream(DbiS->getPublicSymbolStreamIndex());
     if (!PublicS)
       return PublicS.takeError();
     auto TempPublics = llvm::make_unique<PublicsStream>(std::move(*PublicS));
     if (auto EC = TempPublics->reload())
-      return std::move(EC);
+      return EC;
     Publics = std::move(TempPublics);
   }
   return *Publics;
 }
 
 Expected<SymbolStream &> PDBFile::getPDBSymbolStream() {
   if (!Symbols) {
     auto DbiS = getPDBDbiStream();
     if (!DbiS)
       return DbiS.takeError();
 
     uint32_t SymbolStreamNum = DbiS->getSymRecordStreamIndex();
     auto SymbolS = safelyCreateIndexedStream(SymbolStreamNum);
     if (!SymbolS)
       return SymbolS.takeError();
 
     auto TempSymbols = llvm::make_unique<SymbolStream>(std::move(*SymbolS));
     if (auto EC = TempSymbols->reload())
-      return std::move(EC);
+      return EC;
     Symbols = std::move(TempSymbols);
   }
   return *Symbols;
 }
 
 Expected<PDBStringTable &> PDBFile::getStringTable() {
   if (!Strings) {
     auto NS = safelyCreateNamedStream("/names");
     if (!NS)
       return NS.takeError();
 
     auto N = llvm::make_unique<PDBStringTable>();
     BinaryStreamReader Reader(**NS);
     if (auto EC = N->reload(Reader))
-      return std::move(EC);
+      return EC;
     assert(Reader.bytesRemaining() == 0);
     StringTableStream = std::move(*NS);
     Strings = std::move(N);
   }
   return *Strings;
 }
 
 Expected<InjectedSourceStream &> PDBFile::getInjectedSourceStream() {
   if (!InjectedSources) {
     auto IJS = safelyCreateNamedStream("/src/headerblock");
     if (!IJS)
       return IJS.takeError();
 
     auto Strings = getStringTable();
     if (!Strings)
       return Strings.takeError();
 
     auto IJ = llvm::make_unique<InjectedSourceStream>(std::move(*IJS));
     if (auto EC = IJ->reload(*Strings))
-      return std::move(EC);
+      return EC;
     InjectedSources = std::move(IJ);
   }
   return *InjectedSources;
 }
 
 uint32_t PDBFile::getPointerSize() {
   auto DbiS = getPDBDbiStream();
   if (!DbiS)

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

static uint32_t getHashForUdt(const TagRecord &Rec,
   return hashBufferV8(FullRecord);
 }
 
 template <typename T>
 static Expected<uint32_t> getHashForUdt(const CVType &Rec) {
   T Deserialized;
   if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
                                                Deserialized))
-    return std::move(E);
+    return E;
   return getHashForUdt(Deserialized, Rec.data());
 }
 
 template <typename T>
 static Expected<TagRecordHash> getTagRecordHashForUdt(const CVType &Rec) {
   T Deserialized;
   if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
                                                Deserialized))
-    return std::move(E);
+    return E;
 
   ClassOptions Opts = Deserialized.getOptions();
 
   bool ForwardRef = bool(Opts & ClassOptions::ForwardReference);
 
   uint32_t ThisRecordHash = getHashForUdt(Deserialized, Rec.data());
 
   // If we don't have a forward ref we can't compute the hash of it from the
static Expected<TagRecordHash> getTagRecordHashForUdt(const CVType &Rec) {
   return TagRecordHash{std::move(Deserialized), FullHash, ThisRecordHash};
 }
 
 template <typename T>
 static Expected<uint32_t> getSourceLineHash(const CVType &Rec) {
   T Deserialized;
   if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
                                                Deserialized))
-    return std::move(E);
+    return E;
   char Buf[4];
   support::endian::write32le(Buf, Deserialized.getUDT().getIndex());
   return hashStringV1(StringRef(Buf, 4));
 }
 
 Expected<TagRecordHash> llvm::pdb::hashTagRecord(const codeview::CVType &Type) {
   switch (Type.kind()) {
   case LF_CLASS:

llvm/lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

while (I != E) {
       }
       *J++ = I[-1];
     }
     S.erase(J, S.end());
   };
   Uniquify(Fs);
   Uniquify(Os);
 
-  return std::move(res);
+  return res;
 }
 
 SymbolizableObjectFile::SymbolizableObjectFile(const ObjectFile *Obj,
                                                std::unique_ptr<DIContext> DICtx)
     : Module(Obj), DebugInfoContext(std::move(DICtx)) {}
 
 namespace {
 

llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp

 
 Expected<EHFrameParser::AugmentationInfo>
 EHFrameParser::parseAugmentationString() {
   AugmentationInfo AugInfo;
   uint8_t NextChar;
   uint8_t *NextField = &AugInfo.Fields[0];
 
   if (auto Err = EHFrameReader.readInteger(NextChar))
-    return std::move(Err);
+    return Err;
 
   while (NextChar != 0) {
     switch (NextChar) {
     case 'z':
       AugInfo.AugmentationDataPresent = true;
       break;
     case 'e':
       if (auto Err = EHFrameReader.readInteger(NextChar))
-        return std::move(Err);
+        return Err;
       if (NextChar != 'h')
         return make_error<JITLinkError>("Unrecognized substring e" +
                                         Twine(NextChar) +
                                         " in augmentation string");
       AugInfo.EHDataFieldPresent = true;
       break;
     case 'L':
     case 'P':
     case 'R':
       *NextField++ = NextChar;
       break;
     default:
       return make_error<JITLinkError>("Unrecognized character " +
                                       Twine(NextChar) +
                                       " in augmentation string");
     }
 
     if (auto Err = EHFrameReader.readInteger(NextChar))
-      return std::move(Err);
+      return Err;
   }
 
-  return std::move(AugInfo);
+  return AugInfo;
 }
 
 Expected<JITTargetAddress> EHFrameParser::readAbsolutePointer() {
   static_assert(sizeof(JITTargetAddress) == sizeof(uint64_t),
                 "Result must be able to hold a uint64_t");
   JITTargetAddress Addr;
   if (G.getPointerSize() == 8) {
     if (auto Err = EHFrameReader.readInteger(Addr))
-      return std::move(Err);
+      return Err;
   } else if (G.getPointerSize() == 4) {
     uint32_t Addr32;
     if (auto Err = EHFrameReader.readInteger(Addr32))
-      return std::move(Err);
+      return Err;
     Addr = Addr32;
   } else
     llvm_unreachable("Pointer size is not 32-bit or 64-bit");
   return Addr;
 }
 
 Error EHFrameParser::processCIE() {
   // Use the dwarf namespace for convenient access to pointer encoding

llvm/lib/ExecutionEngine/JITLink/MachOAtomGraphBuilder.cpp

 
 namespace llvm {
 namespace jitlink {
 
 MachOAtomGraphBuilder::~MachOAtomGraphBuilder() {}
 
 Expected<std::unique_ptr<AtomGraph>> MachOAtomGraphBuilder::buildGraph() {
   if (auto Err = parseSections())
-    return std::move(Err);
+    return Err;
 
   if (auto Err = addAtoms())
-    return std::move(Err);
+    return Err;
 
   if (auto Err = addRelocations())
-    return std::move(Err);
+    return Err;
 
   return std::move(G);
 }
 
 MachOAtomGraphBuilder::MachOAtomGraphBuilder(const object::MachOObjectFile &Obj)
     : Obj(Obj),
       G(llvm::make_unique<AtomGraph>(Obj.getFileName(), getPointerSize(Obj),
                                      getEndianness(Obj))) {}

llvm/lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp

private:
   }
 
   mutable std::mutex SourceModuleMutex;
   CompileOnDemandLayer &Parent;
 };
 
 Optional<CompileOnDemandLayer::GlobalValueSet>
 CompileOnDemandLayer::compileRequested(GlobalValueSet Requested) {
-  return std::move(Requested);
+  return Requested;
 }
 
 Optional<CompileOnDemandLayer::GlobalValueSet>
 CompileOnDemandLayer::compileWholeModule(GlobalValueSet Requested) {
   return None;
 }
 
 CompileOnDemandLayer::CompileOnDemandLayer(
auto ExtractedTSM =
         auto PromotedGlobals = PromoteSymbols(M);
         if (!PromotedGlobals.empty()) {
           MangleAndInterner Mangle(ES, M.getDataLayout());
           SymbolFlagsMap SymbolFlags;
           for (auto &GV : PromotedGlobals)
             SymbolFlags[Mangle(GV->getName())] =
                 JITSymbolFlags::fromGlobalValue(*GV);
           if (auto Err = R.defineMaterializing(SymbolFlags))
-            return std::move(Err);
+            return Err;
         }
 
         expandPartition(*GVsToExtract);
 
         // Extract the requested partiton (plus any necessary aliases) and
         // put the rest back into the impl dylib.
         auto ShouldExtract = [&](const GlobalValue &GV) -> bool {
           return GVsToExtract->count(&GV);

llvm/lib/ExecutionEngine/Orc/CompileUtils.cpp

SimpleCompiler::CompileResult SimpleCompiler::operator()(Module &M) {
   auto ObjBuffer = llvm::make_unique<SmallVectorMemoryBuffer>(
       std::move(ObjBufferSV),
       "<in memory object compiled from " + M.getModuleIdentifier() + ">");
 
   auto Obj = object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
 
   if (Obj) {
     notifyObjectCompiled(M, *ObjBuffer);
-    return std::move(ObjBuffer);
+    return ObjBuffer;
   }
 
   // TODO: Actually report errors helpfully.
   consumeError(Obj.takeError());
   return nullptr;
 }
 
 SimpleCompiler::CompileResult

llvm/lib/ExecutionEngine/Orc/Core.cpp

if (DefGenerator && !Unresolved.empty()) {
         assert(NewDefs->empty() &&
                "All fallback defs should have been found by lookupImpl");
       }
     }
     return Error::success();
   });
 
   if (Err)
-    return std::move(Err);
+    return Err;
 
   assert((MUs.empty() || !QueryComplete) &&
          "If action flags are set, there should be no work to do (so no MUs)");
 
   if (QueryComplete)
     Q->handleComplete();
 
   // FIXME: Swap back to the old code below once RuntimeDyld works with
else {
     else
       reportError(std::move(Err));
   }
 
 #if LLVM_ENABLE_THREADS
   auto ResultFuture = PromisedResult.get_future();
   auto Result = ResultFuture.get();
   if (ResolutionError)
-    return std::move(ResolutionError);
-  return std::move(Result);
+    return ResolutionError;
+  return Result;
 
 #else
   if (ResolutionError)
     return std::move(ResolutionError);
 
   return Result;
 #endif
 }
#endif
   lookup(SearchOrder, Symbols, RequiredState, NotifyComplete,
          RegisterDependencies);
 
 #if LLVM_ENABLE_THREADS
   auto ResultFuture = PromisedResult.get_future();
   auto Result = ResultFuture.get();
 
   if (ResolutionError)
-    return std::move(ResolutionError);
+    return ResolutionError;
 
-  return std::move(Result);
+  return Result;
 
 #else
   if (ResolutionError)
     return std::move(ResolutionError);
 
   return Result;
 #endif
 }

llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h

addIRModule(LayerT &Layer, std::unique_ptr<Module> M,
     for (auto Dtor : orc::getDestructors(*M))
       DtorNames.push_back(mangle(Dtor.Func->getName()));
 
     // Add the module to the JIT.
     auto K = ES.allocateVModule();
     Resolvers[K] = std::make_shared<CBindingsResolver>(*this, ExternalResolver,
                                                        ExternalResolverCtx);
     if (auto Err = Layer.addModule(K, std::move(M)))
-      return std::move(Err);
+      return Err;
 
     KeyLayers[K] = detail::createGenericLayer(Layer);
 
     // Run the static constructors, and save the static destructor runner for
     // execution when the JIT is torn down.
     orc::LegacyCtorDtorRunner<OrcCBindingsStack> CtorRunner(
         AcknowledgeORCv1Deprecation, std::move(CtorNames), K);
     if (auto Err = CtorRunner.runViaLayer(*this))
-      return std::move(Err);
+      return Err;
 
     IRStaticDestructorRunners.emplace_back(AcknowledgeORCv1Deprecation,
                                            std::move(DtorNames), K);
 
     return K;
   }
 
   Expected<orc::VModuleKey>
Expected<orc::VModuleKey> addObject(std::unique_ptr<MemoryBuffer> ObjBuffer,
     if (auto Obj = object::ObjectFile::createObjectFile(
             ObjBuffer->getMemBufferRef())) {
 
       auto K = ES.allocateVModule();
       Resolvers[K] = std::make_shared<CBindingsResolver>(
           *this, ExternalResolver, ExternalResolverCtx);
 
       if (auto Err = ObjectLayer.addObject(K, std::move(ObjBuffer)))
-        return std::move(Err);
+        return Err;
 
       KeyLayers[K] = detail::createGenericLayer(ObjectLayer);
 
       return K;
     } else
       return Obj.takeError();
   }
 
Expected<JITTargetAddress> findSymbolAddress(const std::string &Name,
     if (auto Sym = findSymbol(Name, ExportedSymbolsOnly)) {
       // Successful lookup, non-null symbol:
       if (auto AddrOrErr = Sym.getAddress())
         return *AddrOrErr;
       else
         return AddrOrErr.takeError();
     } else if (auto Err = Sym.takeError()) {
       // Lookup failure - report error.
-      return std::move(Err);
+      return Err;
     }
 
     // No symbol not found. Return 0.
     return 0;
   }
 
   Expected<JITTargetAddress> findSymbolAddressIn(orc::VModuleKey K,
                                                  const std::string &Name,
                                                  bool ExportedSymbolsOnly) {
     if (auto Sym = findSymbolIn(K, Name, ExportedSymbolsOnly)) {
       // Successful lookup, non-null symbol:
       if (auto AddrOrErr = Sym.getAddress())
         return *AddrOrErr;
       else
         return AddrOrErr.takeError();
     } else if (auto Err = Sym.takeError()) {
       // Lookup failure - report error.
-      return std::move(Err);
+      return Err;
     }
 
     // Symbol not found. Return 0.
     return 0;
   }
 
   const std::string &getErrorMessage() const { return ErrMsg; }
 

llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp

LegacyJITSymbolResolver::getResponsibilitySet(const LookupSet &Symbols) {
   for (auto &Symbol : Symbols) {
     std::string SymName = Symbol.str();
     if (auto Sym = findSymbolInLogicalDylib(SymName)) {
       // If there's an existing def but it is not strong, then the caller is
       // responsible for it.
       if (!Sym.getFlags().isStrong())
         Result.insert(Symbol);
     } else if (auto Err = Sym.takeError())
-      return std::move(Err);
+      return Err;
     else {
       // If there is no existing definition then the caller is responsible for
       // it.
       Result.insert(Symbol);
     }
   }
 
-  return std::move(Result);
+  return Result;
 }

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

RuntimeDyldImpl::loadObjectImpl(const object::ObjectFile &Obj) {
   // and pass this information to the memory manager
   if (MemMgr.needsToReserveAllocationSpace()) {
     uint64_t CodeSize = 0, RODataSize = 0, RWDataSize = 0;
     uint32_t CodeAlign = 1, RODataAlign = 1, RWDataAlign = 1;
     if (auto Err = computeTotalAllocSize(Obj,
                                          CodeSize, CodeAlign,
                                          RODataSize, RODataAlign,
                                          RWDataSize, RWDataAlign))
-      return std::move(Err);
+      return Err;
     MemMgr.reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
                                   RWDataSize, RWDataAlign);
   }
 
   // Used sections from the object file
   ObjSectionToIDMap LocalSections;
 
   // Common symbols requiring allocation, with their sizes and alignments
if (Flags & SymbolRef::SF_Absolute &&
         return SIOrErr.takeError();
 
       if (SI == Obj.section_end())
         continue;
 
       // Get symbol offset.
       uint64_t SectOffset;
       if (auto Err = getOffset(*I, *SI, SectOffset))
-        return std::move(Err);
+        return Err;
 
       bool IsCode = SI->isText();
       unsigned SectionID;
       if (auto SectionIDOrErr =
               findOrEmitSection(Obj, *SI, IsCode, LocalSections))
         SectionID = *SectionIDOrErr;
       else
         return SectionIDOrErr.takeError();
 
       LLVM_DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name
                         << " SID: " << SectionID
                         << " Offset: " << format("%p", (uintptr_t)SectOffset)
                         << " flags: " << Flags << "\n");
       GlobalSymbolTable[Name] =
           SymbolTableEntry(SectionID, SectOffset, *JITSymFlags);
     }
   }
 
   // Allocate common symbols
   if (auto Err = emitCommonSymbols(Obj, CommonSymbolsToAllocate, CommonSize,
                                    CommonAlign))
-    return std::move(Err);
+    return Err;
 
   // Parse and process relocations
   LLVM_DEBUG(dbgs() << "Parse relocations:\n");
   for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
        SI != SE; ++SI) {
     StubMap Stubs;
     section_iterator RelocatedSection = SI->getRelocatedSection();
 
for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
         LLVM_DEBUG(dbgs() << "\tSectionID: " << (*SectionIDOrErr) << "\n");
       else
         return SectionIDOrErr.takeError();
     }
   }
 
   // Give the subclasses a chance to tie-up any loose ends.
   if (auto Err = finalizeLoad(Obj, LocalSections))
-    return std::move(Err);
+    return Err;
 
 //   for (auto E : LocalSections)
 //     llvm::dbgs() << "Added: " << E.first.getRawDataRefImpl() << " -> " << E.second << "\n";
 
   return LocalSections;
 }
 
 // A helper method for computeTotalAllocSize.

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

DyldELFObject<ELFT>::DyldELFObject(ELFObjectFile<ELFT> &&Obj)
   this->isDyldELFObject = true;
 }
 
 template <class ELFT>
 Expected<std::unique_ptr<DyldELFObject<ELFT>>>
 DyldELFObject<ELFT>::create(MemoryBufferRef Wrapper) {
   auto Obj = ELFObjectFile<ELFT>::create(Wrapper);
   if (auto E = Obj.takeError())
-    return std::move(E);
+    return E;
   std::unique_ptr<DyldELFObject<ELFT>> Ret(
       new DyldELFObject<ELFT>(std::move(*Obj)));
-  return std::move(Ret);
+  return Ret;
 }
 
 template <class ELFT>
 void DyldELFObject<ELFT>::updateSectionAddress(const SectionRef &Sec,
                                                uint64_t Addr) {
   DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
   Elf_Shdr *shdr =
       const_cast<Elf_Shdr *>(reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));

 createRTDyldELFObject(MemoryBufferRef Buffer, const ObjectFile &SourceObject,
                       const LoadedELFObjectInfo &L) {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::uint addr_type;
 
   Expected<std::unique_ptr<DyldELFObject<ELFT>>> ObjOrErr =
       DyldELFObject<ELFT>::create(Buffer);
   if (Error E = ObjOrErr.takeError())
-    return std::move(E);
+    return E;
 
   std::unique_ptr<DyldELFObject<ELFT>> Obj = std::move(*ObjOrErr);
 
   // Iterate over all sections in the object.
   auto SI = SourceObject.section_begin();
   for (const auto &Sec : Obj->sections()) {
     StringRef SectionName;
     Sec.getName(SectionName);
     if (SectionName != "") {
       DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
       Elf_Shdr *shdr = const_cast<Elf_Shdr *>(
           reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
 
       if (uint64_t SecLoadAddr = L.getSectionLoadAddress(*SI)) {
         // This assumes that the address passed in matches the target address
         // bitness. The template-based type cast handles everything else.
         shdr->sh_addr = static_cast<addr_type>(SecLoadAddr);
       }
     }
     ++SI;
   }
 
-  return std::move(Obj);
+  return Obj;
 }
 
 static OwningBinary<ObjectFile>
 createELFDebugObject(const ObjectFile &Obj, const LoadedELFObjectInfo &L) {
   assert(Obj.isELF() && "Not an ELF object file.");
 
   std::unique_ptr<MemoryBuffer> Buffer =
     MemoryBuffer::getMemBufferCopy(Obj.getData(), Obj.getFileName());
if (RelType == ELF::R_PPC64_REL24) {
       bool RangeOverflow = false;
       bool IsExtern = Value.SymbolName || SymType == SymbolRef::ST_Unknown;
       if (!IsExtern) {
         if (AbiVariant != 2) {
           // In the ELFv1 ABI, a function call may point to the .opd entry,
           // so the final symbol value is calculated based on the relocation
           // values in the .opd section.
           if (auto Err = findOPDEntrySection(Obj, ObjSectionToID, Value))
-            return std::move(Err);
+            return Err;
         } else {
           // In the ELFv2 ABI, a function symbol may provide a local entry
           // point, which must be used for direct calls.
           if (Value.SectionID == SectionID){
             uint8_t SymOther = Symbol->getOther();
             Value.Addend += ELF::decodePPC64LocalEntryOffset(SymOther);
           }
         }
if (RelType == ELF::R_PPC64_REL24) {
       case ELF::R_PPC64_TOC16_LO_DS: RelType = ELF::R_PPC64_ADDR16_LO_DS; break;
       case ELF::R_PPC64_TOC16_HI: RelType = ELF::R_PPC64_ADDR16_HI; break;
       case ELF::R_PPC64_TOC16_HA: RelType = ELF::R_PPC64_ADDR16_HA; break;
       default: llvm_unreachable("Wrong relocation type.");
       }
 
       RelocationValueRef TOCValue;
       if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, TOCValue))
-        return std::move(Err);
+        return Err;
       if (Value.SymbolName || Value.SectionID != TOCValue.SectionID)
         llvm_unreachable("Unsupported TOC relocation.");
       Value.Addend -= TOCValue.Addend;
       resolveRelocation(Sections[SectionID], Offset, Value.Addend, RelType, 0);
     } else {
       // There are two ways to refer to the TOC address directly: either
       // via a ELF::R_PPC64_TOC relocation (where both symbol and addend are
       // ignored), or via any relocation that refers to the magic ".TOC."
       // symbols (in which case the addend is respected).
       if (RelType == ELF::R_PPC64_TOC) {
         RelType = ELF::R_PPC64_ADDR64;
         if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, Value))
-          return std::move(Err);
+          return Err;
       } else if (TargetName == ".TOC.") {
         if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, Value))
-          return std::move(Err);
+          return Err;
         Value.Addend += Addend;
       }
 
       RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
 
       if (Value.SymbolName)
         addRelocationForSymbol(RE, Value.SymbolName);
       else

llvm/lib/IR/RemarkStreamer.cpp

llvm::setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
 
   Context.setRemarkStreamer(llvm::make_unique<RemarkStreamer>(
       RemarksFilename, std::move(*RemarkSerializer)));
 
   if (!RemarksPasses.empty())
     if (Error E = Context.getRemarkStreamer()->setFilter(RemarksPasses))
       return make_error<RemarkSetupPatternError>(std::move(E));
 
-  return std::move(RemarksFile);
+  return RemarksFile;
 }

llvm/lib/LTO/LTO.cpp

for (const irsymtab::Reader::SymbolRef &Sym :
       // to match the one in Skip() in LTO::addRegularLTO().
       if (Sym.isGlobal() && !Sym.isFormatSpecific())
         File->Symbols.push_back(Sym);
     File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
   }
 
   File->Mods = FOrErr->Mods;
   File->Strtab = std::move(FOrErr->Strtab);
-  return std::move(File);
+  return File;
 }
 
 StringRef InputFile::getName() const {
   return Mods[0].getModuleIdentifier();
 }
 
 BitcodeModule &InputFile::getSingleBitcodeModule() {
   assert(Mods.size() == 1 && "Expect only one bitcode module");
Expected<std::unique_ptr<Module>> MOrErr =
       BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true,
                        /*IsImporting*/ false);
   if (!MOrErr)
     return MOrErr.takeError();
   Module &M = **MOrErr;
   Mod.M = std::move(*MOrErr);
 
   if (Error Err = M.materializeMetadata())
-    return std::move(Err);
+    return Err;
   UpgradeDebugInfo(M);
 
   ModuleSymbolTable SymTab;
   SymTab.addModule(&M);
 
   for (GlobalVariable &GV : M.globals())
     if (GV.hasAppendingLinkage())
       Mod.Keep.push_back(&GV);
if (Sym.isCommon()) {
       CommonRes.Prevailing |= Res.Prevailing;
     }
 
   }
   if (!M.getComdatSymbolTable().empty())
     for (GlobalValue &GV : M.global_values())
       handleNonPrevailingComdat(GV, NonPrevailingComdats);
   assert(MsymI == MsymE);
-  return std::move(Mod);
+  return Mod;
 }
 
 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
                           bool LivenessFromIndex) {
   std::vector<GlobalValue *> Keep;
   for (GlobalValue *GV : Mod.Keep) {
     if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
       continue;
lto::setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
                               bool RemarksWithHotness, int Count) {
   std::string Filename = RemarksFilename;
   if (!Filename.empty() && Count != -1)
     Filename += ".thin." + llvm::utostr(Count) + ".yaml";
 
   auto ResultOrErr = llvm::setupOptimizationRemarks(
       Context, Filename, RemarksPasses, RemarksFormat, RemarksWithHotness);
   if (Error E = ResultOrErr.takeError())
-    return std::move(E);
+    return E;
 
   if (*ResultOrErr)
     (*ResultOrErr)->keep();
 
   return ResultOrErr;
 }
 
 Expected<std::unique_ptr<ToolOutputFile>>
 lto::setupStatsFile(StringRef StatsFilename) {
   // Setup output file to emit statistics.
   if (StatsFilename.empty())
     return nullptr;
 
   llvm::EnableStatistics(false);
   std::error_code EC;
   auto StatsFile =
       llvm::make_unique<ToolOutputFile>(StatsFilename, EC, sys::fs::OF_None);
   if (EC)
     return errorCodeToError(EC);
 
   StatsFile->keep();
-  return std::move(StatsFile);
+  return StatsFile;
 }

llvm/lib/LTO/LTOModule.cpp

LTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
 
   TargetMachine *target =
       march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None);
 
   std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target));
   Ret->parseSymbols();
   Ret->parseMetadata();
 
-  return std::move(Ret);
+  return Ret;
 }
 
 /// Create a MemoryBuffer from a memory range with an optional name.
 std::unique_ptr<MemoryBuffer>
 LTOModule::makeBuffer(const void *mem, size_t length, StringRef name) {
   const char *startPtr = (const char*)mem;
   return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false);
 }

llvm/lib/MCA/InstrBuilder.cpp

InstrBuilder::createInstrDescImpl(const MCInst &MCI) {
   ID->HasSideEffects = MCDesc.hasUnmodeledSideEffects();
   ID->BeginGroup = SCDesc.BeginGroup;
   ID->EndGroup = SCDesc.EndGroup;
 
   initializeUsedResources(*ID, SCDesc, STI, ProcResourceMasks);
   computeMaxLatency(*ID, MCDesc, SCDesc, STI);
 
   if (Error Err = verifyOperands(MCDesc, MCI))
-    return std::move(Err);
+    return Err;
 
   populateWrites(*ID, MCI, SchedClassID);
   populateReads(*ID, MCI, SchedClassID);
 
   LLVM_DEBUG(dbgs() << "\t\tMaxLatency=" << ID->MaxLatency << '\n');
   LLVM_DEBUG(dbgs() << "\t\tNumMicroOps=" << ID->NumMicroOps << '\n');
 
   // Sanity check on the instruction descriptor.
   if (Error Err = verifyInstrDesc(*ID, MCI))
-    return std::move(Err);
+    return Err;
 
   // Now add the new descriptor.
   bool IsVariadic = MCDesc.isVariadic();
   if (!IsVariadic && !IsVariant) {
     Descriptors[MCI.getOpcode()] = std::move(ID);
     return *Descriptors[MCI.getOpcode()];
   }
 
if (IsDepBreaking) {
             RS.setIndependentFromDef();
         }
       }
     }
   }
 
   // Early exit if there are no writes.
   if (D.Writes.empty())
-    return std::move(NewIS);
+    return NewIS;
 
   // Track register writes that implicitly clear the upper portion of the
   // underlying super-registers using an APInt.
   APInt WriteMask(D.Writes.size(), 0);
 
   // Now query the MCInstrAnalysis object to obtain information about which
   // register writes implicitly clear the upper portion of a super-register.
   if (MCIA)
for (const WriteDescriptor &WD : D.Writes) {
 
     assert(RegID && "Expected a valid register ID!");
     NewIS->getDefs().emplace_back(WD, RegID,
                                   /* ClearsSuperRegs */ WriteMask[WriteIndex],
                                   /* WritesZero */ IsZeroIdiom);
     ++WriteIndex;
   }
 
-  return std::move(NewIS);
+  return NewIS;
 }
 } // namespace mca
 } // namespace llvm

llvm/lib/MCA/Pipeline.cpp

 }
 
 Expected<unsigned> Pipeline::run() {
   assert(!Stages.empty() && "Unexpected empty pipeline found!");
 
   do {
     notifyCycleBegin();
     if (Error Err = runCycle())
-      return std::move(Err);
+      return Err;
     notifyCycleEnd();
     ++Cycles;
   } while (hasWorkToProcess());
 
   return Cycles;
 }
 
 Error Pipeline::runCycle() {

llvm/lib/Object/Archive.cpp

if (!NameOrErr) {
       return malformedError(Msg + "at offset " + Twine(Offset));
     } else
       return malformedError(Msg + NameOrErr.get());
   }
 
   Error Err = Error::success();
   Child Ret(Parent, NextLoc, &Err);
   if (Err)
-    return std::move(Err);
+    return Err;
   return Ret;
 }
 
 uint64_t Archive::Child::getChildOffset() const {
   const char *a = Parent->Data.getBuffer().data();
   const char *c = Data.data();
   uint64_t offset = c - a;
   return offset;
if (BinaryOrErr)
     return std::move(*BinaryOrErr);
   return BinaryOrErr.takeError();
 }
 
 Expected<std::unique_ptr<Archive>> Archive::create(MemoryBufferRef Source) {
   Error Err = Error::success();
   std::unique_ptr<Archive> Ret(new Archive(Source, Err));
   if (Err)
-    return std::move(Err);
-  return std::move(Ret);
+    return Err;
+  return Ret;
 }
 
 void Archive::setFirstRegular(const Child &C) {
   FirstRegularData = C.Data;
   FirstRegularStartOfFile = C.StartOfFile;
 }
 
 Archive::Archive(MemoryBufferRef Source, Error &Err)
if (Parent->kind() == K_GNU) {
 
     Offset = read32le(Offsets + OffsetIndex * 4);
   }
 
   const char *Loc = Parent->getData().begin() + Offset;
   Error Err = Error::success();
   Child C(Parent, Loc, &Err);
   if (Err)
-    return std::move(Err);
+    return Err;
   return C;
 }
 
 Archive::Symbol Archive::Symbol::getNext() const {
   Symbol t(*this);
   if (Parent->kind() == K_BSD) {
     // t.StringIndex is an offset from the start of the __.SYMDEF or
     // "__.SYMDEF SORTED" member into the string table for the ranlib

llvm/lib/Object/ArchiveWriter.cpp

if (!Deterministic) {
     if (!GIDOrErr)
       return GIDOrErr.takeError();
     M.GID = GIDOrErr.get();
     Expected<sys::fs::perms> AccessModeOrErr = OldMember.getAccessMode();
     if (!AccessModeOrErr)
       return AccessModeOrErr.takeError();
     M.Perms = AccessModeOrErr.get();
   }
-  return std::move(M);
+  return M;
 }
 
 Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName,
                                                      bool Deterministic) {
   sys::fs::file_status Status;
   auto FDOrErr = sys::fs::openNativeFileForRead(FileName);
   if (!FDOrErr)
     return FDOrErr.takeError();
Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName,
   M.MemberName = M.Buf->getBufferIdentifier();
   if (!Deterministic) {
     M.ModTime = std::chrono::time_point_cast<std::chrono::seconds>(
         Status.getLastModificationTime());
     M.UID = Status.getUser();
     M.GID = Status.getGroup();
     M.Perms = Status.permissions();
   }
-  return std::move(M);
+  return M;
 }
 
 template <typename T>
 static void printWithSpacePadding(raw_ostream &OS, T Data, unsigned Size) {
   uint64_t OldPos = OS.tell();
   OS << Data;
   unsigned SizeSoFar = OS.tell() - OldPos;
   assert(SizeSoFar <= Size && "Data doesn't fit in Size");
getSymbols(MemoryBufferRef Buf, raw_ostream &SymNames, bool &HasObject) {
   }
 
   HasObject = true;
   for (const object::BasicSymbolRef &S : Obj->symbols()) {
     if (!isArchiveSymbol(S))
       continue;
     Ret.push_back(SymNames.tell());
     if (Error E = S.printName(SymNames))
-      return std::move(E);
+      return E;
     SymNames << '\0';
   }
   return Ret;
 }
 
 static Expected<std::vector<MemberData>>
 computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames,
                   object::Archive::Kind Kind, bool Thin, bool Deterministic,
for (const NewArchiveMember &M : NewMembers) {
 
     printMemberHeader(Out, Pos, StringTable, MemberNames, Kind, Thin, M,
                       ModTime, Size);
     Out.flush();
 
     Expected<std::vector<unsigned>> Symbols =
         getSymbols(Buf, SymNames, HasObject);
     if (auto E = Symbols.takeError())
-      return std::move(E);
+      return E;
 
     Pos += Header.size() + Data.size() + Padding.size();
     Ret.push_back({std::move(*Symbols), std::move(Header), Data, Padding});
   }
   // If there are no symbols, emit an empty symbol table, to satisfy Solaris
   // tools, older versions of which expect a symbol table in a non-empty
   // archive, regardless of whether there are any symbols in it.
   if (HasObject && SymNames.tell() == 0)

llvm/lib/Object/COFFModuleDefinition.cpp

 class Parser {
 public:
   explicit Parser(StringRef S, MachineTypes M, bool B)
       : Lex(S), Machine(M), MingwDef(B) {}
 
   Expected<COFFModuleDefinition> parse() {
     do {
       if (Error Err = parseOne())
-        return std::move(Err);
+        return Err;
     } while (Tok.K != Eof);
     return Info;
   }
 
 private:
   void read() {
     if (Stack.empty()) {
       Tok = Lex.lex();

llvm/lib/Object/COFFObjectFile.cpp

uint64_t COFFObjectFile::getSectionSize(DataRefImpl Ref) const {
   return getSectionSize(toSec(Ref));
 }
 
 Expected<ArrayRef<uint8_t>>
 COFFObjectFile::getSectionContents(DataRefImpl Ref) const {
   const coff_section *Sec = toSec(Ref);
   ArrayRef<uint8_t> Res;
   if (Error E = getSectionContents(Sec, Res))
-    return std::move(E);
+    return E;
   return Res;
 }
 
 uint64_t COFFObjectFile::getSectionAlignment(DataRefImpl Ref) const {
   const coff_section *Sec = toSec(Ref);
   return Sec->getAlignment();
 }
 

 }
 
 Expected<std::unique_ptr<COFFObjectFile>>
 ObjectFile::createCOFFObjectFile(MemoryBufferRef Object) {
   std::error_code EC;
   std::unique_ptr<COFFObjectFile> Ret(new COFFObjectFile(Object, EC));
   if (EC)
     return errorCodeToError(EC);
-  return std::move(Ret);
+  return Ret;
 }
 
 bool BaseRelocRef::operator==(const BaseRelocRef &Other) const {
   return Header == Other.Header && Index == Other.Index;
 }
 
 void BaseRelocRef::moveNext() {
   // Header->BlockSize is the size of the current block, including the

llvm/lib/Object/Decompressor.cpp

Expected<Decompressor> Decompressor::create(StringRef Name, StringRef Data,
                                             bool IsLE, bool Is64Bit) {
   if (!zlib::isAvailable())
     return createError("zlib is not available");
 
   Decompressor D(Data);
   Error Err = isGnuStyle(Name) ? D.consumeCompressedGnuHeader()
                                : D.consumeCompressedZLibHeader(Is64Bit, IsLE);
   if (Err)
-    return std::move(Err);
+    return Err;
   return D;
 }
 
 Decompressor::Decompressor(StringRef Data)
     : SectionData(Data), DecompressedSize(0) {}
 
 Error Decompressor::consumeCompressedGnuHeader() {
   if (!SectionData.startswith("ZLIB"))

llvm/lib/Object/ELFObjectFile.cpp

 ELFObjectFileBase::ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)
     : ObjectFile(Type, Source) {}
 
 template <class ELFT>
 static Expected<std::unique_ptr<ELFObjectFile<ELFT>>>
 createPtr(MemoryBufferRef Object) {
   auto Ret = ELFObjectFile<ELFT>::create(Object);
   if (Error E = Ret.takeError())
-    return std::move(E);
+    return E;
   return make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
 }
 
 Expected<std::unique_ptr<ObjectFile>>
 ObjectFile::createELFObjectFile(MemoryBufferRef Obj) {
   std::pair<unsigned char, unsigned char> Ident =
       getElfArchType(Obj.getBuffer());
   std::size_t MaxAlignment =

llvm/lib/Object/IRObjectFile.cpp

Expected<IRSymtabFile> object::readIRSymtab(MemoryBufferRef MBRef) {
   Expected<irsymtab::FileContents> FCOrErr = irsymtab::readBitcode(*BFCOrErr);
   if (!FCOrErr)
     return FCOrErr.takeError();
 
   F.Mods = std::move(BFCOrErr->Mods);
   F.Symtab = std::move(FCOrErr->Symtab);
   F.Strtab = std::move(FCOrErr->Strtab);
   F.TheReader = std::move(FCOrErr->TheReader);
-  return std::move(F);
+  return F;
 }

llvm/lib/Object/IRSymtab.cpp

for (auto BM : BMs) {
 
     Mods.push_back(MOrErr->get());
     OwnedMods.push_back(std::move(*MOrErr));
   }
 
   StringTableBuilder StrtabBuilder(StringTableBuilder::RAW);
   BumpPtrAllocator Alloc;
   if (Error E = build(Mods, FC.Symtab, StrtabBuilder, Alloc))
-    return std::move(E);
+    return E;
 
   StrtabBuilder.finalizeInOrder();
   FC.Strtab.resize(StrtabBuilder.getSize());
   StrtabBuilder.write((uint8_t *)FC.Strtab.data());
 
   FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},
                   {FC.Strtab.data(), FC.Strtab.size()}};
-  return std::move(FC);
+  return FC;
 }
 
 Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {
   if (BFC.Mods.empty())
     return make_error<StringError>("Bitcode file does not contain any modules",
                                    inconvertibleErrorCode());
 
   if (BFC.StrtabForSymtab.empty() ||
Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {
 
   // Finally, make sure that the number of modules in the symbol table matches
   // the number of modules in the bitcode file. If they differ, it may mean that
   // the bitcode file was created by binary concatenation, so we need to create
   // a new symbol table from scratch.
   if (FC.TheReader.getNumModules() != BFC.Mods.size())
     return upgrade(std::move(BFC.Mods));
 
-  return std::move(FC);
+  return FC;
 }

llvm/lib/Object/MachOObjectFile.cpp

MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
                         bool Is64Bits, uint32_t UniversalCputype,
                         uint32_t UniversalIndex) {
   Error Err = Error::success();
   std::unique_ptr<MachOObjectFile> Obj(
       new MachOObjectFile(std::move(Object), IsLittleEndian,
                           Is64Bits, Err, UniversalCputype,
                           UniversalIndex));
   if (Err)
-    return std::move(Err);
-  return std::move(Obj);
+    return Err;
+  return Obj;
 }
 
 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
                                  bool Is64bits, Error &Err,
                                  uint32_t UniversalCputype,
                                  uint32_t UniversalIndex)
     : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object) {
   ErrorAsOutParameter ErrAsOutParam(&Err);

llvm/lib/Object/MachOUniversal.cpp

 void MachOUniversalBinary::anchor() { }
 
 Expected<std::unique_ptr<MachOUniversalBinary>>
 MachOUniversalBinary::create(MemoryBufferRef Source) {
   Error Err = Error::success();
   std::unique_ptr<MachOUniversalBinary> Ret(
       new MachOUniversalBinary(Source, Err));
   if (Err)
-    return std::move(Err);
-  return std::move(Ret);
+    return Err;
+  return Ret;
 }
 
 MachOUniversalBinary::MachOUniversalBinary(MemoryBufferRef Source, Error &Err)
     : Binary(Binary::ID_MachOUniversalBinary, Source), Magic(0),
       NumberOfObjects(0) {
   ErrorAsOutParameter ErrAsOutParam(&Err);
   if (Data.getBufferSize() < sizeof(MachO::fat_header)) {
     Err = make_error<GenericBinaryError>("File too small to be a Mach-O "

llvm/lib/Object/ObjectFile.cpp

ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFile(ObjectPath);
   if (std::error_code EC = FileOrErr.getError())
     return errorCodeToError(EC);
   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);
+    return Err;
   std::unique_ptr<ObjectFile> Obj = std::move(ObjOrErr.get());
 
   return OwningBinary<ObjectFile>(std::move(Obj), std::move(Buffer));
 }

llvm/lib/Object/SymbolicFile.cpp

SymbolicFile::createSymbolicFile(MemoryBufferRef Object, file_magic Type,
   case file_magic::coff_import_library:
     return std::unique_ptr<SymbolicFile>(new COFFImportFile(Object));
   case file_magic::elf_relocatable:
   case file_magic::macho_object:
   case file_magic::coff_object: {
     Expected<std::unique_ptr<ObjectFile>> Obj =
         ObjectFile::createObjectFile(Object, Type);
     if (!Obj || !Context)
-      return std::move(Obj);
+      return Obj;
 
     Expected<MemoryBufferRef> BCData =
         IRObjectFile::findBitcodeInObject(*Obj->get());
     if (!BCData) {
       consumeError(BCData.takeError());
-      return std::move(Obj);
+      return Obj;
     }
 
     return IRObjectFile::create(
         MemoryBufferRef(BCData->getBuffer(), Object.getBufferIdentifier()),
         *Context);
   }
   }
   llvm_unreachable("Unexpected Binary File Type");
 }

llvm/lib/Object/WasmObjectFile.cpp

 LLVM_DUMP_METHOD void WasmSymbol::dump() const { print(dbgs()); }
 #endif
 
 Expected<std::unique_ptr<WasmObjectFile>>
 ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
   Error Err = Error::success();
   auto ObjectFile = llvm::make_unique<WasmObjectFile>(Buffer, Err);
   if (Err)
-    return std::move(Err);
+    return Err;
 
-  return std::move(ObjectFile);
+  return ObjectFile;
 }
 
 #define VARINT7_MAX ((1 << 7) - 1)
 #define VARINT7_MIN (-(1 << 7))
 #define VARUINT7_MAX (1 << 7)
 #define VARUINT1_MAX (1)
 
 static uint8_t readUint8(WasmObjectFile::ReadContext &Ctx) {

llvm/lib/Object/WindowsResource.cpp

 // static
 Expected<std::unique_ptr<WindowsResource>>
 WindowsResource::createWindowsResource(MemoryBufferRef Source) {
   if (Source.getBufferSize() < WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE)
     return make_error<GenericBinaryError>(
         Source.getBufferIdentifier() + ": too small to be a resource file",
         object_error::invalid_file_type);
   std::unique_ptr<WindowsResource> Ret(new WindowsResource(Source));
-  return std::move(Ret);
+  return Ret;
 }
 
 Expected<ResourceEntryRef> WindowsResource::getHeadEntry() {
   if (BBS.getLength() < sizeof(WinResHeaderPrefix) + sizeof(WinResHeaderSuffix))
     return make_error<EmptyResError>(getFileName() + " contains no entries",
                                      object_error::unexpected_eof);
   return ResourceEntryRef::create(BinaryStreamRef(BBS), this);
 }
 
 ResourceEntryRef::ResourceEntryRef(BinaryStreamRef Ref,
                                    const WindowsResource *Owner)
     : Reader(Ref), Owner(Owner) {}
 
 Expected<ResourceEntryRef>
 ResourceEntryRef::create(BinaryStreamRef BSR, const WindowsResource *Owner) {
   auto Ref = ResourceEntryRef(BSR, Owner);
   if (auto E = Ref.loadNext())
-    return std::move(E);
+    return E;
   return Ref;
 }
 
 Error ResourceEntryRef::moveNext(bool &End) {
   // Reached end of all the entries.
   if (Reader.bytesRemaining() == 0) {
     End = true;
     return Error::success();

 
 Expected<std::unique_ptr<MemoryBuffer>>
 writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
                          const WindowsResourceParser &Parser,
                          uint32_t TimeDateStamp) {
   Error E = Error::success();
   WindowsResourceCOFFWriter Writer(MachineType, Parser, E);
   if (E)
-    return std::move(E);
+    return E;
   return Writer.write(TimeDateStamp);
 }
 
 } // namespace object
 } // namespace llvm

llvm/lib/Object/XCOFFObjectFile.cpp

XCOFFObjectFile::parseStringTable(const XCOFFObjectFile *Obj, uint64_t Offset) {
   // If the size is less then 4, then the string table is just a size and no
   // string data.
   if (Size <= 4)
     return XCOFFStringTable{4, nullptr};
 
   auto StringTableOrErr =
       getObject<char>(Obj->Data, Obj->base() + Offset, Size);
   if (Error E = StringTableOrErr.takeError())
-    return std::move(E);
+    return E;
 
   const char *StringTablePtr = StringTableOrErr.get();
   if (StringTablePtr[Size - 1] != '\0')
     return errorCodeToError(object_error::string_table_non_null_end);
 
   return XCOFFStringTable{Size, StringTablePtr};
 }
 
 Expected<std::unique_ptr<XCOFFObjectFile>>
 XCOFFObjectFile::create(unsigned Type, MemoryBufferRef MBR) {
   // Can't use make_unique because of the private constructor.
   std::unique_ptr<XCOFFObjectFile> Obj;
   Obj.reset(new XCOFFObjectFile(Type, MBR));
 
   uint64_t CurOffset = 0;
   const auto *Base = Obj->base();
   MemoryBufferRef Data = Obj->Data;
 
   // Parse file header.
   auto FileHeaderOrErr =
       getObject<void>(Data, Base + CurOffset, Obj->getFileHeaderSize());
   if (Error E = FileHeaderOrErr.takeError())
-    return std::move(E);
+    return E;
   Obj->FileHeader = FileHeaderOrErr.get();
 
   CurOffset += Obj->getFileHeaderSize();
   // TODO FIXME we don't have support for an optional header yet, so just skip
   // past it.
   CurOffset += Obj->getOptionalHeaderSize();
 
   // Parse the section header table if it is present.
   if (Obj->getNumberOfSections()) {
     auto SecHeadersOrErr = getObject<void>(Data, Base + CurOffset,
                                            Obj->getNumberOfSections() *
                                                Obj->getSectionHeaderSize());
     if (Error E = SecHeadersOrErr.takeError())
-      return std::move(E);
+      return E;
     Obj->SectionHeaderTable = SecHeadersOrErr.get();
   }
 
   // 64-bit object supports only file header and section headers for now.
   if (Obj->is64Bit())
-    return std::move(Obj);
+    return Obj;
 
   // If there is no symbol table we are done parsing the memory buffer.
   if (Obj->getLogicalNumberOfSymbolTableEntries32() == 0)
-    return std::move(Obj);
+    return Obj;
 
   // Parse symbol table.
   CurOffset = Obj->fileHeader32()->SymbolTableOffset;
   uint64_t SymbolTableSize = (uint64_t)(sizeof(XCOFFSymbolEntry)) *
                              Obj->getLogicalNumberOfSymbolTableEntries32();
   auto SymTableOrErr =
       getObject<XCOFFSymbolEntry>(Data, Base + CurOffset, SymbolTableSize);
   if (Error E = SymTableOrErr.takeError())
-    return std::move(E);
+    return E;
   Obj->SymbolTblPtr = SymTableOrErr.get();
   CurOffset += SymbolTableSize;
 
   // Parse String table.
   Expected<XCOFFStringTable> StringTableOrErr =
       parseStringTable(Obj.get(), CurOffset);
   if (Error E = StringTableOrErr.takeError())
-    return std::move(E);
+    return E;
   Obj->StringTable = StringTableOrErr.get();
 
-  return std::move(Obj);
+  return Obj;
 }
 
 Expected<std::unique_ptr<ObjectFile>>
 ObjectFile::createXCOFFObjectFile(MemoryBufferRef MemBufRef,
                                   unsigned FileType) {
   return XCOFFObjectFile::create(FileType, MemBufRef);
 }
 

llvm/lib/ObjectYAML/CodeViewYAMLDebugSections.cpp

 Expected<std::shared_ptr<YAMLStringTableSubsection>>
 YAMLStringTableSubsection::fromCodeViewSubsection(
     const DebugStringTableSubsectionRef &Strings) {
   auto Result = std::make_shared<YAMLStringTableSubsection>();
   BinaryStreamReader Reader(Strings.getBuffer());
   StringRef S;
   // First item is a single null string, skip it.
   if (auto EC = Reader.readCString(S))
-    return std::move(EC);
+    return EC;
   assert(S.empty());
   while (Reader.bytesRemaining() > 0) {
     if (auto EC = Reader.readCString(S))
-      return std::move(EC);
+      return EC;
     Result->Strings.push_back(S);
   }
   return Result;
 }
 
 Expected<std::shared_ptr<YAMLFrameDataSubsection>>
 YAMLFrameDataSubsection::fromCodeViewSubsection(
     const DebugStringTableSubsectionRef &Strings,

 }
 
 Expected<std::vector<std::shared_ptr<DebugSubsection>>>
 llvm::CodeViewYAML::toCodeViewSubsectionList(
     BumpPtrAllocator &Allocator, ArrayRef<YAMLDebugSubsection> Subsections,
     const codeview::StringsAndChecksums &SC) {
   std::vector<std::shared_ptr<DebugSubsection>> Result;
   if (Subsections.empty())
-    return std::move(Result);
+    return Result;
 
   for (const auto &SS : Subsections) {
     std::shared_ptr<DebugSubsection> CVS;
     CVS = SS.Subsection->toCodeViewSubsection(Allocator, SC);
     assert(CVS != nullptr);
     Result.push_back(std::move(CVS));
   }
-  return std::move(Result);
+  return Result;
 }
 
 namespace {
 
 struct SubsectionConversionVisitor : public DebugSubsectionVisitor {
   SubsectionConversionVisitor() = default;
 
   Error visitUnknown(DebugUnknownSubsectionRef &Unknown) override;
Error SubsectionConversionVisitor::visitCOFFSymbolRVAs(
   return Error::success();
 }
 
 Expected<YAMLDebugSubsection>
 YAMLDebugSubsection::fromCodeViewSubection(const StringsAndChecksumsRef &SC,
                                            const DebugSubsectionRecord &SS) {
   SubsectionConversionVisitor V;
   if (auto EC = visitDebugSubsection(SS, V, SC))
-    return std::move(EC);
+    return EC;
 
   return V.Subsection;
 }
 
 std::vector<YAMLDebugSubsection>
 llvm::CodeViewYAML::fromDebugS(ArrayRef<uint8_t> Data,
                                const StringsAndChecksumsRef &SC) {
   BinaryStreamReader Reader(Data, support::little);

llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp

 
 template <typename SymbolType>
 static inline Expected<CodeViewYAML::SymbolRecord>
 fromCodeViewSymbolImpl(CVSymbol Symbol) {
   CodeViewYAML::SymbolRecord Result;
 
   auto Impl = std::make_shared<SymbolType>(Symbol.kind());
   if (auto EC = Impl->fromCodeViewSymbol(Symbol))
-    return std::move(EC);
+    return EC;
   Result.Symbol = Impl;
   return Result;
 }
 
 Expected<CodeViewYAML::SymbolRecord>
 CodeViewYAML::SymbolRecord::fromCodeViewSymbol(CVSymbol Symbol) {
 #define SYMBOL_RECORD(EnumName, EnumVal, ClassName)                            \
   case EnumName:                                                               \

llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp

 } // end namespace llvm
 
 template <typename T>
 static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {
   LeafRecord Result;
 
   auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());
   if (auto EC = Impl->fromCodeViewRecord(Type))
-    return std::move(EC);
+    return EC;
   Result.Leaf = Impl;
   return Result;
 }
 
 Expected<LeafRecord> LeafRecord::fromCodeViewRecord(CVType Type) {
 #define TYPE_RECORD(EnumName, EnumVal, ClassName)                              \
   case EnumName:                                                               \
     return fromCodeViewRecordImpl<ClassName##Record>(Type);

llvm/lib/ObjectYAML/DWARFEmitter.cpp

DWARFYAML::EmitDebugSections(StringRef YAMLString, bool ApplyFixups,
   EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugLine, "debug_line",
                        DebugSections);
   EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugStr, "debug_str",
                        DebugSections);
   EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugAbbrev, "debug_abbrev",
                        DebugSections);
   EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugAranges, "debug_aranges",
                        DebugSections);
-  return std::move(DebugSections);
+  return DebugSections;
 }

llvm/lib/Passes/PassBuilder.cpp

if (Params.empty())
     return ParametersT{};
   if (!Params.consume_front("<") || !Params.consume_back(">")) {
     assert(false && "invalid format for parametrized pass name");
   }
 
   Expected<ParametersT> Result = Parser(Params);
   assert((Result || Result.template errorIsA<StringError>()) &&
          "Pass parameter parser can only return StringErrors.");
-  return std::move(Result);
+  return Result;
 }
 
 /// Parser of parameters for LoopUnroll pass.
 Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
   LoopUnrollOptions UnrollOpts;
   while (!Params.empty()) {
     StringRef ParamName;
     std::tie(ParamName, Params) = Params.split(';');

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

 Expected<std::unique_ptr<CoverageMapping>> CoverageMapping::load(
     ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
     IndexedInstrProfReader &ProfileReader) {
   auto Coverage = std::unique_ptr<CoverageMapping>(new CoverageMapping());
 
   for (const auto &CoverageReader : CoverageReaders) {
     for (auto RecordOrErr : *CoverageReader) {
       if (Error E = RecordOrErr.takeError())
-        return std::move(E);
+        return E;
       const auto &Record = *RecordOrErr;
       if (Error E = Coverage->loadFunctionRecord(Record, ProfileReader))
-        return std::move(E);
+        return E;
     }
   }
 
-  return std::move(Coverage);
+  return Coverage;
 }
 
 Expected<std::unique_ptr<CoverageMapping>>
 CoverageMapping::load(ArrayRef<StringRef> ObjectFilenames,
                       StringRef ProfileFilename, ArrayRef<StringRef> Arches) {
   auto ProfileReaderOrErr = IndexedInstrProfReader::create(ProfileFilename);
   if (Error E = ProfileReaderOrErr.takeError())
-    return std::move(E);
+    return E;
   auto ProfileReader = std::move(ProfileReaderOrErr.get());
 
   SmallVector<std::unique_ptr<CoverageMappingReader>, 4> Readers;
   SmallVector<std::unique_ptr<MemoryBuffer>, 4> Buffers;
   for (const auto &File : llvm::enumerate(ObjectFilenames)) {
     auto CovMappingBufOrErr = MemoryBuffer::getFileOrSTDIN(File.value());
     if (std::error_code EC = CovMappingBufOrErr.getError())
       return errorCodeToError(EC);
     StringRef Arch = Arches.empty() ? StringRef() : Arches[File.index()];
     MemoryBufferRef CovMappingBufRef =
         CovMappingBufOrErr.get()->getMemBufferRef();
     auto CoverageReadersOrErr =
         BinaryCoverageReader::create(CovMappingBufRef, Arch, Buffers);
     if (Error E = CoverageReadersOrErr.takeError())
-      return std::move(E);
+      return E;
     for (auto &Reader : CoverageReadersOrErr.get())
       Readers.push_back(std::move(Reader));
     Buffers.push_back(std::move(CovMappingBufOrErr.get()));
   }
   return load(Readers, *ProfileReader);
 }
 
 namespace {

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

Error RawCoverageMappingReader::read() {
 
   return Error::success();
 }
 
 Expected<bool> RawCoverageMappingDummyChecker::isDummy() {
   // A dummy coverage mapping data consists of just one region with zero count.
   uint64_t NumFileMappings;
   if (Error Err = readSize(NumFileMappings))
-    return std::move(Err);
+    return Err;
   if (NumFileMappings != 1)
     return false;
   // We don't expect any specific value for the filename index, just skip it.
   uint64_t FilenameIndex;
   if (Error Err =
           readIntMax(FilenameIndex, std::numeric_limits<unsigned>::max()))
-    return std::move(Err);
+    return Err;
   uint64_t NumExpressions;
   if (Error Err = readSize(NumExpressions))
-    return std::move(Err);
+    return Err;
   if (NumExpressions != 0)
     return false;
   uint64_t NumRegions;
   if (Error Err = readSize(NumRegions))
-    return std::move(Err);
+    return Err;
   if (NumRegions != 1)
     return false;
   uint64_t EncodedCounterAndRegion;
   if (Error Err = readIntMax(EncodedCounterAndRegion,
                              std::numeric_limits<unsigned>::max()))
-    return std::move(Err);
+    return Err;
   unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
   return Tag == Counter::Zero;
 }
 
 Error InstrProfSymtab::create(SectionRef &Section) {
   Expected<StringRef> DataOrErr = Section.getContents();
   if (!DataOrErr)
     return DataOrErr.takeError();
Expected<const char *> readFunctionRecords(const char *Buf,
     const char *FunEnd = Buf;
 
     // Get the filenames.
     if (Buf + FilenamesSize > End)
       return make_error<CoverageMapError>(coveragemap_error::malformed);
     size_t FilenamesBegin = Filenames.size();
     RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize), Filenames);
     if (auto Err = Reader.read())
-      return std::move(Err);
+      return Err;
     Buf += FilenamesSize;
 
     // We'll read the coverage mapping records in the loop below.
     const char *CovBuf = Buf;
     Buf += CoverageSize;
     const char *CovEnd = Buf;
 
     if (Buf > End)
while ((const char *)CFR < FunEnd) {
       // Now use that to read the coverage data.
       if (CovBuf + DataSize > CovEnd)
         return make_error<CoverageMapError>(coveragemap_error::malformed);
       auto Mapping = StringRef(CovBuf, DataSize);
       CovBuf += DataSize;
 
       if (Error Err =
               insertFunctionRecordIfNeeded(CFR, Mapping, FilenamesBegin))
-        return std::move(Err);
+        return Err;
       CFR++;
     }
     return Buf;
   }
 };
 
 } // end anonymous namespace
 
 template <class IntPtrT, support::endianness Endian>
 Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get(
     CovMapVersion Version, InstrProfSymtab &P,
     std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
     std::vector<StringRef> &F) {
   using namespace coverage;
 
   switch (Version) {
   case CovMapVersion::Version1:
     return llvm::make_unique<VersionedCovMapFuncRecordReader<
         CovMapVersion::Version1, IntPtrT, Endian>>(P, R, F);
   case CovMapVersion::Version2:
   case CovMapVersion::Version3:
     // Decompress the name data.
     if (Error E = P.create(P.getNameData()))
-      return std::move(E);
+      return E;
     if (Version == CovMapVersion::Version2)
       return llvm::make_unique<VersionedCovMapFuncRecordReader<
           CovMapVersion::Version2, IntPtrT, Endian>>(P, R, F);
     else
       return llvm::make_unique<VersionedCovMapFuncRecordReader<
           CovMapVersion::Version3, IntPtrT, Endian>>(P, R, F);
   }
   llvm_unreachable("Unsupported version");
BinaryCoverageReader::createCoverageReaderFromBuffer(
     support::endianness Endian) {
   std::unique_ptr<BinaryCoverageReader> Reader(new BinaryCoverageReader());
   Reader->ProfileNames = std::move(ProfileNames);
   if (BytesInAddress == 4 && Endian == support::endianness::little) {
     if (Error E =
             readCoverageMappingData<uint32_t, support::endianness::little>(
                 Reader->ProfileNames, Coverage, Reader->MappingRecords,
                 Reader->Filenames))
-      return std::move(E);
+      return E;
   } else if (BytesInAddress == 4 && Endian == support::endianness::big) {
     if (Error E = readCoverageMappingData<uint32_t, support::endianness::big>(
             Reader->ProfileNames, Coverage, Reader->MappingRecords,
             Reader->Filenames))
-      return std::move(E);
+      return E;
   } else if (BytesInAddress == 8 && Endian == support::endianness::little) {
     if (Error E =
             readCoverageMappingData<uint64_t, support::endianness::little>(
                 Reader->ProfileNames, Coverage, Reader->MappingRecords,
                 Reader->Filenames))
-      return std::move(E);
+      return E;
   } else if (BytesInAddress == 8 && Endian == support::endianness::big) {
     if (Error E = readCoverageMappingData<uint64_t, support::endianness::big>(
             Reader->ProfileNames, Coverage, Reader->MappingRecords,
             Reader->Filenames))
-      return std::move(E);
+      return E;
   } else
     return make_error<CoverageMapError>(coveragemap_error::malformed);
-  return std::move(Reader);
+  return Reader;
 }
 
 static Expected<std::unique_ptr<BinaryCoverageReader>>
 loadTestingFormat(StringRef Data) {
   uint8_t BytesInAddress = 8;
   support::endianness Endian = support::endianness::little;
 
   Data = Data.substr(StringRef(TestingFormatMagic).size());
loadTestingFormat(StringRef Data) {
   uint64_t Address = decodeULEB128(Data.bytes_begin(), &N);
   if (N > Data.size())
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   Data = Data.substr(N);
   if (Data.size() < ProfileNamesSize)
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   InstrProfSymtab ProfileNames;
   if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address))
-    return std::move(E);
+    return E;
   StringRef CoverageMapping = Data.substr(ProfileNamesSize);
   // Skip the padding bytes because coverage map data has an alignment of 8.
   if (CoverageMapping.empty())
     return make_error<CoverageMapError>(coveragemap_error::truncated);
   size_t Pad = alignmentAdjustment(CoverageMapping.data(), 8);
   if (CoverageMapping.size() < Pad)
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   CoverageMapping = CoverageMapping.substr(Pad);
support::endianness Endian = OF->isLittleEndian()
                                    : support::endianness::big;
 
   // Look for the sections that we are interested in.
   auto ObjFormat = OF->getTripleObjectFormat();
   auto NamesSection =
       lookupSection(*OF, getInstrProfSectionName(IPSK_name, ObjFormat,
                                                  /*AddSegmentInfo=*/false));
   if (auto E = NamesSection.takeError())
-    return std::move(E);
+    return E;
   auto CoverageSection =
       lookupSection(*OF, getInstrProfSectionName(IPSK_covmap, ObjFormat,
                                                  /*AddSegmentInfo=*/false));
   if (auto E = CoverageSection.takeError())
-    return std::move(E);
+    return E;
 
   // Get the contents of the given sections.
   auto CoverageMappingOrErr = CoverageSection->getContents();
   if (!CoverageMappingOrErr)
     return CoverageMappingOrErr.takeError();
 
   InstrProfSymtab ProfileNames;
   if (Error E = ProfileNames.create(*NamesSection))
-    return std::move(E);
+    return E;
 
   return BinaryCoverageReader::createCoverageReaderFromBuffer(
       CoverageMappingOrErr.get(), std::move(ProfileNames), BytesInAddress,
       Endian);
 }
 
 Expected<std::vector<std::unique_ptr<BinaryCoverageReader>>>
 BinaryCoverageReader::create(
     MemoryBufferRef ObjectBuffer, StringRef Arch,
     SmallVectorImpl<std::unique_ptr<MemoryBuffer>> &ObjectFileBuffers) {
   std::vector<std::unique_ptr<BinaryCoverageReader>> Readers;
 
   if (ObjectBuffer.getBuffer().startswith(TestingFormatMagic)) {
     // This is a special format used for testing.
     auto ReaderOrErr = loadTestingFormat(ObjectBuffer.getBuffer());
     if (!ReaderOrErr)
       return ReaderOrErr.takeError();
     Readers.push_back(std::move(ReaderOrErr.get()));
-    return std::move(Readers);
+    return Readers;
   }
 
   auto BinOrErr = createBinary(ObjectBuffer);
   if (!BinOrErr)
     return BinOrErr.takeError();
   std::unique_ptr<Binary> Bin = std::move(BinOrErr.get());
 
   // MachO universal binaries which contain archives need to be treated as
for (auto &Child : Ar->children(Err)) {
       auto ChildReadersOrErr = BinaryCoverageReader::create(
           ChildBufOrErr.get(), Arch, ObjectFileBuffers);
       if (!ChildReadersOrErr)
         return ChildReadersOrErr.takeError();
       for (auto &Reader : ChildReadersOrErr.get())
         Readers.push_back(std::move(Reader));
     }
     if (Err)
-      return std::move(Err);
+      return Err;
 
     // Thin archives reference object files outside of the archive file, i.e.
     // files which reside in memory not owned by the caller. Transfer ownership
     // to the caller.
     if (Ar->isThin())
       for (auto &Buffer : Ar->takeThinBuffers())
         ObjectFileBuffers.push_back(std::move(Buffer));
 
-    return std::move(Readers);
+    return Readers;
   }
 
   auto ReaderOrErr = loadBinaryFormat(std::move(Bin), Arch);
   if (!ReaderOrErr)
     return ReaderOrErr.takeError();
   Readers.push_back(std::move(ReaderOrErr.get()));
-  return std::move(Readers);
+  return Readers;
 }
 
 Error BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) {
   if (CurrentRecord >= MappingRecords.size())
     return make_error<CoverageMapError>(coveragemap_error::eof);
 
   FunctionsFilenames.clear();
   Expressions.clear();

llvm/lib/ProfileData/GCOV.cpp

FileInfo::openCoveragePath(StringRef CoveragePath) {
 
   std::error_code EC;
   auto OS =
       llvm::make_unique<raw_fd_ostream>(CoveragePath, EC, sys::fs::OF_Text);
   if (EC) {
     errs() << EC.message() << "\n";
     return llvm::make_unique<raw_null_ostream>();
   }
-  return std::move(OS);
+  return OS;
 }
 
 /// print -  Print source files with collected line count information.
 void FileInfo::print(raw_ostream &InfoOS, StringRef MainFilename,
                      StringRef GCNOFile, StringRef GCDAFile) {
   SmallVector<StringRef, 4> Filenames;
   for (const auto &LI : LineInfo)
     Filenames.push_back(LI.first());

llvm/lib/ProfileData/InstrProf.cpp

ValueProfData::getValueProfData(const unsigned char *D,
 
   std::unique_ptr<ValueProfData> VPD = allocValueProfData(TotalSize);
   memcpy(VPD.get(), D, TotalSize);
   // Byte swap.
   VPD->swapBytesToHost(Endianness);
 
   Error E = VPD->checkIntegrity();
   if (E)
-    return std::move(E);
+    return E;
 
-  return std::move(VPD);
+  return VPD;
 }
 
 void ValueProfData::swapBytesToHost(support::endianness Endianness) {
   using namespace support;
 
   if (Endianness == getHostEndianness())
     return;
 

llvm/lib/ProfileData/InstrProfReader.cpp

static Error initializeReader(InstrProfReader &Reader) {
   return Reader.readHeader();
 }
 
 Expected<std::unique_ptr<InstrProfReader>>
 InstrProfReader::create(const Twine &Path) {
   // Set up the buffer to read.
   auto BufferOrError = setupMemoryBuffer(Path);
   if (Error E = BufferOrError.takeError())
-    return std::move(E);
+    return E;
   return InstrProfReader::create(std::move(BufferOrError.get()));
 }
 
 Expected<std::unique_ptr<InstrProfReader>>
 InstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
   // Sanity check the buffer.
   if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<uint64_t>::max())
     return make_error<InstrProfError>(instrprof_error::too_large);
else if (RawInstrProfReader32::hasFormat(*Buffer))
     Result.reset(new RawInstrProfReader32(std::move(Buffer)));
   else if (TextInstrProfReader::hasFormat(*Buffer))
     Result.reset(new TextInstrProfReader(std::move(Buffer)));
   else
     return make_error<InstrProfError>(instrprof_error::unrecognized_format);
 
   // Initialize the reader and return the result.
   if (Error E = initializeReader(*Result))
-    return std::move(E);
+    return E;
 
-  return std::move(Result);
+  return Result;
 }
 
 Expected<std::unique_ptr<IndexedInstrProfReader>>
 IndexedInstrProfReader::create(const Twine &Path, const Twine &RemappingPath) {
   // Set up the buffer to read.
   auto BufferOrError = setupMemoryBuffer(Path);
   if (Error E = BufferOrError.takeError())
-    return std::move(E);
+    return E;
 
   // Set up the remapping buffer if requested.
   std::unique_ptr<MemoryBuffer> RemappingBuffer;
   std::string RemappingPathStr = RemappingPath.str();
   if (!RemappingPathStr.empty()) {
     auto RemappingBufferOrError = setupMemoryBuffer(RemappingPathStr);
     if (Error E = RemappingBufferOrError.takeError())
-      return std::move(E);
+      return E;
     RemappingBuffer = std::move(RemappingBufferOrError.get());
   }
 
   return IndexedInstrProfReader::create(std::move(BufferOrError.get()),
                                         std::move(RemappingBuffer));
 }
 
 Expected<std::unique_ptr<IndexedInstrProfReader>>
 IndexedInstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer,
                                std::unique_ptr<MemoryBuffer> RemappingBuffer) {
   // Sanity check the buffer.
   if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<uint64_t>::max())
     return make_error<InstrProfError>(instrprof_error::too_large);
 
   // Create the reader.
   if (!IndexedInstrProfReader::hasFormat(*Buffer))
     return make_error<InstrProfError>(instrprof_error::bad_magic);
   auto Result = llvm::make_unique<IndexedInstrProfReader>(
       std::move(Buffer), std::move(RemappingBuffer));
 
   // Initialize the reader and return the result.
   if (Error E = initializeReader(*Result))
-    return std::move(E);
+    return E;
 
-  return std::move(Result);
+  return Result;
 }
 
 void InstrProfIterator::Increment() {
   if (auto E = Reader->readNextRecord(Record)) {
     // Handle errors in the reader.
     InstrProfError::take(std::move(E));
     *this = InstrProfIterator();
   }

 }
 
 Expected<InstrProfRecord>
 IndexedInstrProfReader::getInstrProfRecord(StringRef FuncName,
                                            uint64_t FuncHash) {
   ArrayRef<NamedInstrProfRecord> Data;
   Error Err = Remapper->getRecords(FuncName, Data);
   if (Err)
-    return std::move(Err);
+    return Err;
   // Found it. Look for counters with the right hash.
   for (unsigned I = 0, E = Data.size(); I < E; ++I) {
     // Check for a match and fill the vector if there is one.
     if (Data[I].Hash == FuncHash) {
       return std::move(Data[I]);
     }
   }
   return error(instrprof_error::hash_mismatch);

llvm/lib/ProfileData/SampleProfReader.cpp

setupMemoryBuffer(const Twine &Filename) {
   if (std::error_code EC = BufferOrErr.getError())
     return EC;
   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);
+  return Buffer;
 }
 
 /// Create a sample profile reader based on the format of the input file.
 ///
 /// \param Filename The file to open.
 ///
 /// \param C The LLVM context to use to emit diagnostics.
 ///
else if (SampleProfileReaderText::hasFormat(*B))
     Reader.reset(new SampleProfileReaderText(std::move(B), C));
   else
     return sampleprof_error::unrecognized_format;
 
   FunctionSamples::Format = Reader->getFormat();
   if (std::error_code EC = Reader->readHeader())
     return EC;
 
-  return std::move(Reader);
+  return Reader;
 }
 
 // For text and GCC file formats, we compute the summary after reading the
 // profile. Binary format has the profile summary in its header.
 void SampleProfileReader::computeSummary() {
   SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
   for (const auto &I : Profiles) {
     const FunctionSamples &Profile = I.second;
     Builder.addRecord(Profile);
   }
   Summary = Builder.getSummary();
 }

llvm/lib/ProfileData/SampleProfWriter.cpp

SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
   else if (Format == SPF_GCC)
     EC = sampleprof_error::unsupported_writing_format;
   else
     EC = sampleprof_error::unrecognized_format;
 
   if (EC)
     return EC;
 
-  return std::move(Writer);
+  return Writer;
 }
 
 void SampleProfileWriter::computeSummary(
     const StringMap<FunctionSamples> &ProfileMap) {
   SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
   for (const auto &I : ProfileMap) {
     const FunctionSamples &Profile = I.second;
     Builder.addRecord(Profile);
   }
   Summary = Builder.getSummary();
 }

llvm/lib/Remarks/YAMLRemarkParser.cpp

remarks::createYAMLParserFromMeta(StringRef Buf,
   }
 
   std::unique_ptr<YAMLRemarkParser> Result =
       StrTab
           ? llvm::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(*StrTab))
           : llvm::make_unique<YAMLRemarkParser>(Buf);
   if (SeparateBuf)
     Result->SeparateBuf = std::move(SeparateBuf);
-  return std::move(Result);
+  return Result;
 }
 
 YAMLRemarkParser::YAMLRemarkParser(StringRef Buf)
     : YAMLRemarkParser(Buf, None) {}
 
 YAMLRemarkParser::YAMLRemarkParser(StringRef Buf,
                                    Optional<ParsedStringTable> StrTab)
     : RemarkParser{Format::YAML}, StrTab(std::move(StrTab)), LastErrorMessage(),
Error YAMLRemarkParser::error() {
   Error E = make_error<YAMLParseError>(LastErrorMessage);
   LastErrorMessage.clear();
   return E;
 }
 
 Expected<std::unique_ptr<Remark>>
 YAMLRemarkParser::parseRemark(yaml::Document &RemarkEntry) {
   if (Error E = error())
-    return std::move(E);
+    return E;
 
   yaml::Node *YAMLRoot = RemarkEntry.getRoot();
   if (!YAMLRoot) {
     return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "not a valid YAML file.");
   }
 
   auto *Root = dyn_cast<yaml::MappingNode>(YAMLRoot);
YAMLRemarkParser::parseRemark(yaml::Document &RemarkEntry) {
   }
 
   // Check if any of the mandatory fields are missing.
   if (TheRemark.RemarkType == Type::Unknown || TheRemark.PassName.empty() ||
       TheRemark.RemarkName.empty() || TheRemark.FunctionName.empty())
     return error("Type, Pass, Name or Function missing.",
                  *RemarkEntry.getRoot());
 
-  return std::move(Result);
+  return Result;
 }
 
 Expected<Type> YAMLRemarkParser::parseType(yaml::MappingNode &Node) {
   auto Type = StringSwitch<remarks::Type>(Node.getRawTag())
                   .Case("!Passed", remarks::Type::Passed)
                   .Case("!Missed", remarks::Type::Missed)
                   .Case("!Analysis", remarks::Type::Analysis)
                   .Case("!AnalysisFPCommute", remarks::Type::AnalysisFPCommute)

llvm/lib/Support/FileCheck.cpp

Expected<uint64_t> FileCheckASTBinop::eval() const {
   // Bubble up any error (e.g. undefined variables) in the recursive
   // evaluation.
   if (!LeftOp || !RightOp) {
     Error Err = Error::success();
     if (!LeftOp)
       Err = joinErrors(std::move(Err), LeftOp.takeError());
     if (!RightOp)
       Err = joinErrors(std::move(Err), RightOp.takeError());
-    return std::move(Err);
+    return Err;
   }
 
   return EvalBinop(*LeftOp, *RightOp);
 }
 
 Expected<std::string> FileCheckNumericSubstitution::getResult() const {
   Expected<uint64_t> EvaluatedValue = ExpressionAST->eval();
   if (!EvaluatedValue)

 }
 
 Expected<std::unique_ptr<FileCheckExpressionAST>> FileCheckPattern::parseBinop(
     StringRef &Expr, std::unique_ptr<FileCheckExpressionAST> LeftOp,
     bool IsLegacyLineExpr, Optional<size_t> LineNumber,
     FileCheckPatternContext *Context, const SourceMgr &SM) {
   Expr = Expr.ltrim(SpaceChars);
   if (Expr.empty())
-    return std::move(LeftOp);
+    return LeftOp;
 
   // Check if this is a supported operation and select a function to perform
   // it.
   SMLoc OpLoc = SMLoc::getFromPointer(Expr.data());
   char Operator = popFront(Expr);
   binop_eval_t EvalBinop;
   switch (Operator) {
   case '+':
Expected<FileCheckNumericVariable *> ParseResult =
         parseNumericVariableDefinition(DefExpr, Context, LineNumber,
                                        ExpressionAST.get(), SM);
 
     if (!ParseResult)
       return ParseResult.takeError();
     DefinedNumericVariable = *ParseResult;
   }
 
-  return std::move(ExpressionAST);
+  return ExpressionAST;
 }
 
 bool FileCheckPattern::parsePattern(StringRef PatternStr, StringRef Prefix,
                                     SourceMgr &SM,
                                     const FileCheckRequest &Req) {
   bool MatchFullLinesHere = Req.MatchFullLines && CheckTy != Check::CheckNot;
 
   PatternLoc = SMLoc::getFromPointer(PatternStr.data());

llvm/lib/Support/JSON.cpp

 } // namespace
 
 Expected<Value> parse(StringRef JSON) {
   Parser P(JSON);
   Value E = nullptr;
   if (P.checkUTF8())
     if (P.parseValue(E))
       if (P.assertEnd())
-        return std::move(E);
+        return E;
   return P.takeError();
 }
 char ParseError::ID = 0;
 
 static std::vector<const Object::value_type *> sortedElements(const Object &O) {
   std::vector<const Object::value_type *> Elements;
   for (const auto &E : O)
     Elements.push_back(&E);

llvm/lib/Support/MemoryBuffer.cpp

 }
 
 static ErrorOr<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);
   memcpy(Buf->getBufferStart(), InputData.data(), InputData.size());
-  return std::move(Buf);
+  return 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;
getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize,
 
   std::error_code EC;
   std::unique_ptr<WriteThroughMemoryBuffer> Result(
       new (NamedBufferAlloc(Filename))
           MemoryBufferMMapFile<WriteThroughMemoryBuffer>(false, FD, MapSize,
                                                          Offset, EC));
   if (EC)
     return EC;
-  return std::move(Result);
+  return Result;
 }
 
 ErrorOr<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.
getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
 
   if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator,
                     PageSize, IsVolatile)) {
     std::error_code EC;
     std::unique_ptr<MB> Result(
         new (NamedBufferAlloc(Filename)) MemoryBufferMMapFile<MB>(
             RequiresNullTerminator, FD, MapSize, Offset, EC));
     if (!EC)
-      return std::move(Result);
+      return Result;
   }
 
   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);
   }
 
   sys::fs::readNativeFileSlice(FD, Buf->getBuffer(), Offset);
 
-  return std::move(Buf);
+  return Buf;
 }
 
 ErrorOr<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);
 }

llvm/lib/Support/Path.cpp

 #ifndef _WIN32
   if (sys::RemoveFileOnSignal(ResultPath)) {
     // Make sure we delete the file when RemoveFileOnSignal fails.
     consumeError(Ret.discard());
     std::error_code EC(errc::operation_not_permitted);
     return errorCodeToError(EC);
   }
 #endif
-  return std::move(Ret);
+  return Ret;
 }
 }
 
 } // end namsspace sys
 } // end namespace llvm

llvm/lib/Support/YAMLTraits.cpp

std::unique_ptr<Input::HNode> Input::createHNodes(Node *N) {
   } else if (SequenceNode *SQ = dyn_cast<SequenceNode>(N)) {
     auto SQHNode = llvm::make_unique<SequenceHNode>(N);
     for (Node &SN : *SQ) {
       auto Entry = createHNodes(&SN);
       if (EC)
         break;
       SQHNode->Entries.push_back(std::move(Entry));
     }
-    return std::move(SQHNode);
+    return SQHNode;
   } else if (MappingNode *Map = dyn_cast<MappingNode>(N)) {
     auto mapHNode = llvm::make_unique<MapHNode>(N);
     for (KeyValueNode &KVN : *Map) {
       Node *KeyNode = KVN.getKey();
       ScalarNode *Key = dyn_cast<ScalarNode>(KeyNode);
       Node *Value = KVN.getValue();
       if (!Key || !Value) {
         if (!Key)
           setError(KeyNode, "Map key must be a scalar");
         if (!Value)
           setError(KeyNode, "Map value must not be empty");
         break;
       }
       StringStorage.clear();
       StringRef KeyStr = Key->getValue(StringStorage);
       if (!StringStorage.empty()) {
         // Copy string to permanent storage
         KeyStr = StringStorage.str().copy(StringAllocator);
       }
       auto ValueHNode = createHNodes(Value);
       if (EC)
         break;
       mapHNode->Mapping[KeyStr] = std::move(ValueHNode);
     }
-    return std::move(mapHNode);
+    return mapHNode;
   } else if (isa<NullNode>(N)) {
     return llvm::make_unique<EmptyHNode>(N);
   } else {
     setError(N, "unknown node kind");
     return nullptr;
   }
 }
 

llvm/lib/TableGen/JSONBackend.cpp

json::Value JSONEmitter::translateInit(const Init &I) {
   if (isa<UnsetInit>(&I)) {
     return nullptr;
   } else if (auto *Bit = dyn_cast<BitInit>(&I)) {
     return Bit->getValue() ? 1 : 0;
   } else if (auto *Bits = dyn_cast<BitsInit>(&I)) {
     json::Array array;
     for (unsigned i = 0, limit = Bits->getNumBits(); i < limit; i++)
       array.push_back(translateInit(*Bits->getBit(i)));
-    return std::move(array);
+    return array;
   } else if (auto *Int = dyn_cast<IntInit>(&I)) {
     return Int->getValue();
   } else if (auto *Str = dyn_cast<StringInit>(&I)) {
     return Str->getValue();
   } else if (auto *Code = dyn_cast<CodeInit>(&I)) {
     return Code->getValue();
   } else if (auto *List = dyn_cast<ListInit>(&I)) {
     json::Array array;
     for (auto val : *List)
       array.push_back(translateInit(*val));
-    return std::move(array);
+    return array;
   }
 
   // Init subclasses that we return as JSON objects containing a
   // 'kind' discriminator. For these, we also provide the same
   // translation back into TableGen input syntax that -print-records
   // would give.
 
   json::Object obj;
   obj["printable"] = I.getAsString();
 
   if (auto *Def = dyn_cast<DefInit>(&I)) {
     obj["kind"] = "def";
     obj["def"] = Def->getDef()->getName();
-    return std::move(obj);
+    return obj;
   } else if (auto *Var = dyn_cast<VarInit>(&I)) {
     obj["kind"] = "var";
     obj["var"] = Var->getName();
-    return std::move(obj);
+    return obj;
   } else if (auto *VarBit = dyn_cast<VarBitInit>(&I)) {
     if (auto *Var = dyn_cast<VarInit>(VarBit->getBitVar())) {
       obj["kind"] = "varbit";
       obj["var"] = Var->getName();
       obj["index"] = VarBit->getBitNum();
-      return std::move(obj);
+      return obj;
     }
   } else if (auto *Dag = dyn_cast<DagInit>(&I)) {
     obj["kind"] = "dag";
     obj["operator"] = translateInit(*Dag->getOperator());
     if (auto name = Dag->getName())
       obj["name"] = name->getAsUnquotedString();
     json::Array args;
     for (unsigned i = 0, limit = Dag->getNumArgs(); i < limit; ++i) {
       json::Array arg;
       arg.push_back(translateInit(*Dag->getArg(i)));
       if (auto argname = Dag->getArgName(i))
         arg.push_back(argname->getAsUnquotedString());
       else
         arg.push_back(nullptr);
       args.push_back(std::move(arg));
     }
     obj["args"] = std::move(args);
-    return std::move(obj);
+    return obj;
   }
 
   // Final fallback: anything that gets past here is simply given a
   // kind field of 'complex', and the only other field is the standard
   // 'printable' representation.
 
   assert(!I.isConcrete());
   obj["kind"] = "complex";
-  return std::move(obj);
+  return obj;
 }
 
 void JSONEmitter::run(raw_ostream &OS) {
   json::Object root;
 
   root["!tablegen_json_version"] = 1;
 
   // Prepare the arrays that will list the instances of every class.

llvm/lib/TextAPI/ELF/TBEHandler.cpp

 
 Expected<std::unique_ptr<ELFStub>> elfabi::readTBEFromBuffer(StringRef Buf) {
   yaml::Input YamlIn(Buf);
   std::unique_ptr<ELFStub> Stub(new ELFStub());
   YamlIn >> *Stub;
   if (std::error_code Err = YamlIn.error())
     return createStringError(Err, "YAML failed reading as TBE");
 
-  return std::move(Stub);
+  return Stub;
 }
 
 Error elfabi::writeTBEToOutputStream(raw_ostream &OS, const ELFStub &Stub) {
   yaml::Output YamlOut(OS, NULL, /*WrapColumn =*/0);
 
   YamlOut << const_cast<ELFStub &>(Stub);
   return Error::success();
 }

llvm/lib/TextAPI/MachO/TextStub.cpp

TextAPIReader::get(std::unique_ptr<MemoryBuffer> InputBuffer) {
   YAMLIn >> Files;
 
   auto File = std::unique_ptr<InterfaceFile>(
       const_cast<InterfaceFile *>(Files.front()));
 
   if (YAMLIn.error())
     return make_error<StringError>(Ctx.ErrorMessage, YAMLIn.error());
 
-  return std::move(File);
+  return File;
 }
 
 Error TextAPIWriter::writeToStream(raw_ostream &OS, const InterfaceFile &File) {
   TextAPIContext Ctx;
   Ctx.Path = File.getPath();
   Ctx.FileKind = File.getFileType();
   llvm::yaml::Output YAMLOut(OS, &Ctx, /*WrapColumn=*/80);
 

llvm/lib/Transforms/IPO/FunctionImport.cpp

if (!SrcModuleOrErr)
       return SrcModuleOrErr.takeError();
     std::unique_ptr<Module> SrcModule = std::move(*SrcModuleOrErr);
     assert(&DestModule.getContext() == &SrcModule->getContext() &&
            "Context mismatch");
 
     // If modules were created with lazy metadata loading, materialize it
     // now, before linking it (otherwise this will be a noop).
     if (Error Err = SrcModule->materializeMetadata())
-      return std::move(Err);
+      return Err;
 
     auto &ImportGUIDs = FunctionsToImportPerModule->second;
     // Find the globals to import
     SetVector<GlobalValue *> GlobalsToImport;
     for (Function &F : *SrcModule) {
       if (!F.hasName())
         continue;
       auto GUID = F.getGUID();
       auto Import = ImportGUIDs.count(GUID);
       LLVM_DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing function "
                         << GUID << " " << F.getName() << " from "
                         << SrcModule->getSourceFileName() << "\n");
       if (Import) {
         if (Error Err = F.materialize())
-          return std::move(Err);
+          return Err;
         if (EnableImportMetadata) {
           // Add 'thinlto_src_module' metadata for statistics and debugging.
           F.setMetadata(
               "thinlto_src_module",
               MDNode::get(DestModule.getContext(),
                           {MDString::get(DestModule.getContext(),
                                          SrcModule->getSourceFileName())}));
         }
         GlobalsToImport.insert(&F);
       }
     }
     for (GlobalVariable &GV : SrcModule->globals()) {
       if (!GV.hasName())
         continue;
       auto GUID = GV.getGUID();
       auto Import = ImportGUIDs.count(GUID);
       LLVM_DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing global "
                         << GUID << " " << GV.getName() << " from "
                         << SrcModule->getSourceFileName() << "\n");
       if (Import) {
         if (Error Err = GV.materialize())
-          return std::move(Err);
+          return Err;
         ImportedGVCount += GlobalsToImport.insert(&GV);
       }
     }
     for (GlobalAlias &GA : SrcModule->aliases()) {
       if (!GA.hasName())
         continue;
       auto GUID = GA.getGUID();
       auto Import = ImportGUIDs.count(GUID);
       LLVM_DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing alias "
                         << GUID << " " << GA.getName() << " from "
                         << SrcModule->getSourceFileName() << "\n");
       if (Import) {
         if (Error Err = GA.materialize())
-          return std::move(Err);
+          return Err;
         // Import alias as a copy of its aliasee.
         GlobalObject *Base = GA.getBaseObject();
         if (Error Err = Base->materialize())
-          return std::move(Err);
+          return Err;
         auto *Fn = replaceAliasWithAliasee(SrcModule.get(), &GA);
         LLVM_DEBUG(dbgs() << "Is importing aliasee fn " << Base->getGUID()
                           << " " << Base->getName() << " from "
                           << SrcModule->getSourceFileName() << "\n");
         if (EnableImportMetadata) {
           // Add 'thinlto_src_module' metadata for statistics and debugging.
           Fn->setMetadata(
               "thinlto_src_module",

llvm/lib/XRay/FDRRecordProducer.cpp

if (isMetadataIntroducer(FirstByte)) {
       if (LoadedType == MetadataRecordKinds::BufferExtentsKind) {
         auto MetadataRecordOrErr = metadataRecordType(Header, LoadedType);
         if (!MetadataRecordOrErr)
           return MetadataRecordOrErr.takeError();
 
         R = std::move(MetadataRecordOrErr.get());
         RecordInitializer RI(E, OffsetPtr);
         if (auto Err = R->apply(RI))
-          return std::move(Err);
-        return std::move(R);
+          return Err;
+        return R;
       }
     }
   }
   llvm_unreachable("Must always terminate with either an error or a record.");
 }
 
 Expected<std::unique_ptr<Record>> FileBasedRecordProducer::produce() {
   // First, we set up our result record.
if (!BufferExtentsOrError)
               std::make_error_code(std::errc::executable_format_error),
               "Failed to find the next BufferExtents record."));
 
     R = std::move(BufferExtentsOrError.get());
     assert(R != nullptr);
     assert(isa<BufferExtents>(R.get()));
     auto BE = dyn_cast<BufferExtents>(R.get());
     CurrentBufferBytes = BE->size();
-    return std::move(R);
+    return R;
   }
 
   //
   // At the top level, we read one byte to determine the type of the record to
   // create. This byte will comprise of the following bits:
   //
   //   - offset 0: A '1' indicates a metadata record, a '0' indicates a function
   //     record.
if (!MetadataRecordOrErr)
               LoadedType, PreReadOffset));
     R = std::move(MetadataRecordOrErr.get());
   } else {
     R = llvm::make_unique<FunctionRecord>();
   }
   RecordInitializer RI(E, OffsetPtr);
 
   if (auto Err = R->apply(RI))
-    return std::move(Err);
+    return Err;
 
   // If we encountered a BufferExtents record, we should record the remaining
   // bytes for the current buffer, to determine when we should start ignoring
   // potentially malformed data and looking for buffer extents records.
   if (auto BE = dyn_cast<BufferExtents>(R.get())) {
     CurrentBufferBytes = BE->size();
   } else if (Header.Version >= 3) {
     if (OffsetPtr - PreReadOffset > CurrentBufferBytes)
       return createStringError(
           std::make_error_code(std::errc::executable_format_error),
           "Buffer over-read at offset %d (over-read by %d bytes); Record Type "
           "= %s.",
           OffsetPtr, (OffsetPtr - PreReadOffset) - CurrentBufferBytes,
           Record::kindToString(R->getRecordType()).data());
 
     CurrentBufferBytes -= OffsetPtr - PreReadOffset;
   }
   assert(R != nullptr);
-  return std::move(R);
+  return R;
 }
 
 } // namespace xray
 } // namespace llvm

llvm/lib/XRay/FileHeaderReader.cpp

return createStringError(
         OffsetPtr);
 
   std::memcpy(&FileHeader.FreeFormData,
               HeaderExtractor.getData().bytes_begin() + OffsetPtr, 16);
 
   // Manually advance the offset pointer 16 bytes, after getting a raw memcpy
   // from the underlying data.
   OffsetPtr += 16;
-  return std::move(FileHeader);
+  return FileHeader;
 }
 
 } // namespace xray
 } // namespace llvm

llvm/lib/XRay/InstrumentationMap.cpp

llvm::xray::loadInstrumentationMap(StringRef Filename) {
   auto ObjectFileOrError = object::ObjectFile::createObjectFile(Filename);
   if (!ObjectFileOrError) {
     auto E = ObjectFileOrError.takeError();
     // We try to load it as YAML if the ELF load didn't work.
     Expected<sys::fs::file_t> FdOrErr = sys::fs::openNativeFileForRead(Filename);
     if (!FdOrErr) {
       // Report the ELF load error if YAML failed.
       consumeError(FdOrErr.takeError());
-      return std::move(E);
+      return E;
     }
 
     uint64_t FileSize;
     if (sys::fs::file_size(Filename, FileSize))
-      return std::move(E);
+      return E;
 
     // If the file is empty, we return the original error.
     if (FileSize == 0)
-      return std::move(E);
+      return E;
 
     // From this point on the errors will be only for the YAML parts, so we
     // consume the errors at this point.
     consumeError(std::move(E));
     if (auto E = loadYAML(*FdOrErr, FileSize, Filename, Map.Sleds,
                           Map.FunctionAddresses, Map.FunctionIds))
-      return std::move(E);
+      return E;
   } else if (auto E = loadObj(Filename, *ObjectFileOrError, Map.Sleds,
                                 Map.FunctionAddresses, Map.FunctionIds)) {
-    return std::move(E);
+    return E;
   }
   return Map;
 }

llvm/lib/XRay/Profile.cpp

do {
     FuncId = Extractor.getSigned(&Offset, 4);
     if (CurrentOffset == Offset)
       return make_error<StringError>(
           Twine("Error parsing path at offset '") + Twine(CurrentOffset) + "'",
           std::make_error_code(std::errc::invalid_argument));
     CurrentOffset = Offset;
     Path.push_back(FuncId);
   } while (FuncId != 0);
-  return std::move(Path);
+  return Path;
 }
 
 static Expected<Profile::Data> readData(DataExtractor &Extractor,
                                         uint32_t &Offset) {
   // We expect a certain number of elements for Data:
   //   - A 64-bit CallCount
   //   - A 64-bit CumulativeLocalTime counter
   Profile::Data D;
Expected<std::vector<Profile::FuncID>> Profile::expandPath(PathID P) const {
   auto It = PathIDMap.find(P);
   if (It == PathIDMap.end())
     return make_error<StringError>(
         Twine("PathID not found: ") + Twine(P),
         std::make_error_code(std::errc::invalid_argument));
   std::vector<Profile::FuncID> Path;
   for (auto Node = It->second; Node; Node = Node->Caller)
     Path.push_back(Node->Func);
-  return std::move(Path);
+  return Path;
 }
 
 Profile::PathID Profile::internPath(ArrayRef<FuncID> P) {
   if (P.empty())
     return 0;
 
   auto RootToLeafPath = reverse(P);
 
while (Offset != MappedFile.size()) {
     auto DataOrError = readData(Extractor, Offset);
     if (!DataOrError)
       return DataOrError.takeError();
     auto &Data = DataOrError.get();
 
     if (auto E =
             P.addBlock(Profile::Block{Profile::ThreadID{Header.Thread},
                                       {{P.internPath(Path), std::move(Data)}}}))
-      return std::move(E);
+      return E;
   }
 
   return P;
 }
 
 namespace {
 
 struct StackEntry {
Expected<Profile> profileFromTrace(const Trace &T) {
   for (const auto &ThreadPaths : ThreadPathData) {
     const auto &TID = ThreadPaths.first;
     const auto &PathsData = ThreadPaths.second;
     if (auto E = P.addBlock({
             TID,
             std::vector<std::pair<Profile::PathID, Profile::Data>>(
                 PathsData.begin(), PathsData.end()),
         }))
-      return std::move(E);
+      return E;
   }
 
   return P;
 }
 
 } // namespace xray
 } // namespace llvm

llvm/lib/XRay/Trace.cpp

Expected<Trace> llvm::xray::loadTrace(const DataExtractor &DE, bool Sort) {
   enum BinaryFormatType { NAIVE_FORMAT = 0, FLIGHT_DATA_RECORDER_FORMAT = 1 };
 
   Trace T;
   switch (Type) {
   case NAIVE_FORMAT:
     if (Version == 1 || Version == 2 || Version == 3) {
       if (auto E = loadNaiveFormatLog(DE.getData(), DE.isLittleEndian(),
                                       T.FileHeader, T.Records))
-        return std::move(E);
+        return E;
     } else {
       return make_error<StringError>(
           Twine("Unsupported version for Basic/Naive Mode logging: ") +
               Twine(Version),
           std::make_error_code(std::errc::executable_format_error));
     }
     break;
   case FLIGHT_DATA_RECORDER_FORMAT:
     if (Version >= 1 && Version <= 5) {
       if (auto E = loadFDRLog(DE.getData(), DE.isLittleEndian(), T.FileHeader,
                               T.Records))
-        return std::move(E);
+        return E;
     } else {
       return make_error<StringError>(
           Twine("Unsupported version for FDR Mode logging: ") + Twine(Version),
           std::make_error_code(std::errc::executable_format_error));
     }
     break;
   default:
     if (auto E = loadYAMLLog(DE.getData(), T.FileHeader, T.Records))
-      return std::move(E);
+      return E;
   }
 
   if (Sort)
     llvm::stable_sort(T.Records, [&](const XRayRecord &L, const XRayRecord &R) {
       return L.TSC < R.TSC;
     });
 
-  return std::move(T);
+  return T;
 }

llvm/tools/bugpoint/ExecutionDriver.cpp

Expected<std::string> BugDriver::executeProgram(const Module &Program,
   std::vector<std::string> SharedObjs(AdditionalSOs);
   if (!SharedObj.empty())
     SharedObjs.push_back(SharedObj);
 
   Expected<int> RetVal = AI->ExecuteProgram(BitcodeFile, InputArgv, InputFile,
                                             OutputFile, AdditionalLinkerArgs,
                                             SharedObjs, Timeout, MemoryLimit);
   if (Error E = RetVal.takeError())
-    return std::move(E);
+    return E;
 
   if (*RetVal == -1) {
     errs() << "<timeout>";
     static bool FirstTimeout = true;
     if (FirstTimeout) {
       outs()
           << "\n"
              "*** Program execution timed out!  This mechanism is designed to "

 BugDriver::compileSharedObject(const std::string &BitcodeFile) {
   assert(Interpreter && "Interpreter should have been created already!");
   std::string OutputFile;
 
   // Using the known-good backend.
   Expected<CC::FileType> FT =
       SafeInterpreter->OutputCode(BitcodeFile, OutputFile);
   if (Error E = FT.takeError())
-    return std::move(E);
+    return E;
 
   std::string SharedObjectFile;
   if (Error E = cc->MakeSharedObject(OutputFile, *FT, SharedObjectFile,
                                      AdditionalLinkerArgs))
-    return std::move(E);
+    return E;
 
   // Remove the intermediate C file
   sys::fs::remove(OutputFile);
 
   return SharedObjectFile;
 }
 
 /// Calls compileProgram and then records the output into ReferenceOutputFile.

 Expected<bool> BugDriver::diffProgram(const Module &Program,
                                       const std::string &BitcodeFile,
                                       const std::string &SharedObject,
                                       bool RemoveBitcode) const {
   // Execute the program, generating an output file...
   Expected<std::string> Output =
       executeProgram(Program, "", BitcodeFile, SharedObject, nullptr);
   if (Error E = Output.takeError())
-    return std::move(E);
+    return E;
 
   std::string Error;
   bool FilesDifferent = false;
   if (int Diff = DiffFilesWithTolerance(ReferenceOutputFile, *Output,
                                         AbsTolerance, RelTolerance, &Error)) {
     if (Diff == 2) {
       errs() << "While diffing output: " << Error << '\n';
       exit(1);

llvm/tools/bugpoint/ListReducer.h

template <typename ElTy> struct ListReducer {
   /// This function attempts to reduce the length of the specified list while
   /// still maintaining the "test" property.  This is the core of the "work"
   /// that bugpoint does.
   Expected<bool> reduceList(std::vector<ElTy> &TheList) {
     std::vector<ElTy> empty;
     std::mt19937 randomness(0x6e5ea738);  // Seed the random number generator
     Expected<TestResult> Result = doTest(TheList, empty);
     if (Error E = Result.takeError())
-      return std::move(E);
+      return E;
     switch (*Result) {
     case KeepPrefix:
       if (TheList.size() == 1) // we are done, it's the base case and it fails
         return true;
       else
         break; // there's definitely an error, but we need to narrow it down
 
     case KeepSuffix:
while (MidTop > 1) { // Binary split reduction loop
       }
 
       unsigned Mid = MidTop / 2;
       std::vector<ElTy> Prefix(TheList.begin(), TheList.begin() + Mid);
       std::vector<ElTy> Suffix(TheList.begin() + Mid, TheList.end());
 
       Expected<TestResult> Result = doTest(Prefix, Suffix);
       if (Error E = Result.takeError())
-        return std::move(E);
+        return E;
       switch (*Result) {
       case KeepSuffix:
         // The property still holds.  We can just drop the prefix elements, and
         // shorten the list to the "kept" elements.
         TheList.swap(Suffix);
         MidTop = TheList.size();
         // Reset progress treshold and progress counter
         MaxIterations = MaxIterationsWithoutProgress;
if (TheList.size() > 2) {
             return true;
           }
 
           std::vector<ElTy> TestList(TheList);
           TestList.erase(TestList.begin() + i);
 
           Expected<TestResult> Result = doTest(EmptyList, TestList);
           if (Error E = Result.takeError())
-            return std::move(E);
+            return E;
           if (*Result == KeepSuffix) {
             // We can trim down the list!
             TheList.swap(TestList);
             --i; // Don't skip an element of the list
             Changed = true;
           }
         }
         if (TrimIterations >= MaxTrimIterationsWithoutBackJump)

llvm/tools/bugpoint/Miscompilation.cpp

if (Error E = BD.debugOptimizerCrash())
       exit(1);
     exit(0);
   }
 
   // Check to see if the finished program matches the reference output...
   Expected<bool> Diff = BD.diffProgram(BD.getProgram(), BitcodeResult, "",
                                        true /*delete bitcode*/);
   if (Error E = Diff.takeError())
-    return std::move(E);
+    return E;
   if (*Diff) {
     outs() << " nope.\n";
     if (Suffix.empty()) {
       errs() << BD.getToolName() << ": I'm confused: the test fails when "
              << "no passes are run, nondeterministic program?\n";
       exit(1);
     }
     return KeepSuffix; // Miscompilation detected!
if (BD.runPasses(BD.getProgram(), Prefix, BitcodeResult, false /*delete*/,
     if (Error E = BD.debugOptimizerCrash())
       exit(1);
     exit(0);
   }
 
   // If the prefix maintains the predicate by itself, only keep the prefix!
   Diff = BD.diffProgram(BD.getProgram(), BitcodeResult, "", false);
   if (Error E = Diff.takeError())
-    return std::move(E);
+    return E;
   if (*Diff) {
     outs() << " nope.\n";
     sys::fs::remove(BitcodeResult);
     return KeepPrefix;
   }
   outs() << " yup.\n"; // No miscompilation!
 
   // Ok, so now we know that the prefix passes work, try running the suffix
if (Error E = BD.debugOptimizerCrash())
       exit(1);
     exit(0);
   }
 
   // Run the result...
   Diff = BD.diffProgram(BD.getProgram(), BitcodeResult, "",
                         true /*delete bitcode*/);
   if (Error E = Diff.takeError())
-    return std::move(E);
+    return E;
   if (*Diff) {
     outs() << " nope.\n";
     return KeepSuffix;
   }
 
   // Otherwise, we must not be running the bad pass anymore.
   outs() << " yup.\n"; // No miscompilation!
   // Restore orig program & free test.
ReduceMiscompilingFunctions(BugDriver &bd,
                                                   std::unique_ptr<Module>))
       : BD(bd), TestFn(F) {}
 
   Expected<TestResult> doTest(std::vector<Function *> &Prefix,
                               std::vector<Function *> &Suffix) override {
     if (!Suffix.empty()) {
       Expected<bool> Ret = TestFuncs(Suffix);
       if (Error E = Ret.takeError())
-        return std::move(E);
+        return E;
       if (*Ret)
         return KeepSuffix;
     }
     if (!Prefix.empty()) {
       Expected<bool> Ret = TestFuncs(Prefix);
       if (Error E = Ret.takeError())
-        return std::move(E);
+        return E;
       if (*Ret)
         return KeepPrefix;
     }
     return NoFailure;
   }
 
   Expected<bool> TestFuncs(const std::vector<Function *> &Prefix);
 };
static Expected<std::unique_ptr<Module>> testMergedProgram(const BugDriver &BD,
   auto Merged = CloneModule(M1);
   if (Linker::linkModules(*Merged, CloneModule(M2)))
     // TODO: Shouldn't we thread the error up instead of exiting?
     exit(1);
 
   // Execute the program.
   Expected<bool> Diff = BD.diffProgram(*Merged, "", "", false);
   if (Error E = Diff.takeError())
-    return std::move(E);
+    return E;
   Broken = *Diff;
-  return std::move(Merged);
+  return Merged;
 }
 
 /// split functions in a Module into two groups: those that are under
 /// consideration for miscompilation vs. those that are not, and test
 /// accordingly. Each group of functions becomes a separate Module.
 Expected<bool>
 ReduceMiscompilingFunctions::TestFuncs(const std::vector<Function *> &Funcs) {
   // Test to see if the function is misoptimized if we ONLY run it on the
while (1) {
     // we're going to test the newly loop extracted program to make sure nothing
     // has broken.  If something broke, then we'll inform the user and stop
     // extraction.
     AbstractInterpreter *AI = BD.switchToSafeInterpreter();
     bool Failure;
     Expected<std::unique_ptr<Module>> New = testMergedProgram(
         BD, *ToOptimizeLoopExtracted, *ToNotOptimize, Failure);
     if (Error E = New.takeError())
-      return std::move(E);
+      return E;
     if (!*New)
       return false;
 
     // Delete the original and set the new program.
     std::unique_ptr<Module> Old = BD.swapProgramIn(std::move(*New));
     for (unsigned i = 0, e = MiscompiledFunctions.size(); i != e; ++i)
       MiscompiledFunctions[i] = cast<Function>(VMap[MiscompiledFunctions[i]]);
 
while (1) {
     std::unique_ptr<Module> TNOBackup = CloneModule(*ToNotOptimize, VMap);
 
     for (unsigned i = 0, e = MiscompiledFunctions.size(); i != e; ++i)
       MiscompiledFunctions[i] = cast<Function>(VMap[MiscompiledFunctions[i]]);
 
     Expected<bool> Result = TestFn(BD, std::move(ToOptimizeLoopExtracted),
                                    std::move(ToNotOptimize));
     if (Error E = Result.takeError())
-      return std::move(E);
+      return E;
 
     ToOptimizeLoopExtracted = std::move(TOLEBackup);
     ToNotOptimize = std::move(TNOBackup);
 
     if (!*Result) {
       outs() << "*** Loop extraction masked the problem.  Undoing.\n";
       // If the program is not still broken, then loop extraction did something
       // that masked the error.  Stop loop extraction now.
ReduceMiscompiledBlocks(BugDriver &bd,
                           const std::vector<Function *> &Fns)
       : BD(bd), TestFn(F), FunctionsBeingTested(Fns) {}
 
   Expected<TestResult> doTest(std::vector<BasicBlock *> &Prefix,
                               std::vector<BasicBlock *> &Suffix) override {
     if (!Suffix.empty()) {
       Expected<bool> Ret = TestFuncs(Suffix);
       if (Error E = Ret.takeError())
-        return std::move(E);
+        return E;
       if (*Ret)
         return KeepSuffix;
     }
     if (!Prefix.empty()) {
       Expected<bool> Ret = TestFuncs(Prefix);
       if (Error E = Ret.takeError())
-        return std::move(E);
+        return E;
       if (*Ret)
         return KeepPrefix;
     }
     return NoFailure;
   }
 
   Expected<bool> TestFuncs(const std::vector<BasicBlock *> &BBs);
 };
ExtractBlocks(BugDriver &BD,
   // obscuring the bug.  The Blocks list will end up containing blocks that must
   // be retained from the original program.
   unsigned OldSize = Blocks.size();
 
   // Check to see if all blocks are extractible first.
   Expected<bool> Ret = ReduceMiscompiledBlocks(BD, TestFn, MiscompiledFunctions)
                            .TestFuncs(std::vector<BasicBlock *>());
   if (Error E = Ret.takeError())
-    return std::move(E);
+    return E;
   if (*Ret) {
     Blocks.clear();
   } else {
     Expected<bool> Ret =
         ReduceMiscompiledBlocks(BD, TestFn, MiscompiledFunctions)
             .reduceList(Blocks);
     if (Error E = Ret.takeError())
-      return std::move(E);
+      return E;
     if (Blocks.size() == OldSize)
       return false;
   }
 
   ValueToValueMapTy VMap;
   std::unique_ptr<Module> ProgClone = CloneModule(BD.getProgram(), VMap);
   std::unique_ptr<Module> ToExtract =
       SplitFunctionsOutOfModule(ProgClone.get(), MiscompiledFunctions, VMap);
if (!F.isDeclaration())
       MiscompiledFunctions.push_back(&F);
 
   // Do the reduction...
   if (!BugpointIsInterrupted) {
     Expected<bool> Ret = ReduceMiscompilingFunctions(BD, TestFn)
                              .reduceList(MiscompiledFunctions);
     if (Error E = Ret.takeError()) {
       errs() << "\n***Cannot reduce functions: ";
-      return std::move(E);
+      return E;
     }
   }
   outs() << "\n*** The following function"
          << (MiscompiledFunctions.size() == 1 ? " is" : "s are")
          << " being miscompiled: ";
   PrintFunctionList(MiscompiledFunctions);
   outs() << '\n';
 
   // See if we can rip any loops out of the miscompiled functions and still
   // trigger the problem.
 
   if (!BugpointIsInterrupted && !DisableLoopExtraction) {
     Expected<bool> Ret = ExtractLoops(BD, TestFn, MiscompiledFunctions);
     if (Error E = Ret.takeError())
-      return std::move(E);
+      return E;
     if (*Ret) {
       // Okay, we extracted some loops and the problem still appears.  See if
       // we can eliminate some of the created functions from being candidates.
       DisambiguateGlobalSymbols(BD.getProgram());
 
       // Do the reduction...
       if (!BugpointIsInterrupted)
         Ret = ReduceMiscompilingFunctions(BD, TestFn)
                   .reduceList(MiscompiledFunctions);
       if (Error E = Ret.takeError())
-        return std::move(E);
+        return E;
 
       outs() << "\n*** The following function"
              << (MiscompiledFunctions.size() == 1 ? " is" : "s are")
              << " being miscompiled: ";
       PrintFunctionList(MiscompiledFunctions);
       outs() << '\n';
     }
   }
 
   if (!BugpointIsInterrupted && !DisableBlockExtraction) {
     Expected<bool> Ret = ExtractBlocks(BD, TestFn, MiscompiledFunctions);
     if (Error E = Ret.takeError())
-      return std::move(E);
+      return E;
     if (*Ret) {
       // Okay, we extracted some blocks and the problem still appears.  See if
       // we can eliminate some of the created functions from being candidates.
       DisambiguateGlobalSymbols(BD.getProgram());
 
       // Do the reduction...
       Ret = ReduceMiscompilingFunctions(BD, TestFn)
                 .reduceList(MiscompiledFunctions);
       if (Error E = Ret.takeError())
-        return std::move(E);
+        return E;
 
       outs() << "\n*** The following function"
              << (MiscompiledFunctions.size() == 1 ? " is" : "s are")
              << " being miscompiled: ";
       PrintFunctionList(MiscompiledFunctions);
       outs() << '\n';
     }
   }
static Expected<bool> TestOptimizer(BugDriver &BD, std::unique_ptr<Module> Test,
   std::unique_ptr<Module> Optimized =
       BD.runPassesOn(Test.get(), BD.getPassesToRun());
   if (!Optimized) {
     errs() << " Error running this sequence of passes"
            << " on the input program!\n";
     BD.EmitProgressBitcode(*Test, "pass-error", false);
     BD.setNewProgram(std::move(Test));
     if (Error E = BD.debugOptimizerCrash())
-      return std::move(E);
+      return E;
     return false;
   }
   outs() << "done.\n";
 
   outs() << "  Checking to see if the merged program executes correctly: ";
   bool Broken;
   auto Result = testMergedProgram(BD, *Optimized, *Safe, Broken);
   if (Error E = Result.takeError())
-    return std::move(E);
+    return E;
   if (auto New = std::move(*Result)) {
     outs() << (Broken ? " nope.\n" : " yup.\n");
     // Delete the original and set the new program.
     BD.setNewProgram(std::move(New));
   }
   return Broken;
 }
 
if (BD.writeProgramToFile(SafeModuleBC.str(), SafeModuleFD, *Safe)) {
     exit(1);
   }
 
   FileRemover SafeModuleBCRemover(SafeModuleBC.str(), !SaveTemps);
 
   Expected<std::string> SharedObject =
       BD.compileSharedObject(SafeModuleBC.str());
   if (Error E = SharedObject.takeError())
-    return std::move(E);
+    return E;
 
   FileRemover SharedObjectRemover(*SharedObject, !SaveTemps);
 
   // Run the code generator on the `Test' code, loading the shared library.
   // The function returns whether or not the new output differs from reference.
   Expected<bool> Result =
       BD.diffProgram(BD.getProgram(), TestModuleBC.str(), *SharedObject, false);
   if (Error E = Result.takeError())
-    return std::move(E);
+    return E;
 
   if (*Result)
     errs() << ": still failing!\n";
   else
     errs() << ": didn't fail.\n";
 
   return Result;
 }

llvm/tools/bugpoint/ToolRunner.cpp

Expected<int> LLC::ExecuteProgram(const std::string &Bitcode,
                                   const std::vector<std::string> &SharedLibs,
                                   unsigned Timeout, unsigned MemoryLimit) {
 
   std::string OutputAsmFile;
   Expected<CC::FileType> FileKind =
       OutputCode(Bitcode, OutputAsmFile, Timeout, MemoryLimit);
   FileRemover OutFileRemover(OutputAsmFile, !SaveTemps);
   if (Error E = FileKind.takeError())
-    return std::move(E);
+    return E;
 
   std::vector<std::string> CCArgs(ArgsForCC);
   CCArgs.insert(CCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 
   // Assuming LLC worked, compile the result with CC and run it.
   return cc->ExecuteProgram(OutputAsmFile, Args, *FileKind, InputFile,
                             OutputFile, CCArgs, Timeout, MemoryLimit);
 }

llvm/tools/dsymutil/BinaryHolder.cpp

for (auto Child : Archive->children(Err)) {
           if (!ErrOrObjectFile)
             return ErrOrObjectFile.takeError();
 
           OE.Objects.push_back(std::move(*ErrOrObjectFile));
         }
       }
     }
     if (Err)
-      return std::move(Err);
+      return Err;
   }
 
   if (OE.Objects.empty())
     return errorCodeToError(errc::no_such_file_or_directory);
 
   std::lock_guard<std::mutex> Lock(MemberCacheMutex);
   MemberCache.try_emplace(Key, std::move(OE));
   return MemberCache[Key];
BinaryHolder::getObjectEntry(StringRef Filename, TimestampTy Timestamp) {
   // If this is an object, we might have it cached. If not we'll have to load
   // it from the file system and cache it now.
   std::lock_guard<std::mutex> Lock(ObjectCacheMutex);
   if (!ObjectCache.count(Filename)) {
     ObjectEntry &OE = ObjectCache[Filename];
     auto Err = OE.load(Filename, Verbose);
     if (Err) {
       ObjectCache.erase(Filename);
-      return std::move(Err);
+      return Err;
     }
   }
 
   return ObjectCache[Filename];
 }
 
 void BinaryHolder::clear() {
   std::lock_guard<std::mutex> ArchiveLock(ArchiveCacheMutex);
   std::lock_guard<std::mutex> ObjectLock(ObjectCacheMutex);
   ArchiveCache.clear();
   ObjectCache.clear();
 }
 
 } // namespace dsymutil
 } // namespace llvm

llvm/tools/dsymutil/DebugMap.cpp

DebugMap::parseYAMLDebugMap(StringRef InputFile, StringRef PrependPath,
   std::unique_ptr<DebugMap> Res;
   yaml::Input yin((*ErrOrFile)->getBuffer(), &Ctxt);
   yin >> Res;
 
   if (auto EC = yin.error())
     return EC;
   std::vector<std::unique_ptr<DebugMap>> Result;
   Result.push_back(std::move(Res));
-  return std::move(Result);
+  return Result;
 }
 
 } // end namespace dsymutil
 
 namespace yaml {
 
 // Normalize/Denormalize between YAML and a DebugMapObject.
 struct MappingTraits<dsymutil::DebugMapObject>::YamlDMO {

llvm/tools/dsymutil/MachODebugMapParser.cpp

if (!Objects) {
     return errorToErrorCode(ObjectEntry.takeError());
   }
 
   std::vector<std::unique_ptr<DebugMap>> Results;
   for (const auto *Object : *Objects)
     if (shouldLinkArch(Archs, Object->getArchTriple().getArchName()))
       Results.push_back(parseOneBinary(*Object, BinaryPath));
 
-  return std::move(Results);
+  return Results;
 }
 
 /// Interpret the STAB entries to fill the DebugMap.
 void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex,
                                                      uint8_t Type,
                                                      uint8_t SectionIndex,
                                                      uint16_t Flags,
                                                      uint64_t Value) {

llvm/tools/dsymutil/dsymutil.cpp

static Expected<OutputLocation> getOutputFileName(llvm::StringRef InputFile) {
   //             DWARF/
   //                <DWARF file(s)>
   std::string DwarfFile =
       InputFile == "-" ? llvm::StringRef("a.out") : InputFile;
   llvm::SmallString<128> Path(OutputFileOpt);
   if (Path.empty())
     Path = DwarfFile + ".dSYM";
   if (auto E = createBundleDir(Path))
-    return std::move(E);
+    return E;
   if (auto E = createPlistFile(DwarfFile, Path))
-    return std::move(E);
+    return E;
 
   llvm::sys::path::append(Path, "Contents", "Resources");
   std::string ResourceDir = Path.str();
   llvm::sys::path::append(Path, "DWARF", llvm::sys::path::filename(DwarfFile));
   return OutputLocation(Path.str(), ResourceDir);
 }
 
 /// Parses the command line options into the LinkOptions struct and performs

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));
   if (Error E = MemBufOrErr.takeError())
-    return std::move(E);
+    return 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");
-  return std::move(MemBuf);
+  return MemBuf;
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv, "llvm-bcanalyzer file analyzer\n");
   ExitOnError ExitOnErr("llvm-bcanalyzer: ");
 
   std::unique_ptr<MemoryBuffer> MB = ExitOnErr(openBitcodeFile(InputFilename));

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

default:
       return make_error<UnsupportedDisassembly>("Unsupported architecture.");
   }
 
   Analysis.ObjectTriple = Analysis.Object->makeTriple();
   Analysis.Features = Analysis.Object->getFeatures();
 
   // Init the rest of the object.
   if (auto InitResponse = Analysis.initialiseDisassemblyMembers())
-    return std::move(InitResponse);
+    return InitResponse;
 
   if (auto SectionParseResponse = Analysis.parseCodeSections())
-    return std::move(SectionParseResponse);
+    return SectionParseResponse;
 
   if (auto SymbolTableParseResponse = Analysis.parseSymbolTable())
-    return std::move(SymbolTableParseResponse);
+    return SymbolTableParseResponse;
 
-  return std::move(Analysis);
+  return Analysis;
 }
 
 FileAnalysis::FileAnalysis(object::OwningBinary<object::Binary> Binary)
     : Binary(std::move(Binary)) {}
 
 FileAnalysis::FileAnalysis(const Triple &ObjectTriple,
                            const SubtargetFeatures &Features)
     : ObjectTriple(ObjectTriple), Features(Features) {}

llvm/tools/llvm-cov/SourceCoverageView.cpp

if (auto E = sys::fs::create_directories(ParentDir))
     return errorCodeToError(E);
 
   std::error_code E;
   raw_ostream *RawStream =
       new raw_fd_ostream(FullPath, E, sys::fs::FA_Read | sys::fs::FA_Write);
   auto OS = CoveragePrinter::OwnedStream(RawStream);
   if (E)
     return errorCodeToError(E);
-  return std::move(OS);
+  return OS;
 }
 
 std::unique_ptr<CoveragePrinter>
 CoveragePrinter::create(const CoverageViewOptions &Opts) {
   switch (Opts.Format) {
   case CoverageViewOptions::OutputFormat::Text:
     return llvm::make_unique<CoveragePrinterText>(Opts);
   case CoverageViewOptions::OutputFormat::HTML:

llvm/tools/llvm-dwp/llvm-dwp.cpp

for (const auto &CU : DWARFCtx->compile_units()) {
     if (!DWOCompDir.empty()) {
       SmallString<16> DWOPath;
       sys::path::append(DWOPath, DWOCompDir, DWOName);
       DWOPaths.emplace_back(DWOPath.data(), DWOPath.size());
     } else {
       DWOPaths.push_back(std::move(DWOName));
     }
   }
-  return std::move(DWOPaths);
+  return DWOPaths;
 }
 
 static Error write(MCStreamer &Out, ArrayRef<std::string> Inputs) {
   const auto &MCOFI = *Out.getContext().getObjectFileInfo();
   MCSection *const StrSection = MCOFI.getDwarfStrDWOSection();
   MCSection *const StrOffsetSection = MCOFI.getDwarfStrOffDWOSection();
   MCSection *const TypesSection = MCOFI.getDwarfTypesDWOSection();
   MCSection *const CUIndexSection = MCOFI.getDwarfCUIndexSection();

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

buildStub(const ELFObjectFile<ELFT> &ElfObj) {
   Expected<Elf_Phdr_Range> PHdrs = ElfFile->program_headers();
   if (!PHdrs) {
     return PHdrs.takeError();
   }
 
   // Collect relevant .dynamic entries.
   DynamicEntries DynEnt;
   if (Error Err = populateDynamic<ELFT>(DynEnt, *DynTable))
-    return std::move(Err);
+    return Err;
 
     // Get pointer to in-memory location of .dynstr section.
   Expected<const uint8_t *> DynStrPtr =
       ElfFile->toMappedAddr(DynEnt.StrTabAddr);
   if (!DynStrPtr)
     return appendToError(DynStrPtr.takeError(),
                          "when locating .dynstr section contents");
 
Elf_Sym_Range DynSyms =
         ArrayRef<Elf_Sym>(reinterpret_cast<const Elf_Sym *>(*DynSymPtr),
                           *SymCount);
     Error SymReadError = populateSymbols<ELFT>(*DestStub, DynSyms, DynStr);
     if (SymReadError)
       return appendToError(std::move(SymReadError),
                            "when reading dynamic symbols");
   }
 
-  return std::move(DestStub);
+  return DestStub;
 }
 
 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
   Expected<std::unique_ptr<Binary>> BinOrErr = createBinary(Buf);
   if (!BinOrErr) {
     return BinOrErr.takeError();
   }
 

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

 
 llvm::Expected<std::string>
 BenchmarkRunner::writeObjectFile(const BenchmarkCode &BC,
                                  llvm::ArrayRef<llvm::MCInst> Code) const {
   int ResultFD = 0;
   llvm::SmallString<256> ResultPath;
   if (llvm::Error E = llvm::errorCodeToError(llvm::sys::fs::createTemporaryFile(
           "snippet", "o", ResultFD, ResultPath)))
-    return std::move(E);
+    return E;
   llvm::raw_fd_ostream OFS(ResultFD, true /*ShouldClose*/);
   assembleToStream(State.getExegesisTarget(), State.createTargetMachine(),
                    BC.LiveIns, BC.RegisterInitialValues, Code, OFS);
   return ResultPath.str();
 }
 
 BenchmarkRunner::FunctionExecutor::~FunctionExecutor() {}
 
 } // namespace exegesis
 } // namespace llvm

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

 llvm::Expected<InstructionBenchmarkClustering>
 InstructionBenchmarkClustering::create(
     const std::vector<InstructionBenchmark> &Points, const ModeE Mode,
     const size_t DbscanMinPts, const double AnalysisClusteringEpsilon,
     llvm::Optional<unsigned> NumOpcodes) {
   InstructionBenchmarkClustering Clustering(
       Points, AnalysisClusteringEpsilon * AnalysisClusteringEpsilon);
   if (auto Error = Clustering.validateAndSetup()) {
-    return std::move(Error);
+    return Error;
   }
   if (Clustering.ErrorCluster_.PointIndices.size() == Points.size()) {
     return Clustering; // Nothing to cluster.
   }
 
   if (Mode == ModeE::Dbscan) {
     Clustering.clusterizeDbScan(DbscanMinPts);
 

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

for (const auto ExecutionModeBit : getExecutionModeBits(EM & EC.Mask))
       appendCodeTemplates(State, Instr, ExecutionModeBit, EC.Description,
                           Results);
     if (!Results.empty())
       break;
   }
   if (Results.empty())
     return llvm::make_error<BenchmarkFailure>(
         "No strategy found to make the execution serial");
-  return std::move(Results);
+  return Results;
 }
 
 LatencyBenchmarkRunner::LatencyBenchmarkRunner(const LLVMState &State,
                                                InstructionBenchmark::ModeE Mode)
     : BenchmarkRunner(State, Mode) {
   assert((Mode == InstructionBenchmark::Latency ||
           Mode == InstructionBenchmark::InverseThroughput) &&
          "invalid mode");
case InstructionBenchmark::Latency:
     Result = {BenchmarkMeasure::Create("latency", MinValue)};
     break;
   case InstructionBenchmark::InverseThroughput:
     Result = {BenchmarkMeasure::Create("inverse_throughput", MinValue)};
     break;
   default:
     break;
   }
-  return std::move(Result);
+  return Result;
 }
 
 } // namespace exegesis
 } // namespace llvm

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

if (SelfAliasing.hasImplicitAliasing()) {
     CT.Info = "implicit Self cycles, picking random values.";
   } else {
     CT.Info = "explicit self cycles, selecting one aliasing Conf.";
     // This is a self aliasing instruction so defs and uses are from the same
     // instance, hence twice IT in the following call.
     setRandomAliasing(SelfAliasing, IT, IT);
   }
   CT.Instructions.push_back(std::move(IT));
-  return std::move(Result);
+  return Result;
 }
 
 llvm::Expected<std::vector<CodeTemplate>>
 generateUnconstrainedCodeTemplates(const Instruction &Instr,
                                    llvm::StringRef Msg) {
   std::vector<CodeTemplate> Result;
   Result.emplace_back();
   CodeTemplate &CT = Result.back();
   CT.Info = llvm::formatv("{0}, repeating an unconstrained assignment", Msg);
   CT.Instructions.emplace_back(Instr);
-  return std::move(Result);
+  return Result;
 }
 
 std::mt19937 &randomGenerator() {
   static std::random_device RandomDevice;
   static std::mt19937 RandomGenerator(RandomDevice());
   return RandomGenerator;
 }
 

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

UopsBenchmarkRunner::runMeasurements(const FunctionExecutor &Executor) const {
   // NumMicroOps.
   if (const char *const UopsCounter = PCI.UopsCounter) {
     auto ExpectedCounterValue = Executor.runAndMeasure(UopsCounter);
     if (!ExpectedCounterValue)
       return ExpectedCounterValue.takeError();
     Result.push_back(
         BenchmarkMeasure::Create("NumMicroOps", *ExpectedCounterValue));
   }
-  return std::move(Result);
+  return Result;
 }
 
 constexpr const size_t UopsSnippetGenerator::kMinNumDifferentAddresses;
 
 } // namespace exegesis
 } // namespace llvm

llvm/tools/llvm-exegesis/lib/X86/Target.cpp

public:
   generateCodeTemplates(const Instruction &Instr) const override;
 };
 } // namespace
 
 llvm::Expected<std::vector<CodeTemplate>>
 X86LatencySnippetGenerator::generateCodeTemplates(
     const Instruction &Instr) const {
   if (auto E = IsInvalidOpcode(Instr))
-    return std::move(E);
+    return E;
 
   switch (getX86FPFlags(Instr)) {
   case llvm::X86II::NotFP:
     return LatencySnippetGenerator::generateCodeTemplates(Instr);
   case llvm::X86II::ZeroArgFP:
   case llvm::X86II::OneArgFP:
   case llvm::X86II::SpecialFP:
   case llvm::X86II::CompareFP:
public:
   generateCodeTemplates(const Instruction &Instr) const override;
 };
 } // namespace
 
 llvm::Expected<std::vector<CodeTemplate>>
 X86UopsSnippetGenerator::generateCodeTemplates(
     const Instruction &Instr) const {
   if (auto E = IsInvalidOpcode(Instr))
-    return std::move(E);
+    return E;
 
   switch (getX86FPFlags(Instr)) {
   case llvm::X86II::NotFP:
     return UopsSnippetGenerator::generateCodeTemplates(Instr);
   case llvm::X86II::ZeroArgFP:
   case llvm::X86II::OneArgFP:
   case llvm::X86II::SpecialFP:
     return llvm::make_error<BenchmarkFailure>("Unsupported x87 Instruction");

 
 std::vector<llvm::MCInst> ConstantInliner::loadAndFinalize(unsigned Reg,
                                                            unsigned RegBitWidth,
                                                            unsigned Opcode) {
   assert((RegBitWidth & 7) == 0 && "RegBitWidth must be a multiple of 8 bits");
   initStack(RegBitWidth / 8);
   add(loadToReg(Reg, Opcode));
   add(releaseStackSpace(RegBitWidth / 8));
-  return std::move(Instructions);
+  return Instructions;
 }
 
 std::vector<llvm::MCInst> ConstantInliner::loadX87STAndFinalize(unsigned Reg) {
   initStack(kF80Bytes);
   add(llvm::MCInstBuilder(llvm::X86::LD_F80m)
           // Address = ESP
           .addReg(llvm::X86::RSP) // BaseReg
           .addImm(1)              // ScaleAmt
           .addReg(0)              // IndexReg
           .addImm(0)              // Disp
           .addReg(0));            // Segment
   if (Reg != llvm::X86::ST0)
     add(llvm::MCInstBuilder(llvm::X86::ST_Frr).addReg(Reg));
   add(releaseStackSpace(kF80Bytes));
-  return std::move(Instructions);
+  return Instructions;
 }
 
 std::vector<llvm::MCInst> ConstantInliner::loadX87FPAndFinalize(unsigned Reg) {
   initStack(kF80Bytes);
   add(llvm::MCInstBuilder(llvm::X86::LD_Fp80m)
           .addReg(Reg)
           // Address = ESP
           .addReg(llvm::X86::RSP) // BaseReg
           .addImm(1)              // ScaleAmt
           .addReg(0)              // IndexReg
           .addImm(0)              // Disp
           .addReg(0));            // Segment
   add(releaseStackSpace(kF80Bytes));
-  return std::move(Instructions);
+  return Instructions;
 }
 
 std::vector<llvm::MCInst> ConstantInliner::popFlagAndFinalize() {
   initStack(8);
   add(llvm::MCInstBuilder(llvm::X86::POPF64));
-  return std::move(Instructions);
+  return Instructions;
 }
 
 void ConstantInliner::initStack(unsigned Bytes) {
   assert(Constant_.getBitWidth() <= Bytes * 8 &&
          "Value does not have the correct size");
   const llvm::APInt WideConstant = Constant_.getBitWidth() < Bytes * 8
                                        ? Constant_.sext(Bytes * 8)
                                        : Constant_;

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

 
 ErrorOr<std::unique_ptr<ToolOutputFile>> getOutputStream() {
   if (OutputFilename == "")
     OutputFilename = "-";
   std::error_code EC;
   auto Out =
       llvm::make_unique<ToolOutputFile>(OutputFilename, EC, sys::fs::OF_None);
   if (!EC)
-    return std::move(Out);
+    return Out;
   return EC;
 }
 } // end of anonymous namespace
 
 static void processOptionImpl(cl::opt<bool> &O, const cl::opt<bool> &Default) {
   if (!O.getNumOccurrences() || O.getPosition() < Default.getPosition())
     O = Default.getValue();
 }

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

if (CFH) {
     // Only copying the few fields from the bigobj header that we need
     // and won't recreate in the end.
     Obj->CoffFileHeader.Machine = CBFH->Machine;
     Obj->CoffFileHeader.TimeDateStamp = CBFH->TimeDateStamp;
     IsBigObj = true;
   }
 
   if (Error E = readExecutableHeaders(*Obj))
-    return std::move(E);
+    return E;
   if (Error E = readSections(*Obj))
-    return std::move(E);
+    return E;
   if (Error E = readSymbols(*Obj, IsBigObj))
-    return std::move(E);
+    return E;
   if (Error E = setSymbolTargets(*Obj))
-    return std::move(E);
+    return E;
 
-  return std::move(Obj);
+  return Obj;
 }
 
 } // end namespace coff
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/CopyConfig.cpp

if (!Config.SymbolsToRename.insert(Old2New).second)
       return createStringError(errc::invalid_argument,
                                "multiple redefinition of symbol '%s'",
                                Old2New.first.str().c_str());
   }
 
   for (auto Arg : InputArgs.filtered(OBJCOPY_redefine_symbols))
     if (Error E = addSymbolsToRenameFromFile(Config.SymbolsToRename, DC.Alloc,
                                              Arg->getValue()))
-      return std::move(E);
+      return E;
 
   for (auto Arg : InputArgs.filtered(OBJCOPY_rename_section)) {
     Expected<SectionRename> SR =
         parseRenameSectionValue(StringRef(Arg->getValue()));
     if (!SR)
       return SR.takeError();
     if (!Config.SectionsToRename.try_emplace(SR->OriginalName, *SR).second)
       return createStringError(errc::invalid_argument,
Config.DecompressDebugSections =
       InputArgs.hasArg(OBJCOPY_decompress_debug_sections);
   if (Config.DiscardMode == DiscardType::All)
     Config.StripDebug = true;
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbol))
     Config.SymbolsToLocalize.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToLocalize, DC.Alloc,
                                      Arg->getValue(), UseRegex))
-      return std::move(E);
+      return E;
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbol))
     Config.SymbolsToKeepGlobal.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToKeepGlobal, DC.Alloc,
                                      Arg->getValue(), UseRegex))
-      return std::move(E);
+      return E;
   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbol))
     Config.SymbolsToGlobalize.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToGlobalize, DC.Alloc,
                                      Arg->getValue(), UseRegex))
-      return std::move(E);
+      return E;
   for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbol))
     Config.SymbolsToWeaken.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToWeaken, DC.Alloc,
                                      Arg->getValue(), UseRegex))
-      return std::move(E);
+      return E;
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbol))
     Config.SymbolsToRemove.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToRemove, DC.Alloc,
                                      Arg->getValue(), UseRegex))
-      return std::move(E);
+      return E;
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_unneeded_symbol))
     Config.UnneededSymbolsToRemove.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_unneeded_symbols))
     if (Error E = addSymbolsFromFile(Config.UnneededSymbolsToRemove, DC.Alloc,
                                      Arg->getValue(), UseRegex))
-      return std::move(E);
+      return E;
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbol))
     Config.SymbolsToKeep.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToKeep, DC.Alloc,
                                      Arg->getValue(), UseRegex))
-      return std::move(E);
+      return E;
   for (auto Arg : InputArgs.filtered(OBJCOPY_add_symbol)) {
     Expected<NewSymbolInfo> NSI = parseNewSymbolInfo(Arg->getValue());
     if (!NSI)
       return NSI.takeError();
     Config.SymbolsToAdd.push_back(*NSI);
   }
 
   Config.AllowBrokenLinks = InputArgs.hasArg(OBJCOPY_allow_broken_links);
return createStringError(
         "LLVM was not compiled with LLVM_ENABLE_ZLIB: cannot decompress");
 
   if (Config.ExtractPartition && Config.ExtractMainPartition)
     return createStringError(errc::invalid_argument,
                              "cannot specify --extract-partition together with "
                              "--extract-main-partition");
 
   DC.CopyConfigs.push_back(std::move(Config));
-  return std::move(DC);
+  return DC;
 }
 
 // ParseStripOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseStripOptions will print the help messege and
 // exit.
 Expected<DriverConfig>
 parseStripOptions(ArrayRef<const char *> ArgsArr,
                   std::function<Error(Error)> ErrorCallback) {
for (StringRef Filename : Positional) {
       if (InputFiles[Filename]++ == 1) {
         if (Filename == "-")
           return createStringError(
               errc::invalid_argument,
               "cannot specify '-' as an input file more than once");
         if (Error E = ErrorCallback(createStringError(
                 errc::invalid_argument, "'%s' was already specified",
                 Filename.str().c_str())))
-          return std::move(E);
+          return E;
       }
       Config.InputFilename = Filename;
       Config.OutputFilename = Filename;
       DC.CopyConfigs.push_back(Config);
     }
   }
 
   if (Config.PreserveDates && (is_contained(Positional, "-") ||
                                InputArgs.getLastArgValue(STRIP_output) == "-"))
     return createStringError(errc::invalid_argument,
                              "--preserve-dates requires a file");
 
-  return std::move(DC);
+  return DC;
 }
 
 } // namespace objcopy
 } // namespace llvm

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

Expected<IHexRecord> IHexRecord::parse(StringRef Line) {
   assert(!Line.empty());
 
   // ':' + Length + Address + Type + Checksum with empty data ':LLAAAATTCC'
   if (Line.size() < 11)
     return createStringError(errc::invalid_argument,
                              "line is too short: %zu chars.", Line.size());
 
   if (Error E = checkChars(Line))
-    return std::move(E);
+    return E;
 
   IHexRecord Rec;
   size_t DataLen = checkedGetHex<uint8_t>(Line.substr(1, 2));
   if (Line.size() != getLength(DataLen))
     return createStringError(errc::invalid_argument,
                              "invalid line length %zu (should be %zu)",
                              Line.size(), getLength(DataLen));
 
   Rec.Addr = checkedGetHex<uint16_t>(Line.substr(3, 4));
   Rec.Type = checkedGetHex<uint8_t>(Line.substr(7, 2));
   Rec.HexData = Line.substr(9, DataLen * 2);
 
   if (getChecksum(Line.drop_front(1)) != 0)
     return createStringError(errc::invalid_argument, "incorrect checksum.");
   if (Error E = checkRecord(Rec))
-    return std::move(E);
+    return E;
   return Rec;
 }
 
 static uint64_t sectionPhysicalAddr(const SectionBase *Sec) {
   Segment *Seg = Sec->ParentSegment;
   if (Seg && Seg->Type != ELF::PT_LOAD)
     Seg = nullptr;
   return Seg ? Seg->PAddr + Sec->OriginalOffset - Seg->OriginalOffset
for (size_t LineNo = 1; LineNo <= Lines.size(); ++LineNo) {
     if (R->Type == IHexRecord::EndOfFile)
       break;
     HasSections |= (R->Type == IHexRecord::Data);
     Records.push_back(*R);
   }
   if (!HasSections)
     return parseError(-1U, "no sections");
 
-  return std::move(Records);
+  return Records;
 }
 
 std::unique_ptr<Object> IHexReader::create() const {
   std::vector<IHexRecord> Records = unwrapOrError(parse());
   return IHexELFBuilder(Records).build();
 }
 
 std::unique_ptr<Object> ELFReader::create() const {

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

static Expected<ModuleDebugStreamRef> getModuleDebugStream(PDBFile &File,
 
   auto ModStreamData = File.createIndexedStream(ModiStream);
 
   ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
   if (auto EC = ModS.reload())
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Invalid module stream");
 
-  return std::move(ModS);
+  return ModS;
 }
 
 template <typename CallbackT>
 static void
 iterateOneModule(InputFile &File, const Optional<PrintScope> &HeaderScope,
                  const SymbolGroup &SG, uint32_t Modi, CallbackT Callback) {
   if (HeaderScope) {
     HeaderScope->P.formatLine(

llvm/tools/llvm-pdbutil/InputFile.cpp

getModuleDebugStream(PDBFile &File, StringRef &ModuleName, uint32_t Index) {
 
   auto ModStreamData = File.createIndexedStream(ModiStream);
 
   ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
   if (auto EC = ModS.reload())
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Invalid module stream");
 
-  return std::move(ModS);
+  return ModS;
 }
 
 static inline bool isCodeViewDebugSubsection(object::SectionRef Section,
                                              StringRef Name,
                                              BinaryStreamReader &Reader) {
   StringRef SectionName;
   if (Section.getName(SectionName))
     return false;
Expected<InputFile> InputFile::open(StringRef Path, bool AllowUnknownFile) {
 
   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);
+    return IF;
   }
 
   if (Magic == file_magic::pdb) {
     std::unique_ptr<IPDBSession> Session;
     if (auto Err = loadDataForPDB(PDB_ReaderType::Native, Path, Session))
-      return std::move(Err);
+      return Err;
 
     IF.PdbSession.reset(static_cast<NativeSession *>(Session.release()));
     IF.PdbOrObj = &IF.PdbSession->getPDBFile();
 
-    return std::move(IF);
+    return IF;
   }
 
   if (!AllowUnknownFile)
     return make_error<StringError>(
         formatv("File {0} is not a supported file type", Path),
         inconvertibleErrorCode());
 
   auto Result = MemoryBuffer::getFile(Path, -1LL, false);
   if (!Result)
     return make_error<StringError>(
         formatv("File {0} could not be opened", Path), Result.getError());
 
   IF.UnknownFile = std::move(*Result);
   IF.PdbOrObj = IF.UnknownFile.get();
-  return std::move(IF);
+  return IF;
 }
 
 PDBFile &InputFile::pdb() {
   assert(isPdb());
   return *PdbOrObj.get<PDBFile *>();
 }
 
 const PDBFile &InputFile::pdb() const {

llvm/tools/llvm-rc/ResourceScriptParser.cpp

 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 
 // Take an expression returning llvm::Error and forward the error if it exists.
 #define RETURN_IF_ERROR(Expr)                                                  \
   if (auto Err = (Expr))                                                       \
-    return std::move(Err);
+    return Err;
 
 // Take an expression returning llvm::Expected<T> and assign it to Var or
 // forward the error out of the function.
 #define ASSIGN_OR_RETURN(Var, Expr)                                            \
   auto Var = (Expr);                                                           \
   if (!Var)                                                                    \
     return Var.takeError();
 
Expected<SmallVector<RCInt, 8>> RCParser::readIntsWithCommas(size_t MinCount,
                                                              size_t MaxCount) {
   assert(MinCount <= MaxCount);
 
   SmallVector<RCInt, 8> Result;
 
   auto FailureHandler =
       [&](llvm::Error Err) -> Expected<SmallVector<RCInt, 8>> {
     if (Result.size() < MinCount)
-      return std::move(Err);
+      return Err;
     consumeError(std::move(Err));
     return Result;
   };
 
   for (size_t i = 0; i < MaxCount; ++i) {
     // Try to read a comma unless we read the first token.
     // Sometimes RC tool requires them and sometimes not. We decide to
     // always require them.
     if (i >= 1) {
       if (auto CommaError = consumeType(Kind::Comma))
         return FailureHandler(std::move(CommaError));
     }
 
     if (auto IntResult = readInt())
       Result.push_back(*IntResult);
     else
       return FailureHandler(IntResult.takeError());
   }
 
-  return std::move(Result);
+  return Result;
 }
 
 Expected<uint32_t> RCParser::parseFlags(ArrayRef<StringRef> FlagDesc,
                                         ArrayRef<uint32_t> FlagValues) {
   assert(!FlagDesc.empty());
   assert(FlagDesc.size() == FlagValues.size());
 
   uint32_t Result = 0;
RCParser::parseOptionalStatements(OptStmtType StmtsType) {
   OptionalStmtList Result;
 
   // The last statement is always followed by the start of the block.
   while (!isNextTokenKind(Kind::BlockBegin)) {
     ASSIGN_OR_RETURN(SingleParse, parseSingleOptionalStatement(StmtsType));
     Result.addStmt(std::move(*SingleParse));
   }
 
-  return std::move(Result);
+  return Result;
 }
 
 Expected<std::unique_ptr<OptionalStmt>>
 RCParser::parseSingleOptionalStatement(OptStmtType StmtsType) {
   ASSIGN_OR_RETURN(TypeToken, readIdentifier());
   if (TypeToken->equals_lower("CHARACTERISTICS"))
     return parseCharacteristicsStmt();
   if (TypeToken->equals_lower("LANGUAGE"))
while (!consumeOptionalType(Kind::BlockEnd)) {
     ASSIGN_OR_RETURN(IDResult, readInt());
     ASSIGN_OR_RETURN(
         FlagsResult,
         parseFlags(AcceleratorsResource::Accelerator::OptionsStr,
                    AcceleratorsResource::Accelerator::OptionsFlags));
     Accels->addAccelerator(*EventResult, *IDResult, *FlagsResult);
   }
 
-  return std::move(Accels);
+  return Accels;
 }
 
 RCParser::ParseType RCParser::parseCursorResource() {
   uint16_t MemoryFlags =
       parseMemoryFlags(CursorResource::getDefaultMemoryFlags());
   ASSIGN_OR_RETURN(Arg, readFilename());
   return llvm::make_unique<CursorResource>(*Arg, MemoryFlags);
 }
auto Dialog = llvm::make_unique<DialogResource>(
       (*LocResult)[0], (*LocResult)[1], (*LocResult)[2], (*LocResult)[3],
       HelpID, std::move(*OptStatements), IsExtended, MemoryFlags);
 
   while (!consumeOptionalType(Kind::BlockEnd)) {
     ASSIGN_OR_RETURN(ControlDefResult, parseControl());
     Dialog->addControl(std::move(*ControlDefResult));
   }
 
-  return std::move(Dialog);
+  return Dialog;
 }
 
 RCParser::ParseType RCParser::parseUserDefinedResource(IntOrString Type) {
   uint16_t MemoryFlags =
       parseMemoryFlags(UserDefinedResource::getDefaultMemoryFlags());
   if (isEof())
     return getExpectedError("filename, '{' or BEGIN");
 
if (IsPopup) {
       continue;
     }
 
     assert(IsMenuItem);
     List.addDefinition(
         llvm::make_unique<MenuItem>(*CaptionResult, MenuResult, *FlagsResult));
   }
 
-  return std::move(List);
+  return List;
 }
 
 RCParser::ParseType RCParser::parseStringTableResource() {
   uint16_t MemoryFlags =
       parseMemoryFlags(StringTableResource::getDefaultMemoryFlags());
   ASSIGN_OR_RETURN(OptStatements, parseOptionalStatements());
   RETURN_IF_ERROR(consumeType(Kind::BlockBegin));
 
   auto Table = llvm::make_unique<StringTableResource>(std::move(*OptStatements),
                                                       MemoryFlags);
 
   // Read strings until we reach the end of the block.
   while (!consumeOptionalType(Kind::BlockEnd)) {
     // Each definition consists of string's ID (an integer) and a string.
     // Some examples in documentation suggest that there might be a comma in
     // between, however we strictly adhere to the single statement definition.
     ASSIGN_OR_RETURN(IDResult, readInt());
     consumeOptionalType(Kind::Comma);
     ASSIGN_OR_RETURN(StrResult, readString());
     Table->addString(*IDResult, *StrResult);
   }
 
-  return std::move(Table);
+  return Table;
 }
 
 Expected<std::unique_ptr<VersionInfoBlock>>
 RCParser::parseVersionInfoBlockContents(StringRef BlockName) {
   RETURN_IF_ERROR(consumeType(Kind::BlockBegin));
 
   auto Contents = llvm::make_unique<VersionInfoBlock>(BlockName);
 
   while (!isNextTokenKind(Kind::BlockEnd)) {
     ASSIGN_OR_RETURN(Stmt, parseVersionInfoStmt());
     Contents->addStmt(std::move(*Stmt));
   }
 
   consume(); // Consume BlockEnd.
 
-  return std::move(Contents);
+  return Contents;
 }
 
 Expected<std::unique_ptr<VersionInfoStmt>> RCParser::parseVersionInfoStmt() {
   // Expect either BLOCK or VALUE, then a name or a key (a string).
   ASSIGN_OR_RETURN(TypeResult, readIdentifier());
 
   if (TypeResult->equals_lower("BLOCK")) {
     ASSIGN_OR_RETURN(NameResult, readString());

llvm/tools/llvm-rc/ResourceScriptToken.cpp

if (!skipWhitespaces())
       break;
 
     Kind TokenKind = classifyCurrentToken();
     if (TokenKind == Kind::Invalid)
       return getStringError("Invalid token found at position " + Twine(Pos));
 
     const size_t TokenStart = Pos;
     if (Error TokenError = consumeToken(TokenKind))
-      return std::move(TokenError);
+      return TokenError;
 
     // Comments are just deleted, don't bother saving them.
     if (TokenKind == Kind::LineComment || TokenKind == Kind::StartComment)
       continue;
 
     RCToken Token(TokenKind, Data.take_front(Pos).drop_front(TokenStart));
     if (TokenKind == Kind::Identifier) {
       processIdentifier(Token);

llvm/tools/obj2yaml/elf2yaml.cpp

template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
   Sections = *SectionsOrErr;
   SectionNames.resize(Sections.size());
 
   // Dump symbols. We need to do this early because other sections might want
   // to access the deduplicated symbol names that we also create here.
   for (const Elf_Shdr &Sec : Sections) {
     if (Sec.sh_type == ELF::SHT_SYMTAB)
       if (Error E = dumpSymbols(&Sec, Y->Symbols))
-        return std::move(E);
+        return E;
     if (Sec.sh_type == ELF::SHT_DYNSYM)
       if (Error E = dumpSymbols(&Sec, Y->DynamicSymbols))
-        return std::move(E);
+        return E;
   }
 
   for (const Elf_Shdr &Sec : Sections) {
     switch (Sec.sh_type) {
     case ELF::SHT_DYNAMIC: {
       Expected<ELFYAML::DynamicSection *> SecOrErr = dumpDynamicSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
Error ELFDumper<ELFT>::dumpCommonRelocationSection(
   return Error::success();
 }
 
 template <class ELFT>
 Expected<ELFYAML::DynamicSection *>
 ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::DynamicSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(Shdr);
   if (!DynTagsOrErr)
     return DynTagsOrErr.takeError();
 
   for (const Elf_Dyn &Dyn : *DynTagsOrErr)
     S->Entries.push_back({(ELFYAML::ELF_DYNTAG)Dyn.getTag(), Dyn.getVal()});
 
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::RelocationSection *>
 ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::RelocationSection>();
   if (auto E = dumpCommonRelocationSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
   if (!SymTabOrErr)
     return SymTabOrErr.takeError();
   const Elf_Shdr *SymTab = *SymTabOrErr;
 
   if (Shdr->sh_type == ELF::SHT_REL) {
     auto Rels = Obj.rels(Shdr);
     if (!Rels)
       return Rels.takeError();
     for (const Elf_Rel &Rel : *Rels) {
       ELFYAML::Relocation R;
       if (Error E = dumpRelocation(&Rel, SymTab, R))
-        return std::move(E);
+        return E;
       S->Relocations.push_back(R);
     }
   } else {
     auto Rels = Obj.relas(Shdr);
     if (!Rels)
       return Rels.takeError();
     for (const Elf_Rela &Rel : *Rels) {
       ELFYAML::Relocation R;
       if (Error E = dumpRelocation(&Rel, SymTab, R))
-        return std::move(E);
+        return E;
       R.Addend = Rel.r_addend;
       S->Relocations.push_back(R);
     }
   }
 
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::RawContentSection *>
 ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::RawContentSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)
     return ContentOrErr.takeError();
   ArrayRef<uint8_t> Content = *ContentOrErr;
   if (!Content.empty())
     S->Content = yaml::BinaryRef(Content);
   if (Shdr->sh_info)
     S->Info = static_cast<llvm::yaml::Hex64>(Shdr->sh_info);
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::NoBitsSection *>
 ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::NoBitsSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
   S->Size = Shdr->sh_size;
 
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::VerdefSection *>
 ELFDumper<ELFT>::dumpVerdefSection(const Elf_Shdr *Shdr) {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Verdaux Elf_Verdaux;
 
   auto S = make_unique<ELFYAML::VerdefSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   S->Info = Shdr->sh_info;
 
   auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
   if (!StringTableShdrOrErr)
     return StringTableShdrOrErr.takeError();
 
   auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);

 
 template <class ELFT>
 Expected<ELFYAML::SymverSection *>
 ELFDumper<ELFT>::dumpSymverSection(const Elf_Shdr *Shdr) {
   typedef typename ELFT::Half Elf_Half;
 
   auto S = make_unique<ELFYAML::SymverSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   auto VersionsOrErr = Obj.template getSectionContentsAsArray<Elf_Half>(Shdr);
   if (!VersionsOrErr)
     return VersionsOrErr.takeError();
   for (const Elf_Half &E : *VersionsOrErr)
     S->Entries.push_back(E);
 
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::VerneedSection *>
 ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
   typedef typename ELFT::Verneed Elf_Verneed;
   typedef typename ELFT::Vernaux Elf_Vernaux;
 
   auto S = make_unique<ELFYAML::VerneedSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   S->Info = Shdr->sh_info;
 
   auto Contents = Obj.getSectionContents(Shdr);
   if (!Contents)
     return Contents.takeError();
 
   auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
 
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::Group>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   auto SymtabOrErr = Obj.getSection(Shdr->sh_link);
   if (!SymtabOrErr)
     return SymtabOrErr.takeError();
   // Get symbol with index sh_info which name is the signature of the group.
   const Elf_Shdr *Symtab = *SymtabOrErr;
   auto SymOrErr = Obj.getSymbol(Symtab, Shdr->sh_info);
   if (!SymOrErr)

 
 template <class ELFT>
 Expected<ELFYAML::MipsABIFlags *>
 ELFDumper<ELFT>::dumpMipsABIFlags(const Elf_Shdr *Shdr) {
   assert(Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS &&
          "Section type is not SHT_MIPS_ABIFLAGS");
   auto S = make_unique<ELFYAML::MipsABIFlags>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)
     return ContentOrErr.takeError();
 
   auto *Flags = reinterpret_cast<const object::Elf_Mips_ABIFlags<ELFT> *>(
       ContentOrErr.get().data());
   S->Version = Flags->version;

llvm/tools/obj2yaml/macho2yaml.cpp

Expected<std::unique_ptr<MachOYAML::Object>> MachODumper::dump() {
   Y->IsLittleEndian = Obj.isLittleEndian();
   dumpHeader(Y);
   dumpLoadCommands(Y);
   dumpLinkEdit(Y);
 
   std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
   if (auto Err = dwarf2yaml(*DICtx, Y->DWARF))
     return errorCodeToError(Err);
-  return std::move(Y);
+  return Y;
 }
 
 void MachODumper::dumpHeader(std::unique_ptr<MachOYAML::Object> &Y) {
   Y->Header.magic = Obj.getHeader().magic;
   Y->Header.cputype = Obj.getHeader().cputype;
   Y->Header.cpusubtype = Obj.getHeader().cpusubtype;
   Y->Header.filetype = Obj.getHeader().filetype;
   Y->Header.ncmds = Obj.getHeader().ncmds;

llvm/utils/TableGen/GlobalISelEmitter.cpp

for (unsigned i = 0, e = Src->getNumChildren(); i != e; ++i) {
         }
 
         return failedImport("Expected IntInit containing instrinsic ID)");
       }
 
       if (auto Error =
               importChildMatcher(Rule, InsnMatcher, SrcChild, OperandIsAPointer,
                                  OpIdx++, TempOpIdx))
-        return std::move(Error);
+        return Error;
     }
   }
 
   return InsnMatcher;
 }
 
 Error GlobalISelEmitter::importComplexPatternOperandMatcher(
     OperandMatcher &OM, Record *R, unsigned &TempOpIdx) const {
if (DstChild->getOperator()->isSubClassOf("Instruction")) {
       unsigned TempRegID = Rule.allocateTempRegID();
       InsertPt = Rule.insertAction<MakeTempRegisterAction>(
           InsertPt, OpTyOrNone.getValue(), TempRegID);
       DstMIBuilder.addRenderer<TempRegRenderer>(TempRegID);
 
       auto InsertPtOrError = createAndImportSubInstructionRenderer(
           ++InsertPt, Rule, DstChild, TempRegID);
       if (auto Error = InsertPtOrError.takeError())
-        return std::move(Error);
+        return Error;
       return InsertPtOrError.get();
     }
 
     return failedImport("Dst pattern child isn't a leaf node or an MBB" + llvm::to_string(*DstChild));
   }
 
   // It could be a specific immediate in which case we should just check for
   // that immediate.
Expected<action_iterator> GlobalISelEmitter::importExplicitUseRenderer(
 
   return failedImport("Dst pattern child is an unsupported kind");
 }
 
 Expected<BuildMIAction &> GlobalISelEmitter::createAndImportInstructionRenderer(
     RuleMatcher &M, const TreePatternNode *Dst) {
   auto InsertPtOrError = createInstructionRenderer(M.actions_end(), M, Dst);
   if (auto Error = InsertPtOrError.takeError())
-    return std::move(Error);
+    return Error;
 
   action_iterator InsertPt = InsertPtOrError.get();
   BuildMIAction &DstMIBuilder = *static_cast<BuildMIAction *>(InsertPt->get());
 
   importExplicitDefRenderers(DstMIBuilder);
 
   if (auto Error = importExplicitUseRenderers(InsertPt, M, DstMIBuilder, Dst)
                        .takeError())
-    return std::move(Error);
+    return Error;
 
   return DstMIBuilder;
 }
 
 Expected<action_iterator>
 GlobalISelEmitter::createAndImportSubInstructionRenderer(
     const action_iterator InsertPt, RuleMatcher &M, const TreePatternNode *Dst,
     unsigned TempRegID) {
   auto InsertPtOrError = createInstructionRenderer(InsertPt, M, Dst);
 
   // TODO: Assert there's exactly one result.
 
   if (auto Error = InsertPtOrError.takeError())
-    return std::move(Error);
+    return Error;
 
   BuildMIAction &DstMIBuilder =
       *static_cast<BuildMIAction *>(InsertPtOrError.get()->get());
 
   // Assign the result to TempReg.
   DstMIBuilder.addRenderer<TempRegRenderer>(TempRegID, true);
 
   InsertPtOrError =
       importExplicitUseRenderers(InsertPtOrError.get(), M, DstMIBuilder, Dst);
   if (auto Error = InsertPtOrError.takeError())
-    return std::move(Error);
+    return Error;
 
   M.insertAction<ConstrainOperandsToDefinitionAction>(InsertPt,
                                                       DstMIBuilder.getInsnID());
   return InsertPtOrError.get();
 }
 
 Expected<action_iterator> GlobalISelEmitter::createInstructionRenderer(
     action_iterator InsertPt, RuleMatcher &M, const TreePatternNode *Dst) {
for (unsigned I = 0; I != DstINumUses; ++I) {
     // FIXME: Until we have a decent test case that dictates we should do
     // otherwise, we're going to assume that operands with default values cannot
     // be specified in the patterns. Therefore, adding them will not cause us to
     // end up with too many rendered operands.
     if (DstIOperand.Rec->isSubClassOf("OperandWithDefaultOps")) {
       DagInit *DefaultOps = DstIOperand.Rec->getValueAsDag("DefaultOps");
       if (auto Error = importDefaultOperandRenderers(
             InsertPt, M, DstMIBuilder, DefaultOps))
-        return std::move(Error);
+        return Error;
       ++NumDefaultOps;
       continue;
     }
 
     auto InsertPtOrError = importExplicitUseRenderer(InsertPt, M, DstMIBuilder,
                                                      Dst->getChild(Child));
     if (auto Error = InsertPtOrError.takeError())
-      return std::move(Error);
+      return Error;
     InsertPt = InsertPtOrError.get();
     ++Child;
   }
 
   if (NumDefaultOps + ExpectedDstINumUses != DstINumUses)
     return failedImport("Expected " + llvm::to_string(DstINumUses) +
                         " used operands but found " +
                         llvm::to_string(ExpectedDstINumUses) +
Expected<RuleMatcher> GlobalISelEmitter::runOnPattern(const PatternToMatch &P) {
   int Score = P.getPatternComplexity(CGP);
   RuleMatcher M(P.getSrcRecord()->getLoc());
   RuleMatcherScores[M.getRuleID()] = Score;
   M.addAction<DebugCommentAction>(llvm::to_string(*P.getSrcPattern()) +
                                   "  =>  " +
                                   llvm::to_string(*P.getDstPattern()));
 
   if (auto Error = importRulePredicates(M, P.getPredicates()))
-    return std::move(Error);
+    return Error;
 
   // Next, analyze the pattern operators.
   TreePatternNode *Src = P.getSrcPattern();
   TreePatternNode *Dst = P.getDstPattern();
 
   // If the root of either pattern isn't a simple operator, ignore it.
   if (auto Err = isTrivialOperatorNode(Dst))
     return failedImport("Dst pattern root isn't a trivial operator (" +
Expected<RuleMatcher> GlobalISelEmitter::runOnPattern(const PatternToMatch &P) {
   // the capture accross rules. The downside is that it would
   // introduce a dependency between predicates (captures must happen
   // before their first use.)
   InstructionMatcher &InsnMatcherTemp = M.addInstructionMatcher(Src->getName());
   unsigned TempOpIdx = 0;
   auto InsnMatcherOrError =
       createAndImportSelDAGMatcher(M, InsnMatcherTemp, Src, TempOpIdx);
   if (auto Error = InsnMatcherOrError.takeError())
-    return std::move(Error);
+    return Error;
   InstructionMatcher &InsnMatcher = InsnMatcherOrError.get();
 
   if (Dst->isLeaf()) {
     Record *RCDef = getInitValueAsRegClass(Dst->getLeafValue());
 
     const CodeGenRegisterClass &RC = Target.getRegisterClass(RCDef);
     if (RCDef) {
       // We need to replace the def and all its uses with the specified
if (RCDef) {
           M.addAction<BuildMIAction>(M.allocateOutputInsnID(), &DstI);
       DstMIBuilder.addRenderer<CopyRenderer>(DstIOperand.Name);
       DstMIBuilder.addRenderer<CopyRenderer>(Dst->getName());
       M.addAction<ConstrainOperandToRegClassAction>(0, 0, RC);
 
       // We're done with this pattern!  It's eligible for GISel emission; return
       // it.
       ++NumPatternImported;
-      return std::move(M);
+      return M;
     }
 
     return failedImport("Dst pattern root isn't a known leaf");
   }
 
   // Start with the defined operands (i.e., the results of the root operator).
   Record *DstOp = Dst->getOperator();
   if (!DstOp->isSubClassOf("Instruction"))
for (const TypeSetByHwMode &VTy : Src->getExtTypes()) {
     M.defineOperand(OM.getSymbolicName(), OM);
     OM.addPredicate<RegisterBankOperandMatcher>(
         Target.getRegisterClass(DstIOpRec));
     ++OpIdx;
   }
 
   auto DstMIBuilderOrError = createAndImportInstructionRenderer(M, Dst);
   if (auto Error = DstMIBuilderOrError.takeError())
-    return std::move(Error);
+    return Error;
   BuildMIAction &DstMIBuilder = DstMIBuilderOrError.get();
 
   // Render the implicit defs.
   // These are only added to the root of the result.
   if (auto Error = importImplicitDefRenderers(DstMIBuilder, P.getDstRegs()))
-    return std::move(Error);
+    return Error;
 
   DstMIBuilder.chooseInsnToMutate(M);
 
   // Constrain the registers to classes. This is normally derived from the
   // emitted instruction but a few instructions require special handling.
   if (DstI.TheDef->getName() == "COPY_TO_REGCLASS") {
     // COPY_TO_REGCLASS does not provide operand constraints itself but the
     // result is constrained to the class given by the second child.
     Record *DstIOpRec =
         getInitValueAsRegClass(Dst->getChild(1)->getLeafValue());
 
     if (DstIOpRec == nullptr)
       return failedImport("COPY_TO_REGCLASS operand #1 isn't a register class");
 
     M.addAction<ConstrainOperandToRegClassAction>(
         0, 0, Target.getRegisterClass(DstIOpRec));
 
     // We're done with this pattern!  It's eligible for GISel emission; return
     // it.
     ++NumPatternImported;
-    return std::move(M);
+    return M;
   }
 
   if (DstI.TheDef->getName() == "EXTRACT_SUBREG") {
     // EXTRACT_SUBREG selects into a subregister COPY but unlike most
     // instructions, the result register class is controlled by the
     // subregisters of the operand. As a result, we must constrain the result
     // class rather than check that it's already the right one.
     if (!Dst->getChild(0)->isLeaf())
const auto &SrcRCDstRCPair =
         SrcRC->getMatchingSubClassWithSubRegs(CGRegs, SubIdx);
     assert(SrcRCDstRCPair->second && "Couldn't find a matching subclass");
     M.addAction<ConstrainOperandToRegClassAction>(0, 0, *SrcRCDstRCPair->second);
     M.addAction<ConstrainOperandToRegClassAction>(0, 1, *SrcRCDstRCPair->first);
 
     // We're done with this pattern!  It's eligible for GISel emission; return
     // it.
     ++NumPatternImported;
-    return std::move(M);
+    return M;
   }
 
   M.addAction<ConstrainOperandsToDefinitionAction>(0);
 
   // We're done with this pattern!  It's eligible for GISel emission; return it.
   ++NumPatternImported;
-  return std::move(M);
+  return M;
 }
 
 // Emit imm predicate table and an enum to reference them with.
 // The 'Predicate_' part of the name is redundant but eliminating it is more
 // trouble than it's worth.
 void GlobalISelEmitter::emitCxxPredicateFns(
     raw_ostream &OS, StringRef CodeFieldName, StringRef TypeIdentifier,
     StringRef ArgType, StringRef ArgName, StringRef AdditionalDeclarations,