reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/Support/GenericDomTreeConstruction.h
   65     NodePtr Label = nullptr;
   66     NodePtr IDom = nullptr;
   67     SmallVector<NodePtr, 2> ReverseChildren;
   72   std::vector<NodePtr> NumToNode = {nullptr};
   73   DenseMap<NodePtr, InfoRec> NodeToInfo;
   79     using NodePtrAndKind = PointerIntPair<NodePtr, 1, UpdateKind>;
   88     DenseMap<NodePtr, SmallVector<NodePtrAndKind, 4>> FutureSuccessors;
   89     DenseMap<NodePtr, SmallVector<NodePtrAndKind, 4>> FuturePredecessors;
  110     using ResultTy = SmallVector<NodePtr, 8>;
  112     static ResultTy Get(NodePtr N, std::integral_constant<bool, false>) {
  113       auto RChildren = reverse(children<NodePtr>(N));
  117     static ResultTy Get(NodePtr N, std::integral_constant<bool, true>) {
  118       auto IChildren = inverse_children<NodePtr>(N);
  128     static ResultTy Get(NodePtr N, BatchUpdatePtr BUI) {
  142         const NodePtr Child = ChildAndKind.getPointer();
  169   NodePtr getIDom(NodePtr BB) const {
  169   NodePtr getIDom(NodePtr BB) const {
  176   TreeNodePtr getNodeForBlock(NodePtr BB, DomTreeT &DT) {
  181     NodePtr IDom = getIDom(BB);
  193   static bool AlwaysDescend(NodePtr, NodePtr) { return true; }
  193   static bool AlwaysDescend(NodePtr, NodePtr) { return true; }
  196     NodePtr N;
  198     BlockNamePrinter(NodePtr Block) : N(Block) {}
  219   unsigned runDFS(NodePtr V, unsigned LastNum, DescendCondition Condition,
  222     SmallVector<NodePtr, 64> WorkList = {V};
  226       const NodePtr BB = WorkList.pop_back_val();
  236       for (const NodePtr Succ :
  273   NodePtr eval(NodePtr V, unsigned LastLinked,
  273   NodePtr eval(NodePtr V, unsigned LastLinked,
  308       const NodePtr V = NumToNode[i];
  316       NodePtr W = NumToNode[i];
  340       const NodePtr W = NumToNode[i];
  343       NodePtr WIDomCandidate = WInfo.IDom;
  370   static bool HasForwardSuccessors(const NodePtr N, BatchUpdatePtr BUI) {
  375   static NodePtr GetEntryNode(const DomTreeT &DT) {
  409     for (const NodePtr N : nodes(DT.Parent)) {
  440       SmallPtrSet<NodePtr, 4> ConnectToExitBlock;
  441       for (const NodePtr I : nodes(DT.Parent)) {
  458           const NodePtr FurthestAway = SNCA.NumToNode[NewNum];
  467             const NodePtr N = SNCA.NumToNode[i];
  529         const NodePtr N = SNCA.NumToNode[x];
  559     for (const NodePtr Root : DT.Roots) Num = runDFS(Root, Num, DC, 0);
  586     NodePtr Root = IsPostDom ? nullptr : DT.Roots[0];
  599       NodePtr W = NumToNode[i];
  606       NodePtr ImmDom = getIDom(W);
  621       const NodePtr N = NumToNode[i];
  650                          const NodePtr From, const NodePtr To) {
  650                          const NodePtr From, const NodePtr To) {
  701   static bool isPermutation(const SmallVectorImpl<NodePtr> &A,
  702                             const SmallVectorImpl<NodePtr> &B) {
  705     SmallPtrSet<NodePtr, 4> Set(A.begin(), A.end());
  706     for (NodePtr N : B)
  749     const NodePtr NCDBlock =
  798         for (const NodePtr Succ :
  869                                 const TreeNodePtr From, const NodePtr To) {
  874     SmallVector<std::pair<NodePtr, TreeNodePtr>, 8> DiscoveredEdgesToReachable;
  894       DomTreeT &DT, const BatchUpdatePtr BUI, const NodePtr Root,
  896       SmallVectorImpl<std::pair<NodePtr, TreeNodePtr>>
  919                          const NodePtr From, const NodePtr To) {
  919                          const NodePtr From, const NodePtr To) {
  948     const NodePtr NCDBlock = DT.findNearestCommonDominator(From, To);
  980     const NodePtr ToIDom =
 1016     for (const NodePtr Pred :
 1021       const NodePtr Support =
 1056     SmallVector<NodePtr, 16> AffectedQueue;
 1079     for (const NodePtr N : AffectedQueue) {
 1081       const NodePtr NCDBlock =
 1103       const NodePtr N = SNCA.NumToNode[i];
 1174     cfg::LegalizeUpdates<NodePtr>(Updates, BUI.Updates, IsPostDom);
 1289       for (const NodePtr N : DT.Roots) errs() << BlockNamePrinter(N) << ", ";
 1291       for (const NodePtr N : ComputedRoots)
 1309       const NodePtr BB = TN->getBlock();
 1323     for (const NodePtr N : NumToNode) {
 1342       const NodePtr BB = TN->getBlock();
 1375     const NodePtr RootBB = IsPostDom ? nullptr : DT.getRoots()[0];
 1510       const NodePtr BB = TN->getBlock();
 1543       const NodePtr BB = TN->getBlock();
 1549         NodePtr BBN = N->getBlock();
tools/clang/include/clang/Analysis/Analyses/Dominators.h
  295   auto RChildren = reverse(children<NodePtr>(N));
  310   auto IChildren = inverse_children<NodePtr>(N);
  325   auto RChildren = reverse(children<NodePtr>(N));
  340   auto IChildren = inverse_children<NodePtr>(N);