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>);
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);
}
/// 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,
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; }
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; }
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) {
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.
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:
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
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;
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.
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 &);
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) {
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.
/// 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) {
}
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));
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,
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)) {}
};
}
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)
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();
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.
///
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);
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 {
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(); }
/// 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(); }
///
/// 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,
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.
/// 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 {
}
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);
};
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.
///
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; }
};
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
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) {
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) {
: 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;
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.
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>
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())
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; }
/// 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.
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);
};
SmallVector<Instruction*, 256> Worklist;
DenseMap<Instruction*, unsigned> WorklistMap;
- void operator=(const InstCombineWorklist&RHS) = delete;
- InstCombineWorklist(const InstCombineWorklist&) = delete;
public:
- InstCombineWorklist() {}
-
- 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() = default;
+
+ InstCombineWorklist(InstCombineWorklist &&) = default;
+ InstCombineWorklist &operator=(InstCombineWorklist &&) = default;
bool isEmpty() const { return Worklist.empty(); }
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_,
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.
// 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;
};
Descriptors.splice(Descriptors.begin(), DL);
}
- RewriteSymbolPass(RewriteSymbolPass &&Other)
- : Descriptors(std::move(Other.Descriptors)) {}
-
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
// Glue for old PM
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)
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;
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)
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.
/// 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;
: 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
/// @{
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);
: 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
: 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
/// @{
: 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) {
: 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);
: 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
/// @{
: 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
/// @{
: 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
/// @{
: 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);
: 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;
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())) {}
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.
projects / llvm / commitdiff