Don't barf on empty basic blocks. Do not rely on assert

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

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 49f6abd08076a9be125432091292279b7b6b4ffb..dea94088fa29fb7bdcec1b11b47265003234a958 100644 (file)
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -49,8 +49,7 @@
 #include "llvm/ParameterAttributes.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/InlineAsm.h"
-#include "llvm/Instructions.h"
-#include "llvm/Intrinsics.h"
+#include "llvm/IntrinsicInst.h"
 #include "llvm/PassManager.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/CodeGen/ValueTypes.h"
@@ -68,6 +67,35 @@
 using namespace llvm;
 
 namespace {  // Anonymous namespace for class
+  struct VISIBILITY_HIDDEN PreVerifier : public FunctionPass {
+    static char ID; // Pass ID, replacement for typeid
+
+    PreVerifier() : FunctionPass((intptr_t)&ID) { }
+
+    // Check that the prerequisites for successful DominatorTree construction
+    // are satisfied.
+    bool runOnFunction(Function &F) {
+      bool Broken = false;
+
+      for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
+        if (I->empty() || !I->back().isTerminator()) {
+          cerr << "Basic Block does not have terminator!\n";
+          WriteAsOperand(*cerr, I, true);
+          cerr << "\n";
+          Broken = true;
+        }
+      }
+
+      if (Broken)
+        abort();
+
+      return false;
+    }
+  };
+
+  char PreVerifier::ID = 0;
+  RegisterPass<PreVerifier> PreVer("preverify", "Preliminary module verification");
+  const PassInfo *PreVerifyID = PreVer.getPassInfo();
 
   struct VISIBILITY_HIDDEN
      Verifier : public FunctionPass, InstVisitor<Verifier> {
@@ -158,6 +186,7 @@ namespace {  // Anonymous namespace for class
 
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.setPreservesAll();
+      AU.addRequiredID(PreVerifyID);
       if (RealPass)
         AU.addRequired<DominatorTree>();
     }
@@ -311,10 +340,15 @@ void Verifier::visitGlobalValue(GlobalValue &GV) {
 }
 
 void Verifier::visitGlobalVariable(GlobalVariable &GV) {
-  if (GV.hasInitializer())
+  if (GV.hasInitializer()) {
     Assert1(GV.getInitializer()->getType() == GV.getType()->getElementType(),
             "Global variable initializer type does not match global "
             "variable type!", &GV);
+  } else {
+    Assert1(GV.hasExternalLinkage() || GV.hasDLLImportLinkage() ||
+            GV.hasExternalWeakLinkage(),
+            "invalid linkage type for global declaration", &GV);
+  }
 
   visitGlobalValue(GV);
 }
@@ -468,7 +502,11 @@ void Verifier::visitFunction(Function &F) {
             "Functions cannot take aggregates as arguments by value!", I);
    }
 
-  if (!F.isDeclaration()) {
+  if (F.isDeclaration()) {
+    Assert1(F.hasExternalLinkage() || F.hasDLLImportLinkage() ||
+            F.hasExternalWeakLinkage(),
+            "invalid linkage type for function declaration", &F);
+  } else {
     // Verify that this function (which has a body) is not named "llvm.*".  It
     // is not legal to define intrinsics.
     if (F.getName().size() >= 5)
@@ -798,10 +836,11 @@ void Verifier::visitCallInst(CallInst &CI) {
             "Call parameter type does not match function signature!",
             CI.getOperand(i+1), FTy->getParamType(i), &CI);
 
-  if (Function *F = CI.getCalledFunction())
+  if (Function *F = CI.getCalledFunction()) {
     if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
       visitIntrinsicFunctionCall(ID, CI);
-
+  }
+  
   visitInstruction(CI);
 }
 
@@ -913,7 +952,7 @@ void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
   SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end());
   const Type *ElTy =
     GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(),
-                                      &Idxs[0], Idxs.size(), true);
+                                      Idxs.begin(), Idxs.end(), true);
   Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
   Assert2(isa<PointerType>(GEP.getType()) &&
           cast<PointerType>(GEP.getType())->getElementType() == ElTy,
@@ -1072,6 +1111,12 @@ void Verifier::visitInstruction(Instruction &I) {
   InstsInThisBlock.insert(&I);
 }
 
+static bool HasPtrPtrType(Value *Val) {
+  if (const PointerType *PtrTy = dyn_cast<PointerType>(Val->getType()))
+    return isa<PointerType>(PtrTy->getElementType());
+  return false;
+}
+
 /// visitIntrinsicFunction - Allow intrinsics to be verified in different ways.
 ///
 void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
@@ -1082,6 +1127,35 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
 #define GET_INTRINSIC_VERIFIER
 #include "llvm/Intrinsics.gen"
 #undef GET_INTRINSIC_VERIFIER
+  
+  switch (ID) {
+  default:
+    break;
+  case Intrinsic::gcroot:
+    Assert1(HasPtrPtrType(CI.getOperand(1)),
+            "llvm.gcroot parameter #1 must be a pointer to a pointer.", &CI);
+    Assert1(isa<AllocaInst>(IntrinsicInst::StripPointerCasts(CI.getOperand(1))),
+            "llvm.gcroot parameter #1 must be an alloca (or a bitcast of one).",
+            &CI);
+    Assert1(isa<Constant>(CI.getOperand(2)),
+            "llvm.gcroot parameter #2 must be a constant.", &CI);
+    break;
+  case Intrinsic::gcwrite:
+    Assert1(CI.getOperand(3)->getType()
+            == PointerType::get(CI.getOperand(1)->getType()),
+            "Call to llvm.gcwrite must be with type 'void (%ty*, %ty2*, %ty**)'.",
+            &CI);
+    break;
+  case Intrinsic::gcread:
+    Assert1(CI.getOperand(2)->getType() == PointerType::get(CI.getType()),
+            "Call to llvm.gcread must be with type '%ty* (%ty2*, %ty**).'",
+            &CI);
+    break;
+  case Intrinsic::init_trampoline:
+    Assert1(isa<Function>(IntrinsicInst::StripPointerCasts(CI.getOperand(2))),
+            "llvm.init_trampoline parameter #2 must resolve to a function.",
+            &CI);
+  }
 }
 
 /// VerifyIntrinsicPrototype - TableGen emits calls to this function into