[llvm][NFC] Apply performance-noexcept-move-constructor to llvm core

[Skylion007]

Summary

Applies performance-noexcept-move-constructor to llvm core. One would think that this check does not matter since we do not allow exceptions due to the LLVM styleguide. However, STL containers (including std::variant and std::optional) do check the noexcept tag to see if it's safe to move. Therefore, we should make all these classes as safe to move so these STL containers can be as efficient as possible.

[Skylion007]

Made sure headers updated too. Skip support and ADT files for now.

[Skylion007]

Fixed forward declare bug

[Skylion007]

Fix forward declare typo

[Skylion007]

Fix forward declare typo

[Skylion007]

Fix another forward declare

[Skylion007]

Make jitlink cpp match

[Skylion007]

Fixup one another cpp error

[Skylion007]

revert changes to JITLink

llvm/include/llvm/Analysis/AliasAnalysis.h

   // Make these results default constructable and movable. We have to spell
   // these out because MSVC won't synthesize them.
   AAResults(const TargetLibraryInfo &TLI) : TLI(TLI) {}
-  AAResults(AAResults &&Arg);
+  AAResults(AAResults &&Arg) noexcept;
   ~AAResults();
 
   /// Register a specific AA result.

   // Provide all the copy and move constructors so that derived types aren't
   // constrained.
   AAResultBase(const AAResultBase &Arg) {}
-  AAResultBase(AAResultBase &&Arg) {}
+  AAResultBase(AAResultBase &&Arg) noexcept {}
 
 public:
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,

llvm/include/llvm/Analysis/BasicAliasAnalysis.h

   BasicAAResult(const BasicAAResult &Arg)
       : AAResultBase(Arg), DL(Arg.DL), F(Arg.F), TLI(Arg.TLI), AC(Arg.AC),
         DT(Arg.DT) {}
-  BasicAAResult(BasicAAResult &&Arg)
+  BasicAAResult(BasicAAResult &&Arg) noexcept
       : AAResultBase(std::move(Arg)), DL(Arg.DL), F(Arg.F), TLI(Arg.TLI),
         AC(Arg.AC), DT(Arg.DT) {}
 

llvm/include/llvm/Analysis/BlockFrequencyInfo.h

                      const LoopInfo &LI);
   BlockFrequencyInfo(const BlockFrequencyInfo &) = delete;
   BlockFrequencyInfo &operator=(const BlockFrequencyInfo &) = delete;
-  BlockFrequencyInfo(BlockFrequencyInfo &&Arg);
-  BlockFrequencyInfo &operator=(BlockFrequencyInfo &&RHS);
+  BlockFrequencyInfo(BlockFrequencyInfo &&Arg) noexcept;
+  BlockFrequencyInfo &operator=(BlockFrequencyInfo &&RHS) noexcept;
   ~BlockFrequencyInfo();
 
   /// Handle invalidation explicitly.

llvm/include/llvm/Analysis/BranchProbabilityInfo.h

     calculate(F, LI, TLI, DT, PDT);
   }
 
-  BranchProbabilityInfo(BranchProbabilityInfo &&Arg)
+  BranchProbabilityInfo(BranchProbabilityInfo &&Arg) noexcept
       : Probs(std::move(Arg.Probs)), LastF(Arg.LastF),
         EstimatedBlockWeight(std::move(Arg.EstimatedBlockWeight)) {}
 
   BranchProbabilityInfo(const BranchProbabilityInfo &) = delete;
   BranchProbabilityInfo &operator=(const BranchProbabilityInfo &) = delete;
 
-  BranchProbabilityInfo &operator=(BranchProbabilityInfo &&RHS) {
+  BranchProbabilityInfo &operator=(BranchProbabilityInfo &&RHS) noexcept {
     releaseMemory();
     Probs = std::move(RHS.Probs);
     EstimatedBlockWeight = std::move(RHS.EstimatedBlockWeight);

llvm/include/llvm/Analysis/CGSCCPassManager.h

   explicit ModuleToPostOrderCGSCCPassAdaptor(std::unique_ptr<PassConceptT> Pass)
       : Pass(std::move(Pass)) {}
 
-  ModuleToPostOrderCGSCCPassAdaptor(ModuleToPostOrderCGSCCPassAdaptor &&Arg)
+  ModuleToPostOrderCGSCCPassAdaptor(
+      ModuleToPostOrderCGSCCPassAdaptor &&Arg) noexcept
       : Pass(std::move(Arg.Pass)) {}
 
   friend void swap(ModuleToPostOrderCGSCCPassAdaptor &LHS,

       : Pass(std::move(Pass)), EagerlyInvalidate(EagerlyInvalidate),
         NoRerun(NoRerun) {}
 
-  CGSCCToFunctionPassAdaptor(CGSCCToFunctionPassAdaptor &&Arg)
+  CGSCCToFunctionPassAdaptor(CGSCCToFunctionPassAdaptor &&Arg) noexcept
       : Pass(std::move(Arg.Pass)), EagerlyInvalidate(Arg.EagerlyInvalidate),
         NoRerun(Arg.NoRerun) {}
 

llvm/include/llvm/Analysis/CallGraph.h

 
 public:
   explicit CallGraph(Module &M);
-  CallGraph(CallGraph &&Arg);
+  CallGraph(CallGraph &&Arg) noexcept;
   ~CallGraph();
 
   void print(raw_ostream &OS) const;

llvm/include/llvm/Analysis/DDG.h

   DDGNode() = delete;
   DDGNode(const NodeKind K) : Kind(K) {}
   DDGNode(const DDGNode &N) = default;
-  DDGNode(DDGNode &&N) : DDGNodeBase(std::move(N)), Kind(N.Kind) {}
+  DDGNode(DDGNode &&N) noexcept : DDGNodeBase(std::move(N)), Kind(N.Kind) {}
   virtual ~DDGNode() = 0;
 
   DDGNode &operator=(const DDGNode &N) {

     return *this;
   }
 
-  DDGNode &operator=(DDGNode &&N) {
+  DDGNode &operator=(DDGNode &&N) noexcept {
     DGNode::operator=(std::move(N));
     Kind = N.Kind;
     return *this;

 public:
   RootDDGNode() : DDGNode(NodeKind::Root) {}
   RootDDGNode(const RootDDGNode &N) = delete;
-  RootDDGNode(RootDDGNode &&N) : DDGNode(std::move(N)) {}
+  RootDDGNode(RootDDGNode &&N) noexcept : DDGNode(std::move(N)) {}
   ~RootDDGNode() = default;
 
   /// Define classof to be able to use isa<>, cast<>, dyn_cast<>, etc.

   SimpleDDGNode() = delete;
   SimpleDDGNode(Instruction &I);
   SimpleDDGNode(const SimpleDDGNode &N);
-  SimpleDDGNode(SimpleDDGNode &&N);
+  SimpleDDGNode(SimpleDDGNode &&N) noexcept;
   ~SimpleDDGNode();
 
   SimpleDDGNode &operator=(const SimpleDDGNode &N) = default;
 
-  SimpleDDGNode &operator=(SimpleDDGNode &&N) {
+  SimpleDDGNode &operator=(SimpleDDGNode &&N) noexcept {
     DDGNode::operator=(std::move(N));
     InstList = std::move(N.InstList);
     return *this;

   PiBlockDDGNode() = delete;
   PiBlockDDGNode(const PiNodeList &List);
   PiBlockDDGNode(const PiBlockDDGNode &N);
-  PiBlockDDGNode(PiBlockDDGNode &&N);
+  PiBlockDDGNode(PiBlockDDGNode &&N) noexcept;
   ~PiBlockDDGNode();
 
   PiBlockDDGNode &operator=(const PiBlockDDGNode &N) = default;
 
-  PiBlockDDGNode &operator=(PiBlockDDGNode &&N) {
+  PiBlockDDGNode &operator=(PiBlockDDGNode &&N) noexcept {
     DDGNode::operator=(std::move(N));
     NodeList = std::move(N.NodeList);
     return *this;

   explicit DDGEdge(DDGNode &N) = delete;
   DDGEdge(DDGNode &N, EdgeKind K) : DDGEdgeBase(N), Kind(K) {}
   DDGEdge(const DDGEdge &E) : DDGEdgeBase(E), Kind(E.getKind()) {}
-  DDGEdge(DDGEdge &&E) : DDGEdgeBase(std::move(E)), Kind(E.Kind) {}
+  DDGEdge(DDGEdge &&E) noexcept : DDGEdgeBase(std::move(E)), Kind(E.Kind) {}
   DDGEdge &operator=(const DDGEdge &E) = default;
 
-  DDGEdge &operator=(DDGEdge &&E) {
+  DDGEdge &operator=(DDGEdge &&E) noexcept {
     DDGEdgeBase::operator=(std::move(E));
     Kind = E.Kind;
     return *this;

   DependenceGraphInfo(const DependenceGraphInfo &G) = delete;
   DependenceGraphInfo(const std::string &N, const DependenceInfo &DepInfo)
       : Name(N), DI(DepInfo), Root(nullptr) {}
-  DependenceGraphInfo(DependenceGraphInfo &&G)
+  DependenceGraphInfo(DependenceGraphInfo &&G) noexcept
       : Name(std::move(G.Name)), DI(std::move(G.DI)), Root(G.Root) {}
   virtual ~DependenceGraphInfo() = default;
 

 
   DataDependenceGraph() = delete;
   DataDependenceGraph(const DataDependenceGraph &G) = delete;
-  DataDependenceGraph(DataDependenceGraph &&G)
+  DataDependenceGraph(DataDependenceGraph &&G) noexcept
       : DDGBase(std::move(G)), DDGInfo(std::move(G)) {}
   DataDependenceGraph(Function &F, DependenceInfo &DI);
   DataDependenceGraph(Loop &L, LoopInfo &LI, DependenceInfo &DI);

llvm/include/llvm/Analysis/GlobalsModRef.h

   friend struct RecomputeGlobalsAAPass;
 
 public:
-  GlobalsAAResult(GlobalsAAResult &&Arg);
+  GlobalsAAResult(GlobalsAAResult &&Arg) noexcept;
   ~GlobalsAAResult();
 
   bool invalidate(Module &M, const PreservedAnalyses &PA,

llvm/include/llvm/Analysis/InlineSizeEstimatorAnalysis.h

     : public AnalysisInfoMixin<InlineSizeEstimatorAnalysis> {
 public:
   InlineSizeEstimatorAnalysis();
-  InlineSizeEstimatorAnalysis(InlineSizeEstimatorAnalysis &&);
+  InlineSizeEstimatorAnalysis(InlineSizeEstimatorAnalysis &&) noexcept;
   ~InlineSizeEstimatorAnalysis();
 
   static AnalysisKey Key;

llvm/include/llvm/Analysis/LazyCallGraph.h

   LazyCallGraph(Module &M,
                 function_ref<TargetLibraryInfo &(Function &)> GetTLI);
 
-  LazyCallGraph(LazyCallGraph &&G);
-  LazyCallGraph &operator=(LazyCallGraph &&RHS);
+  LazyCallGraph(LazyCallGraph &&G) noexcept;
+  LazyCallGraph &operator=(LazyCallGraph &&RHS) noexcept;
 
   bool invalidate(Module &, const PreservedAnalyses &PA,
                   ModuleAnalysisManager::Invalidator &);

llvm/include/llvm/Analysis/LazyValueInfo.h

   LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_,
                 TargetLibraryInfo *TLI_)
       : AC(AC_), DL(DL_), TLI(TLI_) {}
-  LazyValueInfo(LazyValueInfo &&Arg)
+  LazyValueInfo(LazyValueInfo &&Arg) noexcept
       : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), PImpl(Arg.PImpl) {
     Arg.PImpl = nullptr;
   }
-  LazyValueInfo &operator=(LazyValueInfo &&Arg) {
+  LazyValueInfo &operator=(LazyValueInfo &&Arg) noexcept {
     releaseMemory();
     AC = Arg.AC;
     DL = Arg.DL;

llvm/include/llvm/Analysis/LoopAnalysisManager.h

 public:
   explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
       : InnerAM(&InnerAM), LI(&LI) {}
-  Result(Result &&Arg)
+  Result(Result &&Arg) noexcept
       : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI), MSSAUsed(Arg.MSSAUsed) {
     // We have to null out the analysis manager in the moved-from state
     // because we are taking ownership of the responsibilty to clear the
     // analysis state.
     Arg.InnerAM = nullptr;
   }
-  Result &operator=(Result &&RHS) {
+  Result &operator=(Result &&RHS) noexcept {
     InnerAM = RHS.InnerAM;
     LI = RHS.LI;
     MSSAUsed = RHS.MSSAUsed;

llvm/include/llvm/Analysis/LoopInfo.h

   LoopInfoBase() = default;
   ~LoopInfoBase() { releaseMemory(); }
 
-  LoopInfoBase(LoopInfoBase &&Arg)
+  LoopInfoBase(LoopInfoBase &&Arg) noexcept
       : BBMap(std::move(Arg.BBMap)),
         TopLevelLoops(std::move(Arg.TopLevelLoops)),
         LoopAllocator(std::move(Arg.LoopAllocator)) {
     // We have to clear the arguments top level loops as we've taken ownership.
     Arg.TopLevelLoops.clear();
   }
-  LoopInfoBase &operator=(LoopInfoBase &&RHS) {
+  LoopInfoBase &operator=(LoopInfoBase &&RHS) noexcept {
     BBMap = std::move(RHS.BBMap);
 
     for (auto *L : TopLevelLoops)

   LoopInfo() = default;
   explicit LoopInfo(const DominatorTreeBase<BasicBlock, false> &DomTree);
 
-  LoopInfo(LoopInfo &&Arg) : BaseT(std::move(static_cast<BaseT &>(Arg))) {}
-  LoopInfo &operator=(LoopInfo &&RHS) {
+  LoopInfo(LoopInfo &&Arg) noexcept
+      : BaseT(std::move(static_cast<BaseT &>(Arg))) {}
+  LoopInfo &operator=(LoopInfo &&RHS) noexcept {
     BaseT::operator=(std::move(static_cast<BaseT &>(RHS)));
     return *this;
   }

llvm/include/llvm/Analysis/MustExecute.h

 
   MustBeExecutedIterator(const MustBeExecutedIterator &Other) = default;
 
-  MustBeExecutedIterator(MustBeExecutedIterator &&Other)
+  MustBeExecutedIterator(MustBeExecutedIterator &&Other) noexcept
       : Visited(std::move(Other.Visited)), Explorer(Other.Explorer),
         CurInst(Other.CurInst), Head(Other.Head), Tail(Other.Tail) {}
 
-  MustBeExecutedIterator &operator=(MustBeExecutedIterator &&Other) {
+  MustBeExecutedIterator &operator=(MustBeExecutedIterator &&Other) noexcept {
     if (this != &Other) {
       std::swap(Visited, Other.Visited);
       std::swap(CurInst, Other.CurInst);

llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h

 
 public:
   explicit ObjCARCAAResult(const DataLayout &DL) : DL(DL) {}
-  ObjCARCAAResult(ObjCARCAAResult &&Arg)
+  ObjCARCAAResult(ObjCARCAAResult &&Arg) noexcept
       : AAResultBase(std::move(Arg)), DL(Arg.DL) {}
 
   /// Handle invalidation events from the new pass manager.

llvm/include/llvm/Analysis/OptimizationRemarkEmitter.h

   /// passes in the old PM.
   OptimizationRemarkEmitter(const Function *F);
 
-  OptimizationRemarkEmitter(OptimizationRemarkEmitter &&Arg)
+  OptimizationRemarkEmitter(OptimizationRemarkEmitter &&Arg) noexcept
       : F(Arg.F), BFI(Arg.BFI) {}
 
-  OptimizationRemarkEmitter &operator=(OptimizationRemarkEmitter &&RHS) {
+  OptimizationRemarkEmitter &
+  operator=(OptimizationRemarkEmitter &&RHS) noexcept {
     F = RHS.F;
     BFI = RHS.BFI;
     return *this;

llvm/include/llvm/Analysis/ScalarEvolution.h

 
   ScalarEvolution(Function &F, TargetLibraryInfo &TLI, AssumptionCache &AC,
                   DominatorTree &DT, LoopInfo &LI);
-  ScalarEvolution(ScalarEvolution &&Arg);
+  ScalarEvolution(ScalarEvolution &&Arg) noexcept;
   ~ScalarEvolution();
 
   LLVMContext &getContext() const { return F.getContext(); }

llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h

 
 public:
   explicit SCEVAAResult(ScalarEvolution &SE) : SE(SE) {}
-  SCEVAAResult(SCEVAAResult &&Arg) : AAResultBase(std::move(Arg)), SE(Arg.SE) {}
+  SCEVAAResult(SCEVAAResult &&Arg) noexcept
+      : AAResultBase(std::move(Arg)), SE(Arg.SE) {}
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI, const Instruction *CtxI);

llvm/include/llvm/Analysis/TargetLibraryInfo.h

 
   // Provide value semantics.
   TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI);
-  TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI);
+  TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI) noexcept;
   TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI);
-  TargetLibraryInfoImpl &operator=(TargetLibraryInfoImpl &&TLI);
+  TargetLibraryInfoImpl &operator=(TargetLibraryInfoImpl &&TLI) noexcept;
 
   /// Searches for a particular function name.
   ///

 
   // Provide value semantics.
   TargetLibraryInfo(const TargetLibraryInfo &TLI) = default;
-  TargetLibraryInfo(TargetLibraryInfo &&TLI)
+  TargetLibraryInfo(TargetLibraryInfo &&TLI) noexcept
       : Impl(TLI.Impl), OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
   TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) = default;
-  TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
+  TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) noexcept {
     Impl = TLI.Impl;
     OverrideAsUnavailable = TLI.OverrideAsUnavailable;
     return *this;

llvm/include/llvm/Analysis/TargetTransformInfo.h

   explicit TargetTransformInfo(const DataLayout &DL);
 
   // Provide move semantics.
-  TargetTransformInfo(TargetTransformInfo &&Arg);
-  TargetTransformInfo &operator=(TargetTransformInfo &&RHS);
+  TargetTransformInfo(TargetTransformInfo &&Arg) noexcept;
+  TargetTransformInfo &operator=(TargetTransformInfo &&RHS) noexcept;
 
   // We need to define the destructor out-of-line to define our sub-classes
   // out-of-line.

   // Value semantics. We spell out the constructors for MSVC.
   TargetIRAnalysis(const TargetIRAnalysis &Arg)
       : TTICallback(Arg.TTICallback) {}
-  TargetIRAnalysis(TargetIRAnalysis &&Arg)
+  TargetIRAnalysis(TargetIRAnalysis &&Arg) noexcept
       : TTICallback(std::move(Arg.TTICallback)) {}
   TargetIRAnalysis &operator=(const TargetIRAnalysis &RHS) {
     TTICallback = RHS.TTICallback;
     return *this;
   }
-  TargetIRAnalysis &operator=(TargetIRAnalysis &&RHS) {
+  TargetIRAnalysis &operator=(TargetIRAnalysis &&RHS) noexcept {
     TTICallback = std::move(RHS.TTICallback);
     return *this;
   }

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

 public:
   // Provide value semantics. MSVC requires that we spell all of these out.
   TargetTransformInfoImplBase(const TargetTransformInfoImplBase &Arg) = default;
-  TargetTransformInfoImplBase(TargetTransformInfoImplBase &&Arg) : DL(Arg.DL) {}
+  TargetTransformInfoImplBase(TargetTransformInfoImplBase &&Arg) noexcept
+      : DL(Arg.DL) {}
 
   const DataLayout &getDataLayout() const { return DL; }
 

llvm/include/llvm/CodeGen/MachineModuleInfo.h

   explicit MachineModuleInfo(const LLVMTargetMachine *TM,
                              MCContext *ExtContext);
 
-  MachineModuleInfo(MachineModuleInfo &&MMII);
+  MachineModuleInfo(MachineModuleInfo &&MMII) noexcept;
 
   ~MachineModuleInfo();
 

llvm/include/llvm/DebugInfo/PDB/PDBSymbol.h

 
 protected:
   explicit PDBSymbol(const IPDBSession &PDBSession);
-  PDBSymbol(PDBSymbol &&Other);
+  PDBSymbol(PDBSymbol &&Other) noexcept;
 
 public:
   static std::unique_ptr<PDBSymbol>

llvm/include/llvm/Demangle/Demangle.h

 struct ItaniumPartialDemangler {
   ItaniumPartialDemangler();
 
-  ItaniumPartialDemangler(ItaniumPartialDemangler &&Other);
-  ItaniumPartialDemangler &operator=(ItaniumPartialDemangler &&Other);
+  ItaniumPartialDemangler(ItaniumPartialDemangler &&Other) noexcept;
+  ItaniumPartialDemangler &operator=(ItaniumPartialDemangler &&Other) noexcept;
 
   /// Demangle into an AST. Subsequent calls to the rest of the member functions
   /// implicitly operate on the AST this produces.

llvm/include/llvm/Demangle/ItaniumDemangle.h

   PODSmallVector(const PODSmallVector &) = delete;
   PODSmallVector &operator=(const PODSmallVector &) = delete;
 
-  PODSmallVector(PODSmallVector &&Other) : PODSmallVector() {
+  PODSmallVector(PODSmallVector &&Other) noexcept : PODSmallVector() {
     if (Other.isInline()) {
       std::copy(Other.begin(), Other.end(), First);
       Last = First + Other.size();

     Other.clearInline();
   }
 
-  PODSmallVector &operator=(PODSmallVector &&Other) {
+  PODSmallVector &operator=(PODSmallVector &&Other) noexcept {
     if (Other.isInline()) {
       if (!isInline()) {
         std::free(First);

llvm/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h

              "Explicitly creating an invalid allocation?");
     }
     FinalizedAlloc(const FinalizedAlloc &) = delete;
-    FinalizedAlloc(FinalizedAlloc &&Other) : A(Other.A) {
+    FinalizedAlloc(FinalizedAlloc &&Other) noexcept : A(Other.A) {
       Other.A.setValue(InvalidAddr);
     }
     FinalizedAlloc &operator=(const FinalizedAlloc &) = delete;
-    FinalizedAlloc &operator=(FinalizedAlloc &&Other) {
+    FinalizedAlloc &operator=(FinalizedAlloc &&Other) noexcept {
       assert(A.getValue() == InvalidAddr &&
              "Cannot overwrite active finalized allocation");
       std::swap(A, Other.A);

                                              const JITLinkDylib *JD,
                                              SegmentMap Segments);
 
-  SimpleSegmentAlloc(SimpleSegmentAlloc &&);
-  SimpleSegmentAlloc &operator=(SimpleSegmentAlloc &&);
+  SimpleSegmentAlloc(SimpleSegmentAlloc &&) noexcept;
+  SimpleSegmentAlloc &operator=(SimpleSegmentAlloc &&) noexcept;
   ~SimpleSegmentAlloc();
 
   /// Returns the SegmentInfo for the given group.

llvm/include/llvm/ExecutionEngine/JITSymbol.h

   JITSymbol(const JITSymbol&) = delete;
   JITSymbol& operator=(const JITSymbol&) = delete;
 
-  JITSymbol(JITSymbol &&Other)
+  JITSymbol(JITSymbol &&Other) noexcept
       : GetAddress(std::move(Other.GetAddress)), Flags(std::move(Other.Flags)) {
     if (Flags.hasError())
       Err = std::move(Other.Err);
     else
       CachedAddr = std::move(Other.CachedAddr);
   }
 
-  JITSymbol& operator=(JITSymbol &&Other) {
+  JITSymbol &operator=(JITSymbol &&Other) noexcept {
     GetAddress = std::move(Other.GetAddress);
     Flags = std::move(Other.Flags);
     if (Flags.hasError())

llvm/include/llvm/ExecutionEngine/Orc/Core.h

 
 public:
   LookupState();
-  LookupState(LookupState &&);
-  LookupState &operator=(LookupState &&);
+  LookupState(LookupState &&) noexcept;
+  LookupState &operator=(LookupState &&) noexcept;
   ~LookupState();
 
   /// Continue the lookup. This can be called by DefinitionGenerators

llvm/include/llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h

   WrapperFunctionResult(const WrapperFunctionResult &) = delete;
   WrapperFunctionResult &operator=(const WrapperFunctionResult &) = delete;
 
-  WrapperFunctionResult(WrapperFunctionResult &&Other) {
+  WrapperFunctionResult(WrapperFunctionResult &&Other) noexcept {
     init(R);
     std::swap(R, Other.R);
   }
 
-  WrapperFunctionResult &operator=(WrapperFunctionResult &&Other) {
+  WrapperFunctionResult &operator=(WrapperFunctionResult &&Other) noexcept {
     WrapperFunctionResult Tmp(std::move(Other));
     std::swap(R, Tmp.R);
     return *this;

llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h

     return *this;
   }
 
-  SymbolStringPtr(SymbolStringPtr &&Other) : S(nullptr) {
+  SymbolStringPtr(SymbolStringPtr &&Other) noexcept : S(nullptr) {
     std::swap(S, Other.S);
   }
 
-  SymbolStringPtr& operator=(SymbolStringPtr &&Other) {
+  SymbolStringPtr &operator=(SymbolStringPtr &&Other) noexcept {
     if (isRealPoolEntry(S)) {
       assert(S->getValue() && "Releasing SymbolStringPtr with zero ref count");
       --S->getValue();

llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h

 
   ThreadSafeModule(ThreadSafeModule &&Other) = default;
 
-  ThreadSafeModule &operator=(ThreadSafeModule &&Other) {
+  ThreadSafeModule &operator=(ThreadSafeModule &&Other) noexcept {
     // We have to explicitly define this move operator to copy the fields in
     // reverse order (i.e. module first) to ensure the dependencies are
     // protected: The old module that is being overwritten must be destroyed

llvm/include/llvm/IR/Comdat.h

   };
 
   Comdat(const Comdat &) = delete;
-  Comdat(Comdat &&C);
+  Comdat(Comdat &&C) noexcept;
 
   SelectionKind getSelectionKind() const { return SK; }
   void setSelectionKind(SelectionKind Val) { SK = Val; }

llvm/include/llvm/IR/Metadata.h

 public:
   MDOperand() = default;
   MDOperand(const MDOperand &) = delete;
-  MDOperand(MDOperand &&Op) {
+  MDOperand(MDOperand &&Op) noexcept {
     MD = Op.MD;
     if (MD)
       (void)MetadataTracking::retrack(Op.MD, MD);
     Op.MD = nullptr;
   }
   MDOperand &operator=(const MDOperand &) = delete;
-  MDOperand &operator=(MDOperand &&Op) {
+  MDOperand &operator=(MDOperand &&Op) noexcept {
     MD = Op.MD;
     if (MD)
       (void)MetadataTracking::retrack(Op.MD, MD);

llvm/include/llvm/IR/PassManager.h

   // assignment. However, using = default triggers linker errors due to the
   // explicit instantiations below. Find away to use the default and remove the
   // duplicated code here.
-  PassManager(PassManager &&Arg) : Passes(std::move(Arg.Passes)) {}
+  PassManager(PassManager &&Arg) noexcept : Passes(std::move(Arg.Passes)) {}
 
-  PassManager &operator=(PassManager &&RHS) {
+  PassManager &operator=(PassManager &&RHS) noexcept {
     Passes = std::move(RHS.Passes);
     return *this;
   }

 
   /// Construct an empty analysis manager.
   AnalysisManager();
-  AnalysisManager(AnalysisManager &&);
-  AnalysisManager &operator=(AnalysisManager &&);
+  AnalysisManager(AnalysisManager &&) noexcept;
+  AnalysisManager &operator=(AnalysisManager &&) noexcept;
 
   /// Returns true if the analysis manager has an empty results cache.
   bool empty() const {

   public:
     explicit Result(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {}
 
-    Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)) {
+    Result(Result &&Arg) noexcept : InnerAM(std::move(Arg.InnerAM)) {
       // We have to null out the analysis manager in the moved-from state
       // because we are taking ownership of the responsibilty to clear the
       // analysis state.

       InnerAM->clear();
     }
 
-    Result &operator=(Result &&RHS) {
+    Result &operator=(Result &&RHS) noexcept {
       InnerAM = RHS.InnerAM;
       // We have to null out the analysis manager in the moved-from state
       // because we are taking ownership of the responsibilty to clear the

llvm/include/llvm/IR/PassManagerInternal.h

   // We have to explicitly define all the special member functions because MSVC
   // refuses to generate them.
   PassModel(const PassModel &Arg) : Pass(Arg.Pass) {}
-  PassModel(PassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
+  PassModel(PassModel &&Arg) noexcept : Pass(std::move(Arg.Pass)) {}
 
   friend void swap(PassModel &LHS, PassModel &RHS) {
     using std::swap;

   // We have to explicitly define all the special member functions because MSVC
   // refuses to generate them.
   AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {}
-  AnalysisResultModel(AnalysisResultModel &&Arg)
+  AnalysisResultModel(AnalysisResultModel &&Arg) noexcept
       : Result(std::move(Arg.Result)) {}
 
   friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) {

   // We have to explicitly define all the special member functions because MSVC
   // refuses to generate them.
   AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {}
-  AnalysisResultModel(AnalysisResultModel &&Arg)
+  AnalysisResultModel(AnalysisResultModel &&Arg) noexcept
       : Result(std::move(Arg.Result)) {}
 
   friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) {

   // We have to explicitly define all the special member functions because MSVC
   // refuses to generate them.
   AnalysisPassModel(const AnalysisPassModel &Arg) : Pass(Arg.Pass) {}
-  AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
+  AnalysisPassModel(AnalysisPassModel &&Arg) noexcept
+      : Pass(std::move(Arg.Pass)) {}
 
   friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS) {
     using std::swap;

llvm/include/llvm/IR/TrackingMDRef.h

   TrackingMDRef() = default;
   explicit TrackingMDRef(Metadata *MD) : MD(MD) { track(); }
 
-  TrackingMDRef(TrackingMDRef &&X) : MD(X.MD) { retrack(X); }
+  TrackingMDRef(TrackingMDRef &&X) noexcept : MD(X.MD) { retrack(X); }
   TrackingMDRef(const TrackingMDRef &X) : MD(X.MD) { track(); }
 
-  TrackingMDRef &operator=(TrackingMDRef &&X) {
+  TrackingMDRef &operator=(TrackingMDRef &&X) noexcept {
     if (&X == this)
       return *this;
 

   TypedTrackingMDRef() = default;
   explicit TypedTrackingMDRef(T *MD) : Ref(static_cast<Metadata *>(MD)) {}
 
-  TypedTrackingMDRef(TypedTrackingMDRef &&X) : Ref(std::move(X.Ref)) {}
+  TypedTrackingMDRef(TypedTrackingMDRef &&X) noexcept : Ref(std::move(X.Ref)) {}
   TypedTrackingMDRef(const TypedTrackingMDRef &X) : Ref(X.Ref) {}
 
-  TypedTrackingMDRef &operator=(TypedTrackingMDRef &&X) {
+  TypedTrackingMDRef &operator=(TypedTrackingMDRef &&X) noexcept {
     Ref = std::move(X.Ref);
     return *this;
   }

llvm/include/llvm/InterfaceStub/IFSStub.h

 
   IFSStub() = default;
   IFSStub(const IFSStub &Stub);
-  IFSStub(IFSStub &&Stub);
+  IFSStub(IFSStub &&Stub) noexcept;
 };
 
 // Create a alias class for IFSStub.

   IFSStubTriple() = default;
   IFSStubTriple(const IFSStub &Stub);
   IFSStubTriple(const IFSStubTriple &Stub);
-  IFSStubTriple(IFSStubTriple &&Stub);
+  IFSStubTriple(IFSStubTriple &&Stub) noexcept;
 };
 
 /// This function convert bit width type from IFS enum to ELF format

llvm/include/llvm/Object/Archive.h

         Header = C.Header->clone();
     }
 
-    Child(Child &&C) {
+    Child(Child &&C) noexcept {
       Parent = std::move(C.Parent);
       Header = std::move(C.Header);
       Data = C.Data;

llvm/include/llvm/Object/Binary.h

 public:
   OwningBinary();
   OwningBinary(std::unique_ptr<T> Bin, std::unique_ptr<MemoryBuffer> Buf);
-  OwningBinary(OwningBinary<T>&& Other);
-  OwningBinary<T> &operator=(OwningBinary<T> &&Other);
+  OwningBinary(OwningBinary<T> &&Other) noexcept;
+  OwningBinary<T> &operator=(OwningBinary<T> &&Other) noexcept;
 
   std::pair<std::unique_ptr<T>, std::unique_ptr<MemoryBuffer>> takeBinary();
 

 template <typename T> OwningBinary<T>::OwningBinary() = default;
 
 template <typename T>
-OwningBinary<T>::OwningBinary(OwningBinary &&Other)
+OwningBinary<T>::OwningBinary(OwningBinary &&Other) noexcept
     : Bin(std::move(Other.Bin)), Buf(std::move(Other.Buf)) {}
 
 template <typename T>
-OwningBinary<T> &OwningBinary<T>::operator=(OwningBinary &&Other) {
+OwningBinary<T> &OwningBinary<T>::operator=(OwningBinary &&Other) noexcept {
   Bin = std::move(Other.Bin);
   Buf = std::move(Other.Buf);
   return *this;

llvm/include/llvm/Object/ELFObjectFile.h

   bool isDyldELFObject;
 
 public:
-  ELFObjectFile(ELFObjectFile<ELFT> &&Other);
+  ELFObjectFile(ELFObjectFile<ELFT> &&Other) noexcept;
   static Expected<ELFObjectFile<ELFT>> create(MemoryBufferRef Object,
                                               bool InitContent = true);
 

       DotSymtabShndxSec(DotSymtabShndx) {}
 
 template <class ELFT>
-ELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other)
+ELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other) noexcept
     : ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec,
                     Other.DotSymtabSec, Other.DotSymtabShndxSec) {}
 

llvm/lib/Analysis/AliasAnalysis.cpp

 static const bool EnableAATrace = false;
 #endif
 
-AAResults::AAResults(AAResults &&Arg)
+AAResults::AAResults(AAResults &&Arg) noexcept
     : TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {}
 
 AAResults::~AAResults() {}

llvm/lib/Analysis/BlockFrequencyInfo.cpp

   calculate(F, BPI, LI);
 }
 
-BlockFrequencyInfo::BlockFrequencyInfo(BlockFrequencyInfo &&Arg)
+BlockFrequencyInfo::BlockFrequencyInfo(BlockFrequencyInfo &&Arg) noexcept
     : BFI(std::move(Arg.BFI)) {}
 
-BlockFrequencyInfo &BlockFrequencyInfo::operator=(BlockFrequencyInfo &&RHS) {
+BlockFrequencyInfo &
+BlockFrequencyInfo::operator=(BlockFrequencyInfo &&RHS) noexcept {
   releaseMemory();
   BFI = std::move(RHS.BFI);
   return *this;

llvm/lib/Analysis/CallGraph.cpp

       addToCallGraph(&F);
 }
 
-CallGraph::CallGraph(CallGraph &&Arg)
+CallGraph::CallGraph(CallGraph &&Arg) noexcept
     : M(Arg.M), FunctionMap(std::move(Arg.FunctionMap)),
       ExternalCallingNode(Arg.ExternalCallingNode),
       CallsExternalNode(std::move(Arg.CallsExternalNode)) {

llvm/lib/Analysis/DDG.cpp

          "constructing from invalid simple node.");
 }
 
-SimpleDDGNode::SimpleDDGNode(SimpleDDGNode &&N)
+SimpleDDGNode::SimpleDDGNode(SimpleDDGNode &&N) noexcept
     : DDGNode(std::move(N)), InstList(std::move(N.InstList)) {
   assert(((getKind() == NodeKind::SingleInstruction && InstList.size() == 1) ||
           (getKind() == NodeKind::MultiInstruction && InstList.size() > 1)) &&

          "constructing from invalid pi-block node.");
 }
 
-PiBlockDDGNode::PiBlockDDGNode(PiBlockDDGNode &&N)
+PiBlockDDGNode::PiBlockDDGNode(PiBlockDDGNode &&N) noexcept
     : DDGNode(std::move(N)), NodeList(std::move(N.NodeList)) {
   assert(getKind() == NodeKind::PiBlock && !NodeList.empty() &&
          "constructing from invalid pi-block node.");

llvm/lib/Analysis/GlobalsModRef.cpp

     if (const auto *ArgPtr = Arg.Info.getPointer())
       Info.setPointer(new AlignedMap(*ArgPtr));
   }
-  FunctionInfo(FunctionInfo &&Arg)
+  FunctionInfo(FunctionInfo &&Arg) noexcept
       : Info(Arg.Info.getPointer(), Arg.Info.getInt()) {
     Arg.Info.setPointerAndInt(nullptr, 0);
   }

       Info.setPointer(new AlignedMap(*RHSPtr));
     return *this;
   }
-  FunctionInfo &operator=(FunctionInfo &&RHS) {
+  FunctionInfo &operator=(FunctionInfo &&RHS) noexcept {
     delete Info.getPointer();
     Info.setPointerAndInt(RHS.Info.getPointer(), RHS.Info.getInt());
     RHS.Info.setPointerAndInt(nullptr, 0);

     std::function<const TargetLibraryInfo &(Function &F)> GetTLI)
     : DL(DL), GetTLI(std::move(GetTLI)) {}
 
-GlobalsAAResult::GlobalsAAResult(GlobalsAAResult &&Arg)
+GlobalsAAResult::GlobalsAAResult(GlobalsAAResult &&Arg) noexcept
     : AAResultBase(std::move(Arg)), DL(Arg.DL), GetTLI(std::move(Arg.GetTLI)),
       NonAddressTakenGlobals(std::move(Arg.NonAddressTakenGlobals)),
       IndirectGlobals(std::move(Arg.IndirectGlobals)),

llvm/lib/Analysis/InlineSizeEstimatorAnalysis.cpp

 } // namespace llvm
 InlineSizeEstimatorAnalysis::InlineSizeEstimatorAnalysis() = default;
 InlineSizeEstimatorAnalysis ::InlineSizeEstimatorAnalysis(
-    InlineSizeEstimatorAnalysis &&) {}
+    InlineSizeEstimatorAnalysis &&) noexcept {}
 InlineSizeEstimatorAnalysis::~InlineSizeEstimatorAnalysis() = default;
 InlineSizeEstimatorAnalysis::Result
 InlineSizeEstimatorAnalysis::run(const Function &F,

llvm/lib/Analysis/LazyCallGraph.cpp

   });
 }
 
-LazyCallGraph::LazyCallGraph(LazyCallGraph &&G)
+LazyCallGraph::LazyCallGraph(LazyCallGraph &&G) noexcept
     : BPA(std::move(G.BPA)), NodeMap(std::move(G.NodeMap)),
       EntryEdges(std::move(G.EntryEdges)), SCCBPA(std::move(G.SCCBPA)),
       SCCMap(std::move(G.SCCMap)), LibFunctions(std::move(G.LibFunctions)) {

   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Module>>());
 }
 
-LazyCallGraph &LazyCallGraph::operator=(LazyCallGraph &&G) {
+LazyCallGraph &LazyCallGraph::operator=(LazyCallGraph &&G) noexcept {
   BPA = std::move(G.BPA);
   NodeMap = std::move(G.NodeMap);
   EntryEdges = std::move(G.EntryEdges);

llvm/lib/Analysis/ScalarEvolution.cpp

   HasGuards = GuardDecl && !GuardDecl->use_empty();
 }
 
-ScalarEvolution::ScalarEvolution(ScalarEvolution &&Arg)
+ScalarEvolution::ScalarEvolution(ScalarEvolution &&Arg) noexcept
     : F(Arg.F), HasGuards(Arg.HasGuards), TLI(Arg.TLI), AC(Arg.AC), DT(Arg.DT),
       LI(Arg.LI), CouldNotCompute(std::move(Arg.CouldNotCompute)),
       ValueExprMap(std::move(Arg.ValueExprMap)),

llvm/lib/Analysis/TargetLibraryInfo.cpp

   ScalarDescs = TLI.ScalarDescs;
 }
 
-TargetLibraryInfoImpl::TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI)
+TargetLibraryInfoImpl::TargetLibraryInfoImpl(
+    TargetLibraryInfoImpl &&TLI) noexcept
     : CustomNames(std::move(TLI.CustomNames)),
       ShouldExtI32Param(TLI.ShouldExtI32Param),
       ShouldExtI32Return(TLI.ShouldExtI32Return),

   return *this;
 }
 
-TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl &&TLI) {
+TargetLibraryInfoImpl &
+TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl &&TLI) noexcept {
   CustomNames = std::move(TLI.CustomNames);
   ShouldExtI32Param = TLI.ShouldExtI32Param;
   ShouldExtI32Return = TLI.ShouldExtI32Return;

llvm/lib/Analysis/TargetTransformInfo.cpp

 
 TargetTransformInfo::~TargetTransformInfo() = default;
 
-TargetTransformInfo::TargetTransformInfo(TargetTransformInfo &&Arg)
+TargetTransformInfo::TargetTransformInfo(TargetTransformInfo &&Arg) noexcept
     : TTIImpl(std::move(Arg.TTIImpl)) {}
 
-TargetTransformInfo &TargetTransformInfo::operator=(TargetTransformInfo &&RHS) {
+TargetTransformInfo &
+TargetTransformInfo::operator=(TargetTransformInfo &&RHS) noexcept {
   TTIImpl = std::move(RHS.TTIImpl);
   return *this;
 }

llvm/lib/Bitcode/Reader/MetadataLoader.h

   MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
                  BitcodeReaderValueList &ValueList, bool IsImporting,
                  std::function<Type *(unsigned)> getTypeByID);
-  MetadataLoader &operator=(MetadataLoader &&);
-  MetadataLoader(MetadataLoader &&);
+  MetadataLoader &operator=(MetadataLoader &&) noexcept;
+  MetadataLoader(MetadataLoader &&) noexcept;
 
   // Parse a module metadata block
   Error parseModuleMetadata() { return parseMetadata(true); }

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

   }
 }
 
-MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) {
+MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) noexcept {
   Pimpl = std::move(RHS.Pimpl);
   return *this;
 }
-MetadataLoader::MetadataLoader(MetadataLoader &&RHS)
+MetadataLoader::MetadataLoader(MetadataLoader &&RHS) noexcept
     : Pimpl(std::move(RHS.Pimpl)) {}
 
 MetadataLoader::~MetadataLoader() = default;

llvm/lib/CodeGen/MachineModuleInfo.cpp

   ObjFileMMI = nullptr;
 }
 
-MachineModuleInfo::MachineModuleInfo(MachineModuleInfo &&MMI)
+MachineModuleInfo::MachineModuleInfo(MachineModuleInfo &&MMI) noexcept
     : TM(std::move(MMI.TM)),
       Context(MMI.TM.getTargetTriple(), MMI.TM.getMCAsmInfo(),
               MMI.TM.getMCRegisterInfo(), MMI.TM.getMCSubtargetInfo(), nullptr,

llvm/lib/DebugInfo/PDB/PDBSymbol.cpp

 
 PDBSymbol::PDBSymbol(const IPDBSession &PDBSession) : Session(PDBSession) {}
 
-PDBSymbol::PDBSymbol(PDBSymbol &&Other)
+PDBSymbol::PDBSymbol(PDBSymbol &&Other) noexcept
     : Session(Other.Session), RawSymbol(std::move(Other.RawSymbol)) {}
 
 PDBSymbol::~PDBSymbol() = default;

llvm/lib/Demangle/ItaniumDemangle.cpp

 }
 
 ItaniumPartialDemangler::ItaniumPartialDemangler(
-    ItaniumPartialDemangler &&Other)
+    ItaniumPartialDemangler &&Other) noexcept
     : RootNode(Other.RootNode), Context(Other.Context) {
   Other.Context = Other.RootNode = nullptr;
 }
 
-ItaniumPartialDemangler &ItaniumPartialDemangler::
-operator=(ItaniumPartialDemangler &&Other) {
+ItaniumPartialDemangler &
+ItaniumPartialDemangler::operator=(ItaniumPartialDemangler &&Other) noexcept {
   std::swap(RootNode, Other.RootNode);
   std::swap(Context, Other.Context);
   return *this;

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

           AllocateDataSection(AllocateDataSection),
           FinalizeMemory(FinalizeMemory), Destroy(Destroy) {}
 
-    MCJITMemoryManagerLikeCallbacks(MCJITMemoryManagerLikeCallbacks &&Other) {
+    MCJITMemoryManagerLikeCallbacks(
+        MCJITMemoryManagerLikeCallbacks &&Other) noexcept {
       std::swap(CreateContextCtx, Other.CreateContextCtx);
       std::swap(CreateContext, Other.CreateContext);
       std::swap(NotifyTerminating, Other.NotifyTerminating);

llvm/lib/IR/Comdat.cpp

 
 using namespace llvm;
 
-Comdat::Comdat(Comdat &&C) : Name(C.Name), SK(C.SK) {}
+Comdat::Comdat(Comdat &&C) noexcept : Name(C.Name), SK(C.SK) {}
 
 Comdat::Comdat() = default;
 

llvm/lib/InterfaceStub/ELFObjHandler.cpp

   using Elf_Dyn = typename ELFT::Dyn;
 
   ELFStubBuilder(const ELFStubBuilder &) = delete;
-  ELFStubBuilder(ELFStubBuilder &&) = default;
+  ELFStubBuilder(ELFStubBuilder &&) noexcept = default;
 
   explicit ELFStubBuilder(const IFSStub &Stub) {
     DynSym.Name = ".dynsym";

llvm/lib/InterfaceStub/IFSStub.cpp

   Symbols = Stub.Symbols;
 }
 
-IFSStub::IFSStub(IFSStub &&Stub) {
+IFSStub::IFSStub(IFSStub &&Stub) noexcept {
   IfsVersion = std::move(Stub.IfsVersion);
   Target = std::move(Stub.Target);
   SoName = std::move(Stub.SoName);

   Symbols = Stub.Symbols;
 }
 
-IFSStubTriple::IFSStubTriple(IFSStubTriple &&Stub) {
+IFSStubTriple::IFSStubTriple(IFSStubTriple &&Stub) noexcept {
   IfsVersion = std::move(Stub.IfsVersion);
   Target = std::move(Stub.Target);
   SoName = std::move(Stub.SoName);

llvm/lib/MC/MCParser/MasmParser.cpp

                    struct StructInfo Structure);
 
   FieldInitializer(const FieldInitializer &Initializer);
-  FieldInitializer(FieldInitializer &&Initializer);
+  FieldInitializer(FieldInitializer &&Initializer) noexcept;
 
   FieldInitializer &operator=(const FieldInitializer &Initializer);
-  FieldInitializer &operator=(FieldInitializer &&Initializer);
+  FieldInitializer &operator=(FieldInitializer &&Initializer) noexcept;
 };
 
 struct StructInitializer {

   }
 }
 
-FieldInitializer::FieldInitializer(FieldInitializer &&Initializer)
+FieldInitializer::FieldInitializer(FieldInitializer &&Initializer) noexcept
     : FT(Initializer.FT) {
   switch (FT) {
   case FT_INTEGRAL:

   return *this;
 }
 
-FieldInitializer &FieldInitializer::operator=(FieldInitializer &&Initializer) {
+FieldInitializer &
+FieldInitializer::operator=(FieldInitializer &&Initializer) noexcept {
   if (FT != Initializer.FT) {
     switch (FT) {
     case FT_INTEGRAL:

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

     return *this;
   }
 
-  State &operator=(State &&R) {
+  State &operator=(State &&R) noexcept {
     if (this == &R)
       return *this;
     std::swap(BS, R.BS);

llvm/lib/Transforms/Scalar/MergeICmps.cpp

   BCEAtom &operator=(const BCEAtom &) = delete;
 
   BCEAtom(BCEAtom &&that) = default;
-  BCEAtom &operator=(BCEAtom &&that) {
+  BCEAtom &operator=(BCEAtom &&that) noexcept {
     if (this == &that)
       return *this;
     GEP = that.GEP;

llvm/lib/Transforms/Scalar/NewGVN.cpp

                const PredicateBase *PredDep = nullptr)
         : Expr(Expr), ExtraDep(ExtraDep), PredDep(PredDep) {}
     ExprResult(const ExprResult &) = delete;
-    ExprResult(ExprResult &&Other)
+    ExprResult(ExprResult &&Other) noexcept
         : Expr(Other.Expr), ExtraDep(Other.ExtraDep), PredDep(Other.PredDep) {
       Other.Expr = nullptr;
       Other.ExtraDep = nullptr;

llvm/tools/llvm-exegesis/lib/PerfHelper.h

   explicit PerfEvent(StringRef PfmEventString);
 
   PerfEvent(const PerfEvent &) = delete;
-  PerfEvent(PerfEvent &&other);
+  PerfEvent(PerfEvent &&other) noexcept;
   ~PerfEvent();
 
   // The pfm_event_string passed at construction time.

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

 #endif
 }
 
-PerfEvent::PerfEvent(PerfEvent &&Other)
+PerfEvent::PerfEvent(PerfEvent &&Other) noexcept
     : EventString(std::move(Other.EventString)),
       FullQualifiedEventString(std::move(Other.FullQualifiedEventString)),
       Attr(Other.Attr) {

llvm/utils/TableGen/DecoderEmitter.cpp

   EncodingIDAndOpcode LastOpcFiltered;
 
 public:
-  Filter(Filter &&f);
+  Filter(Filter &&f) noexcept;
   Filter(FilterChooser &owner, unsigned startBit, unsigned numBits, bool mixed);
 
   ~Filter() = default;

 //                       //
 ///////////////////////////
 
-Filter::Filter(Filter &&f)
+Filter::Filter(Filter &&f) noexcept
     : Owner(f.Owner), StartBit(f.StartBit), NumBits(f.NumBits), Mixed(f.Mixed),
       FilteredInstructions(std::move(f.FilteredInstructions)),
       VariableInstructions(std::move(f.VariableInstructions)),
-    FilterChooserMap(std::move(f.FilterChooserMap)), NumFiltered(f.NumFiltered),
-    LastOpcFiltered(f.LastOpcFiltered) {
-}
+      FilterChooserMap(std::move(f.FilterChooserMap)),
+      NumFiltered(f.NumFiltered), LastOpcFiltered(f.LastOpcFiltered) {}
 
 Filter::Filter(FilterChooser &owner, unsigned startBit, unsigned numBits,
                bool mixed)