[loop-region] Track the backedges of all loop regions.

We already computed this information so this is just storing information
we were already computing.

One thing to note is that in code with canonicalized loops, we will
always only have one backedge. But we would like loop region to be
correct even in the case of non-canonicalized code so we support having
multiple back edges. But since the common case is 1 backedge, we
optimize for that case.

This commit contains updated tests and also updates to the loop region graph
viewer so that it draws backedges as green arrows from the loop to its backedge
subregions. The test updates were done by examining each test case by hand.

Author: gottesmm

include/swift/SILOptimizer/Analysis/LoopRegionAnalysis.h

@@ -131,7 +131,9 @@
 namespace swift {
 
 /// A loop region is a data structure which represents one of a basic block,
-/// loop, or function. In the case of a loop, function, it contains an internal
+/// loop, or function.
+///
+/// In the case of a loop, function, it contains an internal
 /// data structure that represents the subregions of the loop/function. This
 /// data is tail allocated so that the basic block case is not penalized by
 /// storing this unnecessary information.
@@ -319,6 +321,66 @@ class LoopRegion {
   };
   using subregion_reverse_iterator = std::reverse_iterator<subregion_iterator>;
 
+  /// An iterator that knows how to iterate over the backedge indices of a
+  /// region.
+  class backedge_iterator
+      : public std::iterator<std::bidirectional_iterator_tag, unsigned> {
+    friend struct SubregionData;
+    using InnerIterTy = llvm::SmallVectorImpl<unsigned>::const_iterator;
+    llvm::Optional<InnerIterTy> InnerIter;
+
+    backedge_iterator(llvm::SmallVectorImpl<unsigned>::const_iterator iter)
+        : InnerIter(iter) {}
+
+  public:
+    using value_type = unsigned;
+    using reference = unsigned;
+    using pointer = void;
+    using iterator_category = std::bidirectional_iterator_tag;
+    using difference_type = int;
+
+    /// Construct a backedge_iterator suitable for use with a basic block. It
+    /// does not contain any data and can only be compared against another
+    /// invalid iterator (for which it will return true). Any other usage
+    /// results in an unreachable being hit.
+    backedge_iterator() : InnerIter() {}
+
+    bool hasValue() const { return InnerIter.hasValue(); }
+
+    /// Return the index of the current backedge index.
+    unsigned operator*() const { return **InnerIter; }
+
+    backedge_iterator &operator++() {
+      ++(*InnerIter);
+      return *this;
+    }
+    backedge_iterator operator++(int) {
+      backedge_iterator iter = *this;
+      ++iter;
+      return iter;
+    }
+    backedge_iterator &operator--() {
+      --(*InnerIter);
+      return *this;
+    }
+    backedge_iterator operator--(int) {
+      backedge_iterator iter = *this;
+      --iter;
+      return iter;
+    }
+    bool operator==(backedge_iterator rhs) const {
+      if (InnerIter.hasValue() != rhs.InnerIter.hasValue())
+        llvm_unreachable("Comparing uncomparable iterators");
+      // Now we know that the two either both have values or both do not have
+      // values.
+      if (!InnerIter.hasValue())
+        return true;
+      return *InnerIter == *rhs.InnerIter;
+    }
+    bool operator!=(backedge_iterator rhs) const { return !(*this == rhs); }
+  };
+  using backedge_reverse_iterator = std::reverse_iterator<backedge_iterator>;
+
 private:
   /// A pointer to one of a Loop, Basic Block, or Function represented by this
   /// region.
@@ -383,6 +445,13 @@ class LoopRegion {
     /// used as the RPO number for the whole region.
     unsigned RPONumOfHeaderBlock;
 
+    /// The RPO number of the back edge blocks of this loop. We use a
+    /// SmallVector of size 1 since after loop canonicalization we will always
+    /// have exactly one back edge block. But we want to be correct even in a
+    /// non-canonicalized case implying that we need to be able to support
+    /// multiple backedge blocks.
+    llvm::SmallVector<unsigned, 1> BackedgeRegions;
+
     /// A list of subregion IDs of this region sorted in RPO order.
     ///
     /// This takes advantage of the fact that the ID of a basic block is the
@@ -430,6 +499,29 @@ class LoopRegion {
       Subloops.push_back({Header->ID, L->ID});
     }
 
+    void addBackedgeSubregion(unsigned ID) {
+      if (count(BackedgeRegions, ID))
+        return;
+      BackedgeRegions.push_back(ID);
+    }
+
+    backedge_iterator backedge_begin() const {
+      return backedge_iterator(BackedgeRegions.begin());
+    }
+    backedge_iterator backedge_end() const {
+      return backedge_iterator(BackedgeRegions.end());
+    }
+    backedge_reverse_iterator backedge_rbegin() const {
+      return backedge_reverse_iterator(backedge_begin());
+    }
+    backedge_reverse_iterator backedge_rend() const {
+      return backedge_reverse_iterator(backedge_end());
+    }
+    bool backedge_empty() const { return BackedgeRegions.empty(); }
+    unsigned backedge_size() const { return BackedgeRegions.size(); }
+
+    ArrayRef<unsigned> getBackedgeRegions() const { return BackedgeRegions; }
+
     /// Once we finish processing a loop, we sort its subregions so that they
     /// are guaranteed to be in RPO order. This works because each BB's ID is
     /// its RPO number and we represent loops by the RPO number of their
@@ -441,7 +533,6 @@ class LoopRegion {
     /// going to sort just to be careful while bringing this up.
     void sortSubregions() { std::sort(Subregions.begin(), Subregions.end()); }
   };
-
 public:
   ~LoopRegion();
 
@@ -476,21 +567,34 @@ class LoopRegion {
     return getSubregionData().end();
   }
 
-  bool subregions_empty() const { return getSubregionData().empty(); }
-  unsigned subregions_size() const { return getSubregionData().size(); }
+  bool subregions_empty() const {
+    if (isBlock())
+      return true;
+    return getSubregionData().empty();
+  }
+
+  unsigned subregions_size() const {
+    if (isBlock())
+      return 0;
+    return getSubregionData().size();
+  }
+
   subregion_reverse_iterator subregion_rbegin() const {
     if (isBlock())
       return subregion_reverse_iterator();
     return getSubregionData().rbegin();
   }
+
   subregion_reverse_iterator subregion_rend() const {
     if (isBlock())
       return subregion_reverse_iterator();
     return getSubregionData().rend();
   }
+
   llvm::iterator_range<subregion_iterator> getSubregions() const {
     return {subregion_begin(), subregion_end()};
   }
+
   llvm::iterator_range<subregion_reverse_iterator>
   getReverseSubregions() const {
     return {subregion_rbegin(), subregion_rend()};
@@ -510,6 +614,50 @@ class LoopRegion {
     return getSubregionData().ExitingSubregions;
   }
 
+  bool isBackedgeRegion(unsigned ID) const {
+    if (isBlock())
+      return false;
+    return count(getSubregionData().getBackedgeRegions(), ID);
+  }
+
+  ArrayRef<unsigned> getBackedgeRegions() const {
+    if (isBlock())
+      return ArrayRef<unsigned>();
+    return getSubregionData().getBackedgeRegions();
+  }
+
+  Optional<unsigned> getBackedgeRegion() const {
+    if (isBlock())
+      return None;
+    auto bedge_begin = getSubregionData().backedge_begin();
+    auto bedge_end = getSubregionData().backedge_end();
+    if (bedge_begin == bedge_end)
+      return None;
+    return *bedge_begin;
+  }
+
+  using backedge_iterator = backedge_iterator;
+  backedge_iterator backedge_begin() const {
+    if (isBlock())
+      return backedge_iterator();
+    return getSubregionData().backedge_begin();
+  }
+  backedge_iterator backedge_end() const {
+    if (isBlock())
+      return backedge_iterator();
+    return getSubregionData().backedge_end();
+  }
+  bool backedge_empty() const {
+    if (isBlock())
+      return true;
+    return getSubregionData().backedge_empty();
+  }
+  unsigned backedge_size() const {
+    if (isBlock())
+      return 0;
+    return getSubregionData().backedge_size();
+  }
+
   using pred_const_iterator = decltype(Preds)::const_iterator;
   pred_const_iterator pred_begin() const { return Preds.begin(); }
   pred_const_iterator pred_end() const { return Preds.end(); }
@@ -781,9 +929,16 @@ class LoopRegionFunctionInfo {
     return IDToRegionMap[RegionID];
   }
 
-  RegionTy *getRegionForNonLocalSuccessor(const LoopRegion *Child,
+  RegionTy *getRegionForNonLocalSuccessor(const RegionTy *Child,
                                           unsigned SuccID) const;
 
+  Optional<unsigned> getGrandparentID(const RegionTy *GrandChild) {
+    if (auto ParentID = GrandChild->getParentID()) {
+      return getRegion(*ParentID)->getParentID();
+    }
+    return None;
+  }
+
   /// Look up the region associated with this block and return it. Asserts if
   /// the block does not have a region associated with it.
   ///