GenericIteratedDominanceFrontier.h Source File (original) (raw)

23#ifndef LLVM_SUPPORT_GENERICITERATEDDOMINANCEFRONTIER_H

24#define LLVM_SUPPORT_GENERICITERATEDDOMINANCEFRONTIER_H

30#include

32namespace llvm {

34namespace IDFCalculatorDetail {

45};

47}

59public:

61 std::conditional_t<IsPostDom, Inverse<NodeTy *>, NodeTy *>;

69 : DT(DT), ChildrenGetter(C) {}

78 }

86 LiveInBlocks = &Blocks;

87 useLiveIn = true;

88 }

93 LiveInBlocks = nullptr;

94 useLiveIn = false;

95 }

100

101

102

104

105private:

108 bool useLiveIn = false;

111};

112

113

114

115

116

117namespace IDFCalculatorDetail {

118

119template <class NodeTy, bool IsPostDom>

122 using OrderedNodeTy =

124

125 return children(N);

126}

127

128}

129

130template <class NodeTy, bool IsPostDom>

133

134

135

136

137 using DomTreeNodePair =

138 std::pair<DomTreeNodeBase *, std::pair<unsigned, unsigned>>;

139 using IDFPriorityQueue =

140 std::priority_queue<DomTreeNodePair, SmallVector<DomTreeNodePair, 32>,

142

143 IDFPriorityQueue PQ;

144

146

150 if (useLiveIn) {

151 VisitedPQ.reserve(LiveInBlocks->size());

152 VisitedWorklist.reserve(LiveInBlocks->size());

153 }

154

155 for (NodeTy *BB : *DefBlocks)

157 PQ.push({Node, std::make_pair(Node->getLevel(), Node->getDFSNumIn())});

159 }

160

161 while (!PQ.empty()) {

162 DomTreeNodePair RootPair = PQ.top();

163 PQ.pop();

165 unsigned RootLevel = RootPair.second.first;

166

167

168

169

170

171

174

175 while (!Worklist.empty()) {

177 NodeTy *BB = Node->getBlock();

178

179

180 auto DoWork = [&](NodeTy *Succ) {

182

183 const unsigned SuccLevel = SuccNode->getLevel();

184 if (SuccLevel > RootLevel)

185 return;

186

187 if (!VisitedPQ.insert(SuccNode).second)

188 return;

189

190 NodeTy *SuccBB = SuccNode->getBlock();

191 if (useLiveIn && !LiveInBlocks->count(SuccBB))

192 return;

193

195 if (!DefBlocks->count(SuccBB))

196 PQ.push(std::make_pair(

197 SuccNode, std::make_pair(SuccLevel, SuccNode->getDFSNumIn())));

198 };

199

200 for (auto *Succ : ChildrenGetter.get(BB))

201 DoWork(Succ);

202

203 for (auto DomChild : *Node) {

204 if (VisitedWorklist.insert(DomChild).second)

206 }

207 }

208 }

209}

210

211}

212

213#endif

DenseMap< Block *, BlockRelaxAux > Blocks

This file defines a set of templates that efficiently compute a dominator tree over a generic graph.

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This file defines the SmallPtrSet class.

This file defines the SmallVector class.

Base class for the actual dominator tree node.

unsigned getDFSNumIn() const

getDFSNumIn/getDFSNumOut - These return the DFS visitation order for nodes in the dominator tree.

unsigned getLevel() const

Core dominator tree base class.

void updateDFSNumbers() const

updateDFSNumbers - Assign In and Out numbers to the nodes while walking dominator tree in dfs order.

DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const

getNode - return the (Post)DominatorTree node for the specified basic block.

Determine the iterated dominance frontier, given a set of defining blocks, and optionally,...

IDFCalculatorBase(DominatorTreeBase< NodeTy, IsPostDom > &DT)

void resetLiveInBlocks()

Reset the live-in block set to be empty, and tell the IDF calculator to not use liveness anymore.

void calculate(SmallVectorImpl< NodeTy * > &IDFBlocks)

Calculate iterated dominance frontiers.

void setLiveInBlocks(const SmallPtrSetImpl< NodeTy * > &Blocks)

Give the IDF calculator the set of blocks in which the value is live on entry to the block.

void setDefiningBlocks(const SmallPtrSetImpl< NodeTy * > &Blocks)

Give the IDF calculator the set of blocks in which the value is defined.

IDFCalculatorBase(DominatorTreeBase< NodeTy, IsPostDom > &DT, const ChildrenGetterTy &C)

std::conditional_t< IsPostDom, Inverse< NodeTy * >, NodeTy * > OrderedNodeTy

void reserve(size_type NumEntries)

A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

reference emplace_back(ArgTypes &&... Args)

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

A range adaptor for a pair of iterators.

This provides a very simple, boring adaptor for a begin and end iterator into a range type.

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

typename GraphType::UnknownGraphTypeError NodeRef

Specialization for BasicBlock for the optional use of GraphDiff.

Generic utility class used for getting the children of a basic block.

iterator_range< ChildIteratorType > range

typename GraphTraits< NodeTy * >::ChildIteratorType ChildIteratorType

typename GraphTraits< NodeTy * >::NodeRef NodeRef

range get(const NodeRef &N)

Function object to check whether the second component of a container supported by std::get (like std:...