Add iterator and iterator range to PredIteratorCache

[• dberlin]

Summary

This lets us use range based for loops, and generally makes the interface much closer to
normal pred iterators.

[• dberlin]

Update to make interface more consistent with normal pred interface

[dblaikie]

Looks reasonable.

Optional: Rather than having range access as a free function and begin/end as member functions, I'd be inclined to put them at the same level, or possibly even go without begin/end entirely and just have:

PredCache.predecessors(BB);

(or s/predecessors/cached_predecessors/ - though of course both names are somewhat redundant with the name of the object... - maybe it should just be PredCache.get(BB); or something? )

[• dberlin]

The redundancy is why i made it a free function, but happy to make it
a member function.

The liklihood we would ever have cached_predecessors(something else) seems low.
:)

I don't see any loops that use begin()/end(), so i'll delete them for now.

I'll make cached_predecessors a member function named get, and if we
find a use for begin/end later, we can add them then.

include/llvm/IR/PredIteratorCache.h

 //===- PredIteratorCache.h - pred_iterator Cache ----------------*- 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 the PredIteratorCache class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_PREDITERATORCACHE_H
 #define LLVM_IR_PREDITERATORCACHE_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/Support/Allocator.h"
 
 namespace llvm {
 
   /// PredIteratorCache - This class is an extremely trivial cache for
   /// predecessor iterator queries.  This is useful for code that repeatedly
   /// wants the predecessor list for the same blocks.
   class PredIteratorCache {
     /// BlockToPredsMap - Pointer to null-terminated list.
     DenseMap<BasicBlock*, BasicBlock**> BlockToPredsMap;
     DenseMap<BasicBlock*, unsigned> BlockToPredCountMap;
 
     /// Memory - This is the space that holds cached preds.
     BumpPtrAllocator Memory;
   public:
+    ArrayRef<BasicBlock *>::iterator begin(BasicBlock *BB) {
+      return makeArrayRef(GetPreds(BB), GetNumPreds(BB)).begin();
+    }
+
+    ArrayRef<BasicBlock *>::iterator end(BasicBlock *BB) {
+      return makeArrayRef(GetPreds(BB), GetNumPreds(BB)).end();
+    }
 
     /// GetPreds - Get a cached list for the null-terminated predecessor list of
     /// the specified block.  This can be used in a loop like this:
     ///   for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI)
     ///      use(*PI);
     /// instead of:
     /// for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
     BasicBlock **GetPreds(BasicBlock *BB) {
public:
 
     /// clear - Remove all information.
     void clear() {
       BlockToPredsMap.clear();
       BlockToPredCountMap.clear();
       Memory.Reset();
     }
   };
+
+  iterator_range<ArrayRef<BasicBlock *>::iterator>
+  cached_predecessors(PredIteratorCache &PC, BasicBlock *BB) {
+    return make_range(PC.begin(BB), PC.end(BB));
+  }
+
 } // end namespace llvm
 
 #endif