CloneModule: add an option for a custom LLVMContext

[AlexDenisov]

Summary

The patch adds another parameter to the CloneModule family so that one can create a clone of a module using custom context.

Here is a bit of motivation and our use case: we create hundreds (sometimes thousands) of clones during program execution. If we create them using the context of an original module, then all those clones reside in memory until the very end of a program (when the 'global' context destructed).

[pcc]

Does this really work? I believe that with this the original and the cloned module will share things like types, which is a violation of the invariant that LLVM IR objects must not be shared between contexts.

When I needed to clone a module into another LLVMContext, I could not see a better way to do it than to serialize it to bitcode and deserialize it into the new LLVMContext (see http://llvm-cs.pcc.me.uk/lib/CodeGen/ParallelCG.cpp).

[AlexDenisov]

Does this really work? I believe that with this the original and the cloned module will share things like types, which is a violation of the invariant that LLVM IR objects must not be shared between contexts.

Well, it works in our case, but now I see that it may have a problem in other cases.

When I needed to clone a module into another LLVMContext, I could not see a better way to do it than to serialize it to bitcode and deserialize it into the new LLVMContext (see http://llvm-cs.pcc.me.uk/lib/CodeGen/ParallelCG.cpp).

This is a good idea. I think we must go the same way.

Thank you for your hint and the fast response :)

include/llvm/Transforms/Utils/Cloning.h

 class BasicBlock;
 class BlockFrequencyInfo;
 class CallInst;
 class CallGraph;
 class DominatorTree;
 class Function;
 class Instruction;
 class InvokeInst;
+class LLVMContext;
 class Loop;
 class LoopInfo;
 class Module;
 class ReturnInst;
 
 /// 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);
 
 /// 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);
 
+std::unique_ptr<Module>
+CloneModule(const Module *M, ValueToValueMapTy &VMap,
+            function_ref<bool(const GlobalValue *)> ShouldCloneDefinition,
+            LLVMContext &Context);
+
 /// ClonedCodeInfo - This struct can be used to capture information about code
 /// being cloned, while it is being cloned.
 struct ClonedCodeInfo {
   /// ContainsCalls - This is set to true if the cloned code contains a normal
   /// call instruction.
   bool ContainsCalls = false;
 
   /// ContainsDynamicAllocas - This is set to true if the cloned code contains

lib/Transforms/Utils/CloneModule.cpp

 std::unique_ptr<Module> llvm::CloneModule(const Module *M,
                                           ValueToValueMapTy &VMap) {
   return CloneModule(M, VMap, [](const GlobalValue *GV) { return true; });
 }
 
 std::unique_ptr<Module> llvm::CloneModule(
     const Module *M, ValueToValueMapTy &VMap,
     function_ref<bool(const GlobalValue *)> ShouldCloneDefinition) {
+  return CloneModule(M, VMap, ShouldCloneDefinition, M->getContext());
+}
+
+std::unique_ptr<Module> llvm::CloneModule(
+    const Module *M, ValueToValueMapTy &VMap,
+    function_ref<bool(const GlobalValue *)> ShouldCloneDefinition,
+    LLVMContext &Context) {
   // First off, we need to create the new module.
   std::unique_ptr<Module> New =
-      llvm::make_unique<Module>(M->getModuleIdentifier(), M->getContext());
+      llvm::make_unique<Module>(M->getModuleIdentifier(), Context);
   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.
   //