-//===-- 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*> ¶ms,
+//===----------------------------------------------------------------------===//
+// CallInst Implementation
+//===----------------------------------------------------------------------===//
+
+CallInst::CallInst(Value *Meth, const vector<Value*> ¶ms,
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));
- }
+ : Instruction(cast<MethodType>(cast<PointerType>(Meth->getType())
+ ->getValueType())->getReturnType(),
+ Instruction::Call, Name) {
+ Operands.reserve(1+params.size());
+ Operands.push_back(Use(Meth, this));
+
+ const MethodType *MTy =
+ cast<MethodType>(cast<PointerType>(Meth->getType())->getValueType());
+
+ const MethodType::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 *Meth, BasicBlock *IfNormal, \
+ BasicBlock *IfException, const vector<Value*>¶ms,
+ const string &Name)
+ : TerminatorInst(cast<MethodType>(cast<PointerType>(Meth->getType())
+ ->getValueType())->getReturnType(),
+ Instruction::Invoke, Name) {
+ Operands.reserve(3+params.size());
+ Operands.push_back(Use(Meth, this));
+ Operands.push_back(Use(IfNormal, this));
+ Operands.push_back(Use(IfException, this));
+ const MethodType *MTy =
+ cast<MethodType>(cast<PointerType>(Meth->getType())->getValueType());
+
+ const MethodType::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));
}
+