Add convinience constructor for function calls with two args.

[oota-llvm.git] / lib / VMCore / iCall.cpp

diff --git a/lib/VMCore/iCall.cpp b/lib/VMCore/iCall.cpp
index 37298f99fd49e406962559c467d2a85d1c6731c7..1e88be3e935b19905198876b891fa1942612d0f3 100644 (file)
--- a/lib/VMCore/iCall.cpp
+++ b/lib/VMCore/iCall.cpp
@@ -23,43 +23,38 @@ using namespace llvm;
 //                        CallInst Implementation
 //===----------------------------------------------------------------------===//
 
-CallInst::CallInst(Value *Func, const std::vector<Value*> &params, 
-                   const std::string &Name, Instruction *InsertBefore) 
-  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
-                                ->getElementType())->getReturnType(),
-               Instruction::Call, Name, InsertBefore) {
-  Operands.reserve(1+params.size());
+void CallInst::init(Value *Func, const std::vector<Value*> &Params)
+{
+  Operands.reserve(1+Params.size());
   Operands.push_back(Use(Func, this));
 
   const FunctionType *FTy = 
     cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
 
-  assert((params.size() == FTy->getNumParams() || 
-          (FTy->isVarArg() && params.size() > FTy->getNumParams())) &&
+  assert((Params.size() == FTy->getNumParams() || 
+          (FTy->isVarArg() && Params.size() > FTy->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));
 }
 
-CallInst::CallInst(Value *Func, const std::string &Name,
-                   Instruction *InsertBefore)
-  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
-                                   ->getElementType())->getReturnType(),
-                Instruction::Call, Name, InsertBefore) {
-  Operands.reserve(1);
+void CallInst::init(Value *Func, Value *Actual1, Value *Actual2)
+{
+  Operands.reserve(3);
   Operands.push_back(Use(Func, this));
   
   const FunctionType *MTy = 
     cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
 
-  assert(MTy->getNumParams() == 0 && "Calling a function with bad signature");
+  assert((MTy->getNumParams() == 2 ||
+          (MTy->isVarArg() && MTy->getNumParams() == 0)) &&
+        "Calling a function with bad signature");
+  Operands.push_back(Use(Actual1, this));
+  Operands.push_back(Use(Actual2, this));
 }
 
-CallInst::CallInst(Value *Func, Value* A, const std::string &Name,
-                   Instruction  *InsertBefore)
-  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
-                                   ->getElementType())->getReturnType(),
-                Instruction::Call, Name, InsertBefore) {
+void CallInst::init(Value *Func, Value *Actual)
+{
   Operands.reserve(2);
   Operands.push_back(Use(Func, this));
   
@@ -69,7 +64,82 @@ CallInst::CallInst(Value *Func, Value* A, const std::string &Name,
   assert((MTy->getNumParams() == 1 ||
           (MTy->isVarArg() && MTy->getNumParams() == 0)) &&
         "Calling a function with bad signature");
-  Operands.push_back(Use(A, this));
+  Operands.push_back(Use(Actual, this));
+}
+
+void CallInst::init(Value *Func)
+{
+  Operands.reserve(1);
+  Operands.push_back(Use(Func, this));
+  
+  const FunctionType *MTy = 
+    cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
+
+  assert(MTy->getNumParams() == 0 && "Calling a function with bad signature");
+}
+
+CallInst::CallInst(Value *Func, const std::vector<Value*> &Params, 
+                   const std::string &Name, Instruction *InsertBefore) 
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                ->getElementType())->getReturnType(),
+               Instruction::Call, Name, InsertBefore) {
+  init(Func, Params);
+}
+
+CallInst::CallInst(Value *Func, const std::vector<Value*> &Params, 
+                   const std::string &Name, BasicBlock *InsertAtEnd) 
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                ->getElementType())->getReturnType(),
+               Instruction::Call, Name, InsertAtEnd) {
+  init(Func, Params);
+}
+
+CallInst::CallInst(Value *Func, Value *Actual1, Value *Actual2,
+                   const std::string &Name, Instruction  *InsertBefore)
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                   ->getElementType())->getReturnType(),
+                Instruction::Call, Name, InsertBefore) {
+  init(Func, Actual1, Actual2);
+}
+
+CallInst::CallInst(Value *Func, Value *Actual1, Value *Actual2,
+                   const std::string &Name, BasicBlock  *InsertAtEnd)
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                   ->getElementType())->getReturnType(),
+                Instruction::Call, Name, InsertAtEnd) {
+  init(Func, Actual1, Actual2);
+}
+
+CallInst::CallInst(Value *Func, Value* Actual, const std::string &Name,
+                   Instruction  *InsertBefore)
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                   ->getElementType())->getReturnType(),
+                Instruction::Call, Name, InsertBefore) {
+  init(Func, Actual);
+}
+
+CallInst::CallInst(Value *Func, Value* Actual, const std::string &Name,
+                   BasicBlock  *InsertAtEnd)
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                   ->getElementType())->getReturnType(),
+                Instruction::Call, Name, InsertAtEnd) {
+  init(Func, Actual);
+}
+
+CallInst::CallInst(Value *Func, const std::string &Name,
+                   Instruction *InsertBefore)
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                   ->getElementType())->getReturnType(),
+                Instruction::Call, Name, InsertBefore) {
+  init(Func);
+}
+
+CallInst::CallInst(Value *Func, const std::string &Name,
+                   BasicBlock *InsertAtEnd)
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                   ->getElementType())->getReturnType(),
+                Instruction::Call, Name, InsertAtEnd) {
+  init(Func);
 }
 
 CallInst::CallInst(const CallInst &CI) 
@@ -99,51 +169,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)