[C++11] Add range based accessors for the Use-Def chain of a Value.

This requires a number of steps.
1) Move value_use_iterator into the Value class as an implementation
   detail
2) Change it to actually be a *Use* iterator rather than a *User*
   iterator.
3) Add an adaptor which is a User iterator that always looks through the
   Use to the User.
4) Wrap these in Value::use_iterator and Value::user_iterator typedefs.
5) Add the range adaptors as Value::uses() and Value::users().
6) Update *all* of the callers to correctly distinguish between whether
   they wanted a use_iterator (and to explicitly dig out the User when
   needed), or a user_iterator which makes the Use itself totally
   opaque.

Because #6 requires churning essentially everything that walked the
Use-Def chains, I went ahead and added all of the range adaptors and
switched them to range-based loops where appropriate. Also because the
renaming requires at least churning every line of code, it didn't make
any sense to split these up into multiple commits -- all of which would
touch all of the same lies of code.

The result is still not quite optimal. The Value::use_iterator is a nice
regular iterator, but Value::user_iterator is an iterator over User*s
rather than over the User objects themselves. As a consequence, it fits
a bit awkwardly into the range-based world and it has the weird
extra-dereferencing 'operator->' that so many of our iterators have.
I think this could be fixed by providing something which transforms
a range of T&s into a range of T*s, but that *can* be separated into
another patch, and it isn't yet 100% clear whether this is the right
move.

However, this change gets us most of the benefit and cleans up
a substantial amount of code around Use and User. =]

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@203364 91177308-0d34-0410-b5e6-96231b3b80d8

Author: chandlerc

include/llvm/IR/CFG.h

@@ -44,10 +44,10 @@ class PredIterator : public std::iterator<std::forward_iterator_tag,
   typedef typename super::reference reference;
 
   PredIterator() {}
-  explicit inline PredIterator(Ptr *bb) : It(bb->use_begin()) {
+  explicit inline PredIterator(Ptr *bb) : It(bb->user_begin()) {
     advancePastNonTerminators();
   }
-  inline PredIterator(Ptr *bb, bool) : It(bb->use_end()) {}
+  inline PredIterator(Ptr *bb, bool) : It(bb->user_end()) {}
 
   inline bool operator==(const Self& x) const { return It == x.It; }
   inline bool operator!=(const Self& x) const { return !operator==(x); }
@@ -81,9 +81,9 @@ class PredIterator : public std::iterator<std::forward_iterator_tag,
   }
 };
 
-typedef PredIterator<BasicBlock, Value::use_iterator> pred_iterator;
+typedef PredIterator<BasicBlock, Value::user_iterator> pred_iterator;
 typedef PredIterator<const BasicBlock,
-                     Value::const_use_iterator> const_pred_iterator;
+                     Value::const_user_iterator> const_pred_iterator;
 
 inline pred_iterator pred_begin(BasicBlock *BB) { return pred_iterator(BB); }
 inline const_pred_iterator pred_begin(const BasicBlock *BB) {

include/llvm/IR/CallSite.h

@@ -103,11 +103,13 @@ class CallSiteBase {
 
   /// isCallee - Determine whether the passed iterator points to the
   /// callee operand's Use.
-  ///
-  bool isCallee(Value::const_use_iterator UI) const {
-    return getCallee() == &UI.getUse();
+  bool isCallee(Value::const_user_iterator UI) const {
+    return isCallee(&UI.getUse());
   }
 
+  /// Determine whether this Use is the callee operand's Use.
+  bool isCallee(const Use *U) const { return getCallee() == U; }
+
   ValTy *getArgument(unsigned ArgNo) const {
     assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
     return *(arg_begin() + ArgNo);
@@ -121,11 +123,17 @@ class CallSiteBase {
 
   /// Given a value use iterator, returns the argument that corresponds to it.
   /// Iterator must actually correspond to an argument.
-  unsigned getArgumentNo(Value::const_use_iterator I) const {
+  unsigned getArgumentNo(Value::const_user_iterator I) const {
+    return getArgumentNo(&I.getUse());
+  }
+
+  /// Given a use for an argument, get the argument number that corresponds to
+  /// it.
+  unsigned getArgumentNo(const Use *U) const {
     assert(getInstruction() && "Not a call or invoke instruction!");
-    assert(arg_begin() <= &I.getUse() && &I.getUse() < arg_end()
+    assert(arg_begin() <= U && U < arg_end()
            && "Argument # out of range!");
-    return &I.getUse() - arg_begin();
+    return U - arg_begin();
   }
 
   /// arg_iterator - The type of iterator to use when looping over actual

include/llvm/IR/Instruction.h

@@ -45,10 +45,10 @@ class Instruction : public User, public ilist_node<Instruction> {
   // Out of line virtual method, so the vtable, etc has a home.
   ~Instruction();
 
-  /// use_back - Specialize the methods defined in Value, as we know that an
+  /// user_back - Specialize the methods defined in Value, as we know that an
   /// instruction can only be used by other instructions.
-  Instruction       *use_back()       { return cast<Instruction>(*use_begin());}
-  const Instruction *use_back() const { return cast<Instruction>(*use_begin());}
+  Instruction       *user_back()       { return cast<Instruction>(*user_begin());}
+  const Instruction *user_back() const { return cast<Instruction>(*user_begin());}
 
   inline const BasicBlock *getParent() const { return Parent; }
   inline       BasicBlock *getParent()       { return Parent; }

include/llvm/IR/Instructions.h

@@ -2100,7 +2100,7 @@ class PHINode : public Instruction {
   /// getIncomingBlock - Return incoming basic block corresponding
   /// to value use iterator.
   ///
-  BasicBlock *getIncomingBlock(Value::const_use_iterator I) const {
+  BasicBlock *getIncomingBlock(Value::const_user_iterator I) const {
     return getIncomingBlock(I.getUse());
   }
 

include/llvm/IR/Value.h

@@ -15,6 +15,7 @@
 #define LLVM_IR_VALUE_H
 
 #include "llvm-c/Core.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Use.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
@@ -75,13 +76,54 @@ class Value {
   unsigned char SubclassOptionalData : 7;
 
 private:
+  template <typename UseT> // UseT == 'Use' or 'const Use'
+  class use_iterator_impl
+      : public std::iterator<std::forward_iterator_tag, UseT *, ptrdiff_t> {
+    typedef std::iterator<std::forward_iterator_tag, UseT *, ptrdiff_t> super;
+
+    UseT *U;
+    explicit use_iterator_impl(UseT *u) : U(u) {}
+    friend class Value;
+
+  public:
+    typedef typename super::reference reference;
+    typedef typename super::pointer pointer;
+
+    use_iterator_impl() : U() {}
+
+    bool operator==(const use_iterator_impl &x) const { return U == x.U; }
+    bool operator!=(const use_iterator_impl &x) const { return !operator==(x); }
+
+    use_iterator_impl &operator++() { // Preincrement
+      assert(U && "Cannot increment end iterator!");
+      U = U->getNext();
+      return *this;
+    }
+    use_iterator_impl operator++(int) { // Postincrement
+      auto tmp = *this;
+      ++*this;
+      return tmp;
+    }
+
+    UseT &operator*() const {
+      assert(U && "Cannot dereference end iterator!");
+      return *U;
+    }
+
+    UseT *operator->() const { return &operator*(); }
+
+    operator use_iterator_impl<const UseT>() const {
+      return use_iterator_impl<const UseT>(U);
+    }
+  };
+
   template <typename UserTy> // UserTy == 'User' or 'const User'
   class user_iterator_impl
       : public std::iterator<std::forward_iterator_tag, UserTy *, ptrdiff_t> {
     typedef std::iterator<std::forward_iterator_tag, UserTy *, ptrdiff_t> super;
 
-    Use *U;
-    explicit user_iterator_impl(Use *u) : U(u) {}
+    use_iterator_impl<Use> UI;
+    explicit user_iterator_impl(Use *U) : UI(U) {}
     friend class Value;
 
   public:
@@ -90,16 +132,14 @@ class Value {
 
     user_iterator_impl() {}
 
-    bool operator==(const user_iterator_impl &x) const { return U == x.U; }
+    bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }
     bool operator!=(const user_iterator_impl &x) const { return !operator==(x); }
 
-    /// \brief Returns true if this iterator is equal to use_end() on the value.
-    bool atEnd() const { return U == 0; }
+    /// \brief Returns true if this iterator is equal to user_end() on the value.
+    bool atEnd() const { return *this == user_iterator_impl(); }
 
-    // Iterator traversal: forward iteration only
     user_iterator_impl &operator++() { // Preincrement
-      assert(U && "Cannot increment end iterator!");
-      U = U->getNext();
+      ++UI;
       return *this;
     }
     user_iterator_impl operator++(int) { // Postincrement
@@ -110,21 +150,20 @@ class Value {
 
     // Retrieve a pointer to the current User.
     UserTy *operator*() const {
-      assert(U && "Cannot dereference end iterator!");
-      return U->getUser();
+      return UI->getUser();
     }
 
     UserTy *operator->() const { return operator*(); }
 
     operator user_iterator_impl<const UserTy>() const {
-      return user_iterator_impl<const UserTy>(U);
+      return user_iterator_impl<const UserTy>(*UI);
     }
 
-    Use &getUse() const { return *U; }
+    Use &getUse() const { return *UI; }
 
     /// \brief Return the operand # of this use in its User.
     /// FIXME: Replace all callers with a direct call to Use::getOperandNo.
-    unsigned getOperandNo() const { return U->getOperandNo(); }
+    unsigned getOperandNo() const { return UI->getOperandNo(); }
   };
 
   /// SubclassData - This member is defined by this class, but is not used for
@@ -205,14 +244,33 @@ class Value {
   //
   bool               use_empty() const { return UseList == 0; }
 
-  typedef user_iterator_impl<User>       use_iterator;
-  typedef user_iterator_impl<const User> const_use_iterator;
+  typedef use_iterator_impl<Use>       use_iterator;
+  typedef use_iterator_impl<const Use> const_use_iterator;
   use_iterator       use_begin()       { return use_iterator(UseList); }
   const_use_iterator use_begin() const { return const_use_iterator(UseList); }
-  use_iterator       use_end()         { return use_iterator(0);   }
-  const_use_iterator use_end()   const { return const_use_iterator(0);   }
-  User               *use_back()        { return *use_begin(); }
-  const User         *use_back()  const { return *use_begin(); }
+  use_iterator       use_end()         { return use_iterator();   }
+  const_use_iterator use_end()   const { return const_use_iterator();   }
+  iterator_range<use_iterator> uses() {
+    return iterator_range<use_iterator>(use_begin(), use_end());
+  }
+  iterator_range<const_use_iterator> uses() const {
+    return iterator_range<const_use_iterator>(use_begin(), use_end());
+  }
+
+  typedef user_iterator_impl<User>       user_iterator;
+  typedef user_iterator_impl<const User> const_user_iterator;
+  user_iterator       user_begin()       { return user_iterator(UseList); }
+  const_user_iterator user_begin() const { return const_user_iterator(UseList); }
+  user_iterator       user_end()         { return user_iterator();   }
+  const_user_iterator user_end()   const { return const_user_iterator();   }
+  User               *user_back()        { return *user_begin(); }
+  const User         *user_back()  const { return *user_begin(); }
+  iterator_range<user_iterator> users() {
+    return iterator_range<user_iterator>(user_begin(), user_end());
+  }
+  iterator_range<const_user_iterator> users() const {
+    return iterator_range<const_user_iterator>(user_begin(), user_end());
+  }
 
   /// hasOneUse - Return true if there is exactly one user of this value.  This
   /// is specialized because it is a common request and does not require

lib/Analysis/CaptureTracking.cpp

@@ -85,17 +85,15 @@ void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker) {
   SmallSet<const Use *, Threshold> Visited;
   int Count = 0;
 
-  for (Value::const_use_iterator UI = V->use_begin(), UE = V->use_end();
-       UI != UE; ++UI) {
+  for (const Use &U : V->uses()) {
     // If there are lots of uses, conservatively say that the value
     // is captured to avoid taking too much compile time.
     if (Count++ >= Threshold)
       return Tracker->tooManyUses();
 
-    Use *U = &UI.getUse();
-    if (!Tracker->shouldExplore(U)) continue;
-    Visited.insert(U);
-    Worklist.push_back(U);
+    if (!Tracker->shouldExplore(&U)) continue;
+    Visited.insert(&U);
+    Worklist.push_back(&U);
   }
 
   while (!Worklist.empty()) {
@@ -148,17 +146,15 @@ void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker) {
     case Instruction::AddrSpaceCast:
       // The original value is not captured via this if the new value isn't.
       Count = 0;
-      for (Instruction::use_iterator UI = I->use_begin(), UE = I->use_end();
-           UI != UE; ++UI) {
+      for (Use &UU : I->uses()) {
         // If there are lots of uses, conservatively say that the value
         // is captured to avoid taking too much compile time.
         if (Count++ >= Threshold)
           return Tracker->tooManyUses();
 
-        Use *U = &UI.getUse();
-        if (Visited.insert(U))
-          if (Tracker->shouldExplore(U))
-            Worklist.push_back(U);
+        if (Visited.insert(&UU))
+          if (Tracker->shouldExplore(&UU))
+            Worklist.push_back(&UU);
       }
       break;
     case Instruction::ICmp:

lib/Analysis/IPA/GlobalsModRef.cpp

@@ -252,33 +252,33 @@ bool GlobalsModRef::AnalyzeUsesOfPointer(Value *V,
                                          GlobalValue *OkayStoreDest) {
   if (!V->getType()->isPointerTy()) return true;
 
-  for (Value::use_iterator UI = V->use_begin(), E=V->use_end(); UI != E; ++UI) {
-    User *U = *UI;
-    if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
+  for (Use &U : V->uses()) {
+    User *I = U.getUser();
+    if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
       Readers.push_back(LI->getParent()->getParent());
-    } else if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
+    } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
       if (V == SI->getOperand(1)) {
         Writers.push_back(SI->getParent()->getParent());
       } else if (SI->getOperand(1) != OkayStoreDest) {
         return true;  // Storing the pointer
       }
-    } else if (Operator::getOpcode(U) == Instruction::GetElementPtr) {
-      if (AnalyzeUsesOfPointer(U, Readers, Writers))
+    } else if (Operator::getOpcode(I) == Instruction::GetElementPtr) {
+      if (AnalyzeUsesOfPointer(I, Readers, Writers))
         return true;
-    } else if (Operator::getOpcode(U) == Instruction::BitCast) {
-      if (AnalyzeUsesOfPointer(U, Readers, Writers, OkayStoreDest))
+    } else if (Operator::getOpcode(I) == Instruction::BitCast) {
+      if (AnalyzeUsesOfPointer(I, Readers, Writers, OkayStoreDest))
         return true;
-    } else if (CallSite CS = U) {
+    } else if (CallSite CS = I) {
       // Make sure that this is just the function being called, not that it is
       // passing into the function.
-      if (!CS.isCallee(UI)) {
+      if (!CS.isCallee(&U)) {
         // Detect calls to free.
-        if (isFreeCall(U, TLI))
+        if (isFreeCall(I, TLI))
           Writers.push_back(CS->getParent()->getParent());
         else
           return true; // Argument of an unknown call.
       }
-    } else if (ICmpInst *ICI = dyn_cast<ICmpInst>(U)) {
+    } else if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) {
       if (!isa<ConstantPointerNull>(ICI->getOperand(1)))
         return true;  // Allow comparison against null.
     } else {
@@ -303,8 +303,7 @@ bool GlobalsModRef::AnalyzeIndirectGlobalMemory(GlobalValue *GV) {
 
   // Walk the user list of the global.  If we find anything other than a direct
   // load or store, bail out.
-  for (Value::use_iterator I = GV->use_begin(), E = GV->use_end(); I != E; ++I){
-    User *U = *I;
+  for (User *U : GV->users()) {
     if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
       // The pointer loaded from the global can only be used in simple ways:
       // we allow addressing of it and loading storing to it.  We do *not* allow

lib/Analysis/IPA/InlineCost.cpp

@@ -1052,9 +1052,8 @@ bool CallAnalyzer::analyzeCall(CallSite CS) {
 
   Function *Caller = CS.getInstruction()->getParent()->getParent();
   // Check if the caller function is recursive itself.
-  for (Value::use_iterator U = Caller->use_begin(), E = Caller->use_end();
-       U != E; ++U) {
-    CallSite Site(cast<Value>(*U));
+  for (User *U : Caller->users()) {
+    CallSite Site(U);
     if (!Site)
       continue;
     Instruction *I = Site.getInstruction();

lib/Analysis/IVUsers.cpp

@@ -142,9 +142,8 @@ bool IVUsers::AddUsersImpl(Instruction *I,
     return false;
 
   SmallPtrSet<Instruction *, 4> UniqueUsers;
-  for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
-       UI != E; ++UI) {
-    Instruction *User = cast<Instruction>(*UI);
+  for (Use &U : I->uses()) {
+    Instruction *User = cast<Instruction>(U.getUser());
     if (!UniqueUsers.insert(User))
       continue;
 
@@ -157,7 +156,7 @@ bool IVUsers::AddUsersImpl(Instruction *I,
     BasicBlock *UseBB = User->getParent();
     // A phi's use is live out of its predecessor block.
     if (PHINode *PHI = dyn_cast<PHINode>(User)) {
-      unsigned OperandNo = UI.getOperandNo();
+      unsigned OperandNo = U.getOperandNo();
       unsigned ValNo = PHINode::getIncomingValueNumForOperand(OperandNo);
       UseBB = PHI->getIncomingBlock(ValNo);
     }

lib/Analysis/InstructionSimplify.cpp

@@ -3200,10 +3200,9 @@ static bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV,
   // If we have an explicit value to collapse to, do that round of the
   // simplification loop by hand initially.
   if (SimpleV) {
-    for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE;
-         ++UI)
-      if (*UI != I)
-        Worklist.insert(cast<Instruction>(*UI));
+    for (User *U : I->users())
+      if (U != I)
+        Worklist.insert(cast<Instruction>(U));
 
     // Replace the instruction with its simplified value.
     I->replaceAllUsesWith(SimpleV);
@@ -3230,9 +3229,8 @@ static bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV,
     // Stash away all the uses of the old instruction so we can check them for
     // recursive simplifications after a RAUW. This is cheaper than checking all
     // uses of To on the recursive step in most cases.
-    for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE;
-         ++UI)
-      Worklist.insert(cast<Instruction>(*UI));
+    for (User *U : I->users())
+      Worklist.insert(cast<Instruction>(U));
 
     // Replace the instruction with its simplified value.
     I->replaceAllUsesWith(SimpleV);