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