CrashDebugger.cpp revision 207618
1//===- CrashDebugger.cpp - Debug compilation crashes ----------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines the bugpoint internals that narrow down compilation crashes 11// 12//===----------------------------------------------------------------------===// 13 14#include "BugDriver.h" 15#include "ToolRunner.h" 16#include "ListReducer.h" 17#include "llvm/Constants.h" 18#include "llvm/DerivedTypes.h" 19#include "llvm/Instructions.h" 20#include "llvm/Module.h" 21#include "llvm/Pass.h" 22#include "llvm/PassManager.h" 23#include "llvm/ValueSymbolTable.h" 24#include "llvm/ADT/SmallPtrSet.h" 25#include "llvm/Analysis/Verifier.h" 26#include "llvm/Support/CFG.h" 27#include "llvm/Transforms/Scalar.h" 28#include "llvm/Transforms/Utils/Cloning.h" 29#include "llvm/Support/FileUtilities.h" 30#include "llvm/Support/CommandLine.h" 31#include <set> 32using namespace llvm; 33 34namespace { 35 cl::opt<bool> 36 KeepMain("keep-main", 37 cl::desc("Force function reduction to keep main"), 38 cl::init(false)); 39 cl::opt<bool> 40 NoGlobalRM ("disable-global-remove", 41 cl::desc("Do not remove global variables"), 42 cl::init(false)); 43} 44 45namespace llvm { 46 class ReducePassList : public ListReducer<const PassInfo*> { 47 BugDriver &BD; 48 public: 49 ReducePassList(BugDriver &bd) : BD(bd) {} 50 51 // doTest - Return true iff running the "removed" passes succeeds, and 52 // running the "Kept" passes fail when run on the output of the "removed" 53 // passes. If we return true, we update the current module of bugpoint. 54 // 55 virtual TestResult doTest(std::vector<const PassInfo*> &Removed, 56 std::vector<const PassInfo*> &Kept, 57 std::string &Error); 58 }; 59} 60 61ReducePassList::TestResult 62ReducePassList::doTest(std::vector<const PassInfo*> &Prefix, 63 std::vector<const PassInfo*> &Suffix, 64 std::string &Error) { 65 sys::Path PrefixOutput; 66 Module *OrigProgram = 0; 67 if (!Prefix.empty()) { 68 outs() << "Checking to see if these passes crash: " 69 << getPassesString(Prefix) << ": "; 70 std::string PfxOutput; 71 if (BD.runPasses(Prefix, PfxOutput)) 72 return KeepPrefix; 73 74 PrefixOutput.set(PfxOutput); 75 OrigProgram = BD.Program; 76 77 BD.Program = ParseInputFile(PrefixOutput.str(), BD.getContext()); 78 if (BD.Program == 0) { 79 errs() << BD.getToolName() << ": Error reading bitcode file '" 80 << PrefixOutput.str() << "'!\n"; 81 exit(1); 82 } 83 PrefixOutput.eraseFromDisk(); 84 } 85 86 outs() << "Checking to see if these passes crash: " 87 << getPassesString(Suffix) << ": "; 88 89 if (BD.runPasses(Suffix)) { 90 delete OrigProgram; // The suffix crashes alone... 91 return KeepSuffix; 92 } 93 94 // Nothing failed, restore state... 95 if (OrigProgram) { 96 delete BD.Program; 97 BD.Program = OrigProgram; 98 } 99 return NoFailure; 100} 101 102namespace { 103 /// ReduceCrashingGlobalVariables - This works by removing the global 104 /// variable's initializer and seeing if the program still crashes. If it 105 /// does, then we keep that program and try again. 106 /// 107 class ReduceCrashingGlobalVariables : public ListReducer<GlobalVariable*> { 108 BugDriver &BD; 109 bool (*TestFn)(BugDriver &, Module *); 110 public: 111 ReduceCrashingGlobalVariables(BugDriver &bd, 112 bool (*testFn)(BugDriver &, Module *)) 113 : BD(bd), TestFn(testFn) {} 114 115 virtual TestResult doTest(std::vector<GlobalVariable*> &Prefix, 116 std::vector<GlobalVariable*> &Kept, 117 std::string &Error) { 118 if (!Kept.empty() && TestGlobalVariables(Kept)) 119 return KeepSuffix; 120 if (!Prefix.empty() && TestGlobalVariables(Prefix)) 121 return KeepPrefix; 122 return NoFailure; 123 } 124 125 bool TestGlobalVariables(std::vector<GlobalVariable*> &GVs); 126 }; 127} 128 129bool 130ReduceCrashingGlobalVariables::TestGlobalVariables( 131 std::vector<GlobalVariable*> &GVs) { 132 // Clone the program to try hacking it apart... 133 DenseMap<const Value*, Value*> ValueMap; 134 Module *M = CloneModule(BD.getProgram(), ValueMap); 135 136 // Convert list to set for fast lookup... 137 std::set<GlobalVariable*> GVSet; 138 139 for (unsigned i = 0, e = GVs.size(); i != e; ++i) { 140 GlobalVariable* CMGV = cast<GlobalVariable>(ValueMap[GVs[i]]); 141 assert(CMGV && "Global Variable not in module?!"); 142 GVSet.insert(CMGV); 143 } 144 145 outs() << "Checking for crash with only these global variables: "; 146 PrintGlobalVariableList(GVs); 147 outs() << ": "; 148 149 // Loop over and delete any global variables which we aren't supposed to be 150 // playing with... 151 for (Module::global_iterator I = M->global_begin(), E = M->global_end(); 152 I != E; ++I) 153 if (I->hasInitializer() && !GVSet.count(I)) { 154 I->setInitializer(0); 155 I->setLinkage(GlobalValue::ExternalLinkage); 156 } 157 158 // Try running the hacked up program... 159 if (TestFn(BD, M)) { 160 BD.setNewProgram(M); // It crashed, keep the trimmed version... 161 162 // Make sure to use global variable pointers that point into the now-current 163 // module. 164 GVs.assign(GVSet.begin(), GVSet.end()); 165 return true; 166 } 167 168 delete M; 169 return false; 170} 171 172namespace llvm { 173 /// ReduceCrashingFunctions reducer - This works by removing functions and 174 /// seeing if the program still crashes. If it does, then keep the newer, 175 /// smaller program. 176 /// 177 class ReduceCrashingFunctions : public ListReducer<Function*> { 178 BugDriver &BD; 179 bool (*TestFn)(BugDriver &, Module *); 180 public: 181 ReduceCrashingFunctions(BugDriver &bd, 182 bool (*testFn)(BugDriver &, Module *)) 183 : BD(bd), TestFn(testFn) {} 184 185 virtual TestResult doTest(std::vector<Function*> &Prefix, 186 std::vector<Function*> &Kept, 187 std::string &Error) { 188 if (!Kept.empty() && TestFuncs(Kept)) 189 return KeepSuffix; 190 if (!Prefix.empty() && TestFuncs(Prefix)) 191 return KeepPrefix; 192 return NoFailure; 193 } 194 195 bool TestFuncs(std::vector<Function*> &Prefix); 196 }; 197} 198 199bool ReduceCrashingFunctions::TestFuncs(std::vector<Function*> &Funcs) { 200 201 //if main isn't present, claim there is no problem 202 if (KeepMain && find(Funcs.begin(), Funcs.end(), 203 BD.getProgram()->getFunction("main")) == Funcs.end()) 204 return false; 205 206 // Clone the program to try hacking it apart... 207 DenseMap<const Value*, Value*> ValueMap; 208 Module *M = CloneModule(BD.getProgram(), ValueMap); 209 210 // Convert list to set for fast lookup... 211 std::set<Function*> Functions; 212 for (unsigned i = 0, e = Funcs.size(); i != e; ++i) { 213 Function *CMF = cast<Function>(ValueMap[Funcs[i]]); 214 assert(CMF && "Function not in module?!"); 215 assert(CMF->getFunctionType() == Funcs[i]->getFunctionType() && "wrong ty"); 216 assert(CMF->getName() == Funcs[i]->getName() && "wrong name"); 217 Functions.insert(CMF); 218 } 219 220 outs() << "Checking for crash with only these functions: "; 221 PrintFunctionList(Funcs); 222 outs() << ": "; 223 224 // Loop over and delete any functions which we aren't supposed to be playing 225 // with... 226 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) 227 if (!I->isDeclaration() && !Functions.count(I)) 228 DeleteFunctionBody(I); 229 230 // Try running the hacked up program... 231 if (TestFn(BD, M)) { 232 BD.setNewProgram(M); // It crashed, keep the trimmed version... 233 234 // Make sure to use function pointers that point into the now-current 235 // module. 236 Funcs.assign(Functions.begin(), Functions.end()); 237 return true; 238 } 239 delete M; 240 return false; 241} 242 243 244namespace { 245 /// ReduceCrashingBlocks reducer - This works by setting the terminators of 246 /// all terminators except the specified basic blocks to a 'ret' instruction, 247 /// then running the simplify-cfg pass. This has the effect of chopping up 248 /// the CFG really fast which can reduce large functions quickly. 249 /// 250 class ReduceCrashingBlocks : public ListReducer<const BasicBlock*> { 251 BugDriver &BD; 252 bool (*TestFn)(BugDriver &, Module *); 253 public: 254 ReduceCrashingBlocks(BugDriver &bd, bool (*testFn)(BugDriver &, Module *)) 255 : BD(bd), TestFn(testFn) {} 256 257 virtual TestResult doTest(std::vector<const BasicBlock*> &Prefix, 258 std::vector<const BasicBlock*> &Kept, 259 std::string &Error) { 260 if (!Kept.empty() && TestBlocks(Kept)) 261 return KeepSuffix; 262 if (!Prefix.empty() && TestBlocks(Prefix)) 263 return KeepPrefix; 264 return NoFailure; 265 } 266 267 bool TestBlocks(std::vector<const BasicBlock*> &Prefix); 268 }; 269} 270 271bool ReduceCrashingBlocks::TestBlocks(std::vector<const BasicBlock*> &BBs) { 272 // Clone the program to try hacking it apart... 273 DenseMap<const Value*, Value*> ValueMap; 274 Module *M = CloneModule(BD.getProgram(), ValueMap); 275 276 // Convert list to set for fast lookup... 277 SmallPtrSet<BasicBlock*, 8> Blocks; 278 for (unsigned i = 0, e = BBs.size(); i != e; ++i) 279 Blocks.insert(cast<BasicBlock>(ValueMap[BBs[i]])); 280 281 outs() << "Checking for crash with only these blocks:"; 282 unsigned NumPrint = Blocks.size(); 283 if (NumPrint > 10) NumPrint = 10; 284 for (unsigned i = 0, e = NumPrint; i != e; ++i) 285 outs() << " " << BBs[i]->getName(); 286 if (NumPrint < Blocks.size()) 287 outs() << "... <" << Blocks.size() << " total>"; 288 outs() << ": "; 289 290 // Loop over and delete any hack up any blocks that are not listed... 291 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) 292 for (Function::iterator BB = I->begin(), E = I->end(); BB != E; ++BB) 293 if (!Blocks.count(BB) && BB->getTerminator()->getNumSuccessors()) { 294 // Loop over all of the successors of this block, deleting any PHI nodes 295 // that might include it. 296 for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI) 297 (*SI)->removePredecessor(BB); 298 299 TerminatorInst *BBTerm = BB->getTerminator(); 300 301 if (BBTerm->getType()->isStructTy()) 302 BBTerm->replaceAllUsesWith(UndefValue::get(BBTerm->getType())); 303 else if (BB->getTerminator()->getType() != 304 Type::getVoidTy(BB->getContext())) 305 BBTerm->replaceAllUsesWith(Constant::getNullValue(BBTerm->getType())); 306 307 // Replace the old terminator instruction. 308 BB->getInstList().pop_back(); 309 new UnreachableInst(BB->getContext(), BB); 310 } 311 312 // The CFG Simplifier pass may delete one of the basic blocks we are 313 // interested in. If it does we need to take the block out of the list. Make 314 // a "persistent mapping" by turning basic blocks into <function, name> pairs. 315 // This won't work well if blocks are unnamed, but that is just the risk we 316 // have to take. 317 std::vector<std::pair<Function*, std::string> > BlockInfo; 318 319 for (SmallPtrSet<BasicBlock*, 8>::iterator I = Blocks.begin(), 320 E = Blocks.end(); I != E; ++I) 321 BlockInfo.push_back(std::make_pair((*I)->getParent(), (*I)->getName())); 322 323 // Now run the CFG simplify pass on the function... 324 PassManager Passes; 325 Passes.add(createCFGSimplificationPass()); 326 Passes.add(createVerifierPass()); 327 Passes.run(*M); 328 329 // Try running on the hacked up program... 330 if (TestFn(BD, M)) { 331 BD.setNewProgram(M); // It crashed, keep the trimmed version... 332 333 // Make sure to use basic block pointers that point into the now-current 334 // module, and that they don't include any deleted blocks. 335 BBs.clear(); 336 for (unsigned i = 0, e = BlockInfo.size(); i != e; ++i) { 337 ValueSymbolTable &ST = BlockInfo[i].first->getValueSymbolTable(); 338 Value* V = ST.lookup(BlockInfo[i].second); 339 if (V && V->getType() == Type::getLabelTy(V->getContext())) 340 BBs.push_back(cast<BasicBlock>(V)); 341 } 342 return true; 343 } 344 delete M; // It didn't crash, try something else. 345 return false; 346} 347 348namespace { 349 /// ReduceCrashingInstructions reducer - This works by removing the specified 350 /// non-terminator instructions and replacing them with undef. 351 /// 352 class ReduceCrashingInstructions : public ListReducer<const Instruction*> { 353 BugDriver &BD; 354 bool (*TestFn)(BugDriver &, Module *); 355 public: 356 ReduceCrashingInstructions(BugDriver &bd, bool (*testFn)(BugDriver &, 357 Module *)) 358 : BD(bd), TestFn(testFn) {} 359 360 virtual TestResult doTest(std::vector<const Instruction*> &Prefix, 361 std::vector<const Instruction*> &Kept, 362 std::string &Error) { 363 if (!Kept.empty() && TestInsts(Kept)) 364 return KeepSuffix; 365 if (!Prefix.empty() && TestInsts(Prefix)) 366 return KeepPrefix; 367 return NoFailure; 368 } 369 370 bool TestInsts(std::vector<const Instruction*> &Prefix); 371 }; 372} 373 374bool ReduceCrashingInstructions::TestInsts(std::vector<const Instruction*> 375 &Insts) { 376 // Clone the program to try hacking it apart... 377 DenseMap<const Value*, Value*> ValueMap; 378 Module *M = CloneModule(BD.getProgram(), ValueMap); 379 380 // Convert list to set for fast lookup... 381 SmallPtrSet<Instruction*, 64> Instructions; 382 for (unsigned i = 0, e = Insts.size(); i != e; ++i) { 383 assert(!isa<TerminatorInst>(Insts[i])); 384 Instructions.insert(cast<Instruction>(ValueMap[Insts[i]])); 385 } 386 387 outs() << "Checking for crash with only " << Instructions.size(); 388 if (Instructions.size() == 1) 389 outs() << " instruction: "; 390 else 391 outs() << " instructions: "; 392 393 for (Module::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI) 394 for (Function::iterator FI = MI->begin(), FE = MI->end(); FI != FE; ++FI) 395 for (BasicBlock::iterator I = FI->begin(), E = FI->end(); I != E;) { 396 Instruction *Inst = I++; 397 if (!Instructions.count(Inst) && !isa<TerminatorInst>(Inst)) { 398 if (Inst->getType() != Type::getVoidTy(Inst->getContext())) 399 Inst->replaceAllUsesWith(UndefValue::get(Inst->getType())); 400 Inst->eraseFromParent(); 401 } 402 } 403 404 // Verify that this is still valid. 405 PassManager Passes; 406 Passes.add(createVerifierPass()); 407 Passes.run(*M); 408 409 // Try running on the hacked up program... 410 if (TestFn(BD, M)) { 411 BD.setNewProgram(M); // It crashed, keep the trimmed version... 412 413 // Make sure to use instruction pointers that point into the now-current 414 // module, and that they don't include any deleted blocks. 415 Insts.clear(); 416 for (SmallPtrSet<Instruction*, 64>::const_iterator I = Instructions.begin(), 417 E = Instructions.end(); I != E; ++I) 418 Insts.push_back(*I); 419 return true; 420 } 421 delete M; // It didn't crash, try something else. 422 return false; 423} 424 425/// DebugACrash - Given a predicate that determines whether a component crashes 426/// on a program, try to destructively reduce the program while still keeping 427/// the predicate true. 428static bool DebugACrash(BugDriver &BD, bool (*TestFn)(BugDriver &, Module *), 429 std::string &Error) { 430 // See if we can get away with nuking some of the global variable initializers 431 // in the program... 432 if (!NoGlobalRM && 433 BD.getProgram()->global_begin() != BD.getProgram()->global_end()) { 434 // Now try to reduce the number of global variable initializers in the 435 // module to something small. 436 Module *M = CloneModule(BD.getProgram()); 437 bool DeletedInit = false; 438 439 for (Module::global_iterator I = M->global_begin(), E = M->global_end(); 440 I != E; ++I) 441 if (I->hasInitializer()) { 442 I->setInitializer(0); 443 I->setLinkage(GlobalValue::ExternalLinkage); 444 DeletedInit = true; 445 } 446 447 if (!DeletedInit) { 448 delete M; // No change made... 449 } else { 450 // See if the program still causes a crash... 451 outs() << "\nChecking to see if we can delete global inits: "; 452 453 if (TestFn(BD, M)) { // Still crashes? 454 BD.setNewProgram(M); 455 outs() << "\n*** Able to remove all global initializers!\n"; 456 } else { // No longer crashes? 457 outs() << " - Removing all global inits hides problem!\n"; 458 delete M; 459 460 std::vector<GlobalVariable*> GVs; 461 462 for (Module::global_iterator I = BD.getProgram()->global_begin(), 463 E = BD.getProgram()->global_end(); I != E; ++I) 464 if (I->hasInitializer()) 465 GVs.push_back(I); 466 467 if (GVs.size() > 1 && !BugpointIsInterrupted) { 468 outs() << "\n*** Attempting to reduce the number of global " 469 << "variables in the testcase\n"; 470 471 unsigned OldSize = GVs.size(); 472 ReduceCrashingGlobalVariables(BD, TestFn).reduceList(GVs, Error); 473 if (!Error.empty()) 474 return true; 475 476 if (GVs.size() < OldSize) 477 BD.EmitProgressBitcode("reduced-global-variables"); 478 } 479 } 480 } 481 } 482 483 // Now try to reduce the number of functions in the module to something small. 484 std::vector<Function*> Functions; 485 for (Module::iterator I = BD.getProgram()->begin(), 486 E = BD.getProgram()->end(); I != E; ++I) 487 if (!I->isDeclaration()) 488 Functions.push_back(I); 489 490 if (Functions.size() > 1 && !BugpointIsInterrupted) { 491 outs() << "\n*** Attempting to reduce the number of functions " 492 "in the testcase\n"; 493 494 unsigned OldSize = Functions.size(); 495 ReduceCrashingFunctions(BD, TestFn).reduceList(Functions, Error); 496 497 if (Functions.size() < OldSize) 498 BD.EmitProgressBitcode("reduced-function"); 499 } 500 501 // Attempt to delete entire basic blocks at a time to speed up 502 // convergence... this actually works by setting the terminator of the blocks 503 // to a return instruction then running simplifycfg, which can potentially 504 // shrinks the code dramatically quickly 505 // 506 if (!DisableSimplifyCFG && !BugpointIsInterrupted) { 507 std::vector<const BasicBlock*> Blocks; 508 for (Module::const_iterator I = BD.getProgram()->begin(), 509 E = BD.getProgram()->end(); I != E; ++I) 510 for (Function::const_iterator FI = I->begin(), E = I->end(); FI !=E; ++FI) 511 Blocks.push_back(FI); 512 unsigned OldSize = Blocks.size(); 513 ReduceCrashingBlocks(BD, TestFn).reduceList(Blocks, Error); 514 if (Blocks.size() < OldSize) 515 BD.EmitProgressBitcode("reduced-blocks"); 516 } 517 518 // Attempt to delete instructions using bisection. This should help out nasty 519 // cases with large basic blocks where the problem is at one end. 520 if (!BugpointIsInterrupted) { 521 std::vector<const Instruction*> Insts; 522 for (Module::const_iterator MI = BD.getProgram()->begin(), 523 ME = BD.getProgram()->end(); MI != ME; ++MI) 524 for (Function::const_iterator FI = MI->begin(), FE = MI->end(); FI != FE; 525 ++FI) 526 for (BasicBlock::const_iterator I = FI->begin(), E = FI->end(); 527 I != E; ++I) 528 if (!isa<TerminatorInst>(I)) 529 Insts.push_back(I); 530 531 ReduceCrashingInstructions(BD, TestFn).reduceList(Insts, Error); 532 } 533 534 // FIXME: This should use the list reducer to converge faster by deleting 535 // larger chunks of instructions at a time! 536 unsigned Simplification = 2; 537 do { 538 if (BugpointIsInterrupted) break; 539 --Simplification; 540 outs() << "\n*** Attempting to reduce testcase by deleting instruc" 541 << "tions: Simplification Level #" << Simplification << '\n'; 542 543 // Now that we have deleted the functions that are unnecessary for the 544 // program, try to remove instructions that are not necessary to cause the 545 // crash. To do this, we loop through all of the instructions in the 546 // remaining functions, deleting them (replacing any values produced with 547 // nulls), and then running ADCE and SimplifyCFG. If the transformed input 548 // still triggers failure, keep deleting until we cannot trigger failure 549 // anymore. 550 // 551 unsigned InstructionsToSkipBeforeDeleting = 0; 552 TryAgain: 553 554 // Loop over all of the (non-terminator) instructions remaining in the 555 // function, attempting to delete them. 556 unsigned CurInstructionNum = 0; 557 for (Module::const_iterator FI = BD.getProgram()->begin(), 558 E = BD.getProgram()->end(); FI != E; ++FI) 559 if (!FI->isDeclaration()) 560 for (Function::const_iterator BI = FI->begin(), E = FI->end(); BI != E; 561 ++BI) 562 for (BasicBlock::const_iterator I = BI->begin(), E = --BI->end(); 563 I != E; ++I, ++CurInstructionNum) 564 if (InstructionsToSkipBeforeDeleting) { 565 --InstructionsToSkipBeforeDeleting; 566 } else { 567 if (BugpointIsInterrupted) goto ExitLoops; 568 569 outs() << "Checking instruction: " << *I; 570 Module *M = BD.deleteInstructionFromProgram(I, Simplification); 571 572 // Find out if the pass still crashes on this pass... 573 if (TestFn(BD, M)) { 574 // Yup, it does, we delete the old module, and continue trying 575 // to reduce the testcase... 576 BD.setNewProgram(M); 577 InstructionsToSkipBeforeDeleting = CurInstructionNum; 578 goto TryAgain; // I wish I had a multi-level break here! 579 } 580 581 // This pass didn't crash without this instruction, try the next 582 // one. 583 delete M; 584 } 585 586 if (InstructionsToSkipBeforeDeleting) { 587 InstructionsToSkipBeforeDeleting = 0; 588 goto TryAgain; 589 } 590 591 } while (Simplification); 592ExitLoops: 593 594 // Try to clean up the testcase by running funcresolve and globaldce... 595 if (!BugpointIsInterrupted) { 596 outs() << "\n*** Attempting to perform final cleanups: "; 597 Module *M = CloneModule(BD.getProgram()); 598 M = BD.performFinalCleanups(M, true); 599 600 // Find out if the pass still crashes on the cleaned up program... 601 if (TestFn(BD, M)) { 602 BD.setNewProgram(M); // Yup, it does, keep the reduced version... 603 } else { 604 delete M; 605 } 606 } 607 608 BD.EmitProgressBitcode("reduced-simplified"); 609 610 return false; 611} 612 613static bool TestForOptimizerCrash(BugDriver &BD, Module *M) { 614 return BD.runPasses(M); 615} 616 617/// debugOptimizerCrash - This method is called when some pass crashes on input. 618/// It attempts to prune down the testcase to something reasonable, and figure 619/// out exactly which pass is crashing. 620/// 621bool BugDriver::debugOptimizerCrash(const std::string &ID) { 622 outs() << "\n*** Debugging optimizer crash!\n"; 623 624 std::string Error; 625 // Reduce the list of passes which causes the optimizer to crash... 626 if (!BugpointIsInterrupted) 627 ReducePassList(*this).reduceList(PassesToRun, Error); 628 assert(Error.empty()); 629 630 outs() << "\n*** Found crashing pass" 631 << (PassesToRun.size() == 1 ? ": " : "es: ") 632 << getPassesString(PassesToRun) << '\n'; 633 634 EmitProgressBitcode(ID); 635 636 bool Success = DebugACrash(*this, TestForOptimizerCrash, Error); 637 assert(Error.empty()); 638 return Success; 639} 640 641static bool TestForCodeGenCrash(BugDriver &BD, Module *M) { 642 std::string Error; 643 BD.compileProgram(M, &Error); 644 if (!Error.empty()) { 645 errs() << "<crash>\n"; 646 return true; // Tool is still crashing. 647 } 648 errs() << '\n'; 649 return false; 650} 651 652/// debugCodeGeneratorCrash - This method is called when the code generator 653/// crashes on an input. It attempts to reduce the input as much as possible 654/// while still causing the code generator to crash. 655bool BugDriver::debugCodeGeneratorCrash(std::string &Error) { 656 errs() << "*** Debugging code generator crash!\n"; 657 658 return DebugACrash(*this, TestForCodeGenCrash, Error); 659} 660