Rename DIExpressionIterator to DIExpression::iterator.

[opencl/llvm.git] / include / llvm / IR / DebugInfo.h

diff --git a/include/llvm/IR/DebugInfo.h b/include/llvm/IR/DebugInfo.h
index 459e15761930e9822be32ed7cf68a95284755947..ebdd32682393f750c97b1462b36c39b9b1e9f752 100644 (file)
--- a/include/llvm/IR/DebugInfo.h
+++ b/include/llvm/IR/DebugInfo.h
@@ -66,7 +66,7 @@ class DIHeaderFieldIterator
 
 public:
   DIHeaderFieldIterator() {}
-  DIHeaderFieldIterator(StringRef Header)
+  explicit DIHeaderFieldIterator(StringRef Header)
       : Header(Header), Current(Header.slice(0, Header.find('\0'))) {}
   StringRef operator*() const { return Current; }
   const StringRef * operator->() const { return &Current; }
@@ -99,6 +99,16 @@ public:
     return Header.slice(Current.end() - Header.begin() + 1, StringRef::npos);
   }
 
+  /// \brief Get the current field as a number.
+  ///
+  /// Convert the current field into a number.  Return \c 0 on error.
+  template <class T> T getNumber() const {
+    T Int;
+    if (getCurrent().getAsInteger(0, Int))
+      return 0;
+    return Int;
+  }
+
 private:
   void increment() {
     assert(Current.data() != nullptr && "Cannot increment past the end");
@@ -190,20 +200,26 @@ public:
                          DIHeaderFieldIterator());
   }
 
-  StringRef getHeaderField(unsigned Index) const {
+  DIHeaderFieldIterator header_begin() const {
+    return DIHeaderFieldIterator(getHeader());
+  }
+  DIHeaderFieldIterator header_end() const { return DIHeaderFieldIterator(); }
+
+  DIHeaderFieldIterator getHeaderIterator(unsigned Index) const {
     // Since callers expect an empty string for out-of-range accesses, we can't
     // use std::advance() here.
-    for (DIHeaderFieldIterator I(getHeader()), E; I != E; ++I, --Index)
+    for (auto I = header_begin(), E = header_end(); I != E; ++I, --Index)
       if (!Index)
-        return *I;
-    return StringRef();
+        return I;
+    return header_end();
+  }
+
+  StringRef getHeaderField(unsigned Index) const {
+    return *getHeaderIterator(Index);
   }
 
   template <class T> T getHeaderFieldAs(unsigned Index) const {
-    T Int;
-    if (getHeaderField(Index).getAsInteger(0, Int))
-      return 0;
-    return Int;
+    return getHeaderIterator(Index).getNumber<T>();
   }
 
   uint16_t getTag() const { return getHeaderFieldAs<uint16_t>(0); }
@@ -381,7 +397,7 @@ template <> DITypeRef DIDescriptor::getFieldAs<DITypeRef>(unsigned Elt) const;
 /// \brief Specialize DIRef constructor for DITypeRef.
 template <> DIRef<DIType>::DIRef(const Metadata *V);
 
-/// \briefThis is a wrapper for a type.
+/// \brief This is a wrapper for a type.
 ///
 /// FIXME: Types should be factored much better so that CV qualifiers and
 /// others do not require a huge and empty descriptor full of zeros.
@@ -834,8 +850,6 @@ public:
   void printExtendedName(raw_ostream &OS) const;
 };
 
-class DIExpressionIterator;
-
 /// \brief A complex location expression.
 class DIExpression : public DIDescriptor {
   friend class DIDescriptor;
@@ -865,62 +879,55 @@ public:
   /// \brief Return the size of this piece in bytes.
   uint64_t getPieceSize() const;
 
-  DIExpressionIterator begin() const;
-  DIExpressionIterator end() const;
-};
-
-/// \brief An iterator for DIExpression elments.
-class DIExpressionIterator
-    : public std::iterator<std::forward_iterator_tag, StringRef, unsigned,
-                           const uint64_t *, uint64_t> {
-  DIHeaderFieldIterator I;
-  DIExpressionIterator(DIHeaderFieldIterator I) : I(I) {}
-public:
-  DIExpressionIterator() {}
-  DIExpressionIterator(const DIExpression Expr)
-    : I(Expr.getHeader()) { ++I; }
-  uint64_t operator*() const {
-    uint64_t UInt;
-    if (I->getAsInteger(0, UInt))
-      return 0;
-    return UInt;
-  }
-  DIExpressionIterator &operator++() {
-    increment();
-    return *this;
-  }
-  DIExpressionIterator operator++(int) {
-    DIExpressionIterator X(*this);
-    increment();
-    return X;
-  }
-  bool operator==(const DIExpressionIterator &X) const {
-    return I == X.I;
-  }
-  bool operator!=(const DIExpressionIterator &X) const {
-    return !(*this == X);
-  }
-
-  uint64_t getArg(unsigned N) const {
-    auto In = I;
-    std::advance(In, N);
-    return *DIExpressionIterator(In);
-  }
-
-  const DIHeaderFieldIterator& getBase() const { return I; }
-
-private:
-  void increment() {
-    switch (**this) {
-    case dwarf::DW_OP_piece: std::advance(I, 3); break;
-    case dwarf::DW_OP_plus:  std::advance(I, 2); break;
-    case dwarf::DW_OP_deref: std::advance(I, 1); break;
-    default:
-      assert("unsupported operand");
+  /// \brief An iterator for DIExpression elements.
+  class iterator
+      : public std::iterator<std::forward_iterator_tag, StringRef, unsigned,
+                             const uint64_t *, uint64_t> {
+    DIHeaderFieldIterator I;
+    iterator(DIHeaderFieldIterator I) : I(I) {}
+  public:
+    iterator() {}
+    iterator(const DIExpression &Expr) : I(++Expr.header_begin()) {}
+    uint64_t operator*() const { return I.getNumber<uint64_t>(); }
+    iterator &operator++() {
+      increment();
+      return *this;
     }
-  }
-};
+    iterator operator++(int) {
+      iterator X(*this);
+      increment();
+      return X;
+    }
+    bool operator==(const iterator &X) const {
+      return I == X.I;
+    }
+    bool operator!=(const iterator &X) const {
+      return !(*this == X);
+    }
+   
+    uint64_t getArg(unsigned N) const {
+      auto In = I;
+      std::advance(In, N);
+      return In.getNumber<uint64_t>();
+    }
+   
+    const DIHeaderFieldIterator& getBase() const { return I; }
+   
+  private:
+    void increment() {
+      switch (**this) {
+      case dwarf::DW_OP_piece: std::advance(I, 3); break;
+      case dwarf::DW_OP_plus:  std::advance(I, 2); break;
+      case dwarf::DW_OP_deref: std::advance(I, 1); break;
+      default:
+        assert("unsupported operand");
+      }
+    }
+  };
 
+  iterator begin() const;
+  iterator end() const;
+};
 
 /// \brief This object holds location information.
 ///