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 7632798c66a9c2b89e438427fbb6fb6890baeca0..9e5ca0178752445dec89f23b6b9b2ba1de6616e8 100644 (file)
--- a/lib/VMCore/iCall.cpp
+++ b/lib/VMCore/iCall.cpp
@@ -1,47 +1,75 @@
-//===-- iCall.cpp - Implement the Call & Invoke instructions -----*- C++ -*--=//
+//===-- iCall.cpp - Implement the call & invoke instructions -----*- C++ -*--=//
 //
 // This file implements the call and invoke instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/iOther.h"
+#include "llvm/iTerminators.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/Method.h"
-
-CallInst::CallInst(Method *m, vector<Value*> &params, 
-                   const string &Name) 
-  : Instruction(m->getReturnType(), Instruction::Call, Name), M(m, this) {
-
-  const MethodType* MT = M->getMethodType();
-  const MethodType::ParamTypes &PL = MT->getParamTypes();
-  assert(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++) {
-    assert(*It++ == params[i]->getType());
-    Params.push_back(Use(params[i], this));
-  }
+#include "llvm/Function.h"
+
+//===----------------------------------------------------------------------===//
+//                        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(Func, 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));
 }
 
 CallInst::CallInst(const CallInst &CI) 
-  : Instruction(CI.getType(), Instruction::Call), M(CI.M, this) {
-  for (unsigned i = 0; i < CI.Params.size(); i++)
-    Params.push_back(Use(CI.Params[i], this));
+  : Instruction(CI.getType(), Instruction::Call) {
+  Operands.reserve(CI.Operands.size());
+  for (unsigned i = 0; i < CI.Operands.size(); ++i)
+    Operands.push_back(Use(CI.Operands[i], this));
 }
 
-void CallInst::dropAllReferences() { 
-  M = 0;
-  Params.clear(); 
+//===----------------------------------------------------------------------===//
+//                        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));
 }
 
-bool CallInst::setOperand(unsigned i, Value *Val) {
-  if (i > Params.size()) return false;
-  if (i == 0) {
-    M = Val->castMethodAsserting();
-  } else {
-    // TODO: assert = method arg type
-    Params[i-1] = Val;
-  }
-  return true;
+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));
 }
+