Fix various occurences of redundant std::move [gcc 9 -Wredundant-move]

[nhaehnle]

Summary

There are hundreds (thousands?) of instances of this warning left.

A blog post on the new warning in gcc 9 is in
https://developers.redhat.com/blog/2019/04/12/understanding-when-not-to-stdmove-in-c/

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";
   }

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/Object/ELF.h

 ELFFile<ELFT>::getStringTable(const Elf_Shdr *Section,
                               WarningHandler WarnHandler) const {
   if (Section->sh_type != ELF::SHT_STRTAB)
     if (Error E = WarnHandler("invalid sh_type for string table section " +
                               getSecIndexForError(this, Section) +
                               ": expected SHT_STRTAB, but got " +
                               object::getELFSectionTypeName(
                                   getHeader()->e_machine, Section->sh_type)))
-      return std::move(E);
+      return E;
 
   auto V = getSectionContentsAsArray<char>(Section);
   if (!V)
     return V.takeError();
   ArrayRef<char> Data = *V;
   if (Data.empty())
     return createError("SHT_STRTAB string table section " +
                        getSecIndexForError(this, Section) + " is empty");

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/lib/DebugInfo/DWARF/DWARFVerifier.cpp

 DWARFVerifier::DieRangeInfo::address_range_iterator
 DWARFVerifier::DieRangeInfo::insert(const DWARFAddressRange &R) {
   auto Begin = Ranges.begin();
   auto End = Ranges.end();
   auto Pos = std::lower_bound(Begin, End, R);
 
   if (Pos != End) {
     if (Pos->intersects(R))
-      return std::move(Pos);
+      return Pos;
     if (Pos != Begin) {
       auto Iter = Pos - 1;
       if (Iter->intersects(R))
-        return std::move(Iter);
+        return Iter;
     }
   }
 
   Ranges.insert(Pos, R);
   return Ranges.end();
 }
 
 DWARFVerifier::DieRangeInfo::die_range_info_iterator

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/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;
 
 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);
   }
 
   // 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;
 }
 }
 
 } // 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 = 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)
           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 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 *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/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,
                                         uint64_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/tools/obj2yaml/elf2yaml.cpp

ELFDumper<ELFT>::dumpSymtabShndxSection(const Elf_Shdr *Shdr) {
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::NoBitsSection *>
 ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
   auto S = std::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::NoteSection *>
 ELFDumper<ELFT>::dumpNoteSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::NoteSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)
     return ContentOrErr.takeError();
 
   std::vector<ELFYAML::NoteEntry> Entries;
   ArrayRef<uint8_t> Content = *ContentOrErr;
   while (!Content.empty()) {
ELFDumper<ELFT>::dumpNoteSection(const Elf_Shdr *Shdr) {
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::HashSection *>
 ELFDumper<ELFT>::dumpHashSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::HashSection>();
   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.size() % 4 != 0 || Content.size() < 8) {
     S->Content = yaml::BinaryRef(Content);
ELFDumper<ELFT>::dumpHashSection(const Elf_Shdr *Shdr) {
   llvm_unreachable("entries were not read correctly");
 }
 
 template <class ELFT>
 Expected<ELFYAML::GnuHashSection *>
 ELFDumper<ELFT>::dumpGnuHashSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::GnuHashSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)
     return ContentOrErr.takeError();
 
   unsigned AddrSize = ELFT::Is64Bits ? 8 : 4;
   ArrayRef<uint8_t> Content = *ContentOrErr;
   DataExtractor Data(Content, Obj.isLE(), AddrSize);
if (!StrTabOrErr)
     return StrTabOrErr.takeError();
   return getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab);
 }
 
 template <class ELFT>
 Expected<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::Group>();
   if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
+    return E;
 
   // Get symbol with index sh_info. This symbol's name is the signature of the group.
   Expected<StringRef> SymbolName = getSymbolName(Shdr->sh_link, Shdr->sh_info);
   if (!SymbolName)
     return SymbolName.takeError();
   S->Signature = *SymbolName;
 
   auto MembersOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(Shdr);

 
 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 = std::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/utils/TableGen/GlobalISelEmitter.cpp

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, 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, 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>(PhysInput.first,
                                                             true);
     CopyToPhysRegMIBuilder.addRenderer<CopyPhysRegRenderer>(PhysInput.first);
   }
 
   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;
 
   // 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)
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());
 
     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()) {
     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");
 
const auto SrcRCDstRCPair =
       (*SuperClass)->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;
   }
 
   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 (DstIName == "SUBREG_TO_REG") {
     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;
   }
 
   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,