Add function for testing string attributes to InvokeInst and CallSite. NFC.

[oota-llvm.git] / include / llvm / Analysis / IntervalIterator.h

diff --git a/include/llvm/Analysis/IntervalIterator.h b/include/llvm/Analysis/IntervalIterator.h
index 333f289ee1b75e51ddbc28f5d05e850165faa414..655ce2dab4138d212c17cbc8d23bb56a15261de2 100644 (file)
--- a/include/llvm/Analysis/IntervalIterator.h
+++ b/include/llvm/Analysis/IntervalIterator.h
@@ -34,8 +34,8 @@
 #define LLVM_ANALYSIS_INTERVALITERATOR_H
 
 #include "llvm/Analysis/IntervalPartition.h"
+#include "llvm/IR/CFG.h"
 #include "llvm/IR/Function.h"
-#include "llvm/Support/CFG.h"
 #include <algorithm>
 #include <set>
 #include <vector>
@@ -78,7 +78,7 @@ inline void addNodeToInterval(Interval *Int, BasicBlock *BB) {
 //
 inline void addNodeToInterval(Interval *Int, Interval *I) {
   // Add all of the nodes in I as new nodes in Int.
-  copy(I->Nodes.begin(), I->Nodes.end(), back_inserter(Int->Nodes));
+  Int->Nodes.insert(Int->Nodes.end(), I->Nodes.begin(), I->Nodes.end());
 }
 
 
@@ -94,7 +94,6 @@ class IntervalIterator {
   bool IOwnMem;     // If True, delete intervals when done with them
                     // See file header for conditions of use
 public:
-  typedef IntervalIterator<NodeTy, OrigContainer_t> _Self;
   typedef std::forward_iterator_tag iterator_category;
 
   IntervalIterator() {} // End iterator, empty stack
@@ -105,6 +104,12 @@ public:
     }
   }
 
+  IntervalIterator(IntervalIterator &&x)
+      : IntStack(std::move(x.IntStack)), Visited(std::move(x.Visited)),
+        OrigContainer(x.OrigContainer), IOwnMem(x.IOwnMem) {
+    x.IOwnMem = false;
+  }
+
   IntervalIterator(IntervalPartition &IP, bool OwnMemory) : IOwnMem(OwnMemory) {
     OrigContainer = &IP;
     if (!ProcessInterval(IP.getRootInterval())) {
@@ -112,7 +117,7 @@ public:
     }
   }
 
-  inline ~IntervalIterator() {
+  ~IntervalIterator() {
     if (IOwnMem)
       while (!IntStack.empty()) {
         delete operator*();
@@ -120,15 +125,17 @@ public:
       }
   }
 
-  inline bool operator==(const _Self& x) const { return IntStack == x.IntStack;}
-  inline bool operator!=(const _Self& x) const { return !operator==(x); }
+  bool operator==(const IntervalIterator &x) const {
+    return IntStack == x.IntStack;
+  }
+  bool operator!=(const IntervalIterator &x) const { return !(*this == x); }
 
-  inline const Interval *operator*() const { return IntStack.back().first; }
-  inline       Interval *operator*()       { return IntStack.back().first; }
-  inline const Interval *operator->() const { return operator*(); }
-  inline       Interval *operator->()       { return operator*(); }
+  const Interval *operator*() const { return IntStack.back().first; }
+  Interval *operator*() { return IntStack.back().first; }
+  const Interval *operator->() const { return operator*(); }
+  Interval *operator->() { return operator*(); }
 
-  _Self& operator++() {  // Preincrement
+  IntervalIterator &operator++() { // Preincrement
     assert(!IntStack.empty() && "Attempting to use interval iterator at end!");
     do {
       // All of the intervals on the stack have been visited.  Try visiting
@@ -150,14 +157,16 @@ public:
 
     return *this;
   }
-  inline _Self operator++(int) { // Postincrement
-    _Self tmp = *this; ++*this; return tmp;
+  IntervalIterator operator++(int) { // Postincrement
+    IntervalIterator tmp = *this;
+    ++*this;
+    return tmp;
   }
 
 private:
   // ProcessInterval - This method is used during the construction of the
   // interval graph.  It walks through the source graph, recursively creating
-  // an interval per invokation until the entire graph is covered.  This uses
+  // an interval per invocation until the entire graph is covered.  This uses
   // the ProcessNode method to add all of the nodes to the interval.
   //
   // This method is templated because it may operate on two different source
@@ -165,10 +174,10 @@ private:
   //
   bool ProcessInterval(NodeTy *Node) {
     BasicBlock *Header = getNodeHeader(Node);
-    if (Visited.count(Header)) return false;
+    if (!Visited.insert(Header).second)
+      return false;
 
     Interval *Int = new Interval(Header);
-    Visited.insert(Header);   // The header has now been visited!
 
     // Check all of our successors to see if they are in the interval...
     for (typename GT::ChildIteratorType I = GT::child_begin(Node),