Remove two convenience constructors because they're now private, and the

[oota-llvm.git] / include / llvm / Instructions.h

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 80a4b60206fcb2664f8e578304866420ed33b68b..f9e0a2e5ce1fabb02e81adc0fce9b67309c117c6 100644 (file)
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -379,8 +379,9 @@ static inline const Type *checkType(const Type *Ty) {
 ///
 class GetElementPtrInst : public Instruction {
   GetElementPtrInst(const GetElementPtrInst &GEPI);
-  void init(Value *Ptr, Value* const *Idx, unsigned NumIdx);
-  void init(Value *Ptr, Value *Idx);
+  void init(Value *Ptr, Value* const *Idx, unsigned NumIdx,
+            const std::string &Name);
+  void init(Value *Ptr, Value *Idx, const std::string &Name);
 
   template<typename InputIterator>
   void init(Value *Ptr, InputIterator IdxBegin, InputIterator IdxEnd,
@@ -392,14 +393,12 @@ class GetElementPtrInst : public Instruction {
     
     if (NumIdx > 0) {
       // This requires that the iterator points to contiguous memory.
-      init(Ptr, &*IdxBegin, NumIdx); // FIXME: for the general case
+      init(Ptr, &*IdxBegin, NumIdx, Name); // FIXME: for the general case
                                      // we have to build an array here
     }
     else {
-      init(Ptr, 0, NumIdx);
+      init(Ptr, 0, NumIdx, Name);
     }
-
-    setName(Name);
   }
 
   /// getIndexedType - Returns the type of the element that would be loaded with
@@ -1454,15 +1453,16 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
 /// ExtractValueInst - This instruction extracts a struct member or array
 /// element value from an aggregate value.
 ///
-class ExtractValueInst : public Instruction {
+class ExtractValueInst : public UnaryInstruction {
   SmallVector<unsigned, 4> Indices;
 
   ExtractValueInst(const ExtractValueInst &EVI);
-  void init(Value *Agg, const unsigned *Idx, unsigned NumIdx);
-  void init(Value *Agg, unsigned Idx);
+  void init(const unsigned *Idx, unsigned NumIdx,
+            const std::string &Name);
+  void init(unsigned Idx, const std::string &Name);
 
   template<typename InputIterator>
-  void init(Value *Agg, InputIterator IdxBegin, InputIterator IdxEnd,
+  void init(InputIterator IdxBegin, InputIterator IdxEnd,
             const std::string &Name,
             // This argument ensures that we have an iterator we can
             // do arithmetic on in constant time
@@ -1476,10 +1476,8 @@ class ExtractValueInst : public Instruction {
     assert(NumIdx > 0 && "ExtractValueInst must have at least one index");
 
     // This requires that the iterator points to contiguous memory.
-    init(Agg, &*IdxBegin, NumIdx); // FIXME: for the general case
-                                   // we have to build an array here
-
-    setName(Name);
+    init(&*IdxBegin, NumIdx, Name); // FIXME: for the general case
+                                         // we have to build an array here
   }
 
   /// getIndexedType - Returns the type of the element that would be extracted
@@ -1503,7 +1501,7 @@ class ExtractValueInst : public Instruction {
 
     if (NumIdx > 0)
       // This requires that the iterator points to contiguous memory.
-      return getIndexedType(Ptr, (const unsigned *)&*IdxBegin, NumIdx);
+      return getIndexedType(Ptr, &*IdxBegin, NumIdx);
     else
       return getIndexedType(Ptr, (const unsigned *)0, NumIdx);
   }
@@ -1522,18 +1520,12 @@ class ExtractValueInst : public Instruction {
                           InputIterator IdxBegin, InputIterator IdxEnd,
                           const std::string &Name, BasicBlock *InsertAtEnd);
 
-  /// Constructors - These two constructors are convenience methods because one
-  /// and two index extractvalue instructions are so common.
-  ExtractValueInst(Value *Agg, unsigned Idx, const std::string &Name = "",
-                    Instruction *InsertBefore = 0);
-  ExtractValueInst(Value *Agg, unsigned Idx,
-                    const std::string &Name, BasicBlock *InsertAtEnd);
-public:
   // allocate space for exactly one operand
   void *operator new(size_t s) {
     return User::operator new(s, 1);
   }
 
+public:
   template<typename InputIterator>
   static ExtractValueInst *Create(Value *Agg, InputIterator IdxBegin, 
                                   InputIterator IdxEnd,
@@ -1556,19 +1548,18 @@ public:
   static ExtractValueInst *Create(Value *Agg, unsigned Idx,
                                   const std::string &Name = "",
                                   Instruction *InsertBefore = 0) {
-    return new ExtractValueInst(Agg, Idx, Name, InsertBefore);
+    unsigned Idxs[1] = { Idx };
+    return new ExtractValueInst(Agg, Idxs, Idxs + 1, Name, InsertBefore);
   }
   static ExtractValueInst *Create(Value *Agg, unsigned Idx,
                                   const std::string &Name,
                                   BasicBlock *InsertAtEnd) {
-    return new ExtractValueInst(Agg, Idx, Name, InsertAtEnd);
+    unsigned Idxs[1] = { Idx };
+    return new ExtractValueInst(Agg, Idxs, Idxs + 1, Name, InsertAtEnd);
   }
 
   virtual ExtractValueInst *clone() const;
 
-  /// Transparently provide more efficient getOperand methods.
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
-
   // getType - Overload to return most specific pointer type...
   const PointerType *getType() const {
     return reinterpret_cast<const PointerType*>(Instruction::getType());
@@ -1590,8 +1581,9 @@ public:
   }  
   static const Type *getIndexedType(const Type *Ptr, unsigned Idx);
 
-  inline const unsigned *idx_begin() const { return Indices.begin(); }
-  inline const unsigned *idx_end()   const { return Indices.end(); }
+  typedef const unsigned* idx_iterator;
+  inline idx_iterator idx_begin() const { return Indices.begin(); }
+  inline idx_iterator idx_end()   const { return Indices.end(); }
 
   Value *getAggregateOperand() {
     return getOperand(0);
@@ -1604,7 +1596,7 @@ public:
   }
 
   unsigned getNumIndices() const {  // Note: always non-negative
-    return Indices.size();
+    return (unsigned)Indices.size();
   }
 
   bool hasIndices() const {
@@ -1621,21 +1613,16 @@ public:
   }
 };
 
-template <>
-struct OperandTraits<ExtractValueInst> : FixedNumOperandTraits<1> {
-};
-
 template<typename InputIterator>
 ExtractValueInst::ExtractValueInst(Value *Agg,
                                    InputIterator IdxBegin, 
                                    InputIterator IdxEnd,
                                    const std::string &Name,
                                    Instruction *InsertBefore)
-  : Instruction(checkType(getIndexedType(Agg->getType(), IdxBegin, IdxEnd)),
-                ExtractValue,
-                OperandTraits<ExtractValueInst>::op_begin(this),
-                1, InsertBefore) {
-  init(Agg, IdxBegin, IdxEnd, Name,
+  : UnaryInstruction(checkType(getIndexedType(Agg->getType(),
+                                             IdxBegin, IdxEnd)),
+                    ExtractValue, Agg, InsertBefore) {
+  init(IdxBegin, IdxEnd, Name,
        typename std::iterator_traits<InputIterator>::iterator_category());
 }
 template<typename InputIterator>
@@ -1644,16 +1631,13 @@ ExtractValueInst::ExtractValueInst(Value *Agg,
                                    InputIterator IdxEnd,
                                    const std::string &Name,
                                    BasicBlock *InsertAtEnd)
-  : Instruction(checkType(getIndexedType(Agg->getType(), IdxBegin, IdxEnd)),
-                ExtractValue,
-                OperandTraits<ExtractValueInst>::op_begin(this),
-                1, InsertAtEnd) {
-  init(Agg, IdxBegin, IdxEnd, Name,
+  : UnaryInstruction(checkType(getIndexedType(Agg->getType(),
+                                             IdxBegin, IdxEnd)),
+                    ExtractValue, Agg, InsertAtEnd) {
+  init(IdxBegin, IdxEnd, Name,
        typename std::iterator_traits<InputIterator>::iterator_category());
 }
 
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractValueInst, Value)
-
 
 //===----------------------------------------------------------------------===//
 //                                InsertValueInst Class
@@ -1667,8 +1651,9 @@ class InsertValueInst : public Instruction {
 
   void *operator new(size_t, unsigned); // Do not implement
   InsertValueInst(const InsertValueInst &IVI);
-  void init(Value *Agg, Value *Val, const unsigned *Idx, unsigned NumIdx);
-  void init(Value *Agg, Value *Val, unsigned Idx);
+  void init(Value *Agg, Value *Val, const unsigned *Idx, unsigned NumIdx,
+            const std::string &Name);
+  void init(Value *Agg, Value *Val, unsigned Idx, const std::string &Name);
 
   template<typename InputIterator>
   void init(Value *Agg, Value *Val,
@@ -1686,10 +1671,8 @@ class InsertValueInst : public Instruction {
     assert(NumIdx > 0 && "InsertValueInst must have at least one index");
 
     // This requires that the iterator points to contiguous memory.
-    init(Agg, Val, &*IdxBegin, NumIdx); // FIXME: for the general case
-                                        // we have to build an array here
-
-    setName(Name);
+    init(Agg, Val, &*IdxBegin, NumIdx, Name); // FIXME: for the general case
+                                              // we have to build an array here
   }
 
   /// Constructors - Create a insertvalue instruction with a base aggregate
@@ -1720,7 +1703,7 @@ public:
   }
 
   template<typename InputIterator>
-  static InsertValueInst *Create(Value *Agg, Value *Val, InputIterator IdxBegin, 
+  static InsertValueInst *Create(Value *Agg, Value *Val, InputIterator IdxBegin,
                                  InputIterator IdxEnd,
                                  const std::string &Name = "",
                                  Instruction *InsertBefore = 0) {
@@ -1760,8 +1743,9 @@ public:
     return reinterpret_cast<const PointerType*>(Instruction::getType());
   }
 
-  inline const unsigned *idx_begin() const { return Indices.begin(); }
-  inline const unsigned *idx_end()   const { return Indices.end(); }
+  typedef const unsigned* idx_iterator;
+  inline idx_iterator idx_begin() const { return Indices.begin(); }
+  inline idx_iterator idx_end()   const { return Indices.end(); }
 
   Value *getAggregateOperand() {
     return getOperand(0);
@@ -1784,7 +1768,7 @@ public:
   }
 
   unsigned getNumIndices() const {  // Note: always non-negative
-    return Indices.size();
+    return (unsigned)Indices.size();
   }
 
   bool hasIndices() const {