Remove redundant move call in return statements

[vinograd47]

Summary

They might prevent copy-elision optimization and generate noisy warnings with gcc.

[RKSimon]

I'm not certain but I thought some of these moves had to be kept to appease old versions of gcc - but I can't remember any details.

llvm/include/llvm/Bitstream/BitstreamReader.h

429

Any idea what clang-tidy is warning about here?

[thopre]

In D94658#2497570, @RKSimon wrote:

I'm not certain but I thought some of these moves had to be kept to appease old versions of gcc - but I can't remember any details.

I'm pretty sure the std::move I added in FileCheck were because of warning I had on my machine (Ubuntu 18.04). I'll try to give the patch a spin and report.

[RKSimon]

Also, sorry for hijacking but if you're looking at std::move cleanup, this scary static analysis warning has been around for a while: https://llvm.org/reports/scan-build/report-BitcodeReader.cpp-BitcodeReader-0-1.html#EndPath

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/Support/Parallel.h

template <class IterTy, class ResultTy, class ReduceFuncTy,
           class TransformFuncTy>
 ResultTy parallel_transform_reduce(IterTy Begin, IterTy End, ResultTy Init,
                                    ReduceFuncTy Reduce,
                                    TransformFuncTy Transform) {
   // Limit the number of tasks to MaxTasksPerGroup to limit job scheduling
   // overhead on large inputs.
   size_t NumInputs = std::distance(Begin, End);
   if (NumInputs == 0)
-    return std::move(Init);
+    return Init;
   size_t NumTasks = std::min(static_cast<size_t>(MaxTasksPerGroup), NumInputs);
   std::vector<ResultTy> Results(NumTasks, Init);
   {
     // Each task processes either TaskSize or TaskSize+1 inputs. Any inputs
     // remaining after dividing them equally amongst tasks are distributed as
     // one extra input over the first tasks.
     TaskGroup TG;
     size_t TaskSize = NumInputs / NumTasks;
ResultTy parallel_transform_reduce(IterTy Begin, IterTy End, ResultTy Init,
 
   // Do a final reduction. There are at most 1024 tasks, so this only adds
   // constant single-threaded overhead for large inputs. Hopefully most
   // reductions are cheaper than the transformation.
   ResultTy FinalResult = std::move(Results.front());
   for (ResultTy &PartialResult :
        makeMutableArrayRef(Results.data() + 1, Results.size() - 1))
     FinalResult = Reduce(FinalResult, std::move(PartialResult));
-  return std::move(FinalResult);
+  return FinalResult;
 }
 
 #endif
 
 } // namespace detail
 } // namespace parallel
 
 template <class RandomAccessIterator,

 #if LLVM_ENABLE_THREADS
   if (parallel::strategy.ThreadsRequested != 1) {
     return parallel::detail::parallel_transform_reduce(Begin, End, Init, Reduce,
                                                        Transform);
   }
 #endif
   for (IterTy I = Begin; I != End; ++I)
     Init = Reduce(std::move(Init), Transform(*I));
-  return std::move(Init);
+  return Init;
 }
 
 // Range wrappers.
 template <class RangeTy,
           class Comparator = std::less<decltype(*std::begin(RangeTy()))>>
 void parallelSort(RangeTy &&R, const Comparator &Comp = Comparator()) {
   parallelSort(std::begin(R), std::end(R), Comp);
 }

llvm/lib/Bitstream/Reader/BitstreamReader.cpp

if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
       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() + static_cast<uint64_t>(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.
       auto *UPtr = reinterpret_cast<const unsigned char *>(Ptr);
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/FileCheck/FileCheck.cpp

Expected<ExpressionValue> BinaryOperation::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<ExpressionFormat>
 BinaryOperation::getImplicitFormat(const SourceMgr &SM) const {
   Expected<ExpressionFormat> LeftFormat = LeftOperand->getImplicitFormat(SM);
   Expected<ExpressionFormat> RightFormat = RightOperand->getImplicitFormat(SM);
   if (!LeftFormat || !RightFormat) {
     Error Err = Error::success();
     if (!LeftFormat)
       Err = joinErrors(std::move(Err), LeftFormat.takeError());
     if (!RightFormat)
       Err = joinErrors(std::move(Err), RightFormat.takeError());
-    return std::move(Err);
+    return Err;
   }
 
   if (*LeftFormat != ExpressionFormat::Kind::NoFormat &&
       *RightFormat != ExpressionFormat::Kind::NoFormat &&
       *LeftFormat != *RightFormat)
     return ErrorDiagnostic::get(
         SM, getExpressionStr(),
         "implicit format conflict between '" + LeftOperand->getExpressionStr() +

 
 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
                     std::unique_ptr<ExpressionAST> LeftOp,
                     bool IsLegacyLineExpr, Optional<size_t> LineNumber,
                     FileCheckPatternContext *Context, const SourceMgr &SM) {
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);
   if (RemainingExpr.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(RemainingExpr.data());
   char Operator = popFront(RemainingExpr);
   binop_eval_t EvalBinop;
   switch (Operator) {
   case '+':
if (DefEnd != StringRef::npos) {
     Expected<NumericVariable *> ParseResult = parseNumericVariableDefinition(
         DefExpr, Context, LineNumber, ExpressionPointer->getFormat(), SM);
 
     if (!ParseResult)
       return ParseResult.takeError();
     DefinedNumericVariable = *ParseResult;
   }
 
-  return std::move(ExpressionPointer);
+  return ExpressionPointer;
 }
 
 bool Pattern::parsePattern(StringRef PatternStr, StringRef Prefix,
                            SourceMgr &SM, const FileCheckRequest &Req) {
   bool MatchFullLinesHere = Req.MatchFullLines && CheckTy != Check::CheckNot;
   IgnoreCase = Req.IgnoreCase;
 
   PatternLoc = SMLoc::getFromPointer(PatternStr.data());
for (const auto &Substitution : Substitutions) {
         // done here rather than PrintNoMatch since now we know which
         // substitution block caused the overflow.
         Error Err =
             handleErrors(Value.takeError(), [&](const OverflowError &E) {
               return ErrorDiagnostic::get(SM, Substitution->getFromString(),
                                           "unable to substitute variable or "
                                           "numeric expression: overflow error");
             });
-        return std::move(Err);
+        return Err;
       }
 
       // Plop it into the regex at the adjusted offset.
       TmpStr.insert(TmpStr.begin() + Substitution->getIndex() + InsertOffset,
                     Value->begin(), Value->end());
       InsertOffset += Value->size();
     }
 

llvm/lib/IR/DataLayout.cpp

void DataLayout::reset(StringRef Desc) {
 
   if (Error Err = parseSpecifier(Desc))
     return report_fatal_error(std::move(Err));
 }
 
 Expected<DataLayout> DataLayout::parse(StringRef LayoutDescription) {
   DataLayout Layout("");
   if (Error Err = Layout.parseSpecifier(LayoutDescription))
-    return std::move(Err);
+    return Err;
   return Layout;
 }
 
 static Error reportError(const Twine &Message) {
   return createStringError(inconvertibleErrorCode(), Message);
 }
 
 /// Checked version of split, to ensure mandatory subparts.

llvm/lib/IR/LLVMRemarkStreamer.cpp

Expected<std::unique_ptr<ToolOutputFile>> llvm::setupLLVMOptimizationRemarks(
   // Create LLVM's optimization remarks streamer.
   Context.setLLVMRemarkStreamer(
       std::make_unique<LLVMRemarkStreamer>(*Context.getMainRemarkStreamer()));
 
   if (!RemarksPasses.empty())
     if (Error E = Context.getMainRemarkStreamer()->setFilter(RemarksPasses))
       return make_error<LLVMRemarkSetupPatternError>(std::move(E));
 
-  return std::move(RemarksFile);
+  return RemarksFile;
 }
 
 Error llvm::setupLLVMOptimizationRemarks(
     LLVMContext &Context, raw_ostream &OS, StringRef RemarksPasses,
     StringRef RemarksFormat, bool RemarksWithHotness,
     Optional<uint64_t> RemarksHotnessThreshold) {
   if (RemarksWithHotness)
     Context.setDiagnosticsHotnessRequested(true);

llvm/lib/Remarks/BitstreamRemarkParser.cpp

case BitstreamEntry::Error:
     return createStringError(
         std::make_error_code(std::errc::illegal_byte_sequence),
         "Unexpected error while parsing bitstream.");
   default:
     Result = false;
     break;
   }
   if (Error E = Stream.JumpToBit(PreviousBitNo))
-    return std::move(E);
+    return E;
   return Result;
 }
 
 Expected<bool> BitstreamParserHelper::isMetaBlock() {
   return isBlock(Stream, META_BLOCK_ID);
 }
 
 Expected<bool> BitstreamParserHelper::isRemarkBlock() {
remarks::createBitstreamParserFromMeta(
     Optional<StringRef> ExternalFilePrependPath) {
   BitstreamParserHelper Helper(Buf);
   Expected<std::array<char, 4>> MagicNumber = Helper.parseMagic();
   if (!MagicNumber)
     return MagicNumber.takeError();
 
   if (Error E = validateMagicNumber(
           StringRef(MagicNumber->data(), MagicNumber->size())))
-    return std::move(E);
+    return E;
 
   auto Parser =
       StrTab ? std::make_unique<BitstreamRemarkParser>(Buf, std::move(*StrTab))
              : std::make_unique<BitstreamRemarkParser>(Buf);
 
   if (ExternalFilePrependPath)
     Parser->ExternalFilePrependPath = std::string(*ExternalFilePrependPath);
 
-  return std::move(Parser);
+  return Parser;
 }
 
 Expected<std::unique_ptr<Remark>> BitstreamRemarkParser::next() {
   if (ParserHelper.atEndOfStream())
     return make_error<EndOfFileError>();
 
   if (!ReadyToParseRemarks) {
     if (Error E = parseMeta())
-      return std::move(E);
+      return E;
     ReadyToParseRemarks = true;
   }
 
   return parseRemark();
 }
 
 Error BitstreamRemarkParser::parseMeta() {
   // Advance and to the meta block.
Error BitstreamRemarkParser::processSeparateRemarksMetaMeta(
   if (Error E = processStrTab(*this, Helper.StrTabBuf))
     return E;
   return processExternalFilePath(Helper.ExternalFilePath);
 }
 
 Expected<std::unique_ptr<Remark>> BitstreamRemarkParser::parseRemark() {
   BitstreamRemarkParserHelper RemarkHelper(ParserHelper.Stream);
   if (Error E = RemarkHelper.parse())
-    return std::move(E);
+    return E;
 
   return processRemark(RemarkHelper);
 }
 
 Expected<std::unique_ptr<Remark>>
 BitstreamRemarkParser::processRemark(BitstreamRemarkParserHelper &Helper) {
   std::unique_ptr<Remark> Result = std::make_unique<Remark>();
   Remark &R = *Result;
if (Helper.SourceFileNameIdx && Helper.SourceLine && Helper.SourceColumn) {
     R.Loc->SourceLine = *Helper.SourceLine;
     R.Loc->SourceColumn = *Helper.SourceColumn;
   }
 
   if (Helper.Hotness)
     R.Hotness = *Helper.Hotness;
 
   if (!Helper.Args)
-    return std::move(Result);
+    return Result;
 
   for (const BitstreamRemarkParserHelper::Argument &Arg : *Helper.Args) {
     if (!Arg.KeyIdx)
       return createStringError(
           std::make_error_code(std::errc::illegal_byte_sequence),
           "Error while parsing BLOCK_REMARK: missing key in remark argument.");
     if (!Arg.ValueIdx)
       return createStringError(
if (Arg.SourceFileNameIdx && Arg.SourceLine && Arg.SourceColumn) {
         R.Args.back().Loc->SourceFilePath = *SourceFileName;
         R.Args.back().Loc->SourceLine = *Arg.SourceLine;
         R.Args.back().Loc->SourceColumn = *Arg.SourceColumn;
       } else
         return SourceFileName.takeError();
     }
   }
 
-  return std::move(Result);
+  return Result;
 }

llvm/lib/Support/APFloat.cpp

 Expected<IEEEFloat::opStatus>
 IEEEFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode) {
   decimalInfo D;
   opStatus fs;
 
   /* Scan the text.  */
   StringRef::iterator p = str.begin();
   if (Error Err = interpretDecimal(p, str.end(), &D))
-    return std::move(Err);
+    return Err;
 
   /* Handle the quick cases.  First the case of no significant digits,
      i.e. zero, and then exponents that are obviously too large or too
      small.  Writing L for log 10 / log 2, a number d.ddddd*10^exp
      definitely overflows if
 
            (exp - 1) * L >= maxExponent
 

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;
 
 bool isUTF8(llvm::StringRef S, size_t *ErrOffset) {
   // Fast-path for ASCII, which is valid UTF-8.
   if (LLVM_LIKELY(isASCII(S)))
     return true;

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);
   }
 
   // Read until EOF, zero-initialize the rest.
   MutableArrayRef<char> ToRead = Buf->getBuffer();
   while (!ToRead.empty()) {
     Expected<size_t> ReadBytes =
         sys::fs::readNativeFileSlice(FD, ToRead, Offset);
     if (!ReadBytes)
       return errorToErrorCode(ReadBytes.takeError());
     if (*ReadBytes == 0) {
       std::memset(ToRead.data(), 0, ToRead.size());
       break;
     }
     ToRead = ToRead.drop_front(*ReadBytes);
     Offset += *ReadBytes;
   }
 
-  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;
 }
 } // namespace fs
 
 } // namespace sys
 } // 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 = std::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 = std::make_unique<MapHNode>(N);
     for (KeyValueNode &KVN : *Map) {
       Node *KeyNode = KVN.getKey();
       ScalarNode *Key = dyn_cast_or_null<ScalarNode>(KeyNode);
       Node *Value = KVN.getValue();
       if (!Key || !Value) {
         if (!Key)
for (KeyValueNode &KVN : *Map) {
         KeyStr = StringStorage.str().copy(StringAllocator);
       }
       auto ValueHNode = createHNodes(Value);
       if (EC)
         break;
       mapHNode->Mapping[KeyStr] =
           std::make_pair(std::move(ValueHNode), KeyNode->getSourceRange());
     }
-    return std::move(mapHNode);
+    return mapHNode;
   } else if (isa<NullNode>(N)) {
     return std::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 *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/utils/TableGen/GlobalISelEmitter.cpp

for (const TreePredicateCall &Call : Src->getPredicateCalls()) {
     if (Predicate.isImmediatePattern()) {
       InsnMatcher.addPredicate<InstructionImmPredicateMatcher>(Predicate);
       continue;
     }
 
     auto InsnMatcherOrError = addBuiltinPredicates(
         SrcGIEquivOrNull, Predicate, InsnMatcher, HasAddedBuiltinMatcher);
     if (auto Error = InsnMatcherOrError.takeError())
-      return std::move(Error);
+      return Error;
 
     if (Predicate.hasGISelPredicateCode()) {
       if (Predicate.usesOperands()) {
         assert(WaitingForNamedOperands == 0 &&
                "previous predicate didn't find all operands or "
                "nested predicate that uses operands");
         TreePattern *TP = Predicate.getOrigPatFragRecord();
         WaitingForNamedOperands = TP->getNumArgs();
if (Src->isLeaf()) {
     if (IsAtomic && SrcGIOrNull->TheDef->getName() == "G_STORE") {
       assert(NumChildren == 2 && "wrong operands for atomic store");
 
       TreePatternNode *PtrChild = Src->getChild(0);
       TreePatternNode *ValueChild = Src->getChild(1);
 
       if (auto Error = importChildMatcher(Rule, InsnMatcher, PtrChild, true,
                                           false, 1, TempOpIdx))
-        return std::move(Error);
+        return Error;
 
       if (auto Error = importChildMatcher(Rule, InsnMatcher, ValueChild, false,
                                           false, 0, TempOpIdx))
-        return std::move(Error);
+        return Error;
       return InsnMatcher;
     }
 
     // Match the used operands (i.e. the children of the operator).
     bool IsIntrinsic =
         SrcGIOrNull->TheDef->getName() == "G_INTRINSIC" ||
         SrcGIOrNull->TheDef->getName() == "G_INTRINSIC_W_SIDE_EFFECTS";
     const CodeGenIntrinsic *II = Src->getIntrinsicInfo(CGP);
for (unsigned i = 0; i != NumChildren; ++i) {
         // have the intrinsic ID in the intrinsic's parameter list.
         OperandIsAPointer |= II->isParamAPointer(i - 1);
         OperandIsImmArg |= II->isParamImmArg(i - 1);
       }
 
       if (auto Error =
               importChildMatcher(Rule, InsnMatcher, SrcChild, OperandIsAPointer,
                                  OperandIsImmArg, 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, *OpTy, 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, InstructionMatcher &InsnMatcher, const TreePatternNode *Src,
     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());
 
   for (auto PhysInput : InsnMatcher.getPhysRegInputs()) {
     InsertPt = M.insertAction<BuildMIAction>(
         InsertPt, M.allocateOutputInsnID(),
         &Target.getInstruction(RK.getDef("COPY")));
     BuildMIAction &CopyToPhysRegMIBuilder =
         *static_cast<BuildMIAction *>(InsertPt->get());
     CopyToPhysRegMIBuilder.addRenderer<AddRegisterRenderer>(Target,
                                                             PhysInput.first,
                                                             true);
     CopyToPhysRegMIBuilder.addRenderer<CopyPhysRegRenderer>(PhysInput.first);
   }
 
   if (auto Error = importExplicitDefRenderers(InsertPt, M, DstMIBuilder, Dst)
                        .takeError())
-    return std::move(Error);
+    return Error;
 
   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;
 
   // We need to make sure that when we import an INSERT_SUBREG as a
   // subinstruction that it ends up being constrained to the correct super
   // register and subregister classes.
   auto OpName = Target.getInstruction(Dst->getOperator()).TheDef->getName();
   if (OpName == "INSERT_SUBREG") {
     auto SubClass = inferRegClassFromPattern(Dst->getChild(1));
     if (!SubClass)
if (!ValChild->isLeaf()) {
 
       unsigned TempRegID = M.allocateTempRegID();
       InsertPt = M.insertAction<MakeTempRegisterAction>(
         InsertPt, *ExtractSrcTy, TempRegID);
 
       auto InsertPtOrError = createAndImportSubInstructionRenderer(
         ++InsertPt, M, ValChild, TempRegID);
       if (auto Error = InsertPtOrError.takeError())
-        return std::move(Error);
+        return Error;
 
       DstMIBuilder.addRenderer<TempRegRenderer>(TempRegID, false, SubIdx);
       return InsertPt;
     }
 
     // If this is a source operand, this is just a subregister copy.
     Record *RCDef = getInitValueAsRegClass(ValChild->getLeafValue());
     if (!RCDef)
for (unsigned I = 1; I != ExpectedDstINumUses; I += 2) {
 
       if (DefInit *SubRegInit =
               dyn_cast<DefInit>(SubRegChild->getLeafValue())) {
         CodeGenSubRegIndex *SubIdx = CGRegs.getSubRegIdx(SubRegInit->getDef());
 
         auto InsertPtOrError =
             importExplicitUseRenderer(InsertPt, M, DstMIBuilder, ValChild);
         if (auto Error = InsertPtOrError.takeError())
-          return std::move(Error);
+          return Error;
         InsertPt = InsertPtOrError.get();
         DstMIBuilder.addRenderer<SubRegIndexRenderer>(SubIdx);
       }
     }
 
     return InsertPt;
   }
 
if (CGP.operandHasDefault(OperandNode) &&
       // This is a predicate or optional def operand which the pattern has not
       // overridden, or which we aren't letting it override; emit the 'default
       // ops' operands.
 
       const CGIOperandList::OperandInfo &DstIOperand = DstI->Operands[InstOpNo];
       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());
     if (RCDef) {
       const CodeGenRegisterClass &RC = Target.getRegisterClass(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()) {
     OM.addPredicate<RegisterBankOperandMatcher>(
         Target.getRegisterClass(DstIOpRec));
     ++OpIdx;
   }
 
   auto DstMIBuilderOrError =
       createAndImportInstructionRenderer(M, InsnMatcher, Src, 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 (DstIName == "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 (DstIName == "EXTRACT_SUBREG") {
     auto SuperClass = inferRegClassFromPattern(Dst->getChild(0));
     if (!SuperClass)
       return failedImport(
         "Cannot infer register class from EXTRACT_SUBREG operand #0");
 
if (DstIName == "EXTRACT_SUBREG") {
 
     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;
   }
 
   if (DstIName == "INSERT_SUBREG") {
     assert(Src->getExtTypes().size() == 1 &&
            "Expected Src of INSERT_SUBREG to have one result type");
     // We need to constrain the destination, a super regsister source, and a
     // subregister source.
     auto SubClass = inferRegClassFromPattern(Dst->getChild(1));
     if (!SubClass)
       return failedImport(
           "Cannot infer register class from INSERT_SUBREG operand #1");
     auto SuperClass = inferSuperRegisterClassForNode(
         Src->getExtType(0), Dst->getChild(0), Dst->getChild(2));
     if (!SuperClass)
       return failedImport(
           "Cannot infer register class for INSERT_SUBREG operand #0");
     M.addAction<ConstrainOperandToRegClassAction>(0, 0, **SuperClass);
     M.addAction<ConstrainOperandToRegClassAction>(0, 1, **SuperClass);
     M.addAction<ConstrainOperandToRegClassAction>(0, 2, **SubClass);
     ++NumPatternImported;
-    return std::move(M);
+    return M;
   }
 
   if (DstIName == "SUBREG_TO_REG") {
     // We need to constrain the destination and subregister source.
     assert(Src->getExtTypes().size() == 1 &&
            "Expected Src of SUBREG_TO_REG to have one result type");
 
     // Attempt to infer the subregister source from the first child. If it has
     // an explicitly given register class, we'll use that. Otherwise, we will
     // fail.
     auto SubClass = inferRegClassFromPattern(Dst->getChild(1));
     if (!SubClass)
       return failedImport(
           "Cannot infer register class from SUBREG_TO_REG child #1");
     // We don't have a child to look at that might have a super register node.
     auto SuperClass =
         inferSuperRegisterClass(Src->getExtType(0), Dst->getChild(2));
     if (!SuperClass)
       return failedImport(
           "Cannot infer register class for SUBREG_TO_REG operand #0");
     M.addAction<ConstrainOperandToRegClassAction>(0, 0, **SuperClass);
     M.addAction<ConstrainOperandToRegClassAction>(0, 2, **SubClass);
     ++NumPatternImported;
-    return std::move(M);
+    return M;
   }
 
   if (DstIName == "REG_SEQUENCE") {
     auto SuperClass = inferRegClassFromPattern(Dst->getChild(0));
 
     M.addAction<ConstrainOperandToRegClassAction>(0, 0, **SuperClass);
 
     unsigned Num = Dst->getNumChildren();
     for (unsigned I = 1; I != Num; I += 2) {
       TreePatternNode *SubRegChild = Dst->getChild(I + 1);
 
       auto SubIdx = inferSubRegIndexForNode(SubRegChild);
       if (!SubIdx)
         return failedImport("REG_SEQUENCE child is not a subreg index");
 
       const auto SrcRCDstRCPair =
         (*SuperClass)->getMatchingSubClassWithSubRegs(CGRegs, *SubIdx);
 
       M.addAction<ConstrainOperandToRegClassAction>(0, I,
                                                     *SrcRCDstRCPair->second);
     }
 
     ++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 AdditionalArgs,