Miscompilation.cpp revision 8c194eaa0577a207bb1ea91bf2c2a5e664fce9ee
1//===- Miscompilation.cpp - Debug program miscompilations -----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements optimizer and code generation miscompilation debugging 11// support. 12// 13//===----------------------------------------------------------------------===// 14 15#include "BugDriver.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/Analysis/Verifier.h" 23#include "llvm/Support/Mangler.h" 24#include "llvm/Transforms/Utils/Cloning.h" 25#include "llvm/Transforms/Utils/Linker.h" 26#include "Support/CommandLine.h" 27#include "Support/FileUtilities.h" 28using namespace llvm; 29 30namespace llvm { 31 extern cl::list<std::string> InputArgv; 32} 33 34namespace { 35 class ReduceMiscompilingPasses : public ListReducer<const PassInfo*> { 36 BugDriver &BD; 37 public: 38 ReduceMiscompilingPasses(BugDriver &bd) : BD(bd) {} 39 40 virtual TestResult doTest(std::vector<const PassInfo*> &Prefix, 41 std::vector<const PassInfo*> &Suffix); 42 }; 43} 44 45/// TestResult - After passes have been split into a test group and a control 46/// group, see if they still break the program. 47/// 48ReduceMiscompilingPasses::TestResult 49ReduceMiscompilingPasses::doTest(std::vector<const PassInfo*> &Prefix, 50 std::vector<const PassInfo*> &Suffix) { 51 // First, run the program with just the Suffix passes. If it is still broken 52 // with JUST the kept passes, discard the prefix passes. 53 std::cout << "Checking to see if '" << getPassesString(Suffix) 54 << "' compile correctly: "; 55 56 std::string BytecodeResult; 57 if (BD.runPasses(Suffix, BytecodeResult, false/*delete*/, true/*quiet*/)) { 58 std::cerr << " Error running this sequence of passes" 59 << " on the input program!\n"; 60 BD.setPassesToRun(Suffix); 61 BD.EmitProgressBytecode("pass-error", false); 62 exit(BD.debugOptimizerCrash()); 63 } 64 65 // Check to see if the finished program matches the reference output... 66 if (BD.diffProgram(BytecodeResult, "", true /*delete bytecode*/)) { 67 std::cout << "nope.\n"; 68 return KeepSuffix; // Miscompilation detected! 69 } 70 std::cout << "yup.\n"; // No miscompilation! 71 72 if (Prefix.empty()) return NoFailure; 73 74 // Next, see if the program is broken if we run the "prefix" passes first, 75 // then separately run the "kept" passes. 76 std::cout << "Checking to see if '" << getPassesString(Prefix) 77 << "' compile correctly: "; 78 79 // If it is not broken with the kept passes, it's possible that the prefix 80 // passes must be run before the kept passes to break it. If the program 81 // WORKS after the prefix passes, but then fails if running the prefix AND 82 // kept passes, we can update our bytecode file to include the result of the 83 // prefix passes, then discard the prefix passes. 84 // 85 if (BD.runPasses(Prefix, BytecodeResult, false/*delete*/, true/*quiet*/)) { 86 std::cerr << " Error running this sequence of passes" 87 << " on the input program!\n"; 88 BD.setPassesToRun(Prefix); 89 BD.EmitProgressBytecode("pass-error", false); 90 exit(BD.debugOptimizerCrash()); 91 } 92 93 // If the prefix maintains the predicate by itself, only keep the prefix! 94 if (BD.diffProgram(BytecodeResult)) { 95 std::cout << "nope.\n"; 96 removeFile(BytecodeResult); 97 return KeepPrefix; 98 } 99 std::cout << "yup.\n"; // No miscompilation! 100 101 // Ok, so now we know that the prefix passes work, try running the suffix 102 // passes on the result of the prefix passes. 103 // 104 Module *PrefixOutput = ParseInputFile(BytecodeResult); 105 if (PrefixOutput == 0) { 106 std::cerr << BD.getToolName() << ": Error reading bytecode file '" 107 << BytecodeResult << "'!\n"; 108 exit(1); 109 } 110 removeFile(BytecodeResult); // No longer need the file on disk 111 112 std::cout << "Checking to see if '" << getPassesString(Suffix) 113 << "' passes compile correctly after the '" 114 << getPassesString(Prefix) << "' passes: "; 115 116 Module *OriginalInput = BD.swapProgramIn(PrefixOutput); 117 if (BD.runPasses(Suffix, BytecodeResult, false/*delete*/, true/*quiet*/)) { 118 std::cerr << " Error running this sequence of passes" 119 << " on the input program!\n"; 120 BD.setPassesToRun(Suffix); 121 BD.EmitProgressBytecode("pass-error", false); 122 exit(BD.debugOptimizerCrash()); 123 } 124 125 // Run the result... 126 if (BD.diffProgram(BytecodeResult, "", true/*delete bytecode*/)) { 127 std::cout << "nope.\n"; 128 delete OriginalInput; // We pruned down the original input... 129 return KeepSuffix; 130 } 131 132 // Otherwise, we must not be running the bad pass anymore. 133 std::cout << "yup.\n"; // No miscompilation! 134 delete BD.swapProgramIn(OriginalInput); // Restore orig program & free test 135 return NoFailure; 136} 137 138namespace { 139 class ReduceMiscompilingFunctions : public ListReducer<Function*> { 140 BugDriver &BD; 141 bool (*TestFn)(BugDriver &, Module *, Module *); 142 public: 143 ReduceMiscompilingFunctions(BugDriver &bd, 144 bool (*F)(BugDriver &, Module *, Module *)) 145 : BD(bd), TestFn(F) {} 146 147 virtual TestResult doTest(std::vector<Function*> &Prefix, 148 std::vector<Function*> &Suffix) { 149 if (!Suffix.empty() && TestFuncs(Suffix)) 150 return KeepSuffix; 151 if (!Prefix.empty() && TestFuncs(Prefix)) 152 return KeepPrefix; 153 return NoFailure; 154 } 155 156 bool TestFuncs(const std::vector<Function*> &Prefix); 157 }; 158} 159 160/// TestMergedProgram - Given two modules, link them together and run the 161/// program, checking to see if the program matches the diff. If the diff 162/// matches, return false, otherwise return true. If the DeleteInputs argument 163/// is set to true then this function deletes both input modules before it 164/// returns. 165/// 166static bool TestMergedProgram(BugDriver &BD, Module *M1, Module *M2, 167 bool DeleteInputs) { 168 // Link the two portions of the program back to together. 169 std::string ErrorMsg; 170 if (!DeleteInputs) M1 = CloneModule(M1); 171 if (LinkModules(M1, M2, &ErrorMsg)) { 172 std::cerr << BD.getToolName() << ": Error linking modules together:" 173 << ErrorMsg << "\n"; 174 exit(1); 175 } 176 if (DeleteInputs) delete M2; // We are done with this module... 177 178 Module *OldProgram = BD.swapProgramIn(M1); 179 180 // Execute the program. If it does not match the expected output, we must 181 // return true. 182 bool Broken = BD.diffProgram(); 183 184 // Delete the linked module & restore the original 185 BD.swapProgramIn(OldProgram); 186 delete M1; 187 return Broken; 188} 189 190/// TestFuncs - split functions in a Module into two groups: those that are 191/// under consideration for miscompilation vs. those that are not, and test 192/// accordingly. Each group of functions becomes a separate Module. 193/// 194bool ReduceMiscompilingFunctions::TestFuncs(const std::vector<Function*>&Funcs){ 195 // Test to see if the function is misoptimized if we ONLY run it on the 196 // functions listed in Funcs. 197 std::cout << "Checking to see if the program is misoptimized when " 198 << (Funcs.size()==1 ? "this function is" : "these functions are") 199 << " run through the pass" 200 << (BD.getPassesToRun().size() == 1 ? "" : "es") << ":"; 201 PrintFunctionList(Funcs); 202 std::cout << "\n"; 203 204 // Split the module into the two halves of the program we want. 205 Module *ToNotOptimize = CloneModule(BD.getProgram()); 206 Module *ToOptimize = SplitFunctionsOutOfModule(ToNotOptimize, Funcs); 207 208 // Run the predicate, not that the predicate will delete both input modules. 209 return TestFn(BD, ToOptimize, ToNotOptimize); 210} 211 212/// DisambiguateGlobalSymbols - Mangle symbols to guarantee uniqueness by 213/// modifying predominantly internal symbols rather than external ones. 214/// 215static void DisambiguateGlobalSymbols(Module *M) { 216 // Try not to cause collisions by minimizing chances of renaming an 217 // already-external symbol, so take in external globals and functions as-is. 218 // The code should work correctly without disambiguation (assuming the same 219 // mangler is used by the two code generators), but having symbols with the 220 // same name causes warnings to be emitted by the code generator. 221 Mangler Mang(*M); 222 for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 223 I->setName(Mang.getValueName(I)); 224 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) 225 I->setName(Mang.getValueName(I)); 226} 227 228/// ExtractLoops - Given a reduced list of functions that still exposed the bug, 229/// check to see if we can extract the loops in the region without obscuring the 230/// bug. If so, it reduces the amount of code identified. 231/// 232static bool ExtractLoops(BugDriver &BD, 233 bool (*TestFn)(BugDriver &, Module *, Module *), 234 std::vector<Function*> &MiscompiledFunctions) { 235 bool MadeChange = false; 236 while (1) { 237 Module *ToNotOptimize = CloneModule(BD.getProgram()); 238 Module *ToOptimize = SplitFunctionsOutOfModule(ToNotOptimize, 239 MiscompiledFunctions); 240 Module *ToOptimizeLoopExtracted = BD.ExtractLoop(ToOptimize); 241 if (!ToOptimizeLoopExtracted) { 242 // If the loop extractor crashed or if there were no extractible loops, 243 // then this chapter of our odyssey is over with. 244 delete ToNotOptimize; 245 delete ToOptimize; 246 return MadeChange; 247 } 248 249 std::cerr << "Extracted a loop from the breaking portion of the program.\n"; 250 delete ToOptimize; 251 252 // Bugpoint is intentionally not very trusting of LLVM transformations. In 253 // particular, we're not going to assume that the loop extractor works, so 254 // we're going to test the newly loop extracted program to make sure nothing 255 // has broken. If something broke, then we'll inform the user and stop 256 // extraction. 257 AbstractInterpreter *AI = BD.switchToCBE(); 258 if (TestMergedProgram(BD, ToOptimizeLoopExtracted, ToNotOptimize, false)) { 259 BD.switchToInterpreter(AI); 260 261 // Merged program doesn't work anymore! 262 std::cerr << " *** ERROR: Loop extraction broke the program. :(" 263 << " Please report a bug!\n"; 264 std::cerr << " Continuing on with un-loop-extracted version.\n"; 265 delete ToNotOptimize; 266 delete ToOptimizeLoopExtracted; 267 return MadeChange; 268 } 269 BD.switchToInterpreter(AI); 270 271 std::cout << " Testing after loop extraction:\n"; 272 // Clone modules, the tester function will free them. 273 Module *TOLEBackup = CloneModule(ToOptimizeLoopExtracted); 274 Module *TNOBackup = CloneModule(ToNotOptimize); 275 if (!TestFn(BD, ToOptimizeLoopExtracted, ToNotOptimize)) { 276 std::cout << "*** Loop extraction masked the problem. Undoing.\n"; 277 // If the program is not still broken, then loop extraction did something 278 // that masked the error. Stop loop extraction now. 279 delete TOLEBackup; 280 delete TNOBackup; 281 return MadeChange; 282 } 283 ToOptimizeLoopExtracted = TOLEBackup; 284 ToNotOptimize = TNOBackup; 285 286 std::cout << "*** Loop extraction successful!\n"; 287 288 // Okay, great! Now we know that we extracted a loop and that loop 289 // extraction both didn't break the program, and didn't mask the problem. 290 // Replace the current program with the loop extracted version, and try to 291 // extract another loop. 292 std::string ErrorMsg; 293 if (LinkModules(ToNotOptimize, ToOptimizeLoopExtracted, &ErrorMsg)) { 294 std::cerr << BD.getToolName() << ": Error linking modules together:" 295 << ErrorMsg << "\n"; 296 exit(1); 297 } 298 299 // All of the Function*'s in the MiscompiledFunctions list are in the old 300 // module. Update this list to include all of the functions in the 301 // optimized and loop extracted module. 302 MiscompiledFunctions.clear(); 303 for (Module::iterator I = ToOptimizeLoopExtracted->begin(), 304 E = ToOptimizeLoopExtracted->end(); I != E; ++I) { 305 if (!I->isExternal()) { 306 Function *NewF = ToNotOptimize->getFunction(I->getName(), 307 I->getFunctionType()); 308 assert(NewF && "Function not found??"); 309 MiscompiledFunctions.push_back(NewF); 310 } 311 } 312 delete ToOptimizeLoopExtracted; 313 314 BD.setNewProgram(ToNotOptimize); 315 MadeChange = true; 316 } 317} 318 319/// DebugAMiscompilation - This is a generic driver to narrow down 320/// miscompilations, either in an optimization or a code generator. 321/// 322static std::vector<Function*> 323DebugAMiscompilation(BugDriver &BD, 324 bool (*TestFn)(BugDriver &, Module *, Module *)) { 325 // Okay, now that we have reduced the list of passes which are causing the 326 // failure, see if we can pin down which functions are being 327 // miscompiled... first build a list of all of the non-external functions in 328 // the program. 329 std::vector<Function*> MiscompiledFunctions; 330 Module *Prog = BD.getProgram(); 331 for (Module::iterator I = Prog->begin(), E = Prog->end(); I != E; ++I) 332 if (!I->isExternal()) 333 MiscompiledFunctions.push_back(I); 334 335 // Do the reduction... 336 ReduceMiscompilingFunctions(BD, TestFn).reduceList(MiscompiledFunctions); 337 338 std::cout << "\n*** The following function" 339 << (MiscompiledFunctions.size() == 1 ? " is" : "s are") 340 << " being miscompiled: "; 341 PrintFunctionList(MiscompiledFunctions); 342 std::cout << "\n"; 343 344 // See if we can rip any loops out of the miscompiled functions and still 345 // trigger the problem. 346 if (ExtractLoops(BD, TestFn, MiscompiledFunctions)) { 347 // Okay, we extracted some loops and the problem still appears. See if we 348 // can eliminate some of the created functions from being candidates. 349 350 // Loop extraction can introduce functions with the same name (foo_code). 351 // Make sure to disambiguate the symbols so that when the program is split 352 // apart that we can link it back together again. 353 DisambiguateGlobalSymbols(BD.getProgram()); 354 355 // Do the reduction... 356 ReduceMiscompilingFunctions(BD, TestFn).reduceList(MiscompiledFunctions); 357 358 std::cout << "\n*** The following function" 359 << (MiscompiledFunctions.size() == 1 ? " is" : "s are") 360 << " being miscompiled: "; 361 PrintFunctionList(MiscompiledFunctions); 362 std::cout << "\n"; 363 } 364 365 return MiscompiledFunctions; 366} 367 368/// TestOptimizer - This is the predicate function used to check to see if the 369/// "Test" portion of the program is misoptimized. If so, return true. In any 370/// case, both module arguments are deleted. 371/// 372static bool TestOptimizer(BugDriver &BD, Module *Test, Module *Safe) { 373 // Run the optimization passes on ToOptimize, producing a transformed version 374 // of the functions being tested. 375 std::cout << " Optimizing functions being tested: "; 376 Module *Optimized = BD.runPassesOn(Test, BD.getPassesToRun(), 377 /*AutoDebugCrashes*/true); 378 std::cout << "done.\n"; 379 delete Test; 380 381 std::cout << " Checking to see if the merged program executes correctly: "; 382 bool Broken = TestMergedProgram(BD, Optimized, Safe, true); 383 std::cout << (Broken ? " nope.\n" : " yup.\n"); 384 return Broken; 385} 386 387 388/// debugMiscompilation - This method is used when the passes selected are not 389/// crashing, but the generated output is semantically different from the 390/// input. 391/// 392bool BugDriver::debugMiscompilation() { 393 // Make sure something was miscompiled... 394 if (!ReduceMiscompilingPasses(*this).reduceList(PassesToRun)) { 395 std::cerr << "*** Optimized program matches reference output! No problem " 396 << "detected...\nbugpoint can't help you with your problem!\n"; 397 return false; 398 } 399 400 std::cout << "\n*** Found miscompiling pass" 401 << (getPassesToRun().size() == 1 ? "" : "es") << ": " 402 << getPassesString(getPassesToRun()) << "\n"; 403 EmitProgressBytecode("passinput"); 404 405 std::vector<Function*> MiscompiledFunctions = 406 DebugAMiscompilation(*this, TestOptimizer); 407 408 // Output a bunch of bytecode files for the user... 409 std::cout << "Outputting reduced bytecode files which expose the problem:\n"; 410 Module *ToNotOptimize = CloneModule(getProgram()); 411 Module *ToOptimize = SplitFunctionsOutOfModule(ToNotOptimize, 412 MiscompiledFunctions); 413 414 std::cout << " Non-optimized portion: "; 415 ToNotOptimize = swapProgramIn(ToNotOptimize); 416 EmitProgressBytecode("tonotoptimize", true); 417 setNewProgram(ToNotOptimize); // Delete hacked module. 418 419 std::cout << " Portion that is input to optimizer: "; 420 ToOptimize = swapProgramIn(ToOptimize); 421 EmitProgressBytecode("tooptimize"); 422 setNewProgram(ToOptimize); // Delete hacked module. 423 424 return false; 425} 426 427/// CleanupAndPrepareModules - Get the specified modules ready for code 428/// generator testing. 429/// 430static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test, 431 Module *Safe) { 432 // Clean up the modules, removing extra cruft that we don't need anymore... 433 Test = BD.performFinalCleanups(Test); 434 435 // If we are executing the JIT, we have several nasty issues to take care of. 436 if (!BD.isExecutingJIT()) return; 437 438 // First, if the main function is in the Safe module, we must add a stub to 439 // the Test module to call into it. Thus, we create a new function `main' 440 // which just calls the old one. 441 if (Function *oldMain = Safe->getNamedFunction("main")) 442 if (!oldMain->isExternal()) { 443 // Rename it 444 oldMain->setName("llvm_bugpoint_old_main"); 445 // Create a NEW `main' function with same type in the test module. 446 Function *newMain = new Function(oldMain->getFunctionType(), 447 GlobalValue::ExternalLinkage, 448 "main", Test); 449 // Create an `oldmain' prototype in the test module, which will 450 // corresponds to the real main function in the same module. 451 Function *oldMainProto = new Function(oldMain->getFunctionType(), 452 GlobalValue::ExternalLinkage, 453 oldMain->getName(), Test); 454 // Set up and remember the argument list for the main function. 455 std::vector<Value*> args; 456 for (Function::aiterator I = newMain->abegin(), E = newMain->aend(), 457 OI = oldMain->abegin(); I != E; ++I, ++OI) { 458 I->setName(OI->getName()); // Copy argument names from oldMain 459 args.push_back(I); 460 } 461 462 // Call the old main function and return its result 463 BasicBlock *BB = new BasicBlock("entry", newMain); 464 CallInst *call = new CallInst(oldMainProto, args); 465 BB->getInstList().push_back(call); 466 467 // If the type of old function wasn't void, return value of call 468 new ReturnInst(oldMain->getReturnType() != Type::VoidTy ? call : 0, BB); 469 } 470 471 // The second nasty issue we must deal with in the JIT is that the Safe 472 // module cannot directly reference any functions defined in the test 473 // module. Instead, we use a JIT API call to dynamically resolve the 474 // symbol. 475 476 // Add the resolver to the Safe module. 477 // Prototype: void *getPointerToNamedFunction(const char* Name) 478 Function *resolverFunc = 479 Safe->getOrInsertFunction("getPointerToNamedFunction", 480 PointerType::get(Type::SByteTy), 481 PointerType::get(Type::SByteTy), 0); 482 483 // Use the function we just added to get addresses of functions we need. 484 for (Module::iterator F = Safe->begin(), E = Safe->end(); F != E; ++F) { 485 if (F->isExternal() && !F->use_empty() && &*F != resolverFunc && 486 F->getIntrinsicID() == 0 /* ignore intrinsics */) { 487 Function *TestFn = Test->getFunction(F->getName(), F->getFunctionType()); 488 489 // Don't forward functions which are external in the test module too. 490 if (TestFn && !TestFn->isExternal()) { 491 // 1. Add a string constant with its name to the global file 492 Constant *InitArray = ConstantArray::get(F->getName()); 493 GlobalVariable *funcName = 494 new GlobalVariable(InitArray->getType(), true /*isConstant*/, 495 GlobalValue::InternalLinkage, InitArray, 496 F->getName() + "_name", Safe); 497 498 // 2. Use `GetElementPtr *funcName, 0, 0' to convert the string to an 499 // sbyte* so it matches the signature of the resolver function. 500 501 // GetElementPtr *funcName, ulong 0, ulong 0 502 std::vector<Constant*> GEPargs(2,Constant::getNullValue(Type::IntTy)); 503 Value *GEP = 504 ConstantExpr::getGetElementPtr(ConstantPointerRef::get(funcName), 505 GEPargs); 506 std::vector<Value*> ResolverArgs; 507 ResolverArgs.push_back(GEP); 508 509 // Rewrite uses of F in global initializers, etc. to uses of a wrapper 510 // function that dynamically resolves the calls to F via our JIT API 511 if (F->use_begin() != F->use_end()) { 512 // Construct a new stub function that will re-route calls to F 513 const FunctionType *FuncTy = F->getFunctionType(); 514 Function *FuncWrapper = new Function(FuncTy, 515 GlobalValue::InternalLinkage, 516 F->getName() + "_wrapper", 517 F->getParent()); 518 BasicBlock *Header = new BasicBlock("header", FuncWrapper); 519 520 // Resolve the call to function F via the JIT API: 521 // 522 // call resolver(GetElementPtr...) 523 CallInst *resolve = new CallInst(resolverFunc, ResolverArgs, 524 "resolver"); 525 Header->getInstList().push_back(resolve); 526 // cast the result from the resolver to correctly-typed function 527 CastInst *castResolver = 528 new CastInst(resolve, PointerType::get(F->getFunctionType()), 529 "resolverCast"); 530 Header->getInstList().push_back(castResolver); 531 532 // Save the argument list 533 std::vector<Value*> Args; 534 for (Function::aiterator i = FuncWrapper->abegin(), 535 e = FuncWrapper->aend(); i != e; ++i) 536 Args.push_back(i); 537 538 // Pass on the arguments to the real function, return its result 539 if (F->getReturnType() == Type::VoidTy) { 540 CallInst *Call = new CallInst(castResolver, Args); 541 Header->getInstList().push_back(Call); 542 ReturnInst *Ret = new ReturnInst(); 543 Header->getInstList().push_back(Ret); 544 } else { 545 CallInst *Call = new CallInst(castResolver, Args, "redir"); 546 Header->getInstList().push_back(Call); 547 ReturnInst *Ret = new ReturnInst(Call); 548 Header->getInstList().push_back(Ret); 549 } 550 551 // Use the wrapper function instead of the old function 552 F->replaceAllUsesWith(FuncWrapper); 553 } 554 } 555 } 556 } 557 558 if (verifyModule(*Test) || verifyModule(*Safe)) { 559 std::cerr << "Bugpoint has a bug, which corrupted a module!!\n"; 560 abort(); 561 } 562} 563 564 565 566/// TestCodeGenerator - This is the predicate function used to check to see if 567/// the "Test" portion of the program is miscompiled by the code generator under 568/// test. If so, return true. In any case, both module arguments are deleted. 569/// 570static bool TestCodeGenerator(BugDriver &BD, Module *Test, Module *Safe) { 571 CleanupAndPrepareModules(BD, Test, Safe); 572 573 std::string TestModuleBC = getUniqueFilename("bugpoint.test.bc"); 574 if (BD.writeProgramToFile(TestModuleBC, Test)) { 575 std::cerr << "Error writing bytecode to `" << TestModuleBC << "'\nExiting."; 576 exit(1); 577 } 578 delete Test; 579 580 // Make the shared library 581 std::string SafeModuleBC = getUniqueFilename("bugpoint.safe.bc"); 582 583 if (BD.writeProgramToFile(SafeModuleBC, Safe)) { 584 std::cerr << "Error writing bytecode to `" << SafeModuleBC << "'\nExiting."; 585 exit(1); 586 } 587 std::string SharedObject = BD.compileSharedObject(SafeModuleBC); 588 delete Safe; 589 590 // Run the code generator on the `Test' code, loading the shared library. 591 // The function returns whether or not the new output differs from reference. 592 int Result = BD.diffProgram(TestModuleBC, SharedObject, false); 593 594 if (Result) 595 std::cerr << ": still failing!\n"; 596 else 597 std::cerr << ": didn't fail.\n"; 598 removeFile(TestModuleBC); 599 removeFile(SafeModuleBC); 600 removeFile(SharedObject); 601 602 return Result; 603} 604 605 606/// debugCodeGenerator - debug errors in LLC, LLI, or CBE. 607/// 608bool BugDriver::debugCodeGenerator() { 609 if ((void*)cbe == (void*)Interpreter) { 610 std::string Result = executeProgramWithCBE("bugpoint.cbe.out"); 611 std::cout << "\n*** The C backend cannot match the reference diff, but it " 612 << "is used as the 'known good'\n code generator, so I can't" 613 << " debug it. Perhaps you have a front-end problem?\n As a" 614 << " sanity check, I left the result of executing the program " 615 << "with the C backend\n in this file for you: '" 616 << Result << "'.\n"; 617 return true; 618 } 619 620 DisambiguateGlobalSymbols(Program); 621 622 std::vector<Function*> Funcs = DebugAMiscompilation(*this, TestCodeGenerator); 623 624 // Split the module into the two halves of the program we want. 625 Module *ToNotCodeGen = CloneModule(getProgram()); 626 Module *ToCodeGen = SplitFunctionsOutOfModule(ToNotCodeGen, Funcs); 627 628 // Condition the modules 629 CleanupAndPrepareModules(*this, ToCodeGen, ToNotCodeGen); 630 631 std::string TestModuleBC = getUniqueFilename("bugpoint.test.bc"); 632 if (writeProgramToFile(TestModuleBC, ToCodeGen)) { 633 std::cerr << "Error writing bytecode to `" << TestModuleBC << "'\nExiting."; 634 exit(1); 635 } 636 delete ToCodeGen; 637 638 // Make the shared library 639 std::string SafeModuleBC = getUniqueFilename("bugpoint.safe.bc"); 640 if (writeProgramToFile(SafeModuleBC, ToNotCodeGen)) { 641 std::cerr << "Error writing bytecode to `" << SafeModuleBC << "'\nExiting."; 642 exit(1); 643 } 644 std::string SharedObject = compileSharedObject(SafeModuleBC); 645 delete ToNotCodeGen; 646 647 std::cout << "You can reproduce the problem with the command line: \n"; 648 if (isExecutingJIT()) { 649 std::cout << " lli -load " << SharedObject << " " << TestModuleBC; 650 } else { 651 std::cout << " llc " << TestModuleBC << " -o " << TestModuleBC << ".s\n"; 652 std::cout << " gcc " << SharedObject << " " << TestModuleBC 653 << ".s -o " << TestModuleBC << ".exe -Wl,-R.\n"; 654 std::cout << " " << TestModuleBC << ".exe"; 655 } 656 for (unsigned i=0, e = InputArgv.size(); i != e; ++i) 657 std::cout << " " << InputArgv[i]; 658 std::cout << "\n"; 659 std::cout << "The shared object was created with:\n llc -march=c " 660 << SafeModuleBC << " -o temporary.c\n" 661 << " gcc -xc temporary.c -O2 -o " << SharedObject 662#if defined(sparc) || defined(__sparc__) || defined(__sparcv9) 663 << " -G" // Compile a shared library, `-G' for Sparc 664#else 665 << " -shared" // `-shared' for Linux/X86, maybe others 666#endif 667 << " -fno-strict-aliasing\n"; 668 669 return false; 670} 671