---

yaml
---
r: 28221
b: refs/heads/try
c: 19ea3ab
h: refs/heads/master
i:
  28219: 6dab011
v: v3

Author: z0w0

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
-refs/heads/try: 795acb73950adf632d1e3fb48ea6104b4d61f3cd
+refs/heads/try: 19ea3ab480ad273420837da25e428fae597ef9f7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df

branches/try/src/rustc/back/link.rs

@@ -152,27 +152,14 @@ mod write {
             if opts.jit {
                 // If we are using JIT, go ahead and create and
                 // execute the engine now.
-
-                /*llvm::LLVMAddBasicAliasAnalysisPass(pm.llpm);
-                llvm::LLVMAddInstructionCombiningPass(pm.llpm);
-                llvm::LLVMAddReassociatePass(pm.llpm);
-                llvm::LLVMAddGVNPass(pm.llpm);
-                llvm::LLVMAddCFGSimplificationPass(pm.llpm);*/
-
                 // JIT execution takes ownership of the module,
-                // so don't dispose and return. Due to a weird bug
-                // with dynamic libraries, we need to separate jitting
-                // into two functions and load crates inbetween.
-
-                if !llvm::LLVMRustPrepareJIT(pm.llpm,
-                                             llmod,
-                                             CodeGenOptLevel,
-                                             true) {
-                    llvm_err(sess, ~"Could not JIT");
-                }
+                // so don't dispose and return.
 
                 // We need to tell LLVM where to resolve all linked
                 // symbols from. The equivalent of -lstd, -lcore, etc.
+                // By default the JIT will resolve symbols from the std and
+                // core linked into rustc. We don't want that,
+                // incase the user wants to use an older std library.
                 /*let cstore = sess.cstore;
                 for cstore::get_used_crate_files(cstore).each |cratepath| {
                     debug!{"linking: %s", cratepath};
@@ -187,7 +174,10 @@ mod write {
                         });
                 }*/
 
-                if !llvm::LLVMRustExecuteJIT() {
+                if !llvm::LLVMRustJIT(pm.llpm,
+                                      llmod,
+                                      CodeGenOptLevel,
+                                      true) {
                     llvm_err(sess, ~"Could not JIT");
                 }
 

branches/try/src/rustc/lib/llvm.rs

@@ -989,15 +989,12 @@ extern mod llvm {
     /** Load a shared library to resolve symbols against. */
     fn LLVMRustLoadLibrary(Filename: *c_char) -> bool;
 
-    /** Create the JIT engine. */
-    fn LLVMRustPrepareJIT(PM: PassManagerRef,
+    /** Create and execute the JIT engine. */
+    fn LLVMRustJIT(PM: PassManagerRef,
                    M: ModuleRef,
                    OptLevel: c_int,
                    EnableSegmentedStacks: bool) -> bool;
 
-    /** Execute the JIT engine. */
-    fn LLVMRustExecuteJIT() -> bool;
-
     /** Parses the bitcode in the given memory buffer. */
     fn LLVMRustParseBitcode(MemBuf: MemoryBufferRef) -> ModuleRef;
 

branches/try/src/rustllvm/RustWrapper.cpp

@@ -15,6 +15,9 @@
 #include "llvm/LLVMContext.h"
 #include "llvm/Linker.h"
 #include "llvm/PassManager.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/Analysis/Passes.h"
+#include "llvm/Transforms/Scalar.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Assembly/Parser.h"
 #include "llvm/Assembly/PrintModulePass.h"
@@ -35,7 +38,6 @@
 #include "llvm/ExecutionEngine/JITMemoryManager.h"
 #include "llvm/ExecutionEngine/MCJIT.h"
 #include "llvm/ExecutionEngine/Interpreter.h"
-#include "llvm/ExecutionEngine/GenericValue.h"
 #include "llvm-c/Core.h"
 #include "llvm-c/BitReader.h"
 #include "llvm-c/Object.h"
@@ -291,11 +293,8 @@ RustMCJITMemoryManager::~RustMCJITMemoryManager() {
     free(AllocatedDataMem[i].base());
 }
 
-// Separated functions because loading libraries before creating
-// an execution engine seems to break stuff.
-
 extern "C" bool
-LLVMRustPrepareJIT(LLVMPassManagerRef PMR,
+LLVMRustJIT(LLVMPassManagerRef PMR,
             LLVMModuleRef M,
             CodeGenOpt::Level OptLevel,
             bool EnableSegmentedStacks) {
@@ -309,8 +308,16 @@ LLVMRustPrepareJIT(LLVMPassManagerRef PMR,
   Options.JITEmitDebugInfo = true;
   Options.NoFramePointerElim = true;
   Options.EnableSegmentedStacks = EnableSegmentedStacks;
+  PassManager *PM = unwrap<PassManager>(PMR);
 
-  unwrap<PassManager>(PMR)->run(*unwrap(M));
+  PM->add(createBasicAliasAnalysisPass());
+  PM->add(createInstructionCombiningPass());
+  PM->add(createReassociatePass());
+  PM->add(createGVNPass());
+  PM->add(createPromoteMemoryToRegisterPass());
+  PM->add(createCFGSimplificationPass());
+  PM->add(createFunctionInliningPass());
+  PM->run(*unwrap(M));
 
   RustMCJITMemoryManager* MM = new RustMCJITMemoryManager();
   EE = EngineBuilder(unwrap(M))
@@ -326,29 +333,18 @@ LLVMRustPrepareJIT(LLVMPassManagerRef PMR,
   }
 
   MM->invalidateInstructionCache();
-
-  return true;
-}
-
-extern "C" bool
-LLVMRustExecuteJIT() {
-  assert(EE);
-
-  std::string Err;
   Function* func = EE->FindFunctionNamed("main");
 
   if(!func || Err != "") {
     LLVMRustError = Err.c_str();
     return false;
   }
 
-  //std::vector<GenericValue> args;
-  typedef int (*entry_t)(int, int);
-  entry_t entry = (entry_t) EE->getPointerToFunction(func);
+  typedef int (*Entry)(int, int);
+  Entry entry = (Entry) EE->getPointerToFunction(func);
 
   assert(entry);
   entry(0, 0);
-  //EE->runFunction(func, args);
 
   return true;
 }

branches/try/src/rustllvm/rustllvm.def.in

@@ -5,8 +5,7 @@ LLVMRustGetLastError
 LLVMRustConstSmallInt
 LLVMRustConstInt
 LLVMRustLoadLibrary
-LLVMRustPrepareJIT
-LLVMRustExecuteJIT
+LLVMRustJIT
 LLVMRustParseBitcode
 LLVMRustParseAssemblyFile
 LLVMRustPrintPassTimings