[llvm] Add CloneModuleInto to clone a Module into another one, a la assignment

[hintonda]

Summary

The Module class contains an LLVMContext& member, which
prevents assignment. This technique uses placement new and passed the
new instance to the existing CloneModule functions to accomplish the
same thing.

This is useful in passes that want to clone the Module, prospectively
modify it, then decide whether or not to keep the changes, e.g.,
bugpoint type reduction passes.

[hintonda]

Rebase only...

llvm/include/llvm/Transforms/Utils/Cloning.h

 class InvokeInst;
 class Loop;
 class LoopInfo;
 class Module;
 class ProfileSummaryInfo;
 class ReturnInst;
 class DomTreeUpdater;
 
+void CloneModuleInto(Module &M, Module &TargetMod);
+
 /// Return an exact copy of the specified module
-std::unique_ptr<Module> CloneModule(const Module &M);
-std::unique_ptr<Module> CloneModule(const Module &M, ValueToValueMapTy &VMap);
+std::unique_ptr<Module> CloneModule(const Module &M,
+                                    Module *TargetMod = nullptr);
+std::unique_ptr<Module> CloneModule(const Module &M, ValueToValueMapTy &VMap,
+                                    Module *TargetMod = nullptr);
 
 /// Return a copy of the specified module. The ShouldCloneDefinition function
 /// controls whether a specific GlobalValue's definition is cloned. If the
 /// function returns false, the module copy will contain an external reference
 /// in place of the global definition.
 std::unique_ptr<Module>
 CloneModule(const Module &M, ValueToValueMapTy &VMap,
-            function_ref<bool(const GlobalValue *)> ShouldCloneDefinition);
+            function_ref<bool(const GlobalValue *)> ShouldCloneDefinition,
+            Module *TargetMod = nullptr);
 
 /// This struct can be used to capture information about code
 /// being cloned, while it is being cloned.
 struct ClonedCodeInfo {
   /// This is set to true if the cloned code contains a normal call instruction.
   bool ContainsCalls = false;
 
   /// This is set to true if the cloned code contains a 'dynamic' alloca.

llvm/lib/Transforms/Utils/CloneModule.cpp

static void copyComdat(GlobalObject *Dst, const GlobalObject *Src) {
   const Comdat *SC = Src->getComdat();
   if (!SC)
     return;
   Comdat *DC = Dst->getParent()->getOrInsertComdat(SC->getName());
   DC->setSelectionKind(SC->getSelectionKind());
   Dst->setComdat(DC);
 }
 
+void llvm::CloneModuleInto(Module &M, Module &TargetMod) {
+  assert(&M.getContext() == &TargetMod.getContext() && "Context doesn't match.");
+  TargetMod.~Module();
+  new (&TargetMod) Module(M.getModuleIdentifier(), M.getContext());
+  std::unique_ptr<Module>  T = CloneModule(M, &TargetMod);
+  T.release();
+}
+
 /// This is not as easy as it might seem because we have to worry about making
 /// copies of global variables and functions, and making their (initializers and
 /// references, respectively) refer to the right globals.
 ///
-std::unique_ptr<Module> llvm::CloneModule(const Module &M) {
+std::unique_ptr<Module> llvm::CloneModule(const Module &M,
+                                          Module *TargetMod) {
   // Create the value map that maps things from the old module over to the new
   // module.
   ValueToValueMapTy VMap;
-  return CloneModule(M, VMap);
+  return CloneModule(M, VMap, TargetMod);
 }
 
 std::unique_ptr<Module> llvm::CloneModule(const Module &M,
-                                          ValueToValueMapTy &VMap) {
-  return CloneModule(M, VMap, [](const GlobalValue *GV) { return true; });
+                                          ValueToValueMapTy &VMap,
+                                          Module *TargetMod) {
+  return CloneModule(M, VMap, [](const GlobalValue *GV) { return true; },
+                     TargetMod);
 }
 
 std::unique_ptr<Module> llvm::CloneModule(
     const Module &M, ValueToValueMapTy &VMap,
-    function_ref<bool(const GlobalValue *)> ShouldCloneDefinition) {
+    function_ref<bool(const GlobalValue *)> ShouldCloneDefinition,
+    Module *TargetMod) {
   // First off, we need to create the new module.
-  std::unique_ptr<Module> New =
-      llvm::make_unique<Module>(M.getModuleIdentifier(), M.getContext());
+  std::unique_ptr<Module> New;
+  if(TargetMod)
+    New.reset(TargetMod);
+  else
+    New =llvm::make_unique<Module>(M.getModuleIdentifier(), M.getContext());
+
   New->setSourceFileName(M.getSourceFileName());
   New->setDataLayout(M.getDataLayout());
   New->setTargetTriple(M.getTargetTriple());
   New->setModuleInlineAsm(M.getModuleInlineAsm());
 
   // Loop over all of the global variables, making corresponding globals in the
   // new module.  Here we add them to the VMap and to the new Module.  We
   // don't worry about attributes or initializers, they will come later.

llvm/unittests/Transforms/Utils/CloningTest.cpp

protected:
 
   void CreateNewModule() { NewM = llvm::CloneModule(*OldM).release(); }
 
   LLVMContext C;
   Module *OldM;
   Module *NewM;
 };
 
+TEST_F(CloneModule, CloneInto) {
+  Function *OldF = OldM->getFunction("f");
+  OldF->replaceAllUsesWith(UndefValue::get(OldF->getType()));
+  OldF->eraseFromParent();
+  Module *Tmp = NewM;
+  llvm::CloneModuleInto(*OldM, *NewM);
+  EXPECT_FALSE(NewM->getFunction("f"));
+  EXPECT_EQ(Tmp, NewM);
+  EXPECT_FALSE(verifyModule(*NewM));
+}
+
 TEST_F(CloneModule, Verify) {
   EXPECT_FALSE(verifyModule(*NewM));
 }
 
 TEST_F(CloneModule, OldModuleUnchanged) {
   DebugInfoFinder Finder;
   Finder.processModule(*OldM);
   EXPECT_EQ(1U, Finder.subprogram_count());