initial changes to support JIT'ing from multiple module providers, implicitly

linking the program on the fly.

llvm-svn: 29721

include/llvm/ExecutionEngine/ExecutionEngine.h

@@ -20,6 +20,7 @@
 #include <cassert>
 #include <string>
 #include "llvm/System/Mutex.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 
@@ -60,13 +61,12 @@ public:
 
 
 class ExecutionEngine {
-  Module &CurMod;
   const TargetData *TD;
-
   ExecutionEngineState state;
-
 protected:
-  ModuleProvider *MP;
+  /// Modules - This is a list of ModuleProvider's that we are JIT'ing from.  We
+  /// use a smallvector to optimize for the case where there is only one module.
+  SmallVector<ModuleProvider*, 1> Modules;
   
   void setTargetData(const TargetData *td) {
     TD = td;
@@ -88,9 +88,14 @@ public:
   ExecutionEngine(Module *M);
   virtual ~ExecutionEngine();
 
-  Module &getModule() const { return CurMod; }
+  //Module &getModule() const { return CurMod; }
   const TargetData *getTargetData() const { return TD; }
 
+  /// FindFunctionNamed - Search all of the active modules to find the one that
+  /// defines FnName.  This is very slow operation and shouldn't be used for
+  /// general code.
+  Function *FindFunctionNamed(const char *FnName);
+  
   /// create - This is the factory method for creating an execution engine which
   /// is appropriate for the current machine.
   static ExecutionEngine *create(ModuleProvider *MP,

lib/ExecutionEngine/ExecutionEngine.cpp

@@ -35,19 +35,33 @@ namespace {
 ExecutionEngine::EECtorFn ExecutionEngine::JITCtor = 0;
 ExecutionEngine::EECtorFn ExecutionEngine::InterpCtor = 0;
 
-ExecutionEngine::ExecutionEngine(ModuleProvider *P) :
+ExecutionEngine::ExecutionEngine(ModuleProvider *P) {
-  CurMod(*P->getModule()), MP(P) {
+  Modules.push_back(P);
   assert(P && "ModuleProvider is null?");
 }
 
-ExecutionEngine::ExecutionEngine(Module *M) : CurMod(*M), MP(0) {
+ExecutionEngine::ExecutionEngine(Module *M) {
   assert(M && "Module is null?");
+  Modules.push_back(new ExistingModuleProvider(M));
 }
 
 ExecutionEngine::~ExecutionEngine() {
-  delete MP;
+  for (unsigned i = 0, e = Modules.size(); i != e; ++i)
+    delete Modules[i];
 }
 
+/// FindFunctionNamed - Search all of the active modules to find the one that
+/// defines FnName.  This is very slow operation and shouldn't be used for
+/// general code.
+Function *ExecutionEngine::FindFunctionNamed(const char *FnName) {
+  for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
+    if (Function *F = Modules[i]->getModule()->getNamedFunction(FnName))
+      return F;
+  }
+  return 0;
+}
+
+
 /// addGlobalMapping - Tell the execution engine that the specified global is
 /// at the specified location.  This is used internally as functions are JIT'd
 /// and as global variables are laid out in memory.  It can and should also be
@@ -168,37 +182,43 @@ static void *CreateArgv(ExecutionEngine *EE,
 
 
 /// runStaticConstructorsDestructors - This method is used to execute all of
-/// the static constructors or destructors for a module, depending on the
+/// the static constructors or destructors for a program, depending on the
 /// value of isDtors.
 void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) {
   const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors";
-  GlobalVariable *GV = CurMod.getNamedGlobal(Name);
   
-  // If this global has internal linkage, or if it has a use, then it must be
+  // Execute global ctors/dtors for each module in the program.
-  // an old-style (llvmgcc3) static ctor with __main linked in and in use.  If
+  for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
-  // this is the case, don't execute any of the global ctors, __main will do it.
+    GlobalVariable *GV = Modules[m]->getModule()->getNamedGlobal(Name);
-  if (!GV || GV->isExternal() || GV->hasInternalLinkage()) return;
 
-  // Should be an array of '{ int, void ()* }' structs.  The first value is the
+    // If this global has internal linkage, or if it has a use, then it must be
-  // init priority, which we ignore.
+    // an old-style (llvmgcc3) static ctor with __main linked in and in use.  If
-  ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
+    // this is the case, don't execute any of the global ctors, __main will do
-  if (!InitList) return;
+    // it.
-  for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
+    if (!GV || GV->isExternal() || GV->hasInternalLinkage()) continue;
-    if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){
-      if (CS->getNumOperands() != 2) return;  // Not array of 2-element structs.
   
-      Constant *FP = CS->getOperand(1);
+    // Should be an array of '{ int, void ()* }' structs.  The first value is
-      if (FP->isNullValue())
+    // the init priority, which we ignore.
-        return;  // Found a null terminator, exit.
+    ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
+    if (!InitList) continue;
+    for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
+      if (ConstantStruct *CS = 
+          dyn_cast<ConstantStruct>(InitList->getOperand(i))) {
+        if (CS->getNumOperands() != 2) break; // Not array of 2-element structs.
       
-      if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
+        Constant *FP = CS->getOperand(1);
-        if (CE->getOpcode() == Instruction::Cast)
+        if (FP->isNullValue())
-          FP = CE->getOperand(0);
+          break;  // Found a null terminator, exit.
-      if (Function *F = dyn_cast<Function>(FP)) {
+      
-        // Execute the ctor/dtor function!
+        if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
-        runFunction(F, std::vector<GenericValue>());
+          if (CE->getOpcode() == Instruction::Cast)
+            FP = CE->getOperand(0);
+        if (Function *F = dyn_cast<Function>(FP)) {
+          // Execute the ctor/dtor function!
+          runFunction(F, std::vector<GenericValue>());
+        }
       }
-    }
+  }
 }
 
 /// runFunctionAsMain - This is a helper function which wraps runFunction to
@@ -610,36 +630,110 @@ void ExecutionEngine::emitGlobals() {
   const TargetData *TD = getTargetData();
 
   // Loop over all of the global variables in the program, allocating the memory
-  // to hold them.
+  // to hold them.  If there is more than one module, do a prepass over globals
-  Module &M = getModule();
+  // to figure out how the different modules should link together.
-  for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
+  //
-       I != E; ++I)
+  std::map<std::pair<std::string, const Type*>,
-    if (!I->isExternal()) {
+           const GlobalValue*> LinkedGlobalsMap;
-      // Get the type of the global...
-      const Type *Ty = I->getType()->getElementType();
 
-      // Allocate some memory for it!
+  if (Modules.size() != 1) {
-      unsigned Size = TD->getTypeSize(Ty);
+    for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
-      addGlobalMapping(I, new char[Size]);
+      Module &M = *Modules[m]->getModule();
-    } else {
+      for (Module::const_global_iterator I = M.global_begin(),
-      // External variable reference. Try to use the dynamic loader to
+           E = M.global_end(); I != E; ++I) {
-      // get a pointer to it.
+        const GlobalValue *GV = I;
-      if (void *SymAddr = sys::DynamicLibrary::SearchForAddressOfSymbol(
+        if (GV->hasInternalLinkage() || GV->isExternal() ||
-                            I->getName().c_str()))
+            GV->hasAppendingLinkage() || !GV->hasName())
-        addGlobalMapping(I, SymAddr);
+          continue;// Ignore external globals and globals with internal linkage.
-      else {
+          
-        std::cerr << "Could not resolve external global address: "
+        const GlobalValue *&GVEntry = 
-                  << I->getName() << "\n";
+          LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())];
-        abort();
+
+        // If this is the first time we've seen this global, it is the canonical
+        // version.
+        if (!GVEntry) {
+          GVEntry = GV;
+          continue;
+        }
+        
+        // If the existing global is strong, never replace it.
+        if (GVEntry->hasExternalLinkage())
+          continue;
+        
+        // Otherwise, we know it's linkonce/weak, replace it if this is a strong
+        // symbol.
+        if (GV->hasExternalLinkage())
+          GVEntry = GV;
+      }
+    }
+  }
+  
+  std::vector<const GlobalValue*> NonCanonicalGlobals;
+  for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
+    Module &M = *Modules[m]->getModule();
+    for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
+         I != E; ++I) {
+      // In the multi-module case, see what this global maps to.
+      if (!LinkedGlobalsMap.empty()) {
+        if (const GlobalValue *GVEntry = 
+              LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) {
+          // If something else is the canonical global, ignore this one.
+          if (GVEntry != &*I) {
+            NonCanonicalGlobals.push_back(I);
+            continue;
+          }
+        }
+      }
+      
+      if (!I->isExternal()) {
+        // Get the type of the global.
+        const Type *Ty = I->getType()->getElementType();
+
+        // Allocate some memory for it!
+        unsigned Size = TD->getTypeSize(Ty);
+        addGlobalMapping(I, new char[Size]);
+      } else {
+        // External variable reference. Try to use the dynamic loader to
+        // get a pointer to it.
+        if (void *SymAddr =
+            sys::DynamicLibrary::SearchForAddressOfSymbol(I->getName().c_str()))
+          addGlobalMapping(I, SymAddr);
+        else {
+          std::cerr << "Could not resolve external global address: "
+                    << I->getName() << "\n";
+          abort();
+        }
       }
     }
     
-  // Now that all of the globals are set up in memory, loop through them all and
+    // If there are multiple modules, map the non-canonical globals to their
-  // initialize their contents.
+    // canonical location.
-  for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
+    if (!NonCanonicalGlobals.empty()) {
-       I != E; ++I)
+      for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) {
-    if (!I->isExternal())
+        const GlobalValue *GV = NonCanonicalGlobals[i];
-      EmitGlobalVariable(I);
+        const GlobalValue *CGV =
+          LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())];
+        void *Ptr = getPointerToGlobalIfAvailable(CGV);
+        assert(Ptr && "Canonical global wasn't codegen'd!");
+        addGlobalMapping(GV, getPointerToGlobalIfAvailable(CGV));
+      }
+    }
+    
+    // Now that all of the globals are set up in memory, loop through them all and
+    // initialize their contents.
+    for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
+         I != E; ++I) {
+      if (!I->isExternal()) {
+        if (!LinkedGlobalsMap.empty()) {
+          if (const GlobalValue *GVEntry = 
+                LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())])
+            if (GVEntry != &*I)  // Not the canonical variable.
+              continue;
+        }
+        EmitGlobalVariable(I);
+      }
+    }
+  }
 }
 
 // EmitGlobalVariable - This method emits the specified global variable to the

lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp

@@ -313,7 +313,7 @@ GenericValue lle_X_sprintf(FunctionType *M, const vector<GenericValue> &Args) {
       case 'x': case 'X':
         if (HowLong >= 1) {
           if (HowLong == 1 &&
-              TheInterpreter->getModule().getPointerSize()==Module::Pointer64 &&
+              TheInterpreter->getTargetData()->getPointerSizeInBits() == 64 &&
               sizeof(long) < sizeof(int64_t)) {
             // Make sure we use %lld with a 64 bit argument because we might be
             // compiling LLI on a 32 bit compiler.

lib/ExecutionEngine/JIT/JIT.cpp

@@ -263,8 +263,19 @@ void *JIT::getPointerToFunction(Function *F) {
   if (void *Addr = getPointerToGlobalIfAvailable(F))
     return Addr;   // Check if function already code gen'd
 
-  // Make sure we read in the function if it exists in this Module
+  // Make sure we read in the function if it exists in this Module.
   if (F->hasNotBeenReadFromBytecode()) {
+    // Determine the module provider this function is provided by.
+    Module *M = F->getParent();
+    ModuleProvider *MP = 0;
+    for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
+      if (Modules[i]->getModule() == M) {
+        MP = Modules[i];
+        break;
+      }
+    }
+    assert(MP && "Function isn't in a module we know about!");
+    
     std::string ErrorMsg;
     if (MP->materializeFunction(F, &ErrorMsg)) {
       std::cerr << "Error reading function '" << F->getName()

lib/ExecutionEngine/JIT/JITEmitter.cpp

@@ -972,8 +972,7 @@ MachineCodeEmitter *JIT::createEmitter(JIT &jit) {
 // resolve their addresses at runtime, and this is the way to do it.
 extern "C" {
   void *getPointerToNamedFunction(const char *Name) {
-    Module &M = TheJIT->getModule();
+    if (Function *F = TheJIT->FindFunctionNamed(Name))
-    if (Function *F = M.getNamedFunction(Name))
       return TheJIT->getPointerToFunction(F);
     return TheJIT->getPointerToNamedFunction(Name);
   }