Expose CFG Update struct. Define GraphTraits to get children given a snapshot CFG.

[asbirlea]

Summary

Certain passes or analysis need to view a CFG snapshot rather than the actual CFG. This patch provides GraphTraits to offer such a view.

The patch defines GraphTraits for BasicBlock* and Inverse<BasicBlock*> to provide CFG successors and predecessors based on a list of CFG updates.

An Update is defined as a triple {InsertOrDeleteKind, BlockStartOfEdge, BlockEndOfEdge}.
A GraphDiff is defined as a list of Updates that has been preprocessed to treat the CFG as a graph rather than a multi-graph. As such, there can only exist a single Update given two nodes. All duplicates will be filtered and Insert/Delete edges that cancel out will be ignored.
The methods GraphDiff exposes are:

• Determine if an existing child needs to be ignored, i.e. an Update exists in the correct direction to assume the removal of that edge.
• Return a list of new children to be considered, i.e. an Update exists in the correct direction for each child in the list to assume the insertion of that edge.

[asbirlea]

Looking for feedback on this before moving forward. Some questions:

1. Namespace naming (cfg) and placement of Update struct.
2. Move WrappedPairNodeDataIterator somewhere in ADT, to reuse in LoopIterator.h?
3. The part to pre-process the Updates is not part of this patch. I would like to move GenericDomTreeConstruction::LegalizeUpdates somewhere in Support outside DomTreeBuilder namespace, in order to reuse the functionality. Where is a good place to have this, or are there objections to moving it?

Should these follow-up patches be part of this one?

1. Reference cfg::Update in DomTree, remove Update from DomTreeBuilder namespace.
2. Teach IDF to use children based on a GraphDiff, given the new GraphTraits in this patch.

[asbirlea]

Format.

[kuhar]

One thing that is not clear to me is how you decide whether to apply the updates on top of the current CFG or to reverse-apply them. DomTreeConstruction needs the latter, but I don't know what makes sense in your use-case.

I think that this should eventually replace the diffing functionality in the dominator tree construction. This should be also perhaps useful if we decide to go with CFG snapshots for easier incremental updates, like in @NutshellySima 's prototypes.

In D50479#1193105, @asbirlea wrote:

Looking for feedback on this before moving forward. Some questions:

1. Namespace naming (cfg) and placement of Update struct.

Fine with me.

2. Move WrappedPairNodeDataIterator somewhere in ADT, to reuse in LoopIterator.h?

Not familiar enough to suggest anything :/.

3. The part to pre-process the Updates is not part of this patch. I would like to move GenericDomTreeConstruction::LegalizeUpdates somewhere in Support outside DomTreeBuilder namespace, in order to reuse the functionality. Where is a good place to have this, or are there objections to moving it?

Fine with migrating it somewhere. I would keep it close to the update struct.

Should these follow-up patches be part of this one?

1. Reference cfg::Update in DomTree, remove Update from DomTreeBuilder namespace.

Fine with either now or a separate patch.

2. Teach IDF to use children based on a GraphDiff, given the new GraphTraits in this patch.

Where does IDF calculation need the diffing functionality?

include/llvm/IR/CFGDiff.h

41 ↗

(On Diff #159823)

It wan't obvious for me what this is for until I grepped for the field name and saw how it's used -- I'd add a comment saying why you need it.

71 ↗

(On Diff #159823)

Why is returning a pointer better than reference? Can this ever return nullptr?

79 ↗

(On Diff #159823)

I think it would be *extremely* useful to add a dump method here.

[asbirlea]

Right, I'm defining Inverse but not IsPostDom (from ChildrenGetter).
Adding a second bool is an easy option, and defining 2 more traits with:
std::pair<const GraphDiff<Inverse<BasicBlock *>> *, BasicBlock *>>
and
std::pair<const GraphDiff<Inverse<BasicBlock *>> *, Inverse<BasicBlock *>>>
These would set the second bool for the GraphDiff calls to reflect IsPostDom. NodeRef would remain the same.

The children call site in DomTree would look something like:
children<GraphDiffBBPair>({GD, BB})), with
using GraphDiffBBPair = std::pair<const GraphDiff<BasicBlock*> *, Inverse<BasicBlock*>; for predecessors in DomTree (and so on for all combos)

I agree that long term this can and should be reused in DomTree, so I'm trying to make it have the right functionality.
Another possibly related issue, is that I'm not reversing the children, as in DomTree, not sure the reason behind that one.

Another issue with the above traits: is there a way to avoid some of the code duplication, since the only differences are the bool arguments to GraphDiff and succ/pred iterators?

include/llvm/IR/CFGDiff.h

71 ↗

(On Diff #159823)

I really wanted to define the GraphTraits in the other header as a pair of a *const* GraphDiff* and BasicBlock*. This meant that I needed to have the methods const as well and they cannot return a reference. No, this can never return null.

The alternative to all this is to drop the const in the GraphTraits std::pair below and all the related const attributes. Personal preference is to keep them, but if folks have strong preferences otherwise, I'm open to changing it.

[kuhar]

In D50479#1194111, @asbirlea wrote:

Another issue with the above traits: is there a way to avoid some of the code duplication, since the only differences are the bool arguments to GraphDiff and succ/pred iterators?

I think you can create a base class with extra template parameters and then inherit from it, specializing the parameters you want. There's something similar in BlockFrequencyInfoImpl.h.

[kuhar]

In D50479#1194111, @asbirlea wrote:

I agree that long term this can and should be reused in DomTree, so I'm trying to make it have the right functionality.
Another possibly related issue, is that I'm not reversing the children, as in DomTree, not sure the reason behind that one.

Sure. The children are being reversed to preserve the successor order in DFS, which uses stack and reverses them (again) internally. But this reverse can be moved somewhere else and you don't have to worry about it.

[timshen]

include/llvm/IR/CFGDiff.h

59 ↗

(On Diff #159823)

Can we have a void verify() const that verifies the class invariants? e.g. whether duplicated edges are allowed, can one edge exist in both delete and insert, etc. We can call it with the guards of #ifdef EXPENSIVE_CHECKS.

71 ↗

(On Diff #159823)

Would it be better to return iterator_range(SmallVectorImpl<NodePtr>::const_iterator)?

110 ↗

(On Diff #159823)

Optional: The two GraphTraits specializations are highly duplicated. Maybe find a way to de-duplicate them?

The only differences between the two specializations are (1) succ_iterator vs succ_iterator, (2) succ_begin/succ_end vs pred_begin/pred_end, and (3) false vs true gets passed to getAddedChildren.

Both (1) and (2) can be abstracted in a common place. Maybe add some "inverse utility"?

include/llvm/Support/CFGUpdate.h

22 ↗

(On Diff #159823)

Due to the use of PointerIntPair, it's better be a class and hides the data members.

38 ↗

(On Diff #159823)

Can this be a print() and/or dump() function, consistent with other types?

[asbirlea]

Address most comments.
Partially resolved GraphTraits duplication, working out if I can fully parametrize on succ/pred.

[asbirlea]

include/llvm/IR/CFGDiff.h

59 ↗

(On Diff #159823)

I added the LegalizeUpdates call that should guarantee the specified behavior. Let me know if this is a good solution.

71 ↗

(On Diff #159823)

Works for me, updated.

[kuhar]

include/llvm/IR/CFGDiff.h

60 ↗

(On Diff #160164)

It's not clear to me what InverseGraph means here.

82 ↗

(On Diff #160164)

return llvm::find(EdgesForBB, EdgeEnd) != EdgesForBB.end();

101 ↗

(On Diff #160164)

missing )? :P

113 ↗

(On Diff #160164)

please guard this with the macro for dump methods

include/llvm/Support/CFGUpdate.h

47 ↗

(On Diff #160164)

Same as above - please guard this with the macro.

[timshen]

include/llvm/IR/CFGDiff.h

60 ↗

(On Diff #160164)

I imagine that if InverseGraph, then To is a predecessor of From. If not InverseGraph, To is a successor of From. Maybe you want to document that?

87 ↗

(On Diff #160164)

"const" is not necessary here. It doesn't prevent the caller from removing the const anyway.

include/llvm/Support/CFGUpdate.h

72 ↗

(On Diff #160164)

There is no need to swap?

95 ↗

(On Diff #160164)

If the previous swap is removed, I guess this will always be Operations[{U.getFrom(), U.getTo()}] = int(i);.

[kuhar]

include/llvm/IR/CFGDiff.h

60 ↗

(On Diff #160164)

What confuses me is it's already possible to Pass Inverse<BB*> as the template arguments, so it's not clear if InverseGraph is for the graph, the updates, or if it means to swap insertions and deletions of edges.

It would be really helpful to add a comment about it above.

include/llvm/Support/CFGUpdate.h

72 ↗

(On Diff #160164)

DomTree and PostDomTree allow you to pass the same update vector to both, but since PostDomTree operates on inverse CFG, you have to swap somewhere to make it work.

I believe this was just copied from the domtree code.

[timshen]

Unintentional LGTM. But it's close. :)

[asbirlea]

include/llvm/IR/CFGDiff.h

60 ↗

(On Diff #160164)

Let me try to clarify what I had in mind and please let me know if this makes sense in terms of generality. There is also a comment about this below which I'd be happy to move around and expand to give clarity.

There are 2 boolean values used consistently throughout this file: InverseGraph and InverseEdge. InverseGraph refers to having a normal graph, or viewing the graph in reverse, which is analogous with reverse-applying updates.
InverseEdge refers to the direction of the edges you're looking for. For a non-inversed graph, that's naturally successors when InverseEdge is false and predecessors when InverseEdge is true.

Below there are two classes that call into GraphDiff:
CFGViewSuccessors and CFGViewPredecessors, both can be parametrized to consider the graph inverted or not (i.e. InverseGraph). Successors implicitly has InverseEdge = false and Predecessors implicitly has InverseEdge = true (see calls to GraphDiff methods in there).

In the GraphTraits instantiations:

• GraphDiff<BasicBlock *> is equivalent to InverseGraph = false
• GraphDiff<Inverse<BasicBlock *>> is equivalent to InverseGraph = true
• second pair item is BasicBlock *, then InverseEdge = false
• second pair item is Inverse<BasicBlock *>, then InverseEdge = true

The 4 GraphTraits are as follows:

1. std::pair<const GraphDiff<BasicBlock *> *, BasicBlock *>> : CFGViewSuccessors<false>

Regular CFG, children means successors, InverseGraph = false, InverseEdge = false.

2. std::pair<const GraphDiff<Inverse<BasicBlock *>> *, BasicBlock *>> : CFGViewSuccessors<true>

Reverse the graph, get successors but reverse-apply updates, InverseGraph = true, InverseEdge = false.

3. std::pair<const GraphDiff<BasicBlock *> *, Inverse<BasicBlock *>>> : CFGViewPredecessors<false>

Regular CFG, reverse edges, so children mean predecessors, InverseGraph = false, InverseEdge = true.

4. std::pair<const GraphDiff<Inverse<BasicBlock *>> *, Inverse<BasicBlock *>> : CFGViewPredecessors<true>

Reverse the graph and the edges, InverseGraph = true, InverseEdge = true.

If this makes sense, I'll make this explanation into a comment before GraphDiff, rather than before CFGViewSuccessors.

include/llvm/Support/CFGUpdate.h

72 ↗

(On Diff #160164)

The swap is intentional, for reverse-applying updates. It refers to the first bool: InverseGraph and should be used for PostDomTree.
Yes, the method is copied from the domtree code. I have a dependent patch to clean that up (remove Update struct and legalizeUpdates).

[asbirlea]

Updated documentation in CFGDiff to describe InverseEdge adn InverseGraph.
Moved wrapper iterator to ADT/iterator.h

Thanks a lot for the comments so far!

[kuhar]

Thanks for the changes. LGTM.

[asbirlea]

Thank you for the review, Kuba! I'll wait for Tim's input as well in case he has more comments.

[timshen]

include/llvm/Support/CFGUpdate.h

105 ↗

(On Diff #160386)

Just want to make sure that this sorts to descending order.

[asbirlea]

include/llvm/Support/CFGUpdate.h

105 ↗

(On Diff #160386)

Yes, that's right. The reason is that DomTree then applies updates from the end of the vector, so they will be applied in the original order.

My use case of GraphDiff does not care about update order and I don't want to change the order for DomTree, so I'll leave it like this in this patch.
I'm planning to refactor DomTree to use GraphDiff instead of its inner data structure (BatchUpdaterInfo), so then I can tell DT to use the Updates in order, and also reverse the sort here.

llvm/trunk/include/llvm/ADT/iterator.h

template <typename RangeT, typename WrappedIteratorT =
                                decltype(std::begin(std::declval<RangeT>()))>
 iterator_range<pointer_iterator<WrappedIteratorT>>
 make_pointer_range(RangeT &&Range) {
   using PointerIteratorT = pointer_iterator<WrappedIteratorT>;
   return make_range(PointerIteratorT(std::begin(std::forward<RangeT>(Range))),
                     PointerIteratorT(std::end(std::forward<RangeT>(Range))));
 }
 
+// Wrapper iterator over iterator ItType, adding DataRef to the type of ItType,
+// to create NodeRef = std::pair<InnerTypeOfItType, DataRef>.
+template <typename ItType, typename NodeRef, typename DataRef>
+class WrappedPairNodeDataIterator
+    : public iterator_adaptor_base<
+          WrappedPairNodeDataIterator<ItType, NodeRef, DataRef>, ItType,
+          typename std::iterator_traits<ItType>::iterator_category, NodeRef,
+          std::ptrdiff_t, NodeRef *, NodeRef &> {
+  using BaseT = iterator_adaptor_base<
+      WrappedPairNodeDataIterator, ItType,
+      typename std::iterator_traits<ItType>::iterator_category, NodeRef,
+      std::ptrdiff_t, NodeRef *, NodeRef &>;
+
+  const DataRef DR;
+  mutable NodeRef NR;
+
+public:
+  WrappedPairNodeDataIterator(ItType Begin, const DataRef DR)
+      : BaseT(Begin), DR(DR) {
+    NR.first = DR;
+  }
+
+  NodeRef &operator*() const {
+    NR.second = *this->I;
+    return NR;
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_ITERATOR_H

llvm/trunk/include/llvm/IR/CFGDiff.h

+//===- CFGDiff.h - Define a CFG snapshot. -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines specializations of GraphTraits that allows generic
+// algorithms to see a different snapshot of a CFG.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_CFGDIFF_H
+#define LLVM_IR_CFGDIFF_H
+
+#include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/CFG.h"
+#include "llvm/Support/CFGUpdate.h"
+#include "llvm/Support/type_traits.h"
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+
+// Two booleans are used to define orders in graphs:
+// InverseGraph defines when we need to reverse the whole graph and is as such
+// also equivalent to applying updates in reverse.
+// InverseEdge defines whether we want to change the edges direction. E.g., for
+// a non-inversed graph, the children are naturally the successors when
+// InverseEdge is false and the predecessors when InverseEdge is true.
+
+// We define two base clases that call into GraphDiff, one for successors
+// (CFGSuccessors), where InverseEdge is false, and one for predecessors
+// (CFGPredecessors), where InverseEdge is true.
+// FIXME: Further refactoring may merge the two base classes into a single one
+// templated / parametrized on using succ_iterator/pred_iterator and false/true
+// for the InverseEdge.
+
+// CFGViewSuccessors and CFGViewPredecessors, both can be parametrized to
+// consider the graph inverted or not (i.e. InverseGraph). Successors
+// implicitly has InverseEdge = false and Predecessors implicitly has
+// InverseEdge = true (see calls to GraphDiff methods in there). The GraphTraits
+// instantiations that follow define the value of InverseGraph.
+
+// GraphTraits instantiations:
+// - GraphDiff<BasicBlock *> is equivalent to InverseGraph = false
+// - GraphDiff<Inverse<BasicBlock *>> is equivalent to InverseGraph = true
+// - second pair item is BasicBlock *, then InverseEdge = false (so it inherits
+// from CFGViewSuccessors).
+// - second pair item is Inverse<BasicBlock *>, then InverseEdge = true (so it
+// inherits from CFGViewPredecessors).
+
+// The 4 GraphTraits are as follows:
+// 1. std::pair<const GraphDiff<BasicBlock *> *, BasicBlock *>> :
+//        CFGViewSuccessors<false>
+// Regular CFG, children means successors, InverseGraph = false,
+// InverseEdge = false.
+// 2. std::pair<const GraphDiff<Inverse<BasicBlock *>> *, BasicBlock *>> :
+//        CFGViewSuccessors<true>
+// Reverse the graph, get successors but reverse-apply updates,
+// InverseGraph = true, InverseEdge = false.
+// 3. std::pair<const GraphDiff<BasicBlock *> *, Inverse<BasicBlock *>>> :
+//        CFGViewPredecessors<false>
+// Regular CFG, reverse edges, so children mean predecessors,
+// InverseGraph = false, InverseEdge = true.
+// 4. std::pair<const GraphDiff<Inverse<BasicBlock *>> *, Inverse<BasicBlock *>>
+//        : CFGViewPredecessors<true>
+// Reverse the graph and the edges, InverseGraph = true, InverseEdge = true.
+
+namespace llvm {
+
+// GraphDiff defines a CFG snapshot: given a set of Update<NodePtr>, provide
+// utilities to skip edges marked as deleted and return a set of edges marked as
+// newly inserted. The current diff treats the CFG as a graph rather than a
+// multigraph. Added edges are pruned to be unique, and deleted edges will
+// remove all existing edges between two blocks.
+template <typename NodePtr> class GraphDiff {
+  using UpdateMapType = SmallDenseMap<NodePtr, SmallVector<NodePtr, 2>>;
+  UpdateMapType SuccInsert;
+  UpdateMapType SuccDelete;
+  UpdateMapType PredInsert;
+  UpdateMapType PredDelete;
+  // Using a singleton empty vector for all BasicBlock requests with no
+  // children.
+  SmallVector<NodePtr, 1> Empty;
+
+  void printMap(raw_ostream &OS, const UpdateMapType &M) const {
+    for (auto Pair : M)
+      for (auto Child : Pair.second) {
+        OS << "(";
+        Pair.first->printAsOperand(OS, false);
+        OS << ", ";
+        Child->printAsOperand(OS, false);
+        OS << ") ";
+      }
+    OS << "\n";
+  }
+
+public:
+  GraphDiff() {}
+  GraphDiff(ArrayRef<cfg::Update<NodePtr>> Updates, bool InverseGraph = false) {
+    SmallVector<cfg::Update<NodePtr>, 4> LegalizedUpdates;
+    cfg::LegalizeUpdates<NodePtr>(Updates, LegalizedUpdates, InverseGraph);
+    for (auto U : LegalizedUpdates) {
+      if (U.getKind() == cfg::UpdateKind::Insert) {
+        SuccInsert[U.getFrom()].push_back(U.getTo());
+        PredInsert[U.getTo()].push_back(U.getFrom());
+      } else {
+        SuccDelete[U.getFrom()].push_back(U.getTo());
+        PredDelete[U.getTo()].push_back(U.getFrom());
+      }
+    }
+  }
+
+  bool ignoreChild(const NodePtr BB, NodePtr EdgeEnd, bool InverseEdge,
+                   bool InverseGraph) const {
+    auto &DeleteChildren =
+        (InverseEdge != InverseGraph) ? PredDelete : SuccDelete;
+    auto It = DeleteChildren.find(BB);
+    if (It == DeleteChildren.end())
+      return false;
+    auto &EdgesForBB = It->second;
+    return llvm::find(EdgesForBB, EdgeEnd) != EdgesForBB.end();
+  }
+
+  iterator_range<typename SmallVectorImpl<NodePtr>::const_iterator>
+  getAddedChildren(const NodePtr BB, bool InverseEdge,
+                   bool InverseGraph) const {
+    auto &InsertChildren =
+        (InverseEdge != InverseGraph) ? PredInsert : SuccInsert;
+    auto It = InsertChildren.find(BB);
+    if (It == InsertChildren.end())
+      return make_range(Empty.begin(), Empty.end());
+    return make_range(It->second.begin(), It->second.end());
+  }
+
+  void print(raw_ostream &OS) const {
+    OS << "===== GraphDiff: CFG edge changes to create a CFG snapshot. \n"
+          "===== (Note: notion of children/inverse_children depends on "
+          "the direction of edges and the graph.)\n";
+    OS << "Children to insert:\n\t";
+    printMap(OS, SuccInsert);
+    OS << "Children to delete:\n\t";
+    printMap(OS, SuccDelete);
+    OS << "Inverse_children to insert:\n\t";
+    printMap(OS, PredInsert);
+    OS << "Inverse_children to delete:\n\t";
+    printMap(OS, PredDelete);
+    OS << "\n";
+  }
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
+#endif
+};
+
+template <bool InverseGraph = false> struct CFGViewSuccessors {
+  using DataRef = const GraphDiff<BasicBlock *> *;
+  using NodeRef = std::pair<DataRef, BasicBlock *>;
+
+  using ExistingChildIterator =
+      WrappedPairNodeDataIterator<succ_iterator, NodeRef, DataRef>;
+  struct DeletedEdgesFilter {
+    BasicBlock *BB;
+    DeletedEdgesFilter(BasicBlock *BB) : BB(BB){};
+    bool operator()(NodeRef N) const {
+      return !N.first->ignoreChild(BB, N.second, false, InverseGraph);
+    }
+  };
+  using FilterExistingChildrenIterator =
+      filter_iterator<ExistingChildIterator, DeletedEdgesFilter>;
+
+  using vec_iterator = SmallVectorImpl<BasicBlock *>::const_iterator;
+  using AddNewChildrenIterator =
+      WrappedPairNodeDataIterator<vec_iterator, NodeRef, DataRef>;
+  using ChildIteratorType =
+      concat_iterator<NodeRef, FilterExistingChildrenIterator,
+                      AddNewChildrenIterator>;
+
+  static ChildIteratorType child_begin(NodeRef N) {
+    auto InsertVec = N.first->getAddedChildren(N.second, false, InverseGraph);
+    // filter iterator init:
+    auto firstit = make_filter_range(
+        make_range<ExistingChildIterator>({succ_begin(N.second), N.first},
+                                          {succ_end(N.second), N.first}),
+        DeletedEdgesFilter(N.second));
+    // new inserts iterator init:
+    auto secondit = make_range<AddNewChildrenIterator>(
+        {InsertVec.begin(), N.first}, {InsertVec.end(), N.first});
+
+    return concat_iterator<NodeRef, FilterExistingChildrenIterator,
+                           AddNewChildrenIterator>(firstit, secondit);
+  }
+
+  static ChildIteratorType child_end(NodeRef N) {
+    auto InsertVec = N.first->getAddedChildren(N.second, false, InverseGraph);
+    // filter iterator init:
+    auto firstit = make_filter_range(
+        make_range<ExistingChildIterator>({succ_end(N.second), N.first},
+                                          {succ_end(N.second), N.first}),
+        DeletedEdgesFilter(N.second));
+    // new inserts iterator init:
+    auto secondit = make_range<AddNewChildrenIterator>(
+        {InsertVec.end(), N.first}, {InsertVec.end(), N.first});
+
+    return concat_iterator<NodeRef, FilterExistingChildrenIterator,
+                           AddNewChildrenIterator>(firstit, secondit);
+  }
+};
+
+template <bool InverseGraph = false> struct CFGViewPredecessors {
+  using DataRef = const GraphDiff<BasicBlock *> *;
+  using NodeRef = std::pair<DataRef, BasicBlock *>;
+
+  using ExistingChildIterator =
+      WrappedPairNodeDataIterator<pred_iterator, NodeRef, DataRef>;
+  struct DeletedEdgesFilter {
+    BasicBlock *BB;
+    DeletedEdgesFilter(BasicBlock *BB) : BB(BB){};
+    bool operator()(NodeRef N) const {
+      return !N.first->ignoreChild(BB, N.second, true, InverseGraph);
+    }
+  };
+  using FilterExistingChildrenIterator =
+      filter_iterator<ExistingChildIterator, DeletedEdgesFilter>;
+
+  using vec_iterator = SmallVectorImpl<BasicBlock *>::const_iterator;
+  using AddNewChildrenIterator =
+      WrappedPairNodeDataIterator<vec_iterator, NodeRef, DataRef>;
+  using ChildIteratorType =
+      concat_iterator<NodeRef, FilterExistingChildrenIterator,
+                      AddNewChildrenIterator>;
+
+  static ChildIteratorType child_begin(NodeRef N) {
+    auto InsertVec = N.first->getAddedChildren(N.second, true, InverseGraph);
+    // filter iterator init:
+    auto firstit = make_filter_range(
+        make_range<ExistingChildIterator>({pred_begin(N.second), N.first},
+                                          {pred_end(N.second), N.first}),
+        DeletedEdgesFilter(N.second));
+    // new inserts iterator init:
+    auto secondit = make_range<AddNewChildrenIterator>(
+        {InsertVec.begin(), N.first}, {InsertVec.end(), N.first});
+
+    return concat_iterator<NodeRef, FilterExistingChildrenIterator,
+                           AddNewChildrenIterator>(firstit, secondit);
+  }
+
+  static ChildIteratorType child_end(NodeRef N) {
+    auto InsertVec = N.first->getAddedChildren(N.second, true, InverseGraph);
+    // filter iterator init:
+    auto firstit = make_filter_range(
+        make_range<ExistingChildIterator>({pred_end(N.second), N.first},
+                                          {pred_end(N.second), N.first}),
+        DeletedEdgesFilter(N.second));
+    // new inserts iterator init:
+    auto secondit = make_range<AddNewChildrenIterator>(
+        {InsertVec.end(), N.first}, {InsertVec.end(), N.first});
+
+    return concat_iterator<NodeRef, FilterExistingChildrenIterator,
+                           AddNewChildrenIterator>(firstit, secondit);
+  }
+};
+
+template <>
+struct GraphTraits<std::pair<const GraphDiff<BasicBlock *> *, BasicBlock *>>
+    : CFGViewSuccessors<false> {};
+template <>
+struct GraphTraits<
+    std::pair<const GraphDiff<Inverse<BasicBlock *>> *, BasicBlock *>>
+    : CFGViewSuccessors<true> {};
+template <>
+struct GraphTraits<
+    std::pair<const GraphDiff<BasicBlock *> *, Inverse<BasicBlock *>>>
+    : CFGViewPredecessors<false> {};
+template <>
+struct GraphTraits<
+    std::pair<const GraphDiff<Inverse<BasicBlock *>> *, Inverse<BasicBlock *>>>
+    : CFGViewPredecessors<true> {};
+} // end namespace llvm
+
+#endif // LLVM_IR_CFGDIFF_H

llvm/trunk/include/llvm/Support/CFGUpdate.h

+//===- CFGUpdate.h - Encode a CFG Edge Update. ------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a CFG Edge Update: Insert or Delete, and two Nodes as the
+// Edge ends.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_CFGUPDATE_H
+#define LLVM_SUPPORT_CFGUPDATE_H
+
+#include "llvm/Support/Debug.h"
+
+namespace llvm {
+namespace cfg {
+enum class UpdateKind : unsigned char { Insert, Delete };
+
+template <typename NodePtr> class Update {
+  using NodeKindPair = PointerIntPair<NodePtr, 1, UpdateKind>;
+  NodePtr From;
+  NodeKindPair ToAndKind;
+
+public:
+  Update(UpdateKind Kind, NodePtr From, NodePtr To)
+      : From(From), ToAndKind(To, Kind) {}
+
+  UpdateKind getKind() const { return ToAndKind.getInt(); }
+  NodePtr getFrom() const { return From; }
+  NodePtr getTo() const { return ToAndKind.getPointer(); }
+  bool operator==(const Update &RHS) const {
+    return From == RHS.From && ToAndKind == RHS.ToAndKind;
+  }
+
+  void print(raw_ostream &OS) const {
+    OS << (getKind() == UpdateKind::Insert ? "Insert " : "Delete ");
+    getFrom()->printAsOperand(OS, false);
+    OS << " -> ";
+    getTo()->printAsOperand(OS, false);
+  }
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
+#endif
+};
+
+// LegalizeUpdates function simplifies updates assuming a graph structure.
+// This function serves double purpose:
+// a) It removes redundant updates, which makes it easier to reverse-apply
+//    them when traversing CFG.
+// b) It optimizes away updates that cancel each other out, as the end result
+//    is the same.
+template <typename NodePtr>
+void LegalizeUpdates(ArrayRef<Update<NodePtr>> AllUpdates,
+                     SmallVectorImpl<Update<NodePtr>> &Result,
+                     bool InverseGraph) {
+  // Count the total number of inserions of each edge.
+  // Each insertion adds 1 and deletion subtracts 1. The end number should be
+  // one of {-1 (deletion), 0 (NOP), +1 (insertion)}. Otherwise, the sequence
+  // of updates contains multiple updates of the same kind and we assert for
+  // that case.
+  SmallDenseMap<std::pair<NodePtr, NodePtr>, int, 4> Operations;
+  Operations.reserve(AllUpdates.size());
+
+  for (const auto &U : AllUpdates) {
+    NodePtr From = U.getFrom();
+    NodePtr To = U.getTo();
+    if (InverseGraph)
+      std::swap(From, To); // Reverse edge for postdominators.
+
+    Operations[{From, To}] += (U.getKind() == UpdateKind::Insert ? 1 : -1);
+  }
+
+  Result.clear();
+  Result.reserve(Operations.size());
+  for (auto &Op : Operations) {
+    const int NumInsertions = Op.second;
+    assert(std::abs(NumInsertions) <= 1 && "Unbalanced operations!");
+    if (NumInsertions == 0)
+      continue;
+    const UpdateKind UK =
+        NumInsertions > 0 ? UpdateKind::Insert : UpdateKind::Delete;
+    Result.push_back({UK, Op.first.first, Op.first.second});
+  }
+
+  // Make the order consistent by not relying on pointer values within the
+  // set. Reuse the old Operations map.
+  // In the future, we should sort by something else to minimize the amount
+  // of work needed to perform the series of updates.
+  for (size_t i = 0, e = AllUpdates.size(); i != e; ++i) {
+    const auto &U = AllUpdates[i];
+    if (!InverseGraph)
+      Operations[{U.getFrom(), U.getTo()}] = int(i);
+    else
+      Operations[{U.getTo(), U.getFrom()}] = int(i);
+  }
+
+  llvm::sort(Result.begin(), Result.end(),
+             [&Operations](const Update<NodePtr> &A, const Update<NodePtr> &B) {
+               return Operations[{A.getFrom(), A.getTo()}] >
+                      Operations[{B.getFrom(), B.getTo()}];
+             });
+}
+
+} // end namespace cfg
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_CFGUPDATE_H