[llvm][NFC] Use move instead of copy

[ccotter]

Summary

For functions that accept an rvalue reference type
parameter, use move to avoid copying the parameter.

These were found when implementing CppCoreGuideline F.18 in
clang-tidy.

[thieta]

Seems fine to me. Have you tried clang-format locally since the CI job seems broken?

[ccotter]

Yes, locally I get

$ ./clang/tools/clang-format/git-clang-format HEAD~
clang-format did not modify any files

I think (unless something has broken lately) https://buildkite.com/llvm-project/premerge-checks/builds/133226#0185fb40-6564-4910-a1ac-820fd11c0708 is running clang-format. On other PRs I've submitted over the past few weeks have caught an occasional instance where I forgot to run clang-format locally.

The message on this phabricator diff saying "clang-format not found in user’s local PATH; not linting file." is due to my local setup not having arc diff know how to automatically run clang-format before sending up the diff (which I need to fix).

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 }
 
 void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
                                         const LexicalScope *LS) {
   if (const DILocation *InlinedAt = LS->getInlinedAt()) {
     // This variable was inlined. Associate it with the InlineSite.
     const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram();
     InlineSite &Site = getInlineSite(InlinedAt, Inlinee);
-    Site.InlinedLocals.emplace_back(Var);
+    Site.InlinedLocals.emplace_back(std::move(Var));
   } else {
     // This variable goes into the corresponding lexical scope.
-    ScopeVariables[LS].emplace_back(Var);
+    ScopeVariables[LS].emplace_back(std::move(Var));
   }
 }
 
 static void addLocIfNotPresent(SmallVectorImpl<const DILocation *> &Locs,
                                const DILocation *Loc) {
   if (!llvm::is_contained(Locs, Loc))
     Locs.push_back(Loc);
 }

llvm/lib/MC/MCParser/MasmParser.cpp

 // use BumpPtrAllocator, but the lack of a destructor makes that messy.
 
 struct StructInitializer;
 struct IntFieldInfo {
   SmallVector<const MCExpr *, 1> Values;
 
   IntFieldInfo() = default;
   IntFieldInfo(const SmallVector<const MCExpr *, 1> &V) { Values = V; }
-  IntFieldInfo(SmallVector<const MCExpr *, 1> &&V) { Values = V; }
+  IntFieldInfo(SmallVector<const MCExpr *, 1> &&V) { Values = std::move(V); }
 };
 struct RealFieldInfo {
   SmallVector<APInt, 1> AsIntValues;
 
   RealFieldInfo() = default;
   RealFieldInfo(const SmallVector<APInt, 1> &V) { AsIntValues = V; }
-  RealFieldInfo(SmallVector<APInt, 1> &&V) { AsIntValues = V; }
+  RealFieldInfo(SmallVector<APInt, 1> &&V) { AsIntValues = std::move(V); }
 };
 struct StructFieldInfo {
   std::vector<StructInitializer> Initializers;
   StructInfo Structure;
 
   StructFieldInfo() = default;
   StructFieldInfo(std::vector<StructInitializer> V, StructInfo S);
 };
FieldInitializer::FieldInitializer(FieldType FT) : FT(FT) {
   case FT_STRUCT:
     new (&StructInfo) StructFieldInfo();
     break;
   }
 }
 
 FieldInitializer::FieldInitializer(SmallVector<const MCExpr *, 1> &&Values)
     : FT(FT_INTEGRAL) {
-  new (&IntInfo) IntFieldInfo(Values);
+  new (&IntInfo) IntFieldInfo(std::move(Values));
 }
 
 FieldInitializer::FieldInitializer(SmallVector<APInt, 1> &&AsIntValues)
     : FT(FT_REAL) {
-  new (&RealInfo) RealFieldInfo(AsIntValues);
+  new (&RealInfo) RealFieldInfo(std::move(AsIntValues));
 }
 
 FieldInitializer::FieldInitializer(
     std::vector<StructInitializer> &&Initializers, struct StructInfo Structure)
     : FT(FT_STRUCT) {
   new (&StructInfo) StructFieldInfo(std::move(Initializers), Structure);
 }