Load & StoreInst no longer derive from MemAccessInst, so we don't have

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

diff --git a/lib/VMCore/iCall.cpp b/lib/VMCore/iCall.cpp
index f739730b67d593f22770d7408a7bac9c6a5da401..9e5ca0178752445dec89f23b6b9b2ba1de6616e8 100644 (file)
--- a/lib/VMCore/iCall.cpp
+++ b/lib/VMCore/iCall.cpp
@@ -1,27 +1,33 @@
-//===-- iCall.cpp - Implement the call & icall instructions ------*- C++ -*--=//
+//===-- iCall.cpp - Implement the call & invoke instructions -----*- C++ -*--=//
 //
-// This file implements the call and icall instructions.
+// This file implements the call and invoke instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/iOther.h"
+#include "llvm/iTerminators.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
 
-CallInst::CallInst(Method *M, const vector<Value*> &params, 
-                   const string &Name) 
-  : Instruction(M->getReturnType(), Instruction::Call, Name) {
+//===----------------------------------------------------------------------===//
+//                        CallInst Implementation
+//===----------------------------------------------------------------------===//
 
+CallInst::CallInst(Value *Func, const std::vector<Value*> &params, 
+                   const std::string &Name) 
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                ->getElementType())->getReturnType(),
+               Instruction::Call, Name) {
   Operands.reserve(1+params.size());
-  Operands.push_back(Use(M, this));
+  Operands.push_back(Use(Func, this));
+
+  const FunctionType *MTy = 
+    cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
 
-  const MethodType::ParamTypes &PL = M->getMethodType()->getParamTypes();
+  const FunctionType::ParamTypes &PL = MTy->getParamTypes();
   assert((params.size() == PL.size()) || 
-        (M->getMethodType()->isVarArg() && params.size() > PL.size()) &&
+        (MTy->isVarArg() && params.size() >= PL.size()) &&
         "Calling a function with bad signature");
-#ifndef NDEBUG
-  MethodType::ParamTypes::const_iterator It = PL.begin();
-#endif
   for (unsigned i = 0; i < params.size(); i++)
     Operands.push_back(Use(params[i], this));
 }
@@ -33,3 +39,37 @@ CallInst::CallInst(const CallInst &CI)
     Operands.push_back(Use(CI.Operands[i], this));
 }
 
+//===----------------------------------------------------------------------===//
+//                        InvokeInst Implementation
+//===----------------------------------------------------------------------===//
+
+InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
+                      BasicBlock *IfException,
+                       const std::vector<Value*> &params,
+                      const std::string &Name)
+  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->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());
+  
+  const FunctionType::ParamTypes &PL = MTy->getParamTypes();
+  assert((params.size() == PL.size()) || 
+        (MTy->isVarArg() && params.size() > PL.size()) &&
+        "Calling a function with bad signature");
+  
+  for (unsigned i = 0; i < params.size(); i++)
+    Operands.push_back(Use(params[i], this));
+}
+
+InvokeInst::InvokeInst(const InvokeInst &CI) 
+  : TerminatorInst(CI.getType(), Instruction::Invoke) {
+  Operands.reserve(CI.Operands.size());
+  for (unsigned i = 0; i < CI.Operands.size(); ++i)
+    Operands.push_back(Use(CI.Operands[i], this));
+}
+