CrashDebugger.cpp revision 210006
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 ValueMap<const Value*, Value*> VMap; 134 Module *M = CloneModule(BD.getProgram(), VMap); 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>(VMap[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 ValueMap<const Value*, Value*> VMap; 208 Module *M = CloneModule(BD.getProgram(), VMap); 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>(VMap[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 ValueMap<const Value*, Value*> VMap; 274 Module *M = CloneModule(BD.getProgram(), VMap); 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>(VMap[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 (!BB->getTerminator()->getType()->isVoidTy()) 302 BBTerm->replaceAllUsesWith(Constant::getNullValue(BBTerm->getType())); 303 304 // Replace the old terminator instruction. 305 BB->getInstList().pop_back(); 306 new UnreachableInst(BB->getContext(), BB); 307 } 308 309 // The CFG Simplifier pass may delete one of the basic blocks we are 310 // interested in. If it does we need to take the block out of the list. Make 311 // a "persistent mapping" by turning basic blocks into <function, name> pairs. 312 // This won't work well if blocks are unnamed, but that is just the risk we 313 // have to take. 314 std::vector<std::pair<Function*, std::string> > BlockInfo; 315 316 for (SmallPtrSet<BasicBlock*, 8>::iterator I = Blocks.begin(), 317 E = Blocks.end(); I != E; ++I) 318 BlockInfo.push_back(std::make_pair((*I)->getParent(), (*I)->getName())); 319 320 // Now run the CFG simplify pass on the function... 321 PassManager Passes; 322 Passes.add(createCFGSimplificationPass()); 323 Passes.add(createVerifierPass()); 324 Passes.run(*M); 325 326 // Try running on the hacked up program... 327 if (TestFn(BD, M)) { 328 BD.setNewProgram(M); // It crashed, keep the trimmed version... 329 330 // Make sure to use basic block pointers that point into the now-current 331 // module, and that they don't include any deleted blocks. 332 BBs.clear(); 333 for (unsigned i = 0, e = BlockInfo.size(); i != e; ++i) { 334 ValueSymbolTable &ST = BlockInfo[i].first->getValueSymbolTable(); 335 Value* V = ST.lookup(BlockInfo[i].second); 336 if (V && V->getType() == Type::getLabelTy(V->getContext())) 337 BBs.push_back(cast<BasicBlock>(V)); 338 } 339 return true; 340 } 341 delete M; // It didn't crash, try something else. 342 return false; 343} 344 345namespace { 346 /// ReduceCrashingInstructions reducer - This works by removing the specified 347 /// non-terminator instructions and replacing them with undef. 348 /// 349 class ReduceCrashingInstructions : public ListReducer<const Instruction*> { 350 BugDriver &BD; 351 bool (*TestFn)(BugDriver &, Module *); 352 public: 353 ReduceCrashingInstructions(BugDriver &bd, bool (*testFn)(BugDriver &, 354 Module *)) 355 : BD(bd), TestFn(testFn) {} 356 357 virtual TestResult doTest(std::vector<const Instruction*> &Prefix, 358 std::vector<const Instruction*> &Kept, 359 std::string &Error) { 360 if (!Kept.empty() && TestInsts(Kept)) 361 return KeepSuffix; 362 if (!Prefix.empty() && TestInsts(Prefix)) 363 return KeepPrefix; 364 return NoFailure; 365 } 366 367 bool TestInsts(std::vector<const Instruction*> &Prefix); 368 }; 369} 370 371bool ReduceCrashingInstructions::TestInsts(std::vector<const Instruction*> 372 &Insts) { 373 // Clone the program to try hacking it apart... 374 ValueMap<const Value*, Value*> VMap; 375 Module *M = CloneModule(BD.getProgram(), VMap); 376 377 // Convert list to set for fast lookup... 378 SmallPtrSet<Instruction*, 64> Instructions; 379 for (unsigned i = 0, e = Insts.size(); i != e; ++i) { 380 assert(!isa<TerminatorInst>(Insts[i])); 381 Instructions.insert(cast<Instruction>(VMap[Insts[i]])); 382 } 383 384 outs() << "Checking for crash with only " << Instructions.size(); 385 if (Instructions.size() == 1) 386 outs() << " instruction: "; 387 else 388 outs() << " instructions: "; 389 390 for (Module::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI) 391 for (Function::iterator FI = MI->begin(), FE = MI->end(); FI != FE; ++FI) 392 for (BasicBlock::iterator I = FI->begin(), E = FI->end(); I != E;) { 393 Instruction *Inst = I++; 394 if (!Instructions.count(Inst) && !isa<TerminatorInst>(Inst)) { 395 if (!Inst->getType()->isVoidTy()) 396 Inst->replaceAllUsesWith(UndefValue::get(Inst->getType())); 397 Inst->eraseFromParent(); 398 } 399 } 400 401 // Verify that this is still valid. 402 PassManager Passes; 403 Passes.add(createVerifierPass()); 404 Passes.run(*M); 405 406 // Try running on the hacked up program... 407 if (TestFn(BD, M)) { 408 BD.setNewProgram(M); // It crashed, keep the trimmed version... 409 410 // Make sure to use instruction pointers that point into the now-current 411 // module, and that they don't include any deleted blocks. 412 Insts.clear(); 413 for (SmallPtrSet<Instruction*, 64>::const_iterator I = Instructions.begin(), 414 E = Instructions.end(); I != E; ++I) 415 Insts.push_back(*I); 416 return true; 417 } 418 delete M; // It didn't crash, try something else. 419 return false; 420} 421 422/// DebugACrash - Given a predicate that determines whether a component crashes 423/// on a program, try to destructively reduce the program while still keeping 424/// the predicate true. 425static bool DebugACrash(BugDriver &BD, bool (*TestFn)(BugDriver &, Module *), 426 std::string &Error) { 427 // See if we can get away with nuking some of the global variable initializers 428 // in the program... 429 if (!NoGlobalRM && 430 BD.getProgram()->global_begin() != BD.getProgram()->global_end()) { 431 // Now try to reduce the number of global variable initializers in the 432 // module to something small. 433 Module *M = CloneModule(BD.getProgram()); 434 bool DeletedInit = false; 435 436 for (Module::global_iterator I = M->global_begin(), E = M->global_end(); 437 I != E; ++I) 438 if (I->hasInitializer()) { 439 I->setInitializer(0); 440 I->setLinkage(GlobalValue::ExternalLinkage); 441 DeletedInit = true; 442 } 443 444 if (!DeletedInit) { 445 delete M; // No change made... 446 } else { 447 // See if the program still causes a crash... 448 outs() << "\nChecking to see if we can delete global inits: "; 449 450 if (TestFn(BD, M)) { // Still crashes? 451 BD.setNewProgram(M); 452 outs() << "\n*** Able to remove all global initializers!\n"; 453 } else { // No longer crashes? 454 outs() << " - Removing all global inits hides problem!\n"; 455 delete M; 456 457 std::vector<GlobalVariable*> GVs; 458 459 for (Module::global_iterator I = BD.getProgram()->global_begin(), 460 E = BD.getProgram()->global_end(); I != E; ++I) 461 if (I->hasInitializer()) 462 GVs.push_back(I); 463 464 if (GVs.size() > 1 && !BugpointIsInterrupted) { 465 outs() << "\n*** Attempting to reduce the number of global " 466 << "variables in the testcase\n"; 467 468 unsigned OldSize = GVs.size(); 469 ReduceCrashingGlobalVariables(BD, TestFn).reduceList(GVs, Error); 470 if (!Error.empty()) 471 return true; 472 473 if (GVs.size() < OldSize) 474 BD.EmitProgressBitcode("reduced-global-variables"); 475 } 476 } 477 } 478 } 479 480 // Now try to reduce the number of functions in the module to something small. 481 std::vector<Function*> Functions; 482 for (Module::iterator I = BD.getProgram()->begin(), 483 E = BD.getProgram()->end(); I != E; ++I) 484 if (!I->isDeclaration()) 485 Functions.push_back(I); 486 487 if (Functions.size() > 1 && !BugpointIsInterrupted) { 488 outs() << "\n*** Attempting to reduce the number of functions " 489 "in the testcase\n"; 490 491 unsigned OldSize = Functions.size(); 492 ReduceCrashingFunctions(BD, TestFn).reduceList(Functions, Error); 493 494 if (Functions.size() < OldSize) 495 BD.EmitProgressBitcode("reduced-function"); 496 } 497 498 // Attempt to delete entire basic blocks at a time to speed up 499 // convergence... this actually works by setting the terminator of the blocks 500 // to a return instruction then running simplifycfg, which can potentially 501 // shrinks the code dramatically quickly 502 // 503 if (!DisableSimplifyCFG && !BugpointIsInterrupted) { 504 std::vector<const BasicBlock*> Blocks; 505 for (Module::const_iterator I = BD.getProgram()->begin(), 506 E = BD.getProgram()->end(); I != E; ++I) 507 for (Function::const_iterator FI = I->begin(), E = I->end(); FI !=E; ++FI) 508 Blocks.push_back(FI); 509 unsigned OldSize = Blocks.size(); 510 ReduceCrashingBlocks(BD, TestFn).reduceList(Blocks, Error); 511 if (Blocks.size() < OldSize) 512 BD.EmitProgressBitcode("reduced-blocks"); 513 } 514 515 // Attempt to delete instructions using bisection. This should help out nasty 516 // cases with large basic blocks where the problem is at one end. 517 if (!BugpointIsInterrupted) { 518 std::vector<const Instruction*> Insts; 519 for (Module::const_iterator MI = BD.getProgram()->begin(), 520 ME = BD.getProgram()->end(); MI != ME; ++MI) 521 for (Function::const_iterator FI = MI->begin(), FE = MI->end(); FI != FE; 522 ++FI) 523 for (BasicBlock::const_iterator I = FI->begin(), E = FI->end(); 524 I != E; ++I) 525 if (!isa<TerminatorInst>(I)) 526 Insts.push_back(I); 527 528 ReduceCrashingInstructions(BD, TestFn).reduceList(Insts, Error); 529 } 530 531 // FIXME: This should use the list reducer to converge faster by deleting 532 // larger chunks of instructions at a time! 533 unsigned Simplification = 2; 534 do { 535 if (BugpointIsInterrupted) break; 536 --Simplification; 537 outs() << "\n*** Attempting to reduce testcase by deleting instruc" 538 << "tions: Simplification Level #" << Simplification << '\n'; 539 540 // Now that we have deleted the functions that are unnecessary for the 541 // program, try to remove instructions that are not necessary to cause the 542 // crash. To do this, we loop through all of the instructions in the 543 // remaining functions, deleting them (replacing any values produced with 544 // nulls), and then running ADCE and SimplifyCFG. If the transformed input 545 // still triggers failure, keep deleting until we cannot trigger failure 546 // anymore. 547 // 548 unsigned InstructionsToSkipBeforeDeleting = 0; 549 TryAgain: 550 551 // Loop over all of the (non-terminator) instructions remaining in the 552 // function, attempting to delete them. 553 unsigned CurInstructionNum = 0; 554 for (Module::const_iterator FI = BD.getProgram()->begin(), 555 E = BD.getProgram()->end(); FI != E; ++FI) 556 if (!FI->isDeclaration()) 557 for (Function::const_iterator BI = FI->begin(), E = FI->end(); BI != E; 558 ++BI) 559 for (BasicBlock::const_iterator I = BI->begin(), E = --BI->end(); 560 I != E; ++I, ++CurInstructionNum) 561 if (InstructionsToSkipBeforeDeleting) { 562 --InstructionsToSkipBeforeDeleting; 563 } else { 564 if (BugpointIsInterrupted) goto ExitLoops; 565 566 outs() << "Checking instruction: " << *I; 567 Module *M = BD.deleteInstructionFromProgram(I, Simplification); 568 569 // Find out if the pass still crashes on this pass... 570 if (TestFn(BD, M)) { 571 // Yup, it does, we delete the old module, and continue trying 572 // to reduce the testcase... 573 BD.setNewProgram(M); 574 InstructionsToSkipBeforeDeleting = CurInstructionNum; 575 goto TryAgain; // I wish I had a multi-level break here! 576 } 577 578 // This pass didn't crash without this instruction, try the next 579 // one. 580 delete M; 581 } 582 583 if (InstructionsToSkipBeforeDeleting) { 584 InstructionsToSkipBeforeDeleting = 0; 585 goto TryAgain; 586 } 587 588 } while (Simplification); 589ExitLoops: 590 591 // Try to clean up the testcase by running funcresolve and globaldce... 592 if (!BugpointIsInterrupted) { 593 outs() << "\n*** Attempting to perform final cleanups: "; 594 Module *M = CloneModule(BD.getProgram()); 595 M = BD.performFinalCleanups(M, true); 596 597 // Find out if the pass still crashes on the cleaned up program... 598 if (TestFn(BD, M)) { 599 BD.setNewProgram(M); // Yup, it does, keep the reduced version... 600 } else { 601 delete M; 602 } 603 } 604 605 BD.EmitProgressBitcode("reduced-simplified"); 606 607 return false; 608} 609 610static bool TestForOptimizerCrash(BugDriver &BD, Module *M) { 611 return BD.runPasses(M); 612} 613 614/// debugOptimizerCrash - This method is called when some pass crashes on input. 615/// It attempts to prune down the testcase to something reasonable, and figure 616/// out exactly which pass is crashing. 617/// 618bool BugDriver::debugOptimizerCrash(const std::string &ID) { 619 outs() << "\n*** Debugging optimizer crash!\n"; 620 621 std::string Error; 622 // Reduce the list of passes which causes the optimizer to crash... 623 if (!BugpointIsInterrupted) 624 ReducePassList(*this).reduceList(PassesToRun, Error); 625 assert(Error.empty()); 626 627 outs() << "\n*** Found crashing pass" 628 << (PassesToRun.size() == 1 ? ": " : "es: ") 629 << getPassesString(PassesToRun) << '\n'; 630 631 EmitProgressBitcode(ID); 632 633 bool Success = DebugACrash(*this, TestForOptimizerCrash, Error); 634 assert(Error.empty()); 635 return Success; 636} 637 638static bool TestForCodeGenCrash(BugDriver &BD, Module *M) { 639 std::string Error; 640 BD.compileProgram(M, &Error); 641 if (!Error.empty()) { 642 errs() << "<crash>\n"; 643 return true; // Tool is still crashing. 644 } 645 errs() << '\n'; 646 return false; 647} 648 649/// debugCodeGeneratorCrash - This method is called when the code generator 650/// crashes on an input. It attempts to reduce the input as much as possible 651/// while still causing the code generator to crash. 652bool BugDriver::debugCodeGeneratorCrash(std::string &Error) { 653 errs() << "*** Debugging code generator crash!\n"; 654 655 return DebugACrash(*this, TestForCodeGenCrash, Error); 656} 657