Make createVerifierPass return a FunctionPass *.

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

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 0165e3b8cb055eb5280481ab4ab58c7ec1c6cfbd..ace5775a0a719556236bae5cf68d0963f818948f 100644 (file)
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -43,6 +43,7 @@
 #include "llvm/iMemory.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/PassManager.h"
+#include "llvm/Intrinsics.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/InstVisitor.h"
@@ -130,6 +131,7 @@ namespace {  // Anonymous namespace for class
     void visitPHINode(PHINode &PN);
     void visitBinaryOperator(BinaryOperator &B);
     void visitShiftInst(ShiftInst &SI);
+    void visitVarArgInst(VarArgInst &VAI) { visitInstruction(VAI); }
     void visitCallInst(CallInst &CI);
     void visitGetElementPtrInst(GetElementPtrInst &GEP);
     void visitLoadInst(LoadInst &LI);
@@ -139,6 +141,7 @@ namespace {  // Anonymous namespace for class
     void visitReturnInst(ReturnInst &RI);
     void visitUserOp1(Instruction &I);
     void visitUserOp2(Instruction &I) { visitUserOp1(I); }
+    void visitIntrinsicFunctionCall(LLVMIntrinsic::ID ID, CallInst &CI);
 
     // CheckFailed - A check failed, so print out the condition and the message
     // that failed.  This provides a nice place to put a breakpoint if you want
@@ -210,7 +213,6 @@ void Verifier::visitFunction(Function &F) {
   const FunctionType *FT = F.getFunctionType();
   unsigned NumArgs = F.getArgumentList().size();
 
-  Assert2(!FT->isVarArg(), "Cannot define varargs functions in LLVM!", &F, FT);
   Assert2(FT->getNumParams() == NumArgs,
           "# formal arguments must match # of arguments for function type!",
           &F, FT);
@@ -258,7 +260,7 @@ void Verifier::visitReturnInst(ReturnInst &RI) {
             "Function return type does not match operand "
             "type of return inst!", &RI, F->getReturnType());
 
-  // Check to make sure that the return value has neccesary properties for
+  // Check to make sure that the return value has necessary properties for
   // terminators...
   visitTerminatorInst(RI);
 }
@@ -359,6 +361,10 @@ void Verifier::visitCallInst(CallInst &CI) {
             "Call parameter type does not match function signature!",
             CI.getOperand(i+1), FTy->getParamType(i));
 
+  if (Function *F = CI.getCalledFunction())
+    if (LLVMIntrinsic::ID ID = (LLVMIntrinsic::ID)F->getIntrinsicID())
+      visitIntrinsicFunctionCall(ID, CI);
+
   visitInstruction(CI);
 }
 
@@ -403,8 +409,6 @@ void Verifier::visitShiftInst(ShiftInst &SI) {
   visitInstruction(SI);
 }
 
-
-
 void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
   const Type *ElTy =
     GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(),
@@ -490,6 +494,62 @@ void Verifier::visitInstruction(Instruction &I) {
               "Instruction does not dominate all uses!", &I, Use);
     }
   }
+
+  // Check to make sure that the "address of" an intrinsic function is never
+  // taken.
+  for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
+    if (Function *F = dyn_cast<Function>(I.getOperand(i)))
+      Assert1(!F->isIntrinsic() || (i == 0 && isa<CallInst>(I)),
+              "Cannot take the address of an intrinsic!", &I);
+}
+
+/// visitIntrinsicFunction - Allow intrinsics to be verified in different ways.
+void Verifier::visitIntrinsicFunctionCall(LLVMIntrinsic::ID ID, CallInst &CI) {
+  Function *IF = CI.getCalledFunction();
+  const FunctionType *FT = IF->getFunctionType();
+  Assert1(IF->isExternal(), "Intrinsic functions should never be defined!", IF);
+  unsigned NumArgs = 0;
+
+  // FIXME: this should check the return type of each intrinsic as well, also
+  // arguments!
+  switch (ID) {
+  case LLVMIntrinsic::va_start:
+    Assert1(CI.getParent()->getParent()->getFunctionType()->isVarArg(),
+            "llvm.va_start intrinsic may only occur in function with variable"
+            " args!", &CI);
+    NumArgs = 1;
+    break;
+  case LLVMIntrinsic::va_end:          NumArgs = 1; break;
+  case LLVMIntrinsic::va_copy:         NumArgs = 2; break;
+
+  case LLVMIntrinsic::setjmp:          NumArgs = 1; break;
+  case LLVMIntrinsic::longjmp:         NumArgs = 2; break;
+  case LLVMIntrinsic::sigsetjmp:       NumArgs = 2; break;
+  case LLVMIntrinsic::siglongjmp:      NumArgs = 2; break;
+ 
+  case LLVMIntrinsic::alpha_ctlz:      NumArgs = 1; break;
+  case LLVMIntrinsic::alpha_cttz:      NumArgs = 1; break;
+  case LLVMIntrinsic::alpha_ctpop:     NumArgs = 1; break;
+  case LLVMIntrinsic::alpha_umulh:     NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_vecop:     NumArgs = 4; break;
+  case LLVMIntrinsic::alpha_pup:       NumArgs = 3; break;
+  case LLVMIntrinsic::alpha_bytezap:   NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_bytemanip: NumArgs = 3; break;
+  case LLVMIntrinsic::alpha_dfpbop:    NumArgs = 3; break;
+  case LLVMIntrinsic::alpha_dfpuop:    NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_unordered: NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_uqtodfp:   NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_uqtosfp:   NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_dfptosq:   NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_sfptosq:   NumArgs = 2; break;
+
+  case LLVMIntrinsic::not_intrinsic: 
+    assert(0 && "Invalid intrinsic!"); NumArgs = 0; break;
+  }
+
+  Assert1(FT->getNumParams() == NumArgs || (FT->getNumParams() < NumArgs &&
+                                             FT->isVarArg()),
+          "Illegal # arguments for intrinsic function!", IF);
 }
 
 
@@ -497,7 +557,7 @@ void Verifier::visitInstruction(Instruction &I) {
 //  Implement the public interfaces to this file...
 //===----------------------------------------------------------------------===//
 
-Pass *createVerifierPass() {
+FunctionPass *createVerifierPass() {
   return new Verifier();
 }