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

6 files changed, 96 insertions, 98 deletions

diff --git a/lib/VMCore/InstrTypes.cpp b/lib/VMCore/InstrTypes.cpp
index b10f9cc31c..aa5c3514e2 100644
--- a/lib/VMCore/InstrTypes.cpp
+++ b/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) {
 }
 
 
diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp
index 0de34b5bd5..5ddf284354 100644
--- a/lib/VMCore/Instruction.cpp
+++ b/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);
diff --git a/lib/VMCore/iBranch.cpp b/lib/VMCore/iBranch.cpp
index 78951b2965..a5ba36fd17 100644
--- a/lib/VMCore/iBranch.cpp
+++ b/lib/VMCore/iBranch.cpp
@@ -28,52 +28,45 @@ void UnwindInst::setSuccessor(unsigned idx, BasicBlock *NewSucc) {
   assert(0 && "UnwindInst has no successors!");
 }
 
+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));
+}
+
 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));
-    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, 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) {
diff --git a/lib/VMCore/iCall.cpp b/lib/VMCore/iCall.cpp
index 37298f99fd..edd5593301 100644
--- a/lib/VMCore/iCall.cpp
+++ b/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());
-  
-  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));
+		   Instruction::Invoke, Name, InsertBefore) {
+  init(Fn, IfNormal, IfException, Params);
+}
 
-  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) 
diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp
index da4cc7483f..2b731b45c5 100644
--- a/lib/VMCore/iMemory.cpp
+++ b/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.
 //
diff --git a/lib/VMCore/iSwitch.cpp b/lib/VMCore/iSwitch.cpp
index c4cffc22d7..d4dccde5b5 100644
--- a/lib/VMCore/iSwitch.cpp
+++ b/lib/VMCore/iSwitch.cpp
@@ -15,20 +15,22 @@
 #include "llvm/BasicBlock.h"
 using namespace llvm;
 
-SwitchInst::SwitchInst(Value *V, BasicBlock *DefaultDest,
+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 *D,
                        Instruction *InsertBefore) 
   : TerminatorInst(Instruction::Switch, InsertBefore) {
-  assert(V && DefaultDest);
-  Operands.push_back(Use(V, this));
-  Operands.push_back(Use(DefaultDest, this));
+  init(V, D);
 }
 
-SwitchInst::SwitchInst(Value *V, BasicBlock *DefaultDest,
-                       BasicBlock *InsertAtEnd) 
+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)