Start using the new function cloning header

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

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 456d19291b1deb659a01ed38667bf1456d8148f1..da3449b95c02542dacb4e75c3b8659be4d4f9409 100644 (file)
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -17,6 +17,7 @@
 //  * Only phi nodes can be self referential: 'add int %0, %0 ; <int>:0' is bad
 //  * PHI nodes must have an entry for each predecessor, with no extras.
 //  * PHI nodes must be the first thing in a basic block, all grouped together
+//  * PHI nodes must have at least one entry
 //  * All basic blocks should only end with terminator insts, not contain them
 //  * The entry node to a function must not have predecessors
 //  * All Instructions must be embeded into a basic block
@@ -24,7 +25,7 @@
 //  * Verify that a function's argument list agrees with it's declared type.
 //  . Verify that arrays and structures have fixed elements: No unsized arrays.
 //  * It is illegal to specify a name for a void value.
-//  * It is illegal to have a internal function that is just a declaration
+//  * It is illegal to have a internal global value with no intitalizer
 //  * It is illegal to have a ret instruction that returns a value that does not
 //    agree with the function return value type.
 //  * Function call argument types match the function prototype
@@ -48,7 +49,6 @@
 #include "llvm/Support/InstVisitor.h"
 #include "Support/STLExtras.h"
 #include <algorithm>
-#include <iostream>
 
 namespace {  // Anonymous namespace for class
 
@@ -67,6 +67,13 @@ namespace {  // Anonymous namespace for class
 
     bool doInitialization(Module &M) {
       verifySymbolTable(M.getSymbolTable());
+
+      // If this is a real pass, in a pass manager, we must abort before
+      // returning back to the pass manager, or else the pass manager may try to
+      // run other passes on the broken module.
+      //
+      if (RealPass)
+        abortIfBroken();
       return false;
     }
 
@@ -74,6 +81,14 @@ namespace {  // Anonymous namespace for class
       // Get dominator information if we are being run by PassManager
       if (RealPass) DS = &getAnalysis<DominatorSet>();
       visit(F);
+
+      // If this is a real pass, in a pass manager, we must abort before
+      // returning back to the pass manager, or else the pass manager may try to
+      // run other passes on the broken module.
+      //
+      if (RealPass)
+        abortIfBroken();
+
       return false;
     }
 
@@ -83,10 +98,12 @@ namespace {  // Anonymous namespace for class
         if (I->isExternal() && I->hasInternalLinkage())
           CheckFailed("Function Declaration has Internal Linkage!", I);
 
-      if (Broken && AbortBroken) {
-        std::cerr << "Broken module found, compilation aborted!\n";
-        abort();
-      }
+      for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
+        if (I->isExternal() && I->hasInternalLinkage())
+          CheckFailed("Global Variable is external with internal linkage!", I);
+
+      // If the module is broken, abort at this time.
+      abortIfBroken();
       return false;
     }
 
@@ -96,6 +113,16 @@ namespace {  // Anonymous namespace for class
         AU.addRequired<DominatorSet>();
     }
 
+    // abortIfBroken - If the module is broken and we are supposed to abort on
+    // this condition, do so.
+    //
+    void abortIfBroken() const {
+      if (Broken && AbortBroken) {
+        std::cerr << "Broken module found, compilation aborted!\n";
+        abort();
+      }
+    }
+
     // Verification methods...
     void verifySymbolTable(SymbolTable *ST);
     void visitFunction(Function &F);
@@ -166,32 +193,30 @@ void Verifier::verifySymbolTable(SymbolTable *ST) {
 // visitFunction - Verify that a function is ok.
 //
 void Verifier::visitFunction(Function &F) {
-  if (F.isExternal()) return;
-
-  verifySymbolTable(F.getSymbolTable());
-
   // Check function arguments...
   const FunctionType *FT = F.getFunctionType();
   unsigned NumArgs = F.getArgumentList().size();
 
   Assert2(!FT->isVarArg(), "Cannot define varargs functions in LLVM!", &F, FT);
-  Assert2(FT->getParamTypes().size() == NumArgs,
+  Assert2(FT->getNumParams() == NumArgs,
           "# formal arguments must match # of arguments for function type!",
           &F, FT);
 
   // Check that the argument values match the function type for this function...
-  if (FT->getParamTypes().size() == NumArgs) {
-    unsigned i = 0;
-    for (Function::aiterator I = F.abegin(), E = F.aend(); I != E; ++I, ++i)
-      Assert2(I->getType() == FT->getParamType(i),
-              "Argument value does not match function argument type!",
-              I, FT->getParamType(i));
+  unsigned i = 0;
+  for (Function::aiterator I = F.abegin(), E = F.aend(); I != E; ++I, ++i)
+    Assert2(I->getType() == FT->getParamType(i),
+            "Argument value does not match function argument type!",
+            I, FT->getParamType(i));
+
+  if (!F.isExternal()) {
+    verifySymbolTable(F.getSymbolTable());
+
+    // Check the entry node
+    BasicBlock *Entry = &F.getEntryNode();
+    Assert1(pred_begin(Entry) == pred_end(Entry),
+            "Entry block to function must not have predecessors!", Entry);
   }
-
-  // Check the entry node
-  BasicBlock *Entry = &F.getEntryNode();
-  Assert1(pred_begin(Entry) == pred_end(Entry),
-          "Entry block to function must not have predecessors!", Entry);
 }
 
 
@@ -236,6 +261,12 @@ void Verifier::visitPHINode(PHINode &PN) {
           "PHI nodes not grouped at top of basic block!",
           &PN, PN.getParent());
 
+  // Ensure that PHI nodes have at least one entry!
+  Assert1(PN.getNumIncomingValues() != 0,
+          "PHI nodes must have at least one entry.  If the block is dead, "
+          "the PHI should be removed!",
+          &PN);
+
   std::vector<BasicBlock*> Preds(pred_begin(PN.getParent()),
                                  pred_end(PN.getParent()));
   // Loop over all of the incoming values, make sure that there are