Refactor common initialization code in private init() functions.

This is a first step in supplying append to basic block constructors
for all instruction types.


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

include/llvm/InstrTypes.h

@@ -32,9 +32,13 @@ protected:
   TerminatorInst(Instruction::TermOps iType, Instruction *InsertBefore = 0);
   TerminatorInst(const Type *Ty, Instruction::TermOps iType,
                  const std::string &Name = "", Instruction *InsertBefore = 0)
-    : Instruction(Ty, iType, Name, InsertBefore) {
-  }
+    : Instruction(Ty, iType, Name, InsertBefore) {}
+
   TerminatorInst(Instruction::TermOps iType, BasicBlock *InsertAtEnd);
+  TerminatorInst(const Type *Ty, Instruction::TermOps iType,
+                 const std::string &Name, BasicBlock *InsertAtEnd)
+    : Instruction(Ty, iType, Name, InsertAtEnd) {}
+
 public:
 
   /// Terminators must implement the methods required by Instruction...

include/llvm/Instruction.h

@@ -36,11 +36,15 @@ class Instruction : public User, public Annotable {
   friend class SymbolTableListTraits<Instruction, BasicBlock, Function,
                                      ilist_traits<Instruction> >;
   void setParent(BasicBlock *P);
+  void init();
+
 protected:
   unsigned iType;      // InstructionType: The opcode of the instruction
 
   Instruction(const Type *Ty, unsigned iType, const std::string &Name = "",
               Instruction *InsertBefore = 0);
+  Instruction(const Type *Ty, unsigned iType, const std::string &Name,
+              BasicBlock *InsertAtEnd);
 public:
 
   ~Instruction() {

include/llvm/iMemory.h

@@ -163,6 +163,10 @@ class LoadInst : public Instruction {
     Operands.push_back(Use(LI.Operands[0], this));
   }
   bool Volatile;   // True if this is a volatile load
+  void init(Value *Ptr) {
+    Operands.reserve(1);
+    Operands.push_back(Use(Ptr, this));
+  }
 public:
   LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
   LoadInst(Value *Ptr, const std::string &Name = "", bool isVolatile = false,
@@ -210,6 +214,11 @@ class StoreInst : public Instruction {
     Operands.push_back(Use(SI.Operands[1], this));
   }
   bool Volatile;   // True if this is a volatile store
+  void init(Value *Val, Value *Ptr) {
+    Operands.reserve(2);
+    Operands.push_back(Use(Val, this));
+    Operands.push_back(Use(Ptr, this));
+  }
 public:
   StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
@@ -258,6 +267,8 @@ class GetElementPtrInst : public Instruction {
     for (unsigned i = 0, E = EPI.Operands.size(); i != E; ++i)
       Operands.push_back(Use(EPI.Operands[i], this));
   }
+  void init(Value *Ptr, const std::vector<Value*> &Idx);
+
 public:
   GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
 		    const std::string &Name = "", Instruction *InsertBefore =0);

include/llvm/iTerminators.h

@@ -32,6 +32,14 @@ class ReturnInst : public TerminatorInst {
       Operands.push_back(Use(RI.Operands[0], this));
     }
   }
+
+  void init(Value *RetVal) {
+    if (RetVal) {
+      Operands.reserve(1);
+      Operands.push_back(Use(RetVal, this));
+    }
+  }
+
 public:
   // ReturnInst constructors:
   // ReturnInst()                  - 'ret void' instruction
@@ -42,17 +50,11 @@ public:
   // ReturnInst(Value* X, BB *B)   - 'ret X'    instruction, insert @ end of BB
   ReturnInst(Value *RetVal = 0, Instruction *InsertBefore = 0)
     : TerminatorInst(Instruction::Ret, InsertBefore) {
-    if (RetVal) {
-      Operands.reserve(1);
-      Operands.push_back(Use(RetVal, this));
-    }
+    init(RetVal);
   }
   ReturnInst(Value *RetVal, BasicBlock *InsertAtEnd)
     : TerminatorInst(Instruction::Ret, InsertAtEnd) {
-    if (RetVal) {
-      Operands.reserve(1);
-      Operands.push_back(Use(RetVal, this));
-    }
+    init(RetVal);
   }
 
   virtual Instruction *clone() const { return new ReturnInst(*this); }
@@ -87,6 +89,8 @@ public:
 ///
 class BranchInst : public TerminatorInst {
   BranchInst(const BranchInst &BI);
+  void init(BasicBlock *IfTrue);
+  void init(BasicBlock *True, BasicBlock *False, Value *Cond);
 public:
   // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
   // BranchInst(BB *B)                           - 'br B'
@@ -161,6 +165,8 @@ class SwitchInst : public TerminatorInst {
   // Operand[2n  ] = Value to match
   // Operand[2n+1] = BasicBlock to go to on match
   SwitchInst(const SwitchInst &RI);
+  void init(Value *Value, BasicBlock *Default);
+
 public:
   SwitchInst(Value *Value, BasicBlock *Default, Instruction *InsertBefore = 0);
   SwitchInst(Value *Value, BasicBlock *Default, BasicBlock  *InsertAtEnd);
@@ -259,6 +265,8 @@ public:
 ///
 class InvokeInst : public TerminatorInst {
   InvokeInst(const InvokeInst &BI);
+  void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
+            const std::vector<Value*> &Params);
 public:
   InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
 	     const std::vector<Value*> &Params, const std::string &Name = "",

lib/VMCore/InstrTypes.cpp

@@ -29,8 +29,7 @@ TerminatorInst::TerminatorInst(Instruction::TermOps iType, Instruction *IB)
 }
 
 TerminatorInst::TerminatorInst(Instruction::TermOps iType, BasicBlock *IAE)
-  : Instruction(Type::VoidTy, iType) {
-  if (IAE) IAE->getInstList().push_back(this);
+  : Instruction(Type::VoidTy, iType, "", IAE) {
 }
 
 

lib/VMCore/Instruction.cpp

@@ -17,14 +17,18 @@
 #include "Support/LeakDetector.h"
 using namespace llvm;
 
-Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name,
-                         Instruction *InsertBefore)
-  : User(ty, Value::InstructionVal, Name) {
-  Parent = 0;
-  iType = it;
-
+void Instruction::init()
+{
   // Make sure that we get added to a basicblock
   LeakDetector::addGarbageObject(this);
+}
+
+Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name,
+                         Instruction *InsertBefore)
+  : User(ty, Value::InstructionVal, Name),
+    Parent(0),
+    iType(it) {
+  init();
 
   // If requested, insert this instruction into a basic block...
   if (InsertBefore) {
@@ -34,6 +38,18 @@ Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name,
   }
 }
 
+Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name,
+                         BasicBlock *InsertAtEnd)
+  : User(ty, Value::InstructionVal, Name),
+    Parent(0),
+    iType(it) {
+  init();
+
+  // append this instruction into the basic block
+  assert(InsertAtEnd && "Basic block to append to may not be NULL!");
+  InsertAtEnd->getInstList().push_back(this);
+}
+
 void Instruction::setParent(BasicBlock *P) {
   if (getParent()) {
     if (!P) LeakDetector::addGarbageObject(this);

lib/VMCore/iBranch.cpp

@@ -28,52 +28,45 @@ void UnwindInst::setSuccessor(unsigned idx, BasicBlock *NewSucc) {
   assert(0 && "UnwindInst has no successors!");
 }
 
-BranchInst::BranchInst(BasicBlock *True, BasicBlock *False, Value *Cond,
-                       Instruction *InsertBefore) 
-  : TerminatorInst(Instruction::Br, InsertBefore) {
-  assert(True != 0 && "True branch destination may not be null!!!");
-  Operands.reserve(False ? 3 : 1);
-  Operands.push_back(Use(True, this));
-  if (False) {
-    Operands.push_back(Use(False, this));
+void BranchInst::init(BasicBlock *IfTrue)
+{
+  assert(IfTrue != 0 && "Branch destination may not be null!");
+  Operands.reserve(1);
+  Operands.push_back(Use(IfTrue, this));
+}
+
+void BranchInst::init(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond)
+{
+  assert(IfTrue && IfFalse && Cond &&
+         "Branch destinations and condition may not be null!");
+  assert(Cond && Cond->getType() == Type::BoolTy && 
+         "May only branch on boolean predicates!");
+  Operands.reserve(3);
+  Operands.push_back(Use(IfTrue, this));
+  Operands.push_back(Use(IfFalse, this));
   Operands.push_back(Use(Cond, this));
 }
 
-  assert(!!False == !!Cond &&
-	 "Either both cond and false or neither can be specified!");
-  assert((Cond == 0 || Cond->getType() == Type::BoolTy) && 
-         "May only branch on boolean predicates!!!!");
+BranchInst::BranchInst(BasicBlock *True, BasicBlock *False, Value *Cond,
+                       Instruction *InsertBefore) 
+  : TerminatorInst(Instruction::Br, InsertBefore) {
+  init(True, False, Cond);
 }
 
 BranchInst::BranchInst(BasicBlock *True, BasicBlock *False, Value *Cond,
                        BasicBlock *InsertAtEnd) 
   : TerminatorInst(Instruction::Br, InsertAtEnd) {
-  assert(True != 0 && "True branch destination may not be null!!!");
-  Operands.reserve(False ? 3 : 1);
-  Operands.push_back(Use(True, this));
-  if (False) {
-    Operands.push_back(Use(False, this));
-    Operands.push_back(Use(Cond, this));
-  }
-
-  assert(!!False == !!Cond &&
-	 "Either both cond and false or neither can be specified!");
-  assert((Cond == 0 || Cond->getType() == Type::BoolTy) && 
-         "May only branch on boolean predicates!!!!");
+  init(True, False, Cond);
 }
 
 BranchInst::BranchInst(BasicBlock *True, Instruction *InsertBefore) 
   : TerminatorInst(Instruction::Br, InsertBefore) {
-  assert(True != 0 && "True branch destination may not be null!!!");
-  Operands.reserve(1);
-  Operands.push_back(Use(True, this));
+  init(True);
 }
 
 BranchInst::BranchInst(BasicBlock *True, BasicBlock *InsertAtEnd) 
   : TerminatorInst(Instruction::Br, InsertAtEnd) {
-  assert(True != 0 && "True branch destination may not be null!!!");
-  Operands.reserve(1);
-  Operands.push_back(Use(True, this));
+  init(True);
 }
 
 BranchInst::BranchInst(const BranchInst &BI) : TerminatorInst(Instruction::Br) {

lib/VMCore/iCall.cpp

@@ -99,51 +99,42 @@ Function *CallInst::getCalledFunction() {
 //                        InvokeInst Implementation
 //===----------------------------------------------------------------------===//
 
-InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
-		       BasicBlock *IfException,
-                       const std::vector<Value*> &params,
-		       const std::string &Name, Instruction *InsertBefore)
-  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
-				    ->getElementType())->getReturnType(),
-		   Instruction::Invoke, Name, InsertBefore) {
-  Operands.reserve(3+params.size());
-  Operands.push_back(Use(Func, this));
+void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
+                      const std::vector<Value*> &Params)
+{
+  Operands.reserve(3+Params.size());
+  Operands.push_back(Use(Fn, this));
   Operands.push_back(Use((Value*)IfNormal, this));
   Operands.push_back(Use((Value*)IfException, this));
   const FunctionType *MTy = 
-    cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
+    cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType());
   
-  assert((params.size() == MTy->getNumParams()) || 
-	 (MTy->isVarArg() && params.size() > MTy->getNumParams()) &&
+  assert((Params.size() == MTy->getNumParams()) || 
+	 (MTy->isVarArg() && Params.size() > MTy->getNumParams()) &&
 	 "Calling a function with bad signature");
   
-  for (unsigned i = 0; i < params.size(); i++)
-    Operands.push_back(Use(params[i], this));
+  for (unsigned i = 0; i < Params.size(); i++)
+    Operands.push_back(Use(Params[i], this));
 }
 
-InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
+InvokeInst::InvokeInst(Value *Fn, BasicBlock *IfNormal,
 		       BasicBlock *IfException,
-                       const std::vector<Value*> &params,
-		       const std::string &Name, BasicBlock *InsertAtEnd)
-  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
+                       const std::vector<Value*> &Params,
+		       const std::string &Name, Instruction *InsertBefore)
+  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Fn->getType())
 				    ->getElementType())->getReturnType(),
-		   Instruction::Invoke, Name) {
-  Operands.reserve(3+params.size());
-  Operands.push_back(Use(Func, this));
-  Operands.push_back(Use((Value*)IfNormal, this));
-  Operands.push_back(Use((Value*)IfException, this));
-  const FunctionType *MTy = 
-    cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
+		   Instruction::Invoke, Name, InsertBefore) {
+  init(Fn, IfNormal, IfException, Params);
+}
 
-  assert((params.size() == MTy->getNumParams()) || 
-	 (MTy->isVarArg() && params.size() > MTy->getNumParams()) &&
-	 "Calling a function with bad signature");
-  
-  for (unsigned i = 0; i < params.size(); i++)
-    Operands.push_back(Use(params[i], this));
-
-  if (InsertAtEnd)
-    InsertAtEnd->getInstList().push_back(this);
+InvokeInst::InvokeInst(Value *Fn, BasicBlock *IfNormal,
+		       BasicBlock *IfException,
+                       const std::vector<Value*> &Params,
+		       const std::string &Name, BasicBlock *InsertAtEnd)
+  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Fn->getType())
+				    ->getElementType())->getReturnType(),
+		   Instruction::Invoke, Name, InsertAtEnd) {
+  init(Fn, IfNormal, IfException, Params);
 }
 
 InvokeInst::InvokeInst(const InvokeInst &CI) 

lib/VMCore/iMemory.cpp

@@ -67,16 +67,14 @@ FreeInst::FreeInst(Value *Ptr, Instruction *InsertBefore)
 LoadInst::LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBef)
   : Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
                 Load, Name, InsertBef), Volatile(false) {
-  Operands.reserve(1);
-  Operands.push_back(Use(Ptr, this));
+  init(Ptr);
 }
 
 LoadInst::LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
                    Instruction *InsertBef)
   : Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
                 Load, Name, InsertBef), Volatile(isVolatile) {
-  Operands.reserve(1);
-  Operands.push_back(Use(Ptr, this));
+  init(Ptr);
 }
 
 //===----------------------------------------------------------------------===//
@@ -85,19 +83,13 @@ LoadInst::LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
 
 StoreInst::StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore)
   : Instruction(Type::VoidTy, Store, "", InsertBefore), Volatile(false) {
-  
-  Operands.reserve(2);
-  Operands.push_back(Use(Val, this));
-  Operands.push_back(Use(Ptr, this));
+  init(Val, Ptr);
 }
 
 StoreInst::StoreInst(Value *Val, Value *Ptr, bool isVolatile, 
                      Instruction *InsertBefore)
   : Instruction(Type::VoidTy, Store, "", InsertBefore), Volatile(isVolatile) {
-  
-  Operands.reserve(2);
-  Operands.push_back(Use(Val, this));
-  Operands.push_back(Use(Ptr, this));
+  init(Val, Ptr);
 }
 
 
@@ -113,11 +105,8 @@ static inline const Type *checkType(const Type *Ty) {
   return Ty;
 }
 
-GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
-				     const std::string &Name, Instruction *InBe)
-  : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
-                                                          Idx, true))),
-                GetElementPtr, Name, InBe) {
+void GetElementPtrInst::init(Value *Ptr, const std::vector<Value*> &Idx)
+{
   Operands.reserve(1+Idx.size());
   Operands.push_back(Use(Ptr, this));
 
@@ -125,6 +114,14 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
     Operands.push_back(Use(Idx[i], this));
 }
 
+GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
+				     const std::string &Name, Instruction *InBe)
+  : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
+                                                          Idx, true))),
+                GetElementPtr, Name, InBe) {
+  init(Ptr, Idx);
+}
+
 // getIndexedType - Returns the type of the element that would be loaded with
 // a load instruction with the specified parameters.
 //

lib/VMCore/iSwitch.cpp

@@ -15,20 +15,22 @@
 #include "llvm/BasicBlock.h"
 using namespace llvm;
 
-SwitchInst::SwitchInst(Value *V, BasicBlock *DefaultDest,
-                       Instruction *InsertBefore) 
-  : TerminatorInst(Instruction::Switch, InsertBefore) {
-  assert(V && DefaultDest);
-  Operands.push_back(Use(V, this));
-  Operands.push_back(Use(DefaultDest, this));
+void SwitchInst::init(Value *Value, BasicBlock *Default)
+{
+  assert(Value && Default);
+  Operands.push_back(Use(Value, this));
+  Operands.push_back(Use(Default, this));
 }
 
-SwitchInst::SwitchInst(Value *V, BasicBlock *DefaultDest,
-                       BasicBlock *InsertAtEnd) 
+SwitchInst::SwitchInst(Value *V, BasicBlock *D,
+                       Instruction *InsertBefore) 
+  : TerminatorInst(Instruction::Switch, InsertBefore) {
+  init(V, D);
+}
+
+SwitchInst::SwitchInst(Value *V, BasicBlock *D, BasicBlock *InsertAtEnd) 
   : TerminatorInst(Instruction::Switch, InsertAtEnd) {
-  assert(V && DefaultDest);
-  Operands.push_back(Use(V, this));
-  Operands.push_back(Use(DefaultDest, this));
+  init(V, D);
 }
 
 SwitchInst::SwitchInst(const SwitchInst &SI)