Index: llvm/include/llvm/Analysis/AliasAnalysis.h =================================================================== --- llvm/include/llvm/Analysis/AliasAnalysis.h +++ llvm/include/llvm/Analysis/AliasAnalysis.h @@ -296,7 +296,7 @@ // 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. @@ -798,7 +798,7 @@ // 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, Index: llvm/include/llvm/Analysis/BasicAliasAnalysis.h =================================================================== --- llvm/include/llvm/Analysis/BasicAliasAnalysis.h +++ llvm/include/llvm/Analysis/BasicAliasAnalysis.h @@ -56,7 +56,7 @@ 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) {} Index: llvm/include/llvm/Analysis/BlockFrequencyInfo.h =================================================================== --- llvm/include/llvm/Analysis/BlockFrequencyInfo.h +++ llvm/include/llvm/Analysis/BlockFrequencyInfo.h @@ -45,8 +45,8 @@ 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. Index: llvm/include/llvm/Analysis/BranchProbabilityInfo.h =================================================================== --- llvm/include/llvm/Analysis/BranchProbabilityInfo.h +++ llvm/include/llvm/Analysis/BranchProbabilityInfo.h @@ -121,14 +121,14 @@ 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); Index: llvm/include/llvm/Analysis/CGSCCPassManager.h =================================================================== --- llvm/include/llvm/Analysis/CGSCCPassManager.h +++ llvm/include/llvm/Analysis/CGSCCPassManager.h @@ -336,7 +336,8 @@ explicit ModuleToPostOrderCGSCCPassAdaptor(std::unique_ptr Pass) : Pass(std::move(Pass)) {} - ModuleToPostOrderCGSCCPassAdaptor(ModuleToPostOrderCGSCCPassAdaptor &&Arg) + ModuleToPostOrderCGSCCPassAdaptor( + ModuleToPostOrderCGSCCPassAdaptor &&Arg) noexcept : Pass(std::move(Arg.Pass)) {} friend void swap(ModuleToPostOrderCGSCCPassAdaptor &LHS, @@ -466,7 +467,7 @@ : 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) {} Index: llvm/include/llvm/Analysis/CallGraph.h =================================================================== --- llvm/include/llvm/Analysis/CallGraph.h +++ llvm/include/llvm/Analysis/CallGraph.h @@ -88,7 +88,7 @@ public: explicit CallGraph(Module &M); - CallGraph(CallGraph &&Arg); + CallGraph(CallGraph &&Arg) noexcept; ~CallGraph(); void print(raw_ostream &OS) const; Index: llvm/include/llvm/Analysis/DDG.h =================================================================== --- llvm/include/llvm/Analysis/DDG.h +++ llvm/include/llvm/Analysis/DDG.h @@ -56,7 +56,7 @@ 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) { @@ -65,7 +65,7 @@ return *this; } - DDGNode &operator=(DDGNode &&N) { + DDGNode &operator=(DDGNode &&N) noexcept { DGNode::operator=(std::move(N)); Kind = N.Kind; return *this; @@ -94,7 +94,7 @@ 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. @@ -112,12 +112,12 @@ 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; @@ -174,12 +174,12 @@ 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; @@ -224,10 +224,10 @@ 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; @@ -260,7 +260,7 @@ 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; @@ -313,7 +313,7 @@ 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); Index: llvm/include/llvm/Analysis/GlobalsModRef.h =================================================================== --- llvm/include/llvm/Analysis/GlobalsModRef.h +++ llvm/include/llvm/Analysis/GlobalsModRef.h @@ -79,7 +79,7 @@ friend struct RecomputeGlobalsAAPass; public: - GlobalsAAResult(GlobalsAAResult &&Arg); + GlobalsAAResult(GlobalsAAResult &&Arg) noexcept; ~GlobalsAAResult(); bool invalidate(Module &M, const PreservedAnalyses &PA, Index: llvm/include/llvm/Analysis/InlineSizeEstimatorAnalysis.h =================================================================== --- llvm/include/llvm/Analysis/InlineSizeEstimatorAnalysis.h +++ llvm/include/llvm/Analysis/InlineSizeEstimatorAnalysis.h @@ -20,7 +20,7 @@ : public AnalysisInfoMixin { public: InlineSizeEstimatorAnalysis(); - InlineSizeEstimatorAnalysis(InlineSizeEstimatorAnalysis &&); + InlineSizeEstimatorAnalysis(InlineSizeEstimatorAnalysis &&) noexcept; ~InlineSizeEstimatorAnalysis(); static AnalysisKey Key; Index: llvm/include/llvm/Analysis/LazyCallGraph.h =================================================================== --- llvm/include/llvm/Analysis/LazyCallGraph.h +++ llvm/include/llvm/Analysis/LazyCallGraph.h @@ -940,8 +940,8 @@ LazyCallGraph(Module &M, function_ref 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 &); Index: llvm/include/llvm/Analysis/LazyValueInfo.h =================================================================== --- llvm/include/llvm/Analysis/LazyValueInfo.h +++ llvm/include/llvm/Analysis/LazyValueInfo.h @@ -42,11 +42,11 @@ 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; Index: llvm/include/llvm/Analysis/LoopAnalysisManager.h =================================================================== --- llvm/include/llvm/Analysis/LoopAnalysisManager.h +++ llvm/include/llvm/Analysis/LoopAnalysisManager.h @@ -87,14 +87,14 @@ 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; Index: llvm/include/llvm/Analysis/LoopInfo.h =================================================================== --- llvm/include/llvm/Analysis/LoopInfo.h +++ llvm/include/llvm/Analysis/LoopInfo.h @@ -925,14 +925,14 @@ 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) @@ -1117,8 +1117,9 @@ LoopInfo() = default; explicit LoopInfo(const DominatorTreeBase &DomTree); - LoopInfo(LoopInfo &&Arg) : BaseT(std::move(static_cast(Arg))) {} - LoopInfo &operator=(LoopInfo &&RHS) { + LoopInfo(LoopInfo &&Arg) noexcept + : BaseT(std::move(static_cast(Arg))) {} + LoopInfo &operator=(LoopInfo &&RHS) noexcept { BaseT::operator=(std::move(static_cast(RHS))); return *this; } Index: llvm/include/llvm/Analysis/MustExecute.h =================================================================== --- llvm/include/llvm/Analysis/MustExecute.h +++ llvm/include/llvm/Analysis/MustExecute.h @@ -283,11 +283,11 @@ 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); Index: llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h =================================================================== --- llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h +++ llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h @@ -39,7 +39,7 @@ 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. Index: llvm/include/llvm/Analysis/OptimizationRemarkEmitter.h =================================================================== --- llvm/include/llvm/Analysis/OptimizationRemarkEmitter.h +++ llvm/include/llvm/Analysis/OptimizationRemarkEmitter.h @@ -48,10 +48,11 @@ /// 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; Index: llvm/include/llvm/Analysis/ScalarEvolution.h =================================================================== --- llvm/include/llvm/Analysis/ScalarEvolution.h +++ llvm/include/llvm/Analysis/ScalarEvolution.h @@ -488,7 +488,7 @@ 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(); } Index: llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h =================================================================== --- llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h +++ llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h @@ -29,7 +29,8 @@ 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); Index: llvm/include/llvm/Analysis/TargetLibraryInfo.h =================================================================== --- llvm/include/llvm/Analysis/TargetLibraryInfo.h +++ llvm/include/llvm/Analysis/TargetLibraryInfo.h @@ -101,9 +101,9 @@ // 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. /// @@ -265,10 +265,10 @@ // 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; Index: llvm/include/llvm/Analysis/TargetTransformInfo.h =================================================================== --- llvm/include/llvm/Analysis/TargetTransformInfo.h +++ llvm/include/llvm/Analysis/TargetTransformInfo.h @@ -186,8 +186,8 @@ 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. @@ -2609,13 +2609,13 @@ // 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; } Index: llvm/include/llvm/Analysis/TargetTransformInfoImpl.h =================================================================== --- llvm/include/llvm/Analysis/TargetTransformInfoImpl.h +++ llvm/include/llvm/Analysis/TargetTransformInfoImpl.h @@ -42,7 +42,8 @@ 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; } Index: llvm/include/llvm/CodeGen/MachineModuleInfo.h =================================================================== --- llvm/include/llvm/CodeGen/MachineModuleInfo.h +++ llvm/include/llvm/CodeGen/MachineModuleInfo.h @@ -131,7 +131,7 @@ explicit MachineModuleInfo(const LLVMTargetMachine *TM, MCContext *ExtContext); - MachineModuleInfo(MachineModuleInfo &&MMII); + MachineModuleInfo(MachineModuleInfo &&MMII) noexcept; ~MachineModuleInfo(); Index: llvm/include/llvm/DebugInfo/PDB/PDBSymbol.h =================================================================== --- llvm/include/llvm/DebugInfo/PDB/PDBSymbol.h +++ llvm/include/llvm/DebugInfo/PDB/PDBSymbol.h @@ -74,7 +74,7 @@ protected: explicit PDBSymbol(const IPDBSession &PDBSession); - PDBSymbol(PDBSymbol &&Other); + PDBSymbol(PDBSymbol &&Other) noexcept; public: static std::unique_ptr Index: llvm/include/llvm/Demangle/Demangle.h =================================================================== --- llvm/include/llvm/Demangle/Demangle.h +++ llvm/include/llvm/Demangle/Demangle.h @@ -78,8 +78,8 @@ 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. Index: llvm/include/llvm/Demangle/ItaniumDemangle.h =================================================================== --- llvm/include/llvm/Demangle/ItaniumDemangle.h +++ llvm/include/llvm/Demangle/ItaniumDemangle.h @@ -71,7 +71,7 @@ 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(); @@ -85,7 +85,7 @@ Other.clearInline(); } - PODSmallVector &operator=(PODSmallVector &&Other) { + PODSmallVector &operator=(PODSmallVector &&Other) noexcept { if (Other.isInline()) { if (!isInline()) { std::free(First); Index: llvm/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h =================================================================== --- llvm/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h +++ llvm/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h @@ -64,11 +64,11 @@ "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); @@ -323,8 +323,8 @@ 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. Index: llvm/include/llvm/ExecutionEngine/JITSymbol.h =================================================================== --- llvm/include/llvm/ExecutionEngine/JITSymbol.h +++ llvm/include/llvm/ExecutionEngine/JITSymbol.h @@ -299,15 +299,15 @@ JITSymbol(const JITSymbol&) = delete; JITSymbol& operator=(const JITSymbol&) = delete; - JITSymbol(JITSymbol &&Other) - : GetAddress(std::move(Other.GetAddress)), Flags(std::move(Other.Flags)) { + 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()) Index: llvm/include/llvm/ExecutionEngine/Orc/Core.h =================================================================== --- llvm/include/llvm/ExecutionEngine/Orc/Core.h +++ llvm/include/llvm/ExecutionEngine/Orc/Core.h @@ -904,8 +904,8 @@ public: LookupState(); - LookupState(LookupState &&); - LookupState &operator=(LookupState &&); + LookupState(LookupState &&) noexcept; + LookupState &operator=(LookupState &&) noexcept; ~LookupState(); /// Continue the lookup. This can be called by DefinitionGenerators Index: llvm/include/llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h =================================================================== --- llvm/include/llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h +++ llvm/include/llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h @@ -55,12 +55,12 @@ 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; Index: llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h =================================================================== --- llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h +++ llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h @@ -79,11 +79,11 @@ 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(); Index: llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h =================================================================== --- llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h +++ llvm/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h @@ -82,7 +82,7 @@ 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 Index: llvm/include/llvm/IR/Comdat.h =================================================================== --- llvm/include/llvm/IR/Comdat.h +++ llvm/include/llvm/IR/Comdat.h @@ -41,7 +41,7 @@ }; Comdat(const Comdat &) = delete; - Comdat(Comdat &&C); + Comdat(Comdat &&C) noexcept; SelectionKind getSelectionKind() const { return SK; } void setSelectionKind(SelectionKind Val) { SK = Val; } Index: llvm/include/llvm/IR/Metadata.h =================================================================== --- llvm/include/llvm/IR/Metadata.h +++ llvm/include/llvm/IR/Metadata.h @@ -775,14 +775,14 @@ 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); Index: llvm/include/llvm/IR/PassManager.h =================================================================== --- llvm/include/llvm/IR/PassManager.h +++ llvm/include/llvm/IR/PassManager.h @@ -476,9 +476,9 @@ // 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; } @@ -738,8 +738,8 @@ /// 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 { @@ -936,7 +936,7 @@ 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. @@ -953,7 +953,7 @@ 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 Index: llvm/include/llvm/IR/PassManagerInternal.h =================================================================== --- llvm/include/llvm/IR/PassManagerInternal.h +++ llvm/include/llvm/IR/PassManagerInternal.h @@ -72,7 +72,7 @@ // 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; @@ -202,7 +202,7 @@ // 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) { @@ -241,7 +241,7 @@ // 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) { @@ -297,7 +297,8 @@ // 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; Index: llvm/include/llvm/IR/TrackingMDRef.h =================================================================== --- llvm/include/llvm/IR/TrackingMDRef.h +++ llvm/include/llvm/IR/TrackingMDRef.h @@ -29,10 +29,10 @@ 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; @@ -110,10 +110,10 @@ TypedTrackingMDRef() = default; explicit TypedTrackingMDRef(T *MD) : Ref(static_cast(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; } Index: llvm/include/llvm/InterfaceStub/IFSStub.h =================================================================== --- llvm/include/llvm/InterfaceStub/IFSStub.h +++ llvm/include/llvm/InterfaceStub/IFSStub.h @@ -96,7 +96,7 @@ IFSStub() = default; IFSStub(const IFSStub &Stub); - IFSStub(IFSStub &&Stub); + IFSStub(IFSStub &&Stub) noexcept; }; // Create a alias class for IFSStub. @@ -108,7 +108,7 @@ 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 Index: llvm/include/llvm/Object/Archive.h =================================================================== --- llvm/include/llvm/Object/Archive.h +++ llvm/include/llvm/Object/Archive.h @@ -180,7 +180,7 @@ Header = C.Header->clone(); } - Child(Child &&C) { + Child(Child &&C) noexcept { Parent = std::move(C.Parent); Header = std::move(C.Header); Data = C.Data; Index: llvm/include/llvm/Object/Binary.h =================================================================== --- llvm/include/llvm/Object/Binary.h +++ llvm/include/llvm/Object/Binary.h @@ -195,8 +195,8 @@ public: OwningBinary(); OwningBinary(std::unique_ptr Bin, std::unique_ptr Buf); - OwningBinary(OwningBinary&& Other); - OwningBinary &operator=(OwningBinary &&Other); + OwningBinary(OwningBinary &&Other) noexcept; + OwningBinary &operator=(OwningBinary &&Other) noexcept; std::pair, std::unique_ptr> takeBinary(); @@ -212,11 +212,11 @@ template OwningBinary::OwningBinary() = default; template -OwningBinary::OwningBinary(OwningBinary &&Other) +OwningBinary::OwningBinary(OwningBinary &&Other) noexcept : Bin(std::move(Other.Bin)), Buf(std::move(Other.Buf)) {} template -OwningBinary &OwningBinary::operator=(OwningBinary &&Other) { +OwningBinary &OwningBinary::operator=(OwningBinary &&Other) noexcept { Bin = std::move(Other.Bin); Buf = std::move(Other.Buf); return *this; Index: llvm/include/llvm/Object/ELFObjectFile.h =================================================================== --- llvm/include/llvm/Object/ELFObjectFile.h +++ llvm/include/llvm/Object/ELFObjectFile.h @@ -405,7 +405,7 @@ bool isDyldELFObject; public: - ELFObjectFile(ELFObjectFile &&Other); + ELFObjectFile(ELFObjectFile &&Other) noexcept; static Expected> create(MemoryBufferRef Object, bool InitContent = true); @@ -1116,7 +1116,7 @@ DotSymtabShndxSec(DotSymtabShndx) {} template -ELFObjectFile::ELFObjectFile(ELFObjectFile &&Other) +ELFObjectFile::ELFObjectFile(ELFObjectFile &&Other) noexcept : ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec, Other.DotSymtabSec, Other.DotSymtabShndxSec) {} Index: llvm/lib/Analysis/AliasAnalysis.cpp =================================================================== --- llvm/lib/Analysis/AliasAnalysis.cpp +++ llvm/lib/Analysis/AliasAnalysis.cpp @@ -73,7 +73,7 @@ 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() {} Index: llvm/lib/Analysis/BlockFrequencyInfo.cpp =================================================================== --- llvm/lib/Analysis/BlockFrequencyInfo.cpp +++ llvm/lib/Analysis/BlockFrequencyInfo.cpp @@ -158,10 +158,11 @@ 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; Index: llvm/lib/Analysis/CallGraph.cpp =================================================================== --- llvm/lib/Analysis/CallGraph.cpp +++ llvm/lib/Analysis/CallGraph.cpp @@ -38,7 +38,7 @@ 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)) { Index: llvm/lib/Analysis/DDG.cpp =================================================================== --- llvm/lib/Analysis/DDG.cpp +++ llvm/lib/Analysis/DDG.cpp @@ -117,7 +117,7 @@ "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)) && @@ -141,7 +141,7 @@ "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."); Index: llvm/lib/Analysis/GlobalsModRef.cpp =================================================================== --- llvm/lib/Analysis/GlobalsModRef.cpp +++ llvm/lib/Analysis/GlobalsModRef.cpp @@ -110,7 +110,7 @@ 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); } @@ -121,7 +121,7 @@ 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); @@ -953,7 +953,7 @@ std::function 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)), Index: llvm/lib/Analysis/InlineSizeEstimatorAnalysis.cpp =================================================================== --- llvm/lib/Analysis/InlineSizeEstimatorAnalysis.cpp +++ llvm/lib/Analysis/InlineSizeEstimatorAnalysis.cpp @@ -262,7 +262,7 @@ } // namespace llvm InlineSizeEstimatorAnalysis::InlineSizeEstimatorAnalysis() = default; InlineSizeEstimatorAnalysis ::InlineSizeEstimatorAnalysis( - InlineSizeEstimatorAnalysis &&) {} + InlineSizeEstimatorAnalysis &&) noexcept {} InlineSizeEstimatorAnalysis::~InlineSizeEstimatorAnalysis() = default; InlineSizeEstimatorAnalysis::Result InlineSizeEstimatorAnalysis::run(const Function &F, Index: llvm/lib/Analysis/LazyCallGraph.cpp =================================================================== --- llvm/lib/Analysis/LazyCallGraph.cpp +++ llvm/lib/Analysis/LazyCallGraph.cpp @@ -204,7 +204,7 @@ }); } -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)) { @@ -219,7 +219,7 @@ return !(PAC.preserved() || PAC.preservedSet>()); } -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); Index: llvm/lib/Analysis/ScalarEvolution.cpp =================================================================== --- llvm/lib/Analysis/ScalarEvolution.cpp +++ llvm/lib/Analysis/ScalarEvolution.cpp @@ -13411,7 +13411,7 @@ 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)), Index: llvm/lib/Analysis/TargetLibraryInfo.cpp =================================================================== --- llvm/lib/Analysis/TargetLibraryInfo.cpp +++ llvm/lib/Analysis/TargetLibraryInfo.cpp @@ -895,7 +895,8 @@ ScalarDescs = TLI.ScalarDescs; } -TargetLibraryInfoImpl::TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI) +TargetLibraryInfoImpl::TargetLibraryInfoImpl( + TargetLibraryInfoImpl &&TLI) noexcept : CustomNames(std::move(TLI.CustomNames)), ShouldExtI32Param(TLI.ShouldExtI32Param), ShouldExtI32Return(TLI.ShouldExtI32Return), @@ -919,7 +920,8 @@ return *this; } -TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl &&TLI) { +TargetLibraryInfoImpl & +TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl &&TLI) noexcept { CustomNames = std::move(TLI.CustomNames); ShouldExtI32Param = TLI.ShouldExtI32Param; ShouldExtI32Return = TLI.ShouldExtI32Return; Index: llvm/lib/Analysis/TargetTransformInfo.cpp =================================================================== --- llvm/lib/Analysis/TargetTransformInfo.cpp +++ llvm/lib/Analysis/TargetTransformInfo.cpp @@ -187,10 +187,11 @@ 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; } Index: llvm/lib/Bitcode/Reader/MetadataLoader.h =================================================================== --- llvm/lib/Bitcode/Reader/MetadataLoader.h +++ llvm/lib/Bitcode/Reader/MetadataLoader.h @@ -40,8 +40,8 @@ MetadataLoader(BitstreamCursor &Stream, Module &TheModule, BitcodeReaderValueList &ValueList, bool IsImporting, std::function getTypeByID); - MetadataLoader &operator=(MetadataLoader &&); - MetadataLoader(MetadataLoader &&); + MetadataLoader &operator=(MetadataLoader &&) noexcept; + MetadataLoader(MetadataLoader &&) noexcept; // Parse a module metadata block Error parseModuleMetadata() { return parseMetadata(true); } Index: llvm/lib/Bitcode/Reader/MetadataLoader.cpp =================================================================== --- llvm/lib/Bitcode/Reader/MetadataLoader.cpp +++ llvm/lib/Bitcode/Reader/MetadataLoader.cpp @@ -2348,11 +2348,11 @@ } } -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; Index: llvm/lib/CodeGen/MachineModuleInfo.cpp =================================================================== --- llvm/lib/CodeGen/MachineModuleInfo.cpp +++ llvm/lib/CodeGen/MachineModuleInfo.cpp @@ -56,7 +56,7 @@ 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, Index: llvm/lib/DebugInfo/PDB/PDBSymbol.cpp =================================================================== --- llvm/lib/DebugInfo/PDB/PDBSymbol.cpp +++ llvm/lib/DebugInfo/PDB/PDBSymbol.cpp @@ -51,7 +51,7 @@ 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; Index: llvm/lib/Demangle/ItaniumDemangle.cpp =================================================================== --- llvm/lib/Demangle/ItaniumDemangle.cpp +++ llvm/lib/Demangle/ItaniumDemangle.cpp @@ -402,13 +402,13 @@ } 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; Index: llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp =================================================================== --- llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp +++ llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp @@ -1095,7 +1095,8 @@ 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); Index: llvm/lib/IR/Comdat.cpp =================================================================== --- llvm/lib/IR/Comdat.cpp +++ llvm/lib/IR/Comdat.cpp @@ -21,7 +21,7 @@ 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; Index: llvm/lib/InterfaceStub/ELFObjHandler.cpp =================================================================== --- llvm/lib/InterfaceStub/ELFObjHandler.cpp +++ llvm/lib/InterfaceStub/ELFObjHandler.cpp @@ -177,7 +177,7 @@ 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"; Index: llvm/lib/InterfaceStub/IFSStub.cpp =================================================================== --- llvm/lib/InterfaceStub/IFSStub.cpp +++ llvm/lib/InterfaceStub/IFSStub.cpp @@ -21,7 +21,7 @@ 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); @@ -45,7 +45,7 @@ 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); Index: llvm/lib/MC/MCParser/MasmParser.cpp =================================================================== --- llvm/lib/MC/MCParser/MasmParser.cpp +++ llvm/lib/MC/MCParser/MasmParser.cpp @@ -186,10 +186,10 @@ 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 { @@ -298,7 +298,7 @@ } } -FieldInitializer::FieldInitializer(FieldInitializer &&Initializer) +FieldInitializer::FieldInitializer(FieldInitializer &&Initializer) noexcept : FT(Initializer.FT) { switch (FT) { case FT_INTEGRAL: @@ -343,7 +343,8 @@ return *this; } -FieldInitializer &FieldInitializer::operator=(FieldInitializer &&Initializer) { +FieldInitializer & +FieldInitializer::operator=(FieldInitializer &&Initializer) noexcept { if (FT != Initializer.FT) { switch (FT) { case FT_INTEGRAL: Index: llvm/lib/Transforms/IPO/AttributorAttributes.cpp =================================================================== --- llvm/lib/Transforms/IPO/AttributorAttributes.cpp +++ llvm/lib/Transforms/IPO/AttributorAttributes.cpp @@ -766,7 +766,7 @@ return *this; } - State &operator=(State &&R) { + State &operator=(State &&R) noexcept { if (this == &R) return *this; std::swap(BS, R.BS); Index: llvm/lib/Transforms/Scalar/MergeICmps.cpp =================================================================== --- llvm/lib/Transforms/Scalar/MergeICmps.cpp +++ llvm/lib/Transforms/Scalar/MergeICmps.cpp @@ -78,7 +78,7 @@ 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; Index: llvm/lib/Transforms/Scalar/NewGVN.cpp =================================================================== --- llvm/lib/Transforms/Scalar/NewGVN.cpp +++ llvm/lib/Transforms/Scalar/NewGVN.cpp @@ -678,7 +678,7 @@ 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; Index: llvm/tools/llvm-exegesis/lib/PerfHelper.h =================================================================== --- llvm/tools/llvm-exegesis/lib/PerfHelper.h +++ llvm/tools/llvm-exegesis/lib/PerfHelper.h @@ -42,7 +42,7 @@ explicit PerfEvent(StringRef PfmEventString); PerfEvent(const PerfEvent &) = delete; - PerfEvent(PerfEvent &&other); + PerfEvent(PerfEvent &&other) noexcept; ~PerfEvent(); // The pfm_event_string passed at construction time. Index: llvm/tools/llvm-exegesis/lib/PerfHelper.cpp =================================================================== --- llvm/tools/llvm-exegesis/lib/PerfHelper.cpp +++ llvm/tools/llvm-exegesis/lib/PerfHelper.cpp @@ -51,7 +51,7 @@ #endif } -PerfEvent::PerfEvent(PerfEvent &&Other) +PerfEvent::PerfEvent(PerfEvent &&Other) noexcept : EventString(std::move(Other.EventString)), FullQualifiedEventString(std::move(Other.FullQualifiedEventString)), Attr(Other.Attr) { Index: llvm/utils/TableGen/DecoderEmitter.cpp =================================================================== --- llvm/utils/TableGen/DecoderEmitter.cpp +++ llvm/utils/TableGen/DecoderEmitter.cpp @@ -300,7 +300,7 @@ EncodingIDAndOpcode LastOpcFiltered; public: - Filter(Filter &&f); + Filter(Filter &&f) noexcept; Filter(FilterChooser &owner, unsigned startBit, unsigned numBits, bool mixed); ~Filter() = default; @@ -557,13 +557,12 @@ // // /////////////////////////// -Filter::Filter(Filter &&f) - : 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) { -} +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) {} Filter::Filter(FilterChooser &owner, unsigned startBit, unsigned numBits, bool mixed)