Adjust to the changed StructType interface. In particular, getElementTypes() is...

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

diff --git a/lib/VMCore/iCall.cpp b/lib/VMCore/iCall.cpp
index d757ea2349a2a9c24f8aac0428d4f207f4bef4fe..37298f99fd49e406962559c467d2a85d1c6731c7 100644 (file)
--- a/lib/VMCore/iCall.cpp
+++ b/lib/VMCore/iCall.cpp
@@ -1,4 +1,11 @@
-//===-- iCall.cpp - Implement the call & invoke instructions -----*- C++ -*--=//
+//===-- iCall.cpp - Implement the call & invoke instructions --------------===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // This file implements the call and invoke instructions.
 //
@@ -6,32 +13,65 @@
 
 #include "llvm/iOther.h"
 #include "llvm/iTerminators.h"
+#include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
+#include "llvm/Support/CallSite.h"
+using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 //                        CallInst Implementation
 //===----------------------------------------------------------------------===//
 
-CallInst::CallInst(Value *Meth, const std::vector<Value*> &params, 
-                   const std::string &Name) 
-  : Instruction(cast<FunctionType>(cast<PointerType>(Meth->getType())
+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) {
+               Instruction::Call, Name, InsertBefore) {
   Operands.reserve(1+params.size());
-  Operands.push_back(Use(Meth, this));
+  Operands.push_back(Use(Func, this));
 
-  const FunctionType *MTy = 
-    cast<FunctionType>(cast<PointerType>(Meth->getType())->getElementType());
+  const FunctionType *FTy = 
+    cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
 
-  const FunctionType::ParamTypes &PL = MTy->getParamTypes();
-  assert((params.size() == PL.size()) || 
-        (MTy->isVarArg() && params.size() >= PL.size()) &&
+  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++)
+  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);
+  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, Value* A, const std::string &Name,
+                   Instruction  *InsertBefore)
+  : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                   ->getElementType())->getReturnType(),
+                Instruction::Call, Name, InsertBefore) {
+  Operands.reserve(2);
+  Operands.push_back(Use(Func, this));
+  
+  const FunctionType *MTy = 
+    cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
+
+  assert((MTy->getNumParams() == 1 ||
+          (MTy->isVarArg() && MTy->getNumParams() == 0)) &&
+        "Calling a function with bad signature");
+  Operands.push_back(Use(A, this));
+}
+
 CallInst::CallInst(const CallInst &CI) 
   : Instruction(CI.getType(), Instruction::Call) {
   Operands.reserve(CI.Operands.size());
@@ -39,31 +79,71 @@ CallInst::CallInst(const CallInst &CI)
     Operands.push_back(Use(CI.Operands[i], this));
 }
 
+const Function *CallInst::getCalledFunction() const {
+  if (const Function *F = dyn_cast<Function>(Operands[0]))
+    return F;
+  if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0]))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}
+Function *CallInst::getCalledFunction() {
+  if (Function *F = dyn_cast<Function>(Operands[0]))
+    return F;
+  if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0]))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}
+
+
 //===----------------------------------------------------------------------===//
 //                        InvokeInst Implementation
 //===----------------------------------------------------------------------===//
 
-InvokeInst::InvokeInst(Value *Meth, BasicBlock *IfNormal, \
+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));
+  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));
+}
+
+InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
                       BasicBlock *IfException,
                        const std::vector<Value*> &params,
-                      const std::string &Name)
-  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Meth->getType())
+                      const std::string &Name, BasicBlock *InsertAtEnd)
+  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
                                    ->getElementType())->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));
+  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>(Meth->getType())->getElementType());
+    cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
   
-  const FunctionType::ParamTypes &PL = MTy->getParamTypes();
-  assert((params.size() == PL.size()) || 
-        (MTy->isVarArg() && params.size() > PL.size()) &&
+  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));
+
+  if (InsertAtEnd)
+    InsertAtEnd->getInstList().push_back(this);
 }
 
 InvokeInst::InvokeInst(const InvokeInst &CI) 
@@ -73,3 +153,26 @@ InvokeInst::InvokeInst(const InvokeInst &CI)
     Operands.push_back(Use(CI.Operands[i], this));
 }
 
+const Function *InvokeInst::getCalledFunction() const {
+  if (const Function *F = dyn_cast<Function>(Operands[0]))
+    return F;
+  if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0]))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}
+Function *InvokeInst::getCalledFunction() {
+  if (Function *F = dyn_cast<Function>(Operands[0]))
+    return F;
+  if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0]))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}
+
+Function *CallSite::getCalledFunction() const {
+  Value *Callee = getCalledValue();
+  if (Function *F = dyn_cast<Function>(Callee))
+    return F;
+  if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Callee))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}