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