Implement the two constructors in InsertValueInst and ExtractValueInst.

Add a Name argment to two init methods in these classes as well to make things
a bit more consistent.

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

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 80a4b60206fcb2664f8e578304866420ed33b68b..0b9aba94926b3a5be2094c51b313ffb372017a14 100644 (file)
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -1458,8 +1458,8 @@ class ExtractValueInst : public Instruction {
   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(Value *Agg, const unsigned *Idx, unsigned NumIdx, const std::string &Name);
+  void init(Value *Agg, unsigned Idx, const std::string &Name);
 
   template<typename InputIterator>
   void init(Value *Agg, InputIterator IdxBegin, InputIterator IdxEnd,
@@ -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(Agg, &*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
@@ -1667,8 +1665,8 @@ 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 +1684,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

diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 656a51b0549d167c6a2e765775057eda67b00c0d..6da04e7178f99051949ecb48352e6bbc47ac0b79 100644 (file)
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -1350,21 +1350,24 @@ int ShuffleVectorInst::getMaskValue(unsigned i) const {
 //                             InsertValueInst Class
 //===----------------------------------------------------------------------===//
 
-void InsertValueInst::init(Value *Agg, Value *Val,
-                           const unsigned *Idx, unsigned NumIdx) {
+void InsertValueInst::init(Value *Agg, Value *Val, const unsigned *Idx, 
+                           unsigned NumIdx, const std::string &Name) {
   assert(NumOperands == 2 && "NumOperands not initialized?");
   Op<0>() = Agg;
   Op<1>() = Val;
 
   Indices.insert(Indices.end(), Idx, Idx + NumIdx);
+  setName(Name);
 }
 
-void InsertValueInst::init(Value *Agg, Value *Val, unsigned Idx) {
+void InsertValueInst::init(Value *Agg, Value *Val, unsigned Idx, 
+                           const std::string &Name) {
   assert(NumOperands == 2 && "NumOperands not initialized?");
   Op<0>() = Agg;
   Op<1>() = Val;
 
   Indices.push_back(Idx);
+  setName(Name);
 }
 
 InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
@@ -1373,22 +1376,46 @@ InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
     Indices(IVI.Indices) {
 }
 
+InsertValueInst::InsertValueInst(Value *Agg,
+                                 Value *Val,
+                                 unsigned Idx, 
+                                 const std::string &Name,
+                                 Instruction *InsertBefore)
+  : Instruction(Agg->getType(), InsertValue,
+                OperandTraits<InsertValueInst>::op_begin(this),
+                2, InsertBefore) {
+  init(Agg, Val, Idx, Name);
+}
+
+InsertValueInst::InsertValueInst(Value *Agg,
+                                 Value *Val,
+                                 unsigned Idx, 
+                                 const std::string &Name,
+                                 BasicBlock *InsertAtEnd)
+  : Instruction(Agg->getType(), InsertValue,
+                OperandTraits<InsertValueInst>::op_begin(this),
+                2, InsertAtEnd) {
+  init(Agg, Val, Idx, Name);
+}
+
 //===----------------------------------------------------------------------===//
 //                             ExtractValueInst Class
 //===----------------------------------------------------------------------===//
 
-void ExtractValueInst::init(Value *Agg, const unsigned *Idx, unsigned NumIdx) {
+void ExtractValueInst::init(Value *Agg, const unsigned *Idx, unsigned NumIdx, const std::string &Name) {
   assert(NumOperands == 1 && "NumOperands not initialized?");
   Op<0>() = Agg;
 
   Indices.insert(Indices.end(), Idx, Idx + NumIdx);
+  setName(Name);
 }
 
-void ExtractValueInst::init(Value *Agg, unsigned Idx) {
+void ExtractValueInst::init(Value *Agg, unsigned Idx, const std::string &Name) {
   assert(NumOperands == 1 && "NumOperands not initialized?");
   Op<0>() = Agg;
 
   Indices.push_back(Idx);
+  setName(Name);
 }
 
 ExtractValueInst::ExtractValueInst(const ExtractValueInst &EVI)
@@ -1424,6 +1451,28 @@ const Type* ExtractValueInst::getIndexedType(const Type *Agg,
   return CurIdx == NumIdx ? Agg : 0;
 }
 
+ExtractValueInst::ExtractValueInst(Value *Agg,
+                                   unsigned Idx,
+                                   const std::string &Name,
+                                   BasicBlock *InsertAtEnd)
+  : Instruction(checkType(getIndexedType(Agg->getType(), &Idx, 1)),
+                ExtractValue,
+                OperandTraits<ExtractValueInst>::op_begin(this),
+                1, InsertAtEnd) {
+  init(Agg, Idx, Name);
+}
+
+ExtractValueInst::ExtractValueInst(Value *Agg,
+                                   unsigned Idx,
+                                   const std::string &Name,
+                                   Instruction *InsertBefore)
+  : Instruction(checkType(getIndexedType(Agg->getType(), &Idx, 1)),
+                ExtractValue,
+                OperandTraits<ExtractValueInst>::op_begin(this),
+                1, InsertBefore) {
+  init(Agg, Idx, Name);
+}
+
 //===----------------------------------------------------------------------===//
 //                             BinaryOperator Class
 //===----------------------------------------------------------------------===//