Print the top 20 most frequently executed blocks. Fix sort predicate problem

[oota-llvm.git] / tools / bugpoint / CrashDebugger.cpp

diff --git a/tools/bugpoint/CrashDebugger.cpp b/tools/bugpoint/CrashDebugger.cpp
index 852359a8c241bdac819ee18fdeec1e0fc43afed6..fe13e6726dace1f93b2a1a81adfeb68f3b936349 100644 (file)
--- a/tools/bugpoint/CrashDebugger.cpp
+++ b/tools/bugpoint/CrashDebugger.cpp
@@ -1,24 +1,31 @@
 //===- CrashDebugger.cpp - Debug compilation crashes ----------------------===//
+// 
+//                     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 defines the bugpoint internals that narrow down compilation crashes
 //
 //===----------------------------------------------------------------------===//
 
 #include "BugDriver.h"
-#include "SystemUtils.h"
 #include "ListReducer.h"
-#include "llvm/Module.h"
-#include "llvm/PassManager.h"
-#include "llvm/Pass.h"
 #include "llvm/Constant.h"
 #include "llvm/iTerminators.h"
-#include "llvm/Type.h"
+#include "llvm/Module.h"
+#include "llvm/Pass.h"
+#include "llvm/PassManager.h"
 #include "llvm/SymbolTable.h"
-#include "llvm/Support/CFG.h"
+#include "llvm/Type.h"
 #include "llvm/Analysis/Verifier.h"
+#include "llvm/Bytecode/Writer.h"
+#include "llvm/Support/CFG.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/Cloning.h"
-#include "llvm/Bytecode/Writer.h"
+#include "Support/FileUtilities.h"
 #include <fstream>
 #include <set>
 
@@ -80,7 +87,7 @@ public:
 
   virtual TestResult doTest(std::vector<Function*> &Prefix,
                             std::vector<Function*> &Kept) {
-    if (TestFuncs(Kept))
+    if (!Kept.empty() && TestFuncs(Kept))
       return KeepSuffix;
     if (!Prefix.empty() && TestFuncs(Prefix))
       return KeepPrefix;
@@ -91,7 +98,7 @@ public:
 };
 
 bool ReduceCrashingFunctions::TestFuncs(std::vector<Function*> &Funcs) {
-  // Clone the program to try hacking it appart...
+  // Clone the program to try hacking it apart...
   Module *M = CloneModule(BD.Program);
   
   // Convert list to set for fast lookup...
@@ -104,8 +111,12 @@ bool ReduceCrashingFunctions::TestFuncs(std::vector<Function*> &Funcs) {
   }
 
   std::cout << "Checking for crash with only these functions:";
-  for (unsigned i = 0, e = Funcs.size(); i != e; ++i)
+  unsigned NumPrint = Funcs.size();
+  if (NumPrint > 10) NumPrint = 10;
+  for (unsigned i = 0; i != NumPrint; ++i)
     std::cout << " " << Funcs[i]->getName();
+  if (NumPrint < Funcs.size())
+    std::cout << "... <" << Funcs.size() << " total>";
   std::cout << ": ";
 
   // Loop over and delete any functions which we aren't supposed to be playing
@@ -153,7 +164,7 @@ public:
 };
 
 bool ReduceCrashingBlocks::TestBlocks(std::vector<BasicBlock*> &BBs) {
-  // Clone the program to try hacking it appart...
+  // Clone the program to try hacking it apart...
   Module *M = CloneModule(BD.Program);
   
   // Convert list to set for fast lookup...
@@ -171,8 +182,12 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector<BasicBlock*> &BBs) {
   }
 
   std::cout << "Checking for crash with only these blocks:";
-  for (unsigned i = 0, e = Blocks.size(); i != e; ++i)
+  unsigned NumPrint = Blocks.size();
+  if (NumPrint > 10) NumPrint = 10;
+  for (unsigned i = 0, e = NumPrint; i != e; ++i)
     std::cout << " " << BBs[i]->getName();
+  if (NumPrint < Blocks.size())
+    std::cout << "... <" << Blocks.size() << " total>";
   std::cout << ": ";
 
   // Loop over and delete any hack up any blocks that are not listed...
@@ -304,11 +319,13 @@ bool BugDriver::debugCrash() {
   // to a return instruction then running simplifycfg, which can potentially
   // shrinks the code dramatically quickly
   //
-  std::vector<BasicBlock*> Blocks;
-  for (Module::iterator I = Program->begin(), E = Program->end(); I != E; ++I)
-    for (Function::iterator FI = I->begin(), E = I->end(); FI != E; ++FI)
-      Blocks.push_back(FI);
-  ReduceCrashingBlocks(*this).reduceList(Blocks);
+  if (!DisableSimplifyCFG) {
+    std::vector<BasicBlock*> Blocks;
+    for (Module::iterator I = Program->begin(), E = Program->end(); I != E; ++I)
+      for (Function::iterator FI = I->begin(), E = I->end(); FI != E; ++FI)
+        Blocks.push_back(FI);
+    ReduceCrashingBlocks(*this).reduceList(Blocks);
+  }
 
   // FIXME: This should use the list reducer to converge faster by deleting
   // larger chunks of instructions at a time!
@@ -318,8 +335,8 @@ bool BugDriver::debugCrash() {
     std::cout << "\n*** Attempting to reduce testcase by deleting instruc"
               << "tions: Simplification Level #" << Simplification << "\n";
 
-    // Now that we have deleted the functions that are unneccesary for the
-    // program, try to remove instructions that are not neccesary to cause the
+    // Now that we have deleted the functions that are unnecessary for the
+    // program, try to remove instructions that are not necessary to cause the
     // crash.  To do this, we loop through all of the instructions in the
     // remaining functions, deleting them (replacing any values produced with
     // nulls), and then running ADCE and SimplifyCFG.  If the transformed input