[Bugpoint] Fix two crashes in miscompilation debugger

[tobiasvk]

Summary

A while back, a bunch of module pointers were changed to unique_ptrs but the
places where they were used weren't updated correctly. This patch fixes two
crashes I've come across. There may be more.

It's a bit sad that we have no tests for this code path in bugpoint and that
nobody seems to have noticed these until now.

tools/bugpoint/Miscompilation.cpp

while (1) {
     // Bugpoint is intentionally not very trusting of LLVM transformations.  In
     // particular, we're not going to assume that the loop extractor works, so
     // we're going to test the newly loop extracted program to make sure nothing
     // has broken.  If something broke, then we'll inform the user and stop
     // extraction.
     AbstractInterpreter *AI = BD.switchToSafeInterpreter();
     bool Failure;
     std::unique_ptr<Module> New =
-        testMergedProgram(BD, std::move(ToOptimizeLoopExtracted),
-                          std::move(ToNotOptimize), Error, Failure);
+        testMergedProgram(BD, CloneModule(ToOptimizeLoopExtracted.get()),
+                          CloneModule(ToNotOptimize.get()), Error, Failure);
     if (!New)
       return false;
 
     // Delete the original and set the new program.
     Module *Old = BD.swapProgramIn(New.release());
     for (unsigned i = 0, e = MiscompiledFunctions.size(); i != e; ++i)
       MiscompiledFunctions[i] = cast<Function>(VMap[MiscompiledFunctions[i]]);
     delete Old;

 }
 
 /// Get the specified modules ready for code generator testing.
 ///
 static void CleanupAndPrepareModules(BugDriver &BD,
                                      std::unique_ptr<Module> &Test,
                                      Module *Safe) {
   // Clean up the modules, removing extra cruft that we don't need anymore...
-  Test = BD.performFinalCleanups(Test.get());
+  Test = BD.performFinalCleanups(Test.release());
 
   // If we are executing the JIT, we have several nasty issues to take care of.
   if (!BD.isExecutingJIT()) return;
 
   // First, if the main function is in the Safe module, we must add a stub to
   // the Test module to call into it.  Thus, we create a new function `main'
   // which just calls the old one.
   if (Function *oldMain = Safe->getFunction("main"))