summaryrefslogtreecommitdiff
path: root/include/llvm/Analysis
diff options
context:
space:
mode:
Diffstat (limited to 'include/llvm/Analysis')
-rw-r--r--include/llvm/Analysis/AliasSetTracker.h13
-rw-r--r--include/llvm/Analysis/CFLAliasAnalysisUtils.h58
-rw-r--r--include/llvm/Analysis/CFLAndersAliasAnalysis.h27
-rw-r--r--include/llvm/Analysis/CFLSteensAliasAnalysis.h24
-rw-r--r--include/llvm/Analysis/IteratedDominanceFrontier.h1
-rw-r--r--include/llvm/Analysis/MemorySSA.h10
-rw-r--r--include/llvm/Analysis/OptimizationDiagnosticInfo.h6
-rw-r--r--include/llvm/Analysis/RegionInfo.h211
-rw-r--r--include/llvm/Analysis/RegionInfoImpl.h39
-rw-r--r--include/llvm/Analysis/RegionIterator.h77
-rw-r--r--include/llvm/Analysis/ScalarEvolution.h22
-rw-r--r--include/llvm/Analysis/ScalarEvolutionExpressions.h28
-rw-r--r--include/llvm/Analysis/TargetTransformInfo.h34
-rw-r--r--include/llvm/Analysis/TargetTransformInfoImpl.h11
14 files changed, 313 insertions, 248 deletions
diff --git a/include/llvm/Analysis/AliasSetTracker.h b/include/llvm/Analysis/AliasSetTracker.h
index eac97501c759..daafd2fabe78 100644
--- a/include/llvm/Analysis/AliasSetTracker.h
+++ b/include/llvm/Analysis/AliasSetTracker.h
@@ -69,10 +69,15 @@ class AliasSet : public ilist_node<AliasSet> {
if (AAInfo == DenseMapInfo<AAMDNodes>::getEmptyKey())
// We don't have a AAInfo yet. Set it to NewAAInfo.
AAInfo = NewAAInfo;
- else if (AAInfo != NewAAInfo)
- // NewAAInfo conflicts with AAInfo.
- AAInfo = DenseMapInfo<AAMDNodes>::getTombstoneKey();
-
+ else {
+ AAMDNodes Intersection(AAInfo.intersect(NewAAInfo));
+ if (!Intersection) {
+ // NewAAInfo conflicts with AAInfo.
+ AAInfo = DenseMapInfo<AAMDNodes>::getTombstoneKey();
+ return SizeChanged;
+ }
+ AAInfo = Intersection;
+ }
return SizeChanged;
}
diff --git a/include/llvm/Analysis/CFLAliasAnalysisUtils.h b/include/llvm/Analysis/CFLAliasAnalysisUtils.h
new file mode 100644
index 000000000000..981a8ddc2289
--- /dev/null
+++ b/include/llvm/Analysis/CFLAliasAnalysisUtils.h
@@ -0,0 +1,58 @@
+//=- CFLAliasAnalysisUtils.h - Utilities for CFL Alias Analysis ----*- C++-*-=//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// \file
+// These are the utilities/helpers used by the CFL Alias Analyses available in
+// tree, i.e. Steensgaard's and Andersens'.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_CFLALIASANALYSISUTILS_H
+#define LLVM_ANALYSIS_CFLALIASANALYSISUTILS_H
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/ValueHandle.h"
+
+namespace llvm {
+namespace cflaa {
+
+template <typename AAResult> struct FunctionHandle final : public CallbackVH {
+ FunctionHandle(Function *Fn, AAResult *Result)
+ : CallbackVH(Fn), Result(Result) {
+ assert(Fn != nullptr);
+ assert(Result != nullptr);
+ }
+
+ void deleted() override { removeSelfFromCache(); }
+ void allUsesReplacedWith(Value *) override { removeSelfFromCache(); }
+
+private:
+ AAResult *Result;
+
+ void removeSelfFromCache() {
+ assert(Result != nullptr);
+ auto *Val = getValPtr();
+ Result->evict(cast<Function>(Val));
+ setValPtr(nullptr);
+ }
+};
+
+static inline const Function *parentFunctionOfValue(const Value *Val) {
+ if (auto *Inst = dyn_cast<Instruction>(Val)) {
+ auto *Bb = Inst->getParent();
+ return Bb->getParent();
+ }
+
+ if (auto *Arg = dyn_cast<Argument>(Val))
+ return Arg->getParent();
+ return nullptr;
+} // namespace cflaa
+} // namespace llvm
+}
+
+#endif // LLVM_ANALYSIS_CFLALIASANALYSISUTILS_H
diff --git a/include/llvm/Analysis/CFLAndersAliasAnalysis.h b/include/llvm/Analysis/CFLAndersAliasAnalysis.h
index f3520aa3fe82..4146ad4d18ac 100644
--- a/include/llvm/Analysis/CFLAndersAliasAnalysis.h
+++ b/include/llvm/Analysis/CFLAndersAliasAnalysis.h
@@ -18,8 +18,8 @@
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Optional.h"
#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/CFLAliasAnalysisUtils.h"
#include "llvm/IR/Function.h"
-#include "llvm/IR/ValueHandle.h"
#include "llvm/Pass.h"
#include <forward_list>
@@ -47,7 +47,7 @@ public:
return false;
}
/// Evict the given function from cache
- void evict(const Function &Fn);
+ void evict(const Function *Fn);
/// \brief Get the alias summary for the given function
/// Return nullptr if the summary is not found or not available
@@ -57,27 +57,6 @@ public:
AliasResult alias(const MemoryLocation &, const MemoryLocation &);
private:
- struct FunctionHandle final : public CallbackVH {
- FunctionHandle(Function *Fn, CFLAndersAAResult *Result)
- : CallbackVH(Fn), Result(Result) {
- assert(Fn != nullptr);
- assert(Result != nullptr);
- }
-
- void deleted() override { removeSelfFromCache(); }
- void allUsesReplacedWith(Value *) override { removeSelfFromCache(); }
-
- private:
- CFLAndersAAResult *Result;
-
- void removeSelfFromCache() {
- assert(Result != nullptr);
- auto *Val = getValPtr();
- Result->evict(*cast<Function>(Val));
- setValPtr(nullptr);
- }
- };
-
/// \brief Ensures that the given function is available in the cache.
/// Returns the appropriate entry from the cache.
const Optional<FunctionInfo> &ensureCached(const Function &);
@@ -97,7 +76,7 @@ private:
/// that simply has empty sets.
DenseMap<const Function *, Optional<FunctionInfo>> Cache;
- std::forward_list<FunctionHandle> Handles;
+ std::forward_list<cflaa::FunctionHandle<CFLAndersAAResult>> Handles;
};
/// Analysis pass providing a never-invalidated alias analysis result.
diff --git a/include/llvm/Analysis/CFLSteensAliasAnalysis.h b/include/llvm/Analysis/CFLSteensAliasAnalysis.h
index 3aae9a1e9b2e..fd3fa5febcdf 100644
--- a/include/llvm/Analysis/CFLSteensAliasAnalysis.h
+++ b/include/llvm/Analysis/CFLSteensAliasAnalysis.h
@@ -19,6 +19,7 @@
#include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h"
#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/CFLAliasAnalysisUtils.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/ValueHandle.h"
@@ -85,27 +86,6 @@ public:
}
private:
- struct FunctionHandle final : public CallbackVH {
- FunctionHandle(Function *Fn, CFLSteensAAResult *Result)
- : CallbackVH(Fn), Result(Result) {
- assert(Fn != nullptr);
- assert(Result != nullptr);
- }
-
- void deleted() override { removeSelfFromCache(); }
- void allUsesReplacedWith(Value *) override { removeSelfFromCache(); }
-
- private:
- CFLSteensAAResult *Result;
-
- void removeSelfFromCache() {
- assert(Result != nullptr);
- auto *Val = getValPtr();
- Result->evict(cast<Function>(Val));
- setValPtr(nullptr);
- }
- };
-
const TargetLibraryInfo &TLI;
/// \brief Cached mapping of Functions to their StratifiedSets.
@@ -114,7 +94,7 @@ private:
/// have any kind of recursion, it is discernable from a function
/// that simply has empty sets.
DenseMap<Function *, Optional<FunctionInfo>> Cache;
- std::forward_list<FunctionHandle> Handles;
+ std::forward_list<cflaa::FunctionHandle<CFLSteensAAResult>> Handles;
FunctionInfo buildSetsFrom(Function *F);
};
diff --git a/include/llvm/Analysis/IteratedDominanceFrontier.h b/include/llvm/Analysis/IteratedDominanceFrontier.h
index af788c818f80..bd74d6bd14c3 100644
--- a/include/llvm/Analysis/IteratedDominanceFrontier.h
+++ b/include/llvm/Analysis/IteratedDominanceFrontier.h
@@ -86,7 +86,6 @@ public:
private:
DominatorTreeBase<BasicBlock> &DT;
bool useLiveIn;
- DenseMap<DomTreeNode *, unsigned> DomLevels;
const SmallPtrSetImpl<BasicBlock *> *LiveInBlocks;
const SmallPtrSetImpl<BasicBlock *> *DefBlocks;
};
diff --git a/include/llvm/Analysis/MemorySSA.h b/include/llvm/Analysis/MemorySSA.h
index 462e4594266e..5cec2bfb0cfb 100644
--- a/include/llvm/Analysis/MemorySSA.h
+++ b/include/llvm/Analysis/MemorySSA.h
@@ -139,7 +139,7 @@ public:
// Methods for support type inquiry through isa, cast, and
// dyn_cast
- static inline bool classof(const Value *V) {
+ static bool classof(const Value *V) {
unsigned ID = V->getValueID();
return ID == MemoryUseVal || ID == MemoryPhiVal || ID == MemoryDefVal;
}
@@ -241,7 +241,7 @@ public:
/// \brief Get the access that produces the memory state used by this Use.
MemoryAccess *getDefiningAccess() const { return getOperand(0); }
- static inline bool classof(const Value *MA) {
+ static bool classof(const Value *MA) {
return MA->getValueID() == MemoryUseVal || MA->getValueID() == MemoryDefVal;
}
@@ -297,7 +297,7 @@ public:
// allocate space for exactly one operand
void *operator new(size_t s) { return User::operator new(s, 1); }
- static inline bool classof(const Value *MA) {
+ static bool classof(const Value *MA) {
return MA->getValueID() == MemoryUseVal;
}
@@ -353,7 +353,7 @@ public:
// allocate space for exactly one operand
void *operator new(size_t s) { return User::operator new(s, 1); }
- static inline bool classof(const Value *MA) {
+ static bool classof(const Value *MA) {
return MA->getValueID() == MemoryDefVal;
}
@@ -526,7 +526,7 @@ public:
return getIncomingValue(Idx);
}
- static inline bool classof(const Value *V) {
+ static bool classof(const Value *V) {
return V->getValueID() == MemoryPhiVal;
}
diff --git a/include/llvm/Analysis/OptimizationDiagnosticInfo.h b/include/llvm/Analysis/OptimizationDiagnosticInfo.h
index edd9140a3493..64dd0737a112 100644
--- a/include/llvm/Analysis/OptimizationDiagnosticInfo.h
+++ b/include/llvm/Analysis/OptimizationDiagnosticInfo.h
@@ -34,7 +34,7 @@ class Value;
///
/// It allows reporting when optimizations are performed and when they are not
/// along with the reasons for it. Hotness information of the corresponding
-/// code region can be included in the remark if DiagnosticHotnessRequested is
+/// code region can be included in the remark if DiagnosticsHotnessRequested is
/// enabled in the LLVM context.
class OptimizationRemarkEmitter {
public:
@@ -45,10 +45,10 @@ public:
/// analysis pass).
///
/// Note that this ctor has a very different cost depending on whether
- /// F->getContext().getDiagnosticHotnessRequested() is on or not. If it's off
+ /// F->getContext().getDiagnosticsHotnessRequested() is on or not. If it's off
/// the operation is free.
///
- /// Whereas if DiagnosticHotnessRequested is on, it is fairly expensive
+ /// Whereas if DiagnosticsHotnessRequested is on, it is fairly expensive
/// operation since BFI and all its required analyses are computed. This is
/// for example useful for CGSCC passes that can't use function analyses
/// passes in the old PM.
diff --git a/include/llvm/Analysis/RegionInfo.h b/include/llvm/Analysis/RegionInfo.h
index 16ee07fa3177..2e34928b28ad 100644
--- a/include/llvm/Analysis/RegionInfo.h
+++ b/include/llvm/Analysis/RegionInfo.h
@@ -37,18 +37,38 @@
#ifndef LLVM_ANALYSIS_REGIONINFO_H
#define LLVM_ANALYSIS_REGIONINFO_H
+#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DepthFirstIterator.h"
+#include "llvm/ADT/GraphTraits.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/iterator_range.h"
-#include "llvm/IR/CFG.h"
+#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
#include <map>
#include <memory>
#include <set>
+#include <string>
+#include <type_traits>
+#include <vector>
namespace llvm {
+class DominanceFrontier;
+class DominatorTree;
+class Loop;
+class LoopInfo;
+struct PostDominatorTree;
+class Region;
+template <class RegionTr> class RegionBase;
+class RegionInfo;
+template <class RegionTr> class RegionInfoBase;
+class RegionNode;
+
// Class to be specialized for different users of RegionInfo
// (i.e. BasicBlocks or MachineBasicBlocks). This is only to avoid needing to
// pass around an unreasonable number of template parameters.
@@ -59,37 +79,23 @@ struct RegionTraits {
// RegionT
// RegionNodeT
// RegionInfoT
- typedef typename FuncT_::UnknownRegionTypeError BrokenT;
+ using BrokenT = typename FuncT_::UnknownRegionTypeError;
};
-class DominatorTree;
-class DominanceFrontier;
-class Loop;
-class LoopInfo;
-struct PostDominatorTree;
-class raw_ostream;
-class Region;
-template <class RegionTr>
-class RegionBase;
-class RegionNode;
-class RegionInfo;
-template <class RegionTr>
-class RegionInfoBase;
-
template <>
struct RegionTraits<Function> {
- typedef Function FuncT;
- typedef BasicBlock BlockT;
- typedef Region RegionT;
- typedef RegionNode RegionNodeT;
- typedef RegionInfo RegionInfoT;
- typedef DominatorTree DomTreeT;
- typedef DomTreeNode DomTreeNodeT;
- typedef DominanceFrontier DomFrontierT;
- typedef PostDominatorTree PostDomTreeT;
- typedef Instruction InstT;
- typedef Loop LoopT;
- typedef LoopInfo LoopInfoT;
+ using FuncT = Function;
+ using BlockT = BasicBlock;
+ using RegionT = Region;
+ using RegionNodeT = RegionNode;
+ using RegionInfoT = RegionInfo;
+ using DomTreeT = DominatorTree;
+ using DomTreeNodeT = DomTreeNode;
+ using DomFrontierT = DominanceFrontier;
+ using PostDomTreeT = PostDominatorTree;
+ using InstT = Instruction;
+ using LoopT = Loop;
+ using LoopInfoT = LoopInfo;
static unsigned getNumSuccessors(BasicBlock *BB) {
return BB->getTerminator()->getNumSuccessors();
@@ -113,13 +119,10 @@ class RegionNodeBase {
friend class RegionBase<Tr>;
public:
- typedef typename Tr::BlockT BlockT;
- typedef typename Tr::RegionT RegionT;
+ using BlockT = typename Tr::BlockT;
+ using RegionT = typename Tr::RegionT;
private:
- RegionNodeBase(const RegionNodeBase &) = delete;
- const RegionNodeBase &operator=(const RegionNodeBase &) = delete;
-
/// This is the entry basic block that starts this region node. If this is a
/// BasicBlock RegionNode, then entry is just the basic block, that this
/// RegionNode represents. Otherwise it is the entry of this (Sub)RegionNode.
@@ -150,6 +153,9 @@ protected:
: entry(Entry, isSubRegion), parent(Parent) {}
public:
+ RegionNodeBase(const RegionNodeBase &) = delete;
+ RegionNodeBase &operator=(const RegionNodeBase &) = delete;
+
/// @brief Get the parent Region of this RegionNode.
///
/// The parent Region is the Region this RegionNode belongs to. If for
@@ -247,24 +253,22 @@ public:
/// tree, the second one creates a graphical representation using graphviz.
template <class Tr>
class RegionBase : public RegionNodeBase<Tr> {
- typedef typename Tr::FuncT FuncT;
- typedef typename Tr::BlockT BlockT;
- typedef typename Tr::RegionInfoT RegionInfoT;
- typedef typename Tr::RegionT RegionT;
- typedef typename Tr::RegionNodeT RegionNodeT;
- typedef typename Tr::DomTreeT DomTreeT;
- typedef typename Tr::LoopT LoopT;
- typedef typename Tr::LoopInfoT LoopInfoT;
- typedef typename Tr::InstT InstT;
-
- typedef GraphTraits<BlockT *> BlockTraits;
- typedef GraphTraits<Inverse<BlockT *>> InvBlockTraits;
- typedef typename BlockTraits::ChildIteratorType SuccIterTy;
- typedef typename InvBlockTraits::ChildIteratorType PredIterTy;
-
friend class RegionInfoBase<Tr>;
- RegionBase(const RegionBase &) = delete;
- const RegionBase &operator=(const RegionBase &) = delete;
+
+ using FuncT = typename Tr::FuncT;
+ using BlockT = typename Tr::BlockT;
+ using RegionInfoT = typename Tr::RegionInfoT;
+ using RegionT = typename Tr::RegionT;
+ using RegionNodeT = typename Tr::RegionNodeT;
+ using DomTreeT = typename Tr::DomTreeT;
+ using LoopT = typename Tr::LoopT;
+ using LoopInfoT = typename Tr::LoopInfoT;
+ using InstT = typename Tr::InstT;
+
+ using BlockTraits = GraphTraits<BlockT *>;
+ using InvBlockTraits = GraphTraits<Inverse<BlockT *>>;
+ using SuccIterTy = typename BlockTraits::ChildIteratorType;
+ using PredIterTy = typename InvBlockTraits::ChildIteratorType;
// Information necessary to manage this Region.
RegionInfoT *RI;
@@ -274,12 +278,12 @@ class RegionBase : public RegionNodeBase<Tr> {
// (The entry BasicBlock is part of RegionNode)
BlockT *exit;
- typedef std::vector<std::unique_ptr<RegionT>> RegionSet;
+ using RegionSet = std::vector<std::unique_ptr<RegionT>>;
// The subregions of this region.
RegionSet children;
- typedef std::map<BlockT *, std::unique_ptr<RegionNodeT>> BBNodeMapT;
+ using BBNodeMapT = std::map<BlockT *, std::unique_ptr<RegionNodeT>>;
// Save the BasicBlock RegionNodes that are element of this Region.
mutable BBNodeMapT BBNodeMap;
@@ -308,6 +312,9 @@ public:
RegionBase(BlockT *Entry, BlockT *Exit, RegionInfoT *RI, DomTreeT *DT,
RegionT *Parent = nullptr);
+ RegionBase(const RegionBase &) = delete;
+ RegionBase &operator=(const RegionBase &) = delete;
+
/// Delete the Region and all its subregions.
~RegionBase();
@@ -543,8 +550,8 @@ public:
///
/// These iterators iterator over all subregions of this Region.
//@{
- typedef typename RegionSet::iterator iterator;
- typedef typename RegionSet::const_iterator const_iterator;
+ using iterator = typename RegionSet::iterator;
+ using const_iterator = typename RegionSet::const_iterator;
iterator begin() { return children.begin(); }
iterator end() { return children.end(); }
@@ -563,12 +570,13 @@ public:
class block_iterator_wrapper
: public df_iterator<
typename std::conditional<IsConst, const BlockT, BlockT>::type *> {
- typedef df_iterator<
- typename std::conditional<IsConst, const BlockT, BlockT>::type *> super;
+ using super =
+ df_iterator<
+ typename std::conditional<IsConst, const BlockT, BlockT>::type *>;
public:
- typedef block_iterator_wrapper<IsConst> Self;
- typedef typename super::value_type value_type;
+ using Self = block_iterator_wrapper<IsConst>;
+ using value_type = typename super::value_type;
// Construct the begin iterator.
block_iterator_wrapper(value_type Entry, value_type Exit)
@@ -592,8 +600,8 @@ public:
}
};
- typedef block_iterator_wrapper<false> block_iterator;
- typedef block_iterator_wrapper<true> const_block_iterator;
+ using block_iterator = block_iterator_wrapper<false>;
+ using const_block_iterator = block_iterator_wrapper<true>;
block_iterator block_begin() { return block_iterator(getEntry(), getExit()); }
@@ -604,8 +612,8 @@ public:
}
const_block_iterator block_end() const { return const_block_iterator(); }
- typedef iterator_range<block_iterator> block_range;
- typedef iterator_range<const_block_iterator> const_block_range;
+ using block_range = iterator_range<block_iterator>;
+ using const_block_range = iterator_range<const_block_iterator>;
/// @brief Returns a range view of the basic blocks in the region.
inline block_range blocks() {
@@ -626,14 +634,14 @@ public:
/// are direct children of this Region. It does not iterate over any
/// RegionNodes that are also element of a subregion of this Region.
//@{
- typedef df_iterator<RegionNodeT *, df_iterator_default_set<RegionNodeT *>,
- false, GraphTraits<RegionNodeT *>>
- element_iterator;
+ using element_iterator =
+ df_iterator<RegionNodeT *, df_iterator_default_set<RegionNodeT *>, false,
+ GraphTraits<RegionNodeT *>>;
- typedef df_iterator<const RegionNodeT *,
- df_iterator_default_set<const RegionNodeT *>, false,
- GraphTraits<const RegionNodeT *>>
- const_element_iterator;
+ using const_element_iterator =
+ df_iterator<const RegionNodeT *,
+ df_iterator_default_set<const RegionNodeT *>, false,
+ GraphTraits<const RegionNodeT *>>;
element_iterator element_begin();
element_iterator element_end();
@@ -661,29 +669,26 @@ inline raw_ostream &operator<<(raw_ostream &OS, const RegionNodeBase<Tr> &Node);
/// Tree.
template <class Tr>
class RegionInfoBase {
- typedef typename Tr::BlockT BlockT;
- typedef typename Tr::FuncT FuncT;
- typedef typename Tr::RegionT RegionT;
- typedef typename Tr::RegionInfoT RegionInfoT;
- typedef typename Tr::DomTreeT DomTreeT;
- typedef typename Tr::DomTreeNodeT DomTreeNodeT;
- typedef typename Tr::PostDomTreeT PostDomTreeT;
- typedef typename Tr::DomFrontierT DomFrontierT;
- typedef GraphTraits<BlockT *> BlockTraits;
- typedef GraphTraits<Inverse<BlockT *>> InvBlockTraits;
- typedef typename BlockTraits::ChildIteratorType SuccIterTy;
- typedef typename InvBlockTraits::ChildIteratorType PredIterTy;
-
friend class RegionInfo;
friend class MachineRegionInfo;
- typedef DenseMap<BlockT *, BlockT *> BBtoBBMap;
- typedef DenseMap<BlockT *, RegionT *> BBtoRegionMap;
- RegionInfoBase();
- virtual ~RegionInfoBase();
+ using BlockT = typename Tr::BlockT;
+ using FuncT = typename Tr::FuncT;
+ using RegionT = typename Tr::RegionT;
+ using RegionInfoT = typename Tr::RegionInfoT;
+ using DomTreeT = typename Tr::DomTreeT;
+ using DomTreeNodeT = typename Tr::DomTreeNodeT;
+ using PostDomTreeT = typename Tr::PostDomTreeT;
+ using DomFrontierT = typename Tr::DomFrontierT;
+ using BlockTraits = GraphTraits<BlockT *>;
+ using InvBlockTraits = GraphTraits<Inverse<BlockT *>>;
+ using SuccIterTy = typename BlockTraits::ChildIteratorType;
+ using PredIterTy = typename InvBlockTraits::ChildIteratorType;
+
+ using BBtoBBMap = DenseMap<BlockT *, BlockT *>;
+ using BBtoRegionMap = DenseMap<BlockT *, RegionT *>;
- RegionInfoBase(const RegionInfoBase &) = delete;
- const RegionInfoBase &operator=(const RegionInfoBase &) = delete;
+ RegionInfoBase();
RegionInfoBase(RegionInfoBase &&Arg)
: DT(std::move(Arg.DT)), PDT(std::move(Arg.PDT)), DF(std::move(Arg.DF)),
@@ -691,6 +696,7 @@ class RegionInfoBase {
BBtoRegion(std::move(Arg.BBtoRegion)) {
Arg.wipe();
}
+
RegionInfoBase &operator=(RegionInfoBase &&RHS) {
DT = std::move(RHS.DT);
PDT = std::move(RHS.PDT);
@@ -701,12 +707,14 @@ class RegionInfoBase {
return *this;
}
+ virtual ~RegionInfoBase();
+
DomTreeT *DT;
PostDomTreeT *PDT;
DomFrontierT *DF;
/// The top level region.
- RegionT *TopLevelRegion;
+ RegionT *TopLevelRegion = nullptr;
/// Map every BB to the smallest region, that contains BB.
BBtoRegionMap BBtoRegion;
@@ -785,6 +793,9 @@ private:
void calculate(FuncT &F);
public:
+ RegionInfoBase(const RegionInfoBase &) = delete;
+ RegionInfoBase &operator=(const RegionInfoBase &) = delete;
+
static bool VerifyRegionInfo;
static typename RegionT::PrintStyle printStyle;
@@ -887,21 +898,22 @@ public:
class RegionInfo : public RegionInfoBase<RegionTraits<Function>> {
public:
- typedef RegionInfoBase<RegionTraits<Function>> Base;
+ using Base = RegionInfoBase<RegionTraits<Function>>;
explicit RegionInfo();
- ~RegionInfo() override;
-
RegionInfo(RegionInfo &&Arg) : Base(std::move(static_cast<Base &>(Arg))) {
updateRegionTree(*this, TopLevelRegion);
}
+
RegionInfo &operator=(RegionInfo &&RHS) {
Base::operator=(std::move(static_cast<Base &>(RHS)));
updateRegionTree(*this, TopLevelRegion);
return *this;
}
+ ~RegionInfo() override;
+
/// Handle invalidation explicitly.
bool invalidate(Function &F, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &);
@@ -931,8 +943,8 @@ class RegionInfoPass : public FunctionPass {
public:
static char ID;
- explicit RegionInfoPass();
+ explicit RegionInfoPass();
~RegionInfoPass() override;
RegionInfo &getRegionInfo() { return RI; }
@@ -953,10 +965,11 @@ public:
/// \brief Analysis pass that exposes the \c RegionInfo for a function.
class RegionInfoAnalysis : public AnalysisInfoMixin<RegionInfoAnalysis> {
friend AnalysisInfoMixin<RegionInfoAnalysis>;
+
static AnalysisKey Key;
public:
- typedef RegionInfo Result;
+ using Result = RegionInfo;
RegionInfo run(Function &F, FunctionAnalysisManager &AM);
};
@@ -967,6 +980,7 @@ class RegionInfoPrinterPass : public PassInfoMixin<RegionInfoPrinterPass> {
public:
explicit RegionInfoPrinterPass(raw_ostream &OS);
+
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
};
@@ -995,8 +1009,8 @@ RegionNodeBase<RegionTraits<Function>>::getNodeAs<Region>() const {
template <class Tr>
inline raw_ostream &operator<<(raw_ostream &OS,
const RegionNodeBase<Tr> &Node) {
- typedef typename Tr::BlockT BlockT;
- typedef typename Tr::RegionT RegionT;
+ using BlockT = typename Tr::BlockT;
+ using RegionT = typename Tr::RegionT;
if (Node.isSubRegion())
return OS << Node.template getNodeAs<RegionT>()->getNameStr();
@@ -1008,5 +1022,6 @@ extern template class RegionBase<RegionTraits<Function>>;
extern template class RegionNodeBase<RegionTraits<Function>>;
extern template class RegionInfoBase<RegionTraits<Function>>;
-} // End llvm namespace
-#endif
+} // end namespace llvm
+
+#endif // LLVM_ANALYSIS_REGIONINFO_H
diff --git a/include/llvm/Analysis/RegionInfoImpl.h b/include/llvm/Analysis/RegionInfoImpl.h
index a16c534484b3..c0337b6daf37 100644
--- a/include/llvm/Analysis/RegionInfoImpl.h
+++ b/include/llvm/Analysis/RegionInfoImpl.h
@@ -12,7 +12,11 @@
#ifndef LLVM_ANALYSIS_REGIONINFOIMPL_H
#define LLVM_ANALYSIS_REGIONINFOIMPL_H
+#include "llvm/ADT/GraphTraits.h"
#include "llvm/ADT/PostOrderIterator.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/iterator_range.h"
#include "llvm/Analysis/DominanceFrontier.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/PostDominators.h"
@@ -20,9 +24,15 @@
#include "llvm/Analysis/RegionIterator.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
#include <algorithm>
+#include <cassert>
#include <iterator>
+#include <memory>
#include <set>
+#include <string>
+#include <type_traits>
+#include <vector>
namespace llvm {
@@ -303,7 +313,8 @@ RegionBase<Tr>::element_end() const {
template <class Tr>
typename Tr::RegionT *RegionBase<Tr>::getSubRegionNode(BlockT *BB) const {
- typedef typename Tr::RegionT RegionT;
+ using RegionT = typename Tr::RegionT;
+
RegionT *R = RI->getRegionFor(BB);
if (!R || R == this)
@@ -330,7 +341,8 @@ typename Tr::RegionNodeT *RegionBase<Tr>::getBBNode(BlockT *BB) const {
if (at == BBNodeMap.end()) {
auto Deconst = const_cast<RegionBase<Tr> *>(this);
typename BBNodeMapT::value_type V = {
- BB, make_unique<RegionNodeT>(static_cast<RegionT *>(Deconst), BB)};
+ BB,
+ llvm::make_unique<RegionNodeT>(static_cast<RegionT *>(Deconst), BB)};
at = BBNodeMap.insert(std::move(V)).first;
}
return at->second.get();
@@ -357,10 +369,10 @@ void RegionBase<Tr>::transferChildrenTo(RegionT *To) {
template <class Tr>
void RegionBase<Tr>::addSubRegion(RegionT *SubRegion, bool moveChildren) {
assert(!SubRegion->parent && "SubRegion already has a parent!");
- assert(find_if(*this,
- [&](const std::unique_ptr<RegionT> &R) {
- return R.get() == SubRegion;
- }) == children.end() &&
+ assert(llvm::find_if(*this,
+ [&](const std::unique_ptr<RegionT> &R) {
+ return R.get() == SubRegion;
+ }) == children.end() &&
"Subregion already exists!");
SubRegion->parent = static_cast<RegionT *>(this);
@@ -402,7 +414,7 @@ typename Tr::RegionT *RegionBase<Tr>::removeSubRegion(RegionT *Child) {
assert(Child->parent == this && "Child is not a child of this region!");
Child->parent = nullptr;
typename RegionSet::iterator I =
- find_if(children, [&](const std::unique_ptr<RegionT> &R) {
+ llvm::find_if(children, [&](const std::unique_ptr<RegionT> &R) {
return R.get() == Child;
});
assert(I != children.end() && "Region does not exit. Unable to remove.");
@@ -505,8 +517,7 @@ void RegionBase<Tr>::clearNodeCache() {
//
template <class Tr>
-RegionInfoBase<Tr>::RegionInfoBase()
- : TopLevelRegion(nullptr) {}
+RegionInfoBase<Tr>::RegionInfoBase() = default;
template <class Tr>
RegionInfoBase<Tr>::~RegionInfoBase() {
@@ -543,7 +554,8 @@ bool RegionInfoBase<Tr>::isCommonDomFrontier(BlockT *BB, BlockT *entry,
template <class Tr>
bool RegionInfoBase<Tr>::isRegion(BlockT *entry, BlockT *exit) const {
assert(entry && exit && "entry and exit must not be null!");
- typedef typename DomFrontierT::DomSetType DST;
+
+ using DST = typename DomFrontierT::DomSetType;
DST *entrySuccs = &DF->find(entry)->second;
@@ -689,7 +701,8 @@ void RegionInfoBase<Tr>::findRegionsWithEntry(BlockT *entry,
template <class Tr>
void RegionInfoBase<Tr>::scanForRegions(FuncT &F, BBtoBBMap *ShortCut) {
- typedef typename std::add_pointer<FuncT>::type FuncPtrT;
+ using FuncPtrT = typename std::add_pointer<FuncT>::type;
+
BlockT *entry = GraphTraits<FuncPtrT>::getEntryNode(&F);
DomTreeNodeT *N = DT->getNode(entry);
@@ -876,7 +889,7 @@ RegionInfoBase<Tr>::getCommonRegion(SmallVectorImpl<BlockT *> &BBs) const {
template <class Tr>
void RegionInfoBase<Tr>::calculate(FuncT &F) {
- typedef typename std::add_pointer<FuncT>::type FuncPtrT;
+ using FuncPtrT = typename std::add_pointer<FuncT>::type;
// ShortCut a function where for every BB the exit of the largest region
// starting with BB is stored. These regions can be threated as single BBS.
@@ -892,4 +905,4 @@ void RegionInfoBase<Tr>::calculate(FuncT &F) {
} // end namespace llvm
-#endif
+#endif // LLVM_ANALYSIS_REGIONINFOIMPL_H
diff --git a/include/llvm/Analysis/RegionIterator.h b/include/llvm/Analysis/RegionIterator.h
index de2f3bf3f12b..4f823cc82210 100644
--- a/include/llvm/Analysis/RegionIterator.h
+++ b/include/llvm/Analysis/RegionIterator.h
@@ -8,17 +8,23 @@
//===----------------------------------------------------------------------===//
// This file defines the iterators to iterate over the elements of a Region.
//===----------------------------------------------------------------------===//
+
#ifndef LLVM_ANALYSIS_REGIONITERATOR_H
#define LLVM_ANALYSIS_REGIONITERATOR_H
+#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/GraphTraits.h"
#include "llvm/ADT/PointerIntPair.h"
-#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Analysis/RegionInfo.h"
#include "llvm/IR/CFG.h"
-#include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <iterator>
+#include <type_traits>
namespace llvm {
+
+class BasicBlock;
+
//===----------------------------------------------------------------------===//
/// @brief Hierarchical RegionNode successor iterator.
///
@@ -33,10 +39,9 @@ namespace llvm {
template <class NodeRef, class BlockT, class RegionT>
class RNSuccIterator
: public std::iterator<std::forward_iterator_tag, NodeRef> {
- typedef std::iterator<std::forward_iterator_tag, NodeRef> super;
-
- typedef GraphTraits<BlockT*> BlockTraits;
- typedef typename BlockTraits::ChildIteratorType SuccIterTy;
+ using super = std::iterator<std::forward_iterator_tag, NodeRef>;
+ using BlockTraits = GraphTraits<BlockT *>;
+ using SuccIterTy = typename BlockTraits::ChildIteratorType;
// The iterator works in two modes, bb mode or region mode.
enum ItMode {
@@ -92,16 +97,15 @@ class RNSuccIterator
inline bool isExit(BlockT* BB) const {
return getNode()->getParent()->getExit() == BB;
}
-public:
- typedef RNSuccIterator<NodeRef, BlockT, RegionT> Self;
- typedef typename super::value_type value_type;
+public:
+ using Self = RNSuccIterator<NodeRef, BlockT, RegionT>;
+ using value_type = typename super::value_type;
/// @brief Create begin iterator of a RegionNode.
inline RNSuccIterator(NodeRef node)
: Node(node, node->isSubRegion() ? ItRgBegin : ItBB),
BItor(BlockTraits::child_begin(node->getEntry())) {
-
// Skip the exit block
if (!isRegionMode())
while (BlockTraits::child_end(node->getEntry()) != BItor && isExit(*BItor))
@@ -153,7 +157,6 @@ public:
}
};
-
//===----------------------------------------------------------------------===//
/// @brief Flat RegionNode iterator.
///
@@ -163,16 +166,16 @@ public:
template <class NodeRef, class BlockT, class RegionT>
class RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>
: public std::iterator<std::forward_iterator_tag, NodeRef> {
- typedef std::iterator<std::forward_iterator_tag, NodeRef> super;
- typedef GraphTraits<BlockT*> BlockTraits;
- typedef typename BlockTraits::ChildIteratorType SuccIterTy;
+ using super = std::iterator<std::forward_iterator_tag, NodeRef>;
+ using BlockTraits = GraphTraits<BlockT *>;
+ using SuccIterTy = typename BlockTraits::ChildIteratorType;
NodeRef Node;
SuccIterTy Itor;
public:
- typedef RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT> Self;
- typedef typename super::value_type value_type;
+ using Self = RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>;
+ using value_type = typename super::value_type;
/// @brief Create the iterator from a RegionNode.
///
@@ -255,8 +258,8 @@ inline RNSuccIterator<NodeRef, BlockT, RegionT> succ_end(NodeRef Node) {
#define RegionNodeGraphTraits(NodeT, BlockT, RegionT) \
template <> struct GraphTraits<NodeT *> { \
- typedef NodeT *NodeRef; \
- typedef RNSuccIterator<NodeRef, BlockT, RegionT> ChildIteratorType; \
+ using NodeRef = NodeT *; \
+ using ChildIteratorType = RNSuccIterator<NodeRef, BlockT, RegionT>; \
static NodeRef getEntryNode(NodeRef N) { return N; } \
static inline ChildIteratorType child_begin(NodeRef N) { \
return RNSuccIterator<NodeRef, BlockT, RegionT>(N); \
@@ -266,9 +269,9 @@ inline RNSuccIterator<NodeRef, BlockT, RegionT> succ_end(NodeRef Node) {
} \
}; \
template <> struct GraphTraits<FlatIt<NodeT *>> { \
- typedef NodeT *NodeRef; \
- typedef RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT> \
- ChildIteratorType; \
+ using NodeRef = NodeT *; \
+ using ChildIteratorType = \
+ RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>; \
static NodeRef getEntryNode(NodeRef N) { return N; } \
static inline ChildIteratorType child_begin(NodeRef N) { \
return RNSuccIterator<FlatIt<NodeRef>, BlockT, RegionT>(N); \
@@ -280,7 +283,7 @@ inline RNSuccIterator<NodeRef, BlockT, RegionT> succ_end(NodeRef Node) {
#define RegionGraphTraits(RegionT, NodeT) \
template <> struct GraphTraits<RegionT *> : public GraphTraits<NodeT *> { \
- typedef df_iterator<NodeRef> nodes_iterator; \
+ using nodes_iterator = df_iterator<NodeRef>; \
static NodeRef getEntryNode(RegionT *R) { \
return R->getNode(R->getEntry()); \
} \
@@ -294,9 +297,9 @@ inline RNSuccIterator<NodeRef, BlockT, RegionT> succ_end(NodeRef Node) {
template <> \
struct GraphTraits<FlatIt<RegionT *>> \
: public GraphTraits<FlatIt<NodeT *>> { \
- typedef df_iterator<NodeRef, df_iterator_default_set<NodeRef>, false, \
- GraphTraits<FlatIt<NodeRef>>> \
- nodes_iterator; \
+ using nodes_iterator = \
+ df_iterator<NodeRef, df_iterator_default_set<NodeRef>, false, \
+ GraphTraits<FlatIt<NodeRef>>>; \
static NodeRef getEntryNode(RegionT *R) { \
return R->getBBNode(R->getEntry()); \
} \
@@ -315,17 +318,19 @@ RegionGraphTraits(Region, RegionNode);
RegionGraphTraits(const Region, const RegionNode);
template <> struct GraphTraits<RegionInfo*>
- : public GraphTraits<FlatIt<RegionNode*> > {
- typedef df_iterator<NodeRef, df_iterator_default_set<NodeRef>, false,
- GraphTraits<FlatIt<NodeRef>>>
- nodes_iterator;
+ : public GraphTraits<FlatIt<RegionNode*>> {
+ using nodes_iterator =
+ df_iterator<NodeRef, df_iterator_default_set<NodeRef>, false,
+ GraphTraits<FlatIt<NodeRef>>>;
static NodeRef getEntryNode(RegionInfo *RI) {
- return GraphTraits<FlatIt<Region*> >::getEntryNode(RI->getTopLevelRegion());
+ return GraphTraits<FlatIt<Region*>>::getEntryNode(RI->getTopLevelRegion());
}
+
static nodes_iterator nodes_begin(RegionInfo* RI) {
return nodes_iterator::begin(getEntryNode(RI));
}
+
static nodes_iterator nodes_end(RegionInfo *RI) {
return nodes_iterator::end(getEntryNode(RI));
}
@@ -333,21 +338,23 @@ template <> struct GraphTraits<RegionInfo*>
template <> struct GraphTraits<RegionInfoPass*>
: public GraphTraits<RegionInfo *> {
- typedef df_iterator<NodeRef, df_iterator_default_set<NodeRef>, false,
- GraphTraits<FlatIt<NodeRef>>>
- nodes_iterator;
+ using nodes_iterator =
+ df_iterator<NodeRef, df_iterator_default_set<NodeRef>, false,
+ GraphTraits<FlatIt<NodeRef>>>;
static NodeRef getEntryNode(RegionInfoPass *RI) {
return GraphTraits<RegionInfo*>::getEntryNode(&RI->getRegionInfo());
}
+
static nodes_iterator nodes_begin(RegionInfoPass* RI) {
return GraphTraits<RegionInfo*>::nodes_begin(&RI->getRegionInfo());
}
+
static nodes_iterator nodes_end(RegionInfoPass *RI) {
return GraphTraits<RegionInfo*>::nodes_end(&RI->getRegionInfo());
}
};
-} // End namespace llvm
+} // end namespace llvm
-#endif
+#endif // LLVM_ANALYSIS_REGIONITERATOR_H
diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h
index 002a3174fd19..c7accfae78b0 100644
--- a/include/llvm/Analysis/ScalarEvolution.h
+++ b/include/llvm/Analysis/ScalarEvolution.h
@@ -262,7 +262,7 @@ public:
const SCEVConstant *getRHS() const { return RHS; }
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEVPredicate *P) {
+ static bool classof(const SCEVPredicate *P) {
return P->getKind() == P_Equal;
}
};
@@ -360,7 +360,7 @@ public:
bool isAlwaysTrue() const override;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEVPredicate *P) {
+ static bool classof(const SCEVPredicate *P) {
return P->getKind() == P_Wrap;
}
};
@@ -406,7 +406,7 @@ public:
unsigned getComplexity() const override { return Preds.size(); }
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEVPredicate *P) {
+ static bool classof(const SCEVPredicate *P) {
return P->getKind() == P_Union;
}
};
@@ -1197,20 +1197,8 @@ public:
const SCEV *getConstant(const APInt &Val);
const SCEV *getConstant(Type *Ty, uint64_t V, bool isSigned = false);
const SCEV *getTruncateExpr(const SCEV *Op, Type *Ty);
-
- typedef SmallDenseMap<std::pair<const SCEV *, Type *>, const SCEV *, 8>
- ExtendCacheTy;
- const SCEV *getZeroExtendExpr(const SCEV *Op, Type *Ty);
- const SCEV *getZeroExtendExprCached(const SCEV *Op, Type *Ty,
- ExtendCacheTy &Cache);
- const SCEV *getZeroExtendExprImpl(const SCEV *Op, Type *Ty,
- ExtendCacheTy &Cache);
-
- const SCEV *getSignExtendExpr(const SCEV *Op, Type *Ty);
- const SCEV *getSignExtendExprCached(const SCEV *Op, Type *Ty,
- ExtendCacheTy &Cache);
- const SCEV *getSignExtendExprImpl(const SCEV *Op, Type *Ty,
- ExtendCacheTy &Cache);
+ const SCEV *getZeroExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
+ const SCEV *getSignExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
const SCEV *getAnyExtendExpr(const SCEV *Op, Type *Ty);
const SCEV *getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap,
diff --git a/include/llvm/Analysis/ScalarEvolutionExpressions.h b/include/llvm/Analysis/ScalarEvolutionExpressions.h
index 2c693bceb24d..56ddb5028d6d 100644
--- a/include/llvm/Analysis/ScalarEvolutionExpressions.h
+++ b/include/llvm/Analysis/ScalarEvolutionExpressions.h
@@ -46,7 +46,7 @@ namespace llvm {
Type *getType() const { return V->getType(); }
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scConstant;
}
};
@@ -65,7 +65,7 @@ namespace llvm {
Type *getType() const { return Ty; }
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scTruncate ||
S->getSCEVType() == scZeroExtend ||
S->getSCEVType() == scSignExtend;
@@ -82,7 +82,7 @@ namespace llvm {
public:
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scTruncate;
}
};
@@ -97,7 +97,7 @@ namespace llvm {
public:
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scZeroExtend;
}
};
@@ -112,7 +112,7 @@ namespace llvm {
public:
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scSignExtend;
}
};
@@ -167,7 +167,7 @@ namespace llvm {
}
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scAddExpr ||
S->getSCEVType() == scMulExpr ||
S->getSCEVType() == scSMaxExpr ||
@@ -185,7 +185,7 @@ namespace llvm {
public:
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scAddExpr ||
S->getSCEVType() == scMulExpr ||
S->getSCEVType() == scSMaxExpr ||
@@ -217,7 +217,7 @@ namespace llvm {
}
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scAddExpr;
}
};
@@ -234,7 +234,7 @@ namespace llvm {
public:
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scMulExpr;
}
};
@@ -263,7 +263,7 @@ namespace llvm {
}
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scUDivExpr;
}
};
@@ -345,7 +345,7 @@ namespace llvm {
}
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scAddRecExpr;
}
};
@@ -363,7 +363,7 @@ namespace llvm {
public:
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scSMaxExpr;
}
};
@@ -382,7 +382,7 @@ namespace llvm {
public:
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scUMaxExpr;
}
};
@@ -428,7 +428,7 @@ namespace llvm {
Type *getType() const { return getValPtr()->getType(); }
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEV *S) {
+ static bool classof(const SCEV *S) {
return S->getSCEVType() == scUnknown;
}
};
diff --git a/include/llvm/Analysis/TargetTransformInfo.h b/include/llvm/Analysis/TargetTransformInfo.h
index af2ebb7b6b44..68fbf640994c 100644
--- a/include/llvm/Analysis/TargetTransformInfo.h
+++ b/include/llvm/Analysis/TargetTransformInfo.h
@@ -216,9 +216,23 @@ public:
/// other context they may not be folded. This routine can distinguish such
/// cases.
///
+ /// \p Operands is a list of operands which can be a result of transformations
+ /// of the current operands. The number of the operands on the list must equal
+ /// to the number of the current operands the IR user has. Their order on the
+ /// list must be the same as the order of the current operands the IR user
+ /// has.
+ ///
/// The returned cost is defined in terms of \c TargetCostConstants, see its
/// comments for a detailed explanation of the cost values.
- int getUserCost(const User *U) const;
+ int getUserCost(const User *U, ArrayRef<const Value *> Operands) const;
+
+ /// \brief This is a helper function which calls the two-argument getUserCost
+ /// with \p Operands which are the current operands U has.
+ int getUserCost(const User *U) const {
+ SmallVector<const Value *, 4> Operands(U->value_op_begin(),
+ U->value_op_end());
+ return getUserCost(U, Operands);
+ }
/// \brief Return true if branch divergence exists.
///
@@ -366,7 +380,8 @@ public:
/// \brief Get target-customized preferences for the generic loop unrolling
/// transformation. The caller will initialize UP with the current
/// target-independent defaults.
- void getUnrollingPreferences(Loop *L, UnrollingPreferences &UP) const;
+ void getUnrollingPreferences(Loop *L, ScalarEvolution &,
+ UnrollingPreferences &UP) const;
/// @}
@@ -823,13 +838,15 @@ public:
ArrayRef<const Value *> Arguments) = 0;
virtual unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
unsigned &JTSize) = 0;
- virtual int getUserCost(const User *U) = 0;
+ virtual int
+ getUserCost(const User *U, ArrayRef<const Value *> Operands) = 0;
virtual bool hasBranchDivergence() = 0;
virtual bool isSourceOfDivergence(const Value *V) = 0;
virtual bool isAlwaysUniform(const Value *V) = 0;
virtual unsigned getFlatAddressSpace() = 0;
virtual bool isLoweredToCall(const Function *F) = 0;
- virtual void getUnrollingPreferences(Loop *L, UnrollingPreferences &UP) = 0;
+ virtual void getUnrollingPreferences(Loop *L, ScalarEvolution &,
+ UnrollingPreferences &UP) = 0;
virtual bool isLegalAddImmediate(int64_t Imm) = 0;
virtual bool isLegalICmpImmediate(int64_t Imm) = 0;
virtual bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV,
@@ -998,7 +1015,9 @@ public:
ArrayRef<const Value *> Arguments) override {
return Impl.getIntrinsicCost(IID, RetTy, Arguments);
}
- int getUserCost(const User *U) override { return Impl.getUserCost(U); }
+ int getUserCost(const User *U, ArrayRef<const Value *> Operands) override {
+ return Impl.getUserCost(U, Operands);
+ }
bool hasBranchDivergence() override { return Impl.hasBranchDivergence(); }
bool isSourceOfDivergence(const Value *V) override {
return Impl.isSourceOfDivergence(V);
@@ -1015,8 +1034,9 @@ public:
bool isLoweredToCall(const Function *F) override {
return Impl.isLoweredToCall(F);
}
- void getUnrollingPreferences(Loop *L, UnrollingPreferences &UP) override {
- return Impl.getUnrollingPreferences(L, UP);
+ void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
+ UnrollingPreferences &UP) override {
+ return Impl.getUnrollingPreferences(L, SE, UP);
}
bool isLegalAddImmediate(int64_t Imm) override {
return Impl.isLegalAddImmediate(Imm);
diff --git a/include/llvm/Analysis/TargetTransformInfoImpl.h b/include/llvm/Analysis/TargetTransformInfoImpl.h
index 24ac3b1213e1..0246fc1c02cc 100644
--- a/include/llvm/Analysis/TargetTransformInfoImpl.h
+++ b/include/llvm/Analysis/TargetTransformInfoImpl.h
@@ -217,7 +217,8 @@ public:
return true;
}
- void getUnrollingPreferences(Loop *, TTI::UnrollingPreferences &) {}
+ void getUnrollingPreferences(Loop *, ScalarEvolution &,
+ TTI::UnrollingPreferences &) {}
bool isLegalAddImmediate(int64_t Imm) { return false; }
@@ -684,14 +685,14 @@ public:
return static_cast<T *>(this)->getIntrinsicCost(IID, RetTy, ParamTys);
}
- unsigned getUserCost(const User *U) {
+ unsigned getUserCost(const User *U, ArrayRef<const Value *> Operands) {
if (isa<PHINode>(U))
return TTI::TCC_Free; // Model all PHI nodes as free.
if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
- SmallVector<Value *, 4> Indices(GEP->idx_begin(), GEP->idx_end());
- return static_cast<T *>(this)->getGEPCost(
- GEP->getSourceElementType(), GEP->getPointerOperand(), Indices);
+ return static_cast<T *>(this)->getGEPCost(GEP->getSourceElementType(),
+ GEP->getPointerOperand(),
+ Operands.drop_front());
}
if (auto CS = ImmutableCallSite(U)) {
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-20 04:30:38 +0000