Do a sweep over move ctors and remove those that are identical to the default.

All of these existed because MSVC 2013 was unable to synthesize default
move ctors. We recently dropped support for it so all that error-prone
boilerplate can go.

No functionality change intended.

llvm-svn: 284721

llvm/include/llvm/Analysis/AliasAnalysis.h

@@ -854,20 +854,6 @@ class AAManager : public AnalysisInfoMixin<AAManager> {
 public:
   typedef AAResults Result;
 
-  // This type has value semantics. We have to spell these out because MSVC
-  // won't synthesize them.
-  AAManager() {}
-  AAManager(AAManager &&Arg) : ResultGetters(std::move(Arg.ResultGetters)) {}
-  AAManager(const AAManager &Arg) : ResultGetters(Arg.ResultGetters) {}
-  AAManager &operator=(AAManager &&RHS) {
-    ResultGetters = std::move(RHS.ResultGetters);
-    return *this;
-  }
-  AAManager &operator=(const AAManager &RHS) {
-    ResultGetters = RHS.ResultGetters;
-    return *this;
-  }
-
   /// Register a specific AA result.
   template <typename AnalysisT> void registerFunctionAnalysis() {
     ResultGetters.push_back(&getFunctionAAResultImpl<AnalysisT>);

llvm/include/llvm/Analysis/AssumptionCache.h

@@ -100,12 +100,6 @@ class AssumptionAnalysis : public AnalysisInfoMixin<AssumptionAnalysis> {
 public:
   typedef AssumptionCache Result;
 
-  AssumptionAnalysis() {}
-  AssumptionAnalysis(const AssumptionAnalysis &Arg) {}
-  AssumptionAnalysis(AssumptionAnalysis &&Arg) {}
-  AssumptionAnalysis &operator=(const AssumptionAnalysis &RHS) { return *this; }
-  AssumptionAnalysis &operator=(AssumptionAnalysis &&RHS) { return *this; }
-
   AssumptionCache run(Function &F, FunctionAnalysisManager &) {
     return AssumptionCache(F);
   }

llvm/include/llvm/Analysis/DependenceAnalysis.h

@@ -70,13 +70,8 @@ template <typename T> class ArrayRef;
   /// itelf.
   class Dependence {
   protected:
-    Dependence(const Dependence &) = default;
-
-    // FIXME: When we move to MSVC 2015 as the base compiler for Visual Studio
-    // support, uncomment this line to allow a defaulted move constructor for
-    // Dependence. Currently, FullDependence relies on the copy constructor, but
-    // that is acceptable given the triviality of the class.
-    // Dependence(Dependence &&) = default;
+    Dependence(Dependence &&) = default;
+    Dependence &operator=(Dependence &&) = default;
 
   public:
     Dependence(Instruction *Source,
@@ -222,11 +217,6 @@ template <typename T> class ArrayRef;
     FullDependence(Instruction *Src, Instruction *Dst, bool LoopIndependent,
                    unsigned Levels);
 
-    FullDependence(FullDependence &&RHS)
-        : Dependence(std::move(RHS)), Levels(RHS.Levels),
-          LoopIndependent(RHS.LoopIndependent), Consistent(RHS.Consistent),
-          DV(std::move(RHS.DV)) {}
-
     /// isLoopIndependent - Returns true if this is a loop-independent
     /// dependence.
     bool isLoopIndependent() const override { return LoopIndependent; }

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

@@ -518,38 +518,6 @@ public:
   LoopAccessInfo(Loop *L, ScalarEvolution *SE, const TargetLibraryInfo *TLI,
                  AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI);
 
-  // FIXME:
-  // Hack for MSVC 2013 which sems like it can't synthesize this even 
-  // with default keyword:
-  // LoopAccessInfo(LoopAccessInfo &&LAI) = default;
-  LoopAccessInfo(LoopAccessInfo &&LAI)
-      : PSE(std::move(LAI.PSE)), PtrRtChecking(std::move(LAI.PtrRtChecking)),
-        DepChecker(std::move(LAI.DepChecker)), TheLoop(LAI.TheLoop),
-        NumLoads(LAI.NumLoads), NumStores(LAI.NumStores),
-        MaxSafeDepDistBytes(LAI.MaxSafeDepDistBytes), CanVecMem(LAI.CanVecMem),
-        StoreToLoopInvariantAddress(LAI.StoreToLoopInvariantAddress),
-        Report(std::move(LAI.Report)),
-        SymbolicStrides(std::move(LAI.SymbolicStrides)),
-        StrideSet(std::move(LAI.StrideSet)) {}
-  // LoopAccessInfo &operator=(LoopAccessInfo &&LAI) = default;
-  LoopAccessInfo &operator=(LoopAccessInfo &&LAI) {
-    assert(this != &LAI);
-
-    PSE = std::move(LAI.PSE);
-    PtrRtChecking = std::move(LAI.PtrRtChecking);
-    DepChecker = std::move(LAI.DepChecker);
-    TheLoop = LAI.TheLoop;
-    NumLoads = LAI.NumLoads;
-    NumStores = LAI.NumStores;
-    MaxSafeDepDistBytes = LAI.MaxSafeDepDistBytes;
-    CanVecMem = LAI.CanVecMem;
-    StoreToLoopInvariantAddress = LAI.StoreToLoopInvariantAddress;
-    Report = std::move(LAI.Report);
-    SymbolicStrides = std::move(LAI.SymbolicStrides);
-    StrideSet = std::move(LAI.StrideSet);
-    return *this;
-  }
-
   /// Return true we can analyze the memory accesses in the loop and there are
   /// no memory dependence cycles.
   bool canVectorizeMemory() const { return CanVecMem; }

llvm/include/llvm/Analysis/LoopPassManager.h

@@ -64,21 +64,6 @@ class FunctionToLoopPassAdaptor
 public:
   explicit FunctionToLoopPassAdaptor(LoopPassT Pass)
       : Pass(std::move(Pass)) {}
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  FunctionToLoopPassAdaptor(const FunctionToLoopPassAdaptor &Arg)
-      : Pass(Arg.Pass) {}
-  FunctionToLoopPassAdaptor(FunctionToLoopPassAdaptor &&Arg)
-      : Pass(std::move(Arg.Pass)) {}
-  friend void swap(FunctionToLoopPassAdaptor &LHS,
-                   FunctionToLoopPassAdaptor &RHS) {
-    using std::swap;
-    swap(LHS.Pass, RHS.Pass);
-  }
-  FunctionToLoopPassAdaptor &operator=(FunctionToLoopPassAdaptor RHS) {
-    swap(*this, RHS);
-    return *this;
-  }
 
   /// \brief Runs the loop passes across every loop in the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {

llvm/include/llvm/Analysis/PostDominators.h

@@ -26,14 +26,6 @@ struct PostDominatorTree : public DominatorTreeBase<BasicBlock> {
   typedef DominatorTreeBase<BasicBlock> Base;
 
   PostDominatorTree() : DominatorTreeBase<BasicBlock>(true) {}
-
-  PostDominatorTree(PostDominatorTree &&Arg)
-    : Base(std::move(static_cast<Base &>(Arg))) {}
-
-  PostDominatorTree &operator=(PostDominatorTree &&RHS) {
-    Base::operator=(std::move(static_cast<Base &>(RHS)));
-    return *this;
-  }
 };
 
 /// \brief Analysis pass which computes a \c PostDominatorTree.

llvm/include/llvm/Analysis/ProfileSummaryInfo.h

@@ -86,16 +86,6 @@ class ProfileSummaryAnalysis
 public:
   typedef ProfileSummaryInfo Result;
 
-  ProfileSummaryAnalysis() {}
-  ProfileSummaryAnalysis(const ProfileSummaryAnalysis &Arg) {}
-  ProfileSummaryAnalysis(ProfileSummaryAnalysis &&Arg) {}
-  ProfileSummaryAnalysis &operator=(const ProfileSummaryAnalysis &RHS) {
-    return *this;
-  }
-  ProfileSummaryAnalysis &operator=(ProfileSummaryAnalysis &&RHS) {
-    return *this;
-  }
-
   Result run(Module &M, ModuleAnalysisManager &);
 
 private:

llvm/include/llvm/Analysis/ScalarEvolution.h

@@ -609,22 +609,6 @@ private:
                               std::unique_ptr<SCEVUnionPredicate> Predicate)
         : ExitingBlock(ExitingBlock), ExactNotTaken(ExactNotTaken),
           Predicate(std::move(Predicate)) {}
-
-    // Clang builds fine without this, but MSVC does not.
-    ExitNotTakenInfo(const ExitNotTakenInfo &) = delete;
-
-    ExitNotTakenInfo(ExitNotTakenInfo &&Other) {
-      ExitingBlock = std::move(Other.ExitingBlock);
-      ExactNotTaken = std::move(Other.ExactNotTaken);
-      Predicate = std::move(Other.Predicate);
-    }
-
-    ExitNotTakenInfo &operator=(ExitNotTakenInfo &&Other) {
-      ExitingBlock = std::move(Other.ExitingBlock);
-      ExactNotTaken = std::move(Other.ExactNotTaken);
-      Predicate = std::move(Other.Predicate);
-      return *this;
-    }
   };
 
   /// Information about the backedge-taken count of a loop. This currently
@@ -653,18 +637,8 @@ private:
   public:
     BackedgeTakenInfo() : MaxAndComplete(nullptr, 0) {}
 
-    BackedgeTakenInfo(const BackedgeTakenInfo &) = delete;
-
-    BackedgeTakenInfo(BackedgeTakenInfo &&Other) {
-      ExitNotTaken = std::move(Other.ExitNotTaken);
-      MaxAndComplete = std::move(Other.MaxAndComplete);
-    }
-
-    BackedgeTakenInfo &operator=(BackedgeTakenInfo &&Other) {
-      ExitNotTaken = std::move(Other.ExitNotTaken);
-      MaxAndComplete = std::move(Other.MaxAndComplete);
-      return *this;
-    }
+    BackedgeTakenInfo(BackedgeTakenInfo &&) = default;
+    BackedgeTakenInfo &operator=(BackedgeTakenInfo &&) = default;
 
     typedef std::pair<BasicBlock *, ExitLimit> EdgeExitInfo;
 

llvm/include/llvm/Analysis/ScopedNoAliasAA.h

@@ -27,10 +27,6 @@ class ScopedNoAliasAAResult : public AAResultBase<ScopedNoAliasAAResult> {
   friend AAResultBase<ScopedNoAliasAAResult>;
 
 public:
-  explicit ScopedNoAliasAAResult() : AAResultBase() {}
-  ScopedNoAliasAAResult(ScopedNoAliasAAResult &&Arg)
-      : AAResultBase(std::move(Arg)) {}
-
   /// Handle invalidation events from the new pass manager.
   ///
   /// By definition, this result is stateless and so remains valid.

llvm/include/llvm/Analysis/TargetLibraryInfo.h

@@ -297,15 +297,6 @@ public:
   TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl)
       : PresetInfoImpl(std::move(PresetInfoImpl)) {}
 
-  // Move semantics. We spell out the constructors for MSVC.
-  TargetLibraryAnalysis(TargetLibraryAnalysis &&Arg)
-      : PresetInfoImpl(std::move(Arg.PresetInfoImpl)), Impls(std::move(Arg.Impls)) {}
-  TargetLibraryAnalysis &operator=(TargetLibraryAnalysis &&RHS) {
-    PresetInfoImpl = std::move(RHS.PresetInfoImpl);
-    Impls = std::move(RHS.Impls);
-    return *this;
-  }
-
   TargetLibraryInfo run(Module &M, ModuleAnalysisManager &);
   TargetLibraryInfo run(Function &F, FunctionAnalysisManager &);
 

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

@@ -435,12 +435,6 @@ protected:
   explicit TargetTransformInfoImplCRTPBase(const DataLayout &DL) : BaseT(DL) {}
 
 public:
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  TargetTransformInfoImplCRTPBase(const TargetTransformInfoImplCRTPBase &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)) {}
-  TargetTransformInfoImplCRTPBase(TargetTransformInfoImplCRTPBase &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))) {}
-
   using BaseT::getCallCost;
 
   unsigned getCallCost(const Function *F, int NumArgs) {

llvm/include/llvm/Analysis/TypeBasedAliasAnalysis.h

@@ -27,9 +27,6 @@ class TypeBasedAAResult : public AAResultBase<TypeBasedAAResult> {
   friend AAResultBase<TypeBasedAAResult>;
 
 public:
-  explicit TypeBasedAAResult() {}
-  TypeBasedAAResult(TypeBasedAAResult &&Arg) : AAResultBase(std::move(Arg)) {}
-
   /// Handle invalidation events from the new pass manager.
   ///
   /// By definition, this result is stateless and so remains valid.

llvm/include/llvm/Bitcode/BitstreamReader.h

@@ -58,9 +58,6 @@ private:
   /// information in the BlockInfo block. Only llvm-bcanalyzer uses this.
   bool IgnoreBlockInfoNames;
 
-  BitstreamReader(const BitstreamReader&) = delete;
-  void operator=(const BitstreamReader&) = delete;
-
 public:
   BitstreamReader() : IgnoreBlockInfoNames(true) {
   }
@@ -73,18 +70,6 @@ public:
   BitstreamReader(std::unique_ptr<MemoryObject> BitcodeBytes)
       : BitcodeBytes(std::move(BitcodeBytes)), IgnoreBlockInfoNames(true) {}
 
-  BitstreamReader(BitstreamReader &&Other) {
-    *this = std::move(Other);
-  }
-
-  BitstreamReader &operator=(BitstreamReader &&Other) {
-    BitcodeBytes = std::move(Other.BitcodeBytes);
-    // Explicitly swap block info, so that nothing gets destroyed twice.
-    std::swap(BlockInfoRecords, Other.BlockInfoRecords);
-    IgnoreBlockInfoNames = Other.IgnoreBlockInfoNames;
-    return *this;
-  }
-
   void init(const unsigned char *Start, const unsigned char *End) {
     assert(((End-Start) & 3) == 0 &&"Bitcode stream not a multiple of 4 bytes");
     BitcodeBytes.reset(getNonStreamedMemoryObject(Start, End));

llvm/include/llvm/CodeGen/BasicTTIImpl.h

@@ -97,12 +97,6 @@ protected:
   using TargetTransformInfoImplBase::DL;
 
 public:
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  BasicTTIImplBase(const BasicTTIImplBase &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)) {}
-  BasicTTIImplBase(BasicTTIImplBase &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))) {}
-
   /// \name Scalar TTI Implementations
   /// @{
   bool allowsMisalignedMemoryAccesses(LLVMContext &Context,
@@ -961,13 +955,6 @@ class BasicTTIImpl : public BasicTTIImplBase<BasicTTIImpl> {
 
 public:
   explicit BasicTTIImpl(const TargetMachine *ST, const Function &F);
-
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  BasicTTIImpl(const BasicTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  BasicTTIImpl(BasicTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
 };
 
 }

llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

@@ -89,15 +89,9 @@ private:
 
   class StaticGlobalRenamer {
   public:
-    StaticGlobalRenamer() {}
-
-    StaticGlobalRenamer(StaticGlobalRenamer &&Other)
-      : NextId(Other.NextId) {}
-
-    StaticGlobalRenamer& operator=(StaticGlobalRenamer &&Other) {
-      NextId = Other.NextId;
-      return *this;
-    }
+    StaticGlobalRenamer() = default;
+    StaticGlobalRenamer(StaticGlobalRenamer &&) = default;
+    StaticGlobalRenamer &operator=(StaticGlobalRenamer &&) = default;
 
     void rename(Module &M) {
       for (auto &F : M)
@@ -124,45 +118,11 @@ private:
     struct SourceModuleEntry {
       std::unique_ptr<ResourceOwner<Module>> SourceMod;
       std::set<Function*> StubsToClone;
-
-      SourceModuleEntry() = default;
-      SourceModuleEntry(SourceModuleEntry &&Other)
-          : SourceMod(std::move(Other.SourceMod)),
-            StubsToClone(std::move(Other.StubsToClone)) {}
-      SourceModuleEntry& operator=(SourceModuleEntry &&Other) {
-        SourceMod = std::move(Other.SourceMod);
-        StubsToClone = std::move(Other.StubsToClone);
-        return *this;
-      }
     };
 
     typedef std::vector<SourceModuleEntry> SourceModulesList;
     typedef typename SourceModulesList::size_type SourceModuleHandle;
 
-    LogicalDylib() = default;
-
-    // Explicit move constructor to make MSVC happy.
-    LogicalDylib(LogicalDylib &&Other)
-      : ExternalSymbolResolver(std::move(Other.ExternalSymbolResolver)),
-        MemMgr(std::move(Other.MemMgr)),
-        StubsMgr(std::move(Other.StubsMgr)),
-        StaticRenamer(std::move(Other.StaticRenamer)),
-        ModuleAdder(std::move(Other.ModuleAdder)),
-        SourceModules(std::move(Other.SourceModules)),
-        BaseLayerHandles(std::move(Other.BaseLayerHandles)) {}
-
-    // Explicit move assignment operator to make MSVC happy.
-    LogicalDylib& operator=(LogicalDylib &&Other) {
-      ExternalSymbolResolver = std::move(Other.ExternalSymbolResolver);
-      MemMgr = std::move(Other.MemMgr);
-      StubsMgr = std::move(Other.StubsMgr);
-      StaticRenamer = std::move(Other.StaticRenamer);
-      ModuleAdder = std::move(Other.ModuleAdder);
-      SourceModules = std::move(Other.SourceModules);
-      BaseLayerHandles = std::move(Other.BaseLayerHandles);
-      return *this;
-    }
-
     SourceModuleHandle
     addSourceModule(std::unique_ptr<ResourceOwner<Module>> M) {
       SourceModuleHandle H = SourceModules.size();

llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h

@@ -409,24 +409,8 @@ public:
   RPC() = default;
 
   /// RPC instances cannot be copied.
-  RPC(const RPC &) = delete;
-
-  /// RPC instances cannot be copied.
-  RPC &operator=(const RPC &) = delete;
-
-  /// RPC move constructor.
-  // FIXME: Remove once MSVC can synthesize move ops.
-  RPC(RPC &&Other)
-      : SequenceNumberMgr(std::move(Other.SequenceNumberMgr)),
-        OutstandingResults(std::move(Other.OutstandingResults)) {}
-
-  /// RPC move assignment.
-  // FIXME: Remove once MSVC can synthesize move ops.
-  RPC &operator=(RPC &&Other) {
-    SequenceNumberMgr = std::move(Other.SequenceNumberMgr);
-    OutstandingResults = std::move(Other.OutstandingResults);
-    return *this;
-  }
+  RPC(RPC &&) = default;
+  RPC &operator=(RPC &&) = default;
 
   /// Utility class for defining/referring to RPC procedures.
   ///

llvm/include/llvm/IR/DebugLoc.h

@@ -35,17 +35,7 @@ namespace llvm {
     TrackingMDNodeRef Loc;
 
   public:
-    DebugLoc() {}
-    DebugLoc(DebugLoc &&X) : Loc(std::move(X.Loc)) {}
-    DebugLoc(const DebugLoc &X) : Loc(X.Loc) {}
-    DebugLoc &operator=(DebugLoc &&X) {
-      Loc = std::move(X.Loc);
-      return *this;
-    }
-    DebugLoc &operator=(const DebugLoc &X) {
-      Loc = X.Loc;
-      return *this;
-    }
+    DebugLoc() = default;
 
     /// \brief Construct from an \a DILocation.
     DebugLoc(const DILocation *L);

llvm/include/llvm/IR/Dominators.h

@@ -102,13 +102,6 @@ public:
     recalculate(F);
   }
 
-  DominatorTree(DominatorTree &&Arg)
-      : Base(std::move(static_cast<Base &>(Arg))) {}
-  DominatorTree &operator=(DominatorTree &&RHS) {
-    Base::operator=(std::move(static_cast<Base &>(RHS)));
-    return *this;
-  }
-
   /// \brief Returns *false* if the other dominator tree matches this dominator
   /// tree.
   inline bool compare(const DominatorTree &Other) const {

llvm/include/llvm/IR/ModuleSummaryIndex.h

@@ -358,16 +358,6 @@ private:
   ModulePathStringTableTy ModulePathStringTable;
 
 public:
-  ModuleSummaryIndex() = default;
-  ModuleSummaryIndex(ModuleSummaryIndex &&Arg)
-      : GlobalValueMap(std::move(Arg.GlobalValueMap)),
-        ModulePathStringTable(std::move(Arg.ModulePathStringTable)) {}
-  ModuleSummaryIndex &operator=(ModuleSummaryIndex &&RHS) {
-    GlobalValueMap = std::move(RHS.GlobalValueMap);
-    ModulePathStringTable = std::move(RHS.ModulePathStringTable);
-    return *this;
-  }
-
   gvsummary_iterator begin() { return GlobalValueMap.begin(); }
   const_gvsummary_iterator begin() const { return GlobalValueMap.begin(); }
   gvsummary_iterator end() { return GlobalValueMap.end(); }

llvm/include/llvm/IR/PassManager.h

@@ -65,22 +65,6 @@ namespace llvm {
 /// the IR is not mutated at all.
 class PreservedAnalyses {
 public:
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  PreservedAnalyses() {}
-  PreservedAnalyses(const PreservedAnalyses &Arg)
-      : PreservedPassIDs(Arg.PreservedPassIDs) {}
-  PreservedAnalyses(PreservedAnalyses &&Arg)
-      : PreservedPassIDs(std::move(Arg.PreservedPassIDs)) {}
-  friend void swap(PreservedAnalyses &LHS, PreservedAnalyses &RHS) {
-    using std::swap;
-    swap(LHS.PreservedPassIDs, RHS.PreservedPassIDs);
-  }
-  PreservedAnalyses &operator=(PreservedAnalyses RHS) {
-    swap(*this, RHS);
-    return *this;
-  }
-
   /// \brief Convenience factory function for the empty preserved set.
   static PreservedAnalyses none() { return PreservedAnalyses(); }
 
@@ -257,16 +241,8 @@ public:
   ///
   /// It can be passed a flag to get debug logging as the passes are run.
   PassManager(bool DebugLogging = false) : DebugLogging(DebugLogging) {}
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  PassManager(PassManager &&Arg)
-      : Passes(std::move(Arg.Passes)),
-        DebugLogging(std::move(Arg.DebugLogging)) {}
-  PassManager &operator=(PassManager &&RHS) {
-    Passes = std::move(RHS.Passes);
-    DebugLogging = std::move(RHS.DebugLogging);
-    return *this;
-  }
+  PassManager(PassManager &&) = default;
+  PassManager &operator=(PassManager &&) = default;
 
   /// \brief Run all of the passes in this manager over the IR.
   PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
@@ -323,9 +299,6 @@ private:
   typedef detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>
       PassConceptT;
 
-  PassManager(const PassManager &) = delete;
-  PassManager &operator=(const PassManager &) = delete;
-
   std::vector<std::unique_ptr<PassConceptT>> Passes;
 
   /// \brief Flag indicating whether we should do debug logging.
@@ -358,19 +331,8 @@ public:
   /// A flag can be passed to indicate that the manager should perform debug
   /// logging.
   AnalysisManager(bool DebugLogging = false) : DebugLogging(DebugLogging) {}
-
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  AnalysisManager(AnalysisManager &&Arg)
-      : AnalysisPasses(std::move(Arg.AnalysisPasses)),
-        AnalysisResults(std::move(Arg.AnalysisResults)),
-        DebugLogging(std::move(Arg.DebugLogging)) {}
-  AnalysisManager &operator=(AnalysisManager &&RHS) {
-    AnalysisPasses = std::move(RHS.AnalysisPasses);
-    AnalysisResults = std::move(RHS.AnalysisResults);
-    DebugLogging = std::move(RHS.DebugLogging);
-    return *this;
-  }
+  AnalysisManager(AnalysisManager &&) = default;
+  AnalysisManager &operator=(AnalysisManager &&) = default;
 
   /// \brief Returns true if the analysis manager has an empty results cache.
   bool empty() const {
@@ -543,9 +505,6 @@ public:
   }
 
 private:
-  AnalysisManager(const AnalysisManager &) = delete;
-  AnalysisManager &operator=(const AnalysisManager &) = delete;
-
   /// \brief Lookup a registered analysis pass.
   PassConceptT &lookupPass(void *PassID) {
     typename AnalysisPassMapT::iterator PI = AnalysisPasses.find(PassID);
@@ -731,16 +690,6 @@ public:
   };
 
   explicit InnerAnalysisManagerProxy(AnalysisManagerT &AM) : AM(&AM) {}
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  InnerAnalysisManagerProxy(const InnerAnalysisManagerProxy &Arg)
-      : AM(Arg.AM) {}
-  InnerAnalysisManagerProxy(InnerAnalysisManagerProxy &&Arg)
-      : AM(std::move(Arg.AM)) {}
-  InnerAnalysisManagerProxy &operator=(InnerAnalysisManagerProxy RHS) {
-    std::swap(AM, RHS.AM);
-    return *this;
-  }
 
   /// \brief Run the analysis pass and create our proxy result object.
   ///
@@ -795,14 +744,6 @@ public:
   class Result {
   public:
     explicit Result(const AnalysisManagerT &AM) : AM(&AM) {}
-    // We have to explicitly define all the special member functions because
-    // MSVC refuses to generate them.
-    Result(const Result &Arg) : AM(Arg.AM) {}
-    Result(Result &&Arg) : AM(std::move(Arg.AM)) {}
-    Result &operator=(Result RHS) {
-      std::swap(AM, RHS.AM);
-      return *this;
-    }
 
     const AnalysisManagerT &getManager() const { return *AM; }
 
@@ -814,16 +755,6 @@ public:
   };
 
   OuterAnalysisManagerProxy(const AnalysisManagerT &AM) : AM(&AM) {}
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  OuterAnalysisManagerProxy(const OuterAnalysisManagerProxy &Arg)
-      : AM(Arg.AM) {}
-  OuterAnalysisManagerProxy(OuterAnalysisManagerProxy &&Arg)
-      : AM(std::move(Arg.AM)) {}
-  OuterAnalysisManagerProxy &operator=(OuterAnalysisManagerProxy RHS) {
-    std::swap(AM, RHS.AM);
-    return *this;
-  }
 
   /// \brief Run the analysis pass and create our proxy result object.
   /// Nothing to see here, it just forwards the \c AM reference into the
@@ -879,21 +810,6 @@ class ModuleToFunctionPassAdaptor
 public:
   explicit ModuleToFunctionPassAdaptor(FunctionPassT Pass)
       : Pass(std::move(Pass)) {}
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  ModuleToFunctionPassAdaptor(const ModuleToFunctionPassAdaptor &Arg)
-      : Pass(Arg.Pass) {}
-  ModuleToFunctionPassAdaptor(ModuleToFunctionPassAdaptor &&Arg)
-      : Pass(std::move(Arg.Pass)) {}
-  friend void swap(ModuleToFunctionPassAdaptor &LHS,
-                   ModuleToFunctionPassAdaptor &RHS) {
-    using std::swap;
-    swap(LHS.Pass, RHS.Pass);
-  }
-  ModuleToFunctionPassAdaptor &operator=(ModuleToFunctionPassAdaptor RHS) {
-    swap(*this, RHS);
-    return *this;
-  }
 
   /// \brief Runs the function pass across every function in the module.
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
@@ -1014,19 +930,6 @@ template <typename PassT>
 class RepeatedPass : public PassInfoMixin<RepeatedPass<PassT>> {
 public:
   RepeatedPass(int Count, PassT P) : Count(Count), P(std::move(P)) {}
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  RepeatedPass(const RepeatedPass &Arg) : Count(Arg.Count), P(Arg.P) {}
-  RepeatedPass(RepeatedPass &&Arg) : Count(Arg.Count), P(std::move(Arg.P)) {}
-  friend void swap(RepeatedPass &LHS, RepeatedPass &RHS) {
-    using std::swap;
-    swap(LHS.Count, RHS.Count);
-    swap(LHS.P, RHS.P);
-  }
-  RepeatedPass &operator=(RepeatedPass RHS) {
-    swap(*this, RHS);
-    return *this;
-  }
 
   template <typename IRUnitT, typename AnalysisManagerT, typename... Ts>
   PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, Ts &&... Args) {

llvm/include/llvm/IR/UseListOrder.h

@@ -34,18 +34,8 @@ struct UseListOrder {
       : V(V), F(F), Shuffle(ShuffleSize) {}
 
   UseListOrder() : V(nullptr), F(nullptr) {}
-  UseListOrder(UseListOrder &&X)
-      : V(X.V), F(X.F), Shuffle(std::move(X.Shuffle)) {}
-  UseListOrder &operator=(UseListOrder &&X) {
-    V = X.V;
-    F = X.F;
-    Shuffle = std::move(X.Shuffle);
-    return *this;
-  }
-
-private:
-  UseListOrder(const UseListOrder &X) = delete;
-  UseListOrder &operator=(const UseListOrder &X) = delete;
+  UseListOrder(UseListOrder &&) = default;
+  UseListOrder &operator=(UseListOrder &&) = default;
 };
 
 typedef std::vector<UseListOrder> UseListOrderStack;

llvm/include/llvm/LTO/Config.h

@@ -134,56 +134,6 @@ struct Config {
       CombinedIndexHookFn;
   CombinedIndexHookFn CombinedIndexHook;
 
-  Config() {}
-  // FIXME: Remove once MSVC can synthesize move ops.
-  Config(Config &&X)
-      : CPU(std::move(X.CPU)), Features(std::move(X.Features)),
-        Options(std::move(X.Options)), MAttrs(std::move(X.MAttrs)),
-        RelocModel(std::move(X.RelocModel)), CodeModel(std::move(X.CodeModel)),
-        CGOptLevel(std::move(X.CGOptLevel)), OptLevel(std::move(X.OptLevel)),
-        DisableVerify(std::move(X.DisableVerify)),
-        OptPipeline(std::move(X.OptPipeline)),
-        AAPipeline(std::move(X.AAPipeline)),
-        OverrideTriple(std::move(X.OverrideTriple)),
-        DefaultTriple(std::move(X.DefaultTriple)),
-        ShouldDiscardValueNames(std::move(X.ShouldDiscardValueNames)),
-        DiagHandler(std::move(X.DiagHandler)),
-        ResolutionFile(std::move(X.ResolutionFile)),
-        PreOptModuleHook(std::move(X.PreOptModuleHook)),
-        PostPromoteModuleHook(std::move(X.PostPromoteModuleHook)),
-        PostInternalizeModuleHook(std::move(X.PostInternalizeModuleHook)),
-        PostImportModuleHook(std::move(X.PostImportModuleHook)),
-        PostOptModuleHook(std::move(X.PostOptModuleHook)),
-        PreCodeGenModuleHook(std::move(X.PreCodeGenModuleHook)),
-        CombinedIndexHook(std::move(X.CombinedIndexHook)) {}
-  // FIXME: Remove once MSVC can synthesize move ops.
-  Config &operator=(Config &&X) {
-    CPU = std::move(X.CPU);
-    Features = std::move(X.Features);
-    Options = std::move(X.Options);
-    MAttrs = std::move(X.MAttrs);
-    RelocModel = std::move(X.RelocModel);
-    CodeModel = std::move(X.CodeModel);
-    CGOptLevel = std::move(X.CGOptLevel);
-    OptLevel = std::move(X.OptLevel);
-    DisableVerify = std::move(X.DisableVerify);
-    OptPipeline = std::move(X.OptPipeline);
-    AAPipeline = std::move(X.AAPipeline);
-    OverrideTriple = std::move(X.OverrideTriple);
-    DefaultTriple = std::move(X.DefaultTriple);
-    ShouldDiscardValueNames = std::move(X.ShouldDiscardValueNames);
-    DiagHandler = std::move(X.DiagHandler);
-    ResolutionFile = std::move(X.ResolutionFile);
-    PreOptModuleHook = std::move(X.PreOptModuleHook);
-    PostPromoteModuleHook = std::move(X.PostPromoteModuleHook);
-    PostInternalizeModuleHook = std::move(X.PostInternalizeModuleHook);
-    PostImportModuleHook = std::move(X.PostImportModuleHook);
-    PostOptModuleHook = std::move(X.PostOptModuleHook);
-    PreCodeGenModuleHook = std::move(X.PreCodeGenModuleHook);
-    CombinedIndexHook = std::move(X.CombinedIndexHook);
-    return *this;
-  }
-
   /// This is a convenience function that configures this Config object to write
   /// temporary files named after the given OutputFileName for each of the LTO
   /// phases to disk. A client can use this function to implement -save-temps.

llvm/include/llvm/Object/ArchiveWriter.h

@@ -26,17 +26,6 @@ struct NewArchiveMember {
   unsigned UID = 0, GID = 0, Perms = 0644;
 
   NewArchiveMember() = default;
-  NewArchiveMember(NewArchiveMember &&Other)
-      : Buf(std::move(Other.Buf)), ModTime(Other.ModTime), UID(Other.UID),
-        GID(Other.GID), Perms(Other.Perms) {}
-  NewArchiveMember &operator=(NewArchiveMember &&Other) {
-    Buf = std::move(Other.Buf);
-    ModTime = Other.ModTime;
-    UID = Other.UID;
-    GID = Other.GID;
-    Perms = Other.Perms;
-    return *this;
-  }
   NewArchiveMember(MemoryBufferRef BufRef);
 
   static Expected<NewArchiveMember>

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

@@ -291,13 +291,8 @@ struct FunctionRecord {
   FunctionRecord(StringRef Name, ArrayRef<StringRef> Filenames)
       : Name(Name), Filenames(Filenames.begin(), Filenames.end()) {}
 
-  FunctionRecord(FunctionRecord &&FR)
-      : Name(FR.Name), Filenames(std::move(FR.Filenames)),
-        CountedRegions(std::move(FR.CountedRegions)),
-        ExecutionCount(FR.ExecutionCount) {}
-
-  FunctionRecord(const FunctionRecord &) = delete;
-  const FunctionRecord &operator=(const FunctionRecord &) = delete;
+  FunctionRecord(FunctionRecord &&FR) = default;
+  FunctionRecord &operator=(FunctionRecord &&) = default;
 
   void pushRegion(CounterMappingRegion Region, uint64_t Count) {
     if (CountedRegions.empty())
@@ -405,10 +400,6 @@ public:
 
   CoverageData(StringRef Filename) : Filename(Filename) {}
 
-  CoverageData(CoverageData &&RHS)
-      : Filename(std::move(RHS.Filename)), Segments(std::move(RHS.Segments)),
-        Expansions(std::move(RHS.Expansions)) {}
-
   /// \brief Get the name of the file this data covers.
   StringRef getFilename() const { return Filename; }
 

llvm/include/llvm/Support/SourceMgr.h

@@ -51,11 +51,6 @@ private:
 
     /// This is the location of the parent include, or null if at the top level.
     SMLoc IncludeLoc;
-
-    SrcBuffer() {}
-
-    SrcBuffer(SrcBuffer &&O)
-        : Buffer(std::move(O.Buffer)), IncludeLoc(O.IncludeLoc) {}
   };
 
   /// This is all of the buffers that we are reading from.

llvm/include/llvm/Transforms/InstCombine/InstCombine.h

@@ -31,17 +31,8 @@ class InstCombinePass : public PassInfoMixin<InstCombinePass> {
 public:
   static StringRef name() { return "InstCombinePass"; }
 
-  // Explicitly define constructors for MSVC.
-  InstCombinePass(bool ExpensiveCombines = true)
+  explicit InstCombinePass(bool ExpensiveCombines = true)
       : ExpensiveCombines(ExpensiveCombines) {}
-  InstCombinePass(InstCombinePass &&Arg)
-      : Worklist(std::move(Arg.Worklist)),
-        ExpensiveCombines(Arg.ExpensiveCombines) {}
-  InstCombinePass &operator=(InstCombinePass &&RHS) {
-    Worklist = std::move(RHS.Worklist);
-    ExpensiveCombines = RHS.ExpensiveCombines;
-    return *this;
-  }
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };

llvm/include/llvm/Transforms/InstCombine/InstCombineWorklist.h

@@ -28,19 +28,11 @@ class InstCombineWorklist {
   SmallVector<Instruction*, 256> Worklist;
   DenseMap<Instruction*, unsigned> WorklistMap;
 
-  void operator=(const InstCombineWorklist&RHS) = delete;
-  InstCombineWorklist(const InstCombineWorklist&) = delete;
 public:
-  InstCombineWorklist() {}
+  InstCombineWorklist() = default;
 
-  InstCombineWorklist(InstCombineWorklist &&Arg)
-      : Worklist(std::move(Arg.Worklist)),
-        WorklistMap(std::move(Arg.WorklistMap)) {}
-  InstCombineWorklist &operator=(InstCombineWorklist &&RHS) {
-    Worklist = std::move(RHS.Worklist);
-    WorklistMap = std::move(RHS.WorklistMap);
-    return *this;
-  }
+  InstCombineWorklist(InstCombineWorklist &&) = default;
+  InstCombineWorklist &operator=(InstCombineWorklist &&) = default;
 
   bool isEmpty() const { return Worklist.empty(); }
 

llvm/include/llvm/Transforms/Scalar/JumpThreading.h

@@ -85,13 +85,6 @@ class JumpThreadingPass : public PassInfoMixin<JumpThreadingPass> {
 
 public:
   JumpThreadingPass(int T = -1);
-  // Hack for MSVC 2013 which seems like it can't synthesize this.
-  JumpThreadingPass(JumpThreadingPass &&Other)
-      : TLI(Other.TLI), LVI(Other.LVI), BFI(std::move(Other.BFI)),
-        BPI(std::move(Other.BPI)), HasProfileData(Other.HasProfileData),
-        LoopHeaders(std::move(Other.LoopHeaders)),
-        RecursionSet(std::move(Other.RecursionSet)),
-        BBDupThreshold(Other.BBDupThreshold) {}
 
   // Glue for old PM.
   bool runImpl(Function &F, TargetLibraryInfo *TLI_, LazyValueInfo *LVI_,

llvm/include/llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h

@@ -48,26 +48,8 @@ private:
   struct InlineGraphNode {
     // Default-constructible and movable.
     InlineGraphNode() = default;
-    // FIXME: make them default ctors when we won't support ancient compilers
-    // like MSVS-2013.
-    InlineGraphNode(InlineGraphNode &&Other)
-      : InlinedCallees(std::move(Other.InlinedCallees)),
-      NumberOfInlines(Other.NumberOfInlines),
-      NumberOfRealInlines(Other.NumberOfRealInlines),
-      Imported(Other.Imported),
-      Visited(Other.Visited) {}
-
-    InlineGraphNode &operator=(InlineGraphNode &&Other) {
-      InlinedCallees = std::move(Other.InlinedCallees);
-      NumberOfInlines = Other.NumberOfInlines;
-      NumberOfRealInlines = Other.NumberOfRealInlines;
-      Imported = Other.Imported;
-      Visited = Other.Visited;
-      return *this;
-    }
-
-    InlineGraphNode(const InlineGraphNode &) = delete;
-    InlineGraphNode &operator=(const InlineGraphNode &) = delete;
+    InlineGraphNode(InlineGraphNode &&) = default;
+    InlineGraphNode &operator=(InlineGraphNode &&) = default;
 
     llvm::SmallVector<InlineGraphNode *, 8> InlinedCallees;
     /// Incremented every direct inline.

llvm/include/llvm/Transforms/Utils/MemorySSA.h

@@ -662,12 +662,8 @@ public:
   // unique_ptr<MemorySSA> to avoid build breakage on MSVC.
   struct Result {
     Result(std::unique_ptr<MemorySSA> &&MSSA) : MSSA(std::move(MSSA)) {}
-    Result(Result &&R) : MSSA(std::move(R.MSSA)) {}
     MemorySSA &getMSSA() { return *MSSA.get(); }
 
-    Result(const Result &) = delete;
-    void operator=(const Result &) = delete;
-
     std::unique_ptr<MemorySSA> MSSA;
   };
 

llvm/include/llvm/Transforms/Utils/SymbolRewriter.h

@@ -120,9 +120,6 @@ public:
     Descriptors.splice(Descriptors.begin(), DL);
   }
 
-  RewriteSymbolPass(RewriteSymbolPass &&Other)
-      : Descriptors(std::move(Other.Descriptors)) {}
-
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
   // Glue for old PM

llvm/lib/Analysis/StratifiedSets.h

@@ -85,17 +85,8 @@ struct StratifiedLink {
 template <typename T> class StratifiedSets {
 public:
   StratifiedSets() = default;
-
-  // TODO: Figure out how to make MSVC not call the copy ctor here, and delete
-  // it.
-
-  // Can't default these due to compile errors in MSVC2013
-  StratifiedSets(StratifiedSets &&Other) { *this = std::move(Other); }
-  StratifiedSets &operator=(StratifiedSets &&Other) {
-    Values = std::move(Other.Values);
-    Links = std::move(Other.Links);
-    return *this;
-  }
+  StratifiedSets(StratifiedSets &&) = default;
+  StratifiedSets &operator=(StratifiedSets &&) = default;
 
   StratifiedSets(DenseMap<T, StratifiedInfo> Map,
                  std::vector<StratifiedLink> Links)

llvm/lib/ExecutionEngine/GDBRegistrationListener.cpp

@@ -69,16 +69,6 @@ struct RegisteredObjectInfo {
                        OwningBinary<ObjectFile> Obj)
     : Size(Size), Entry(Entry), Obj(std::move(Obj)) {}
 
-  RegisteredObjectInfo(RegisteredObjectInfo &&Other)
-    : Size(Other.Size), Entry(Other.Entry), Obj(std::move(Other.Obj)) {}
-
-  RegisteredObjectInfo& operator=(RegisteredObjectInfo &&Other) {
-    Size = Other.Size;
-    Entry = Other.Entry;
-    Obj = std::move(Other.Obj);
-    return *this;
-  }
-
   std::size_t Size;
   jit_code_entry *Entry;
   OwningBinary<ObjectFile> Obj;

llvm/lib/ExecutionEngine/Interpreter/Interpreter.h

@@ -41,12 +41,9 @@ class AllocaHolder {
 public:
   AllocaHolder() {}
 
-  // Make this type move-only. Define explicit move special members for MSVC.
-  AllocaHolder(AllocaHolder &&RHS) : Allocations(std::move(RHS.Allocations)) {}
-  AllocaHolder &operator=(AllocaHolder &&RHS) {
-    Allocations = std::move(RHS.Allocations);
-    return *this;
-  }
+  // Make this type move-only.
+  AllocaHolder(AllocaHolder &&) = default;
+  AllocaHolder &operator=(AllocaHolder &&RHS) = default;
 
   ~AllocaHolder() {
     for (void *Allocation : Allocations)
@@ -72,22 +69,6 @@ struct ExecutionContext {
   AllocaHolder Allocas;            // Track memory allocated by alloca
 
   ExecutionContext() : CurFunction(nullptr), CurBB(nullptr), CurInst(nullptr) {}
-
-  ExecutionContext(ExecutionContext &&O)
-      : CurFunction(O.CurFunction), CurBB(O.CurBB), CurInst(O.CurInst),
-        Caller(O.Caller), Values(std::move(O.Values)),
-        VarArgs(std::move(O.VarArgs)), Allocas(std::move(O.Allocas)) {}
-
-  ExecutionContext &operator=(ExecutionContext &&O) {
-    CurFunction = O.CurFunction;
-    CurBB = O.CurBB;
-    CurInst = O.CurInst;
-    Caller = O.Caller;
-    Values = std::move(O.Values);
-    VarArgs = std::move(O.VarArgs);
-    Allocas = std::move(O.Allocas);
-    return *this;
-  }
 };
 
 // Interpreter - This class represents the entirety of the interpreter.

llvm/lib/Support/SpecialCaseList.cpp

@@ -32,10 +32,6 @@ namespace llvm {
 /// reason for doing so is efficiency; StringSet is much faster at matching
 /// literal strings than Regex.
 struct SpecialCaseList::Entry {
-  Entry() {}
-  Entry(Entry &&Other)
-      : Strings(std::move(Other.Strings)), RegEx(std::move(Other.RegEx)) {}
-
   StringSet<> Strings;
   std::unique_ptr<Regex> RegEx;
 

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h

@@ -52,13 +52,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  AArch64TTIImpl(const AArch64TTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  AArch64TTIImpl(AArch64TTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   /// \name Scalar TTI Implementations
   /// @{
 

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.h

@@ -64,13 +64,6 @@ public:
       ST(TM->getSubtargetImpl(F)),
       TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  AMDGPUTTIImpl(const AMDGPUTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  AMDGPUTTIImpl(AMDGPUTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   bool hasBranchDivergence() { return true; }
 
   void getUnrollingPreferences(Loop *L, TTI::UnrollingPreferences &UP);

llvm/lib/Target/ARM/ARMTargetTransformInfo.h

@@ -45,13 +45,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  ARMTTIImpl(const ARMTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  ARMTTIImpl(ARMTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   bool enableInterleavedAccessVectorization() { return true; }
 
   /// Floating-point computation using ARMv8 AArch32 Advanced

llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.h

@@ -40,13 +40,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  HexagonTTIImpl(const HexagonTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  HexagonTTIImpl(HexagonTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   /// \name Scalar TTI Implementations
   /// @{
 

llvm/lib/Target/Lanai/LanaiTargetTransformInfo.h

@@ -41,11 +41,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
         TLI(ST->getTargetLowering()) {}
 
-  LanaiTTIImpl(const LanaiTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  LanaiTTIImpl(LanaiTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(Arg.ST), TLI(Arg.TLI) {}
-
   bool shouldBuildLookupTables() const { return false; }
 
   TargetTransformInfo::PopcntSupportKind getPopcntSupport(unsigned TyWidth) {

llvm/lib/Target/NVPTX/NVPTXTargetTransformInfo.h

@@ -41,13 +41,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl()),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  NVPTXTTIImpl(const NVPTXTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  NVPTXTTIImpl(NVPTXTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   bool hasBranchDivergence() { return true; }
 
   bool isSourceOfDivergence(const Value *V);

llvm/lib/Target/PowerPC/PPCTargetTransformInfo.h

@@ -41,13 +41,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  PPCTTIImpl(const PPCTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  PPCTTIImpl(PPCTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   /// \name Scalar TTI Implementations
   /// @{
 

llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.h

@@ -32,13 +32,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  SystemZTTIImpl(const SystemZTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  SystemZTTIImpl(SystemZTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   /// \name Scalar TTI Implementations
   /// @{
 

llvm/lib/Target/WebAssembly/WebAssemblyTargetTransformInfo.h

@@ -42,13 +42,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  WebAssemblyTTIImpl(const WebAssemblyTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  WebAssemblyTTIImpl(WebAssemblyTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   /// \name Scalar TTI Implementations
   /// @{
 

llvm/lib/Target/X86/X86TargetTransformInfo.h

@@ -43,13 +43,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl(F)),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  X86TTIImpl(const X86TTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  X86TTIImpl(X86TTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   /// \name Scalar TTI Implementations
   /// @{
   TTI::PopcntSupportKind getPopcntSupport(unsigned TyWidth);

llvm/lib/Target/XCore/XCoreTargetTransformInfo.h

@@ -41,13 +41,6 @@ public:
       : BaseT(TM, F.getParent()->getDataLayout()), ST(TM->getSubtargetImpl()),
         TLI(ST->getTargetLowering()) {}
 
-  // Provide value semantics. MSVC requires that we spell all of these out.
-  XCoreTTIImpl(const XCoreTTIImpl &Arg)
-      : BaseT(static_cast<const BaseT &>(Arg)), ST(Arg.ST), TLI(Arg.TLI) {}
-  XCoreTTIImpl(XCoreTTIImpl &&Arg)
-      : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
-        TLI(std::move(Arg.TLI)) {}
-
   unsigned getNumberOfRegisters(bool Vector) {
     if (Vector) {
       return 0;

llvm/lib/Transforms/Utils/ValueMapper.cpp

@@ -38,15 +38,6 @@ struct DelayedBasicBlock {
   BasicBlock *OldBB;
   std::unique_ptr<BasicBlock> TempBB;
 
-  // Explicit move for MSVC.
-  DelayedBasicBlock(DelayedBasicBlock &&X)
-      : OldBB(std::move(X.OldBB)), TempBB(std::move(X.TempBB)) {}
-  DelayedBasicBlock &operator=(DelayedBasicBlock &&X) {
-    OldBB = std::move(X.OldBB);
-    TempBB = std::move(X.TempBB);
-    return *this;
-  }
-
   DelayedBasicBlock(const BlockAddress &Old)
       : OldBB(Old.getBasicBlock()),
         TempBB(BasicBlock::Create(Old.getContext())) {}
@@ -184,17 +175,6 @@ class MDNodeMapper {
     bool HasChanged = false;
     unsigned ID = ~0u;
     TempMDNode Placeholder;
-
-    Data() {}
-    Data(Data &&X)
-        : HasChanged(std::move(X.HasChanged)), ID(std::move(X.ID)),
-          Placeholder(std::move(X.Placeholder)) {}
-    Data &operator=(Data &&X) {
-      HasChanged = std::move(X.HasChanged);
-      ID = std::move(X.ID);
-      Placeholder = std::move(X.Placeholder);
-      return *this;
-    }
   };
 
   /// A graph of uniqued nodes.