---

yaml
---
r: 24216
b: refs/heads/master
c: 64de6d6
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ebe6b2d15c3d007df93601fde99bb06f96c480c1
+refs/heads/master: 64de6d638da71f7b3a55d663b194b95f7f06d6c8
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/libcore/str.rs

@@ -1827,10 +1827,10 @@ const tag_six_b: uint = 252u;
  * let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) };
  * ~~~
  */
-pure fn as_bytes<T>(s: &const ~str, f: fn(~[u8]) -> T) -> T {
+pure fn as_bytes<T>(s: &const ~str, f: fn((&~[u8])) -> T) -> T {
     unsafe {
         let v: *~[u8] = cast::transmute(copy s);
-        f(*v)
+        f(&*v)
     }
 }
 
@@ -1945,7 +1945,7 @@ fn reserve_at_least(s: &const ~str, n: uint) {
  */
 pure fn capacity(s: &const ~str) -> uint {
     do as_bytes(s) |buf| {
-        let vcap = vec::capacity(buf);
+        let vcap = vec::capacity(*buf);
         assert vcap > 0u;
         vcap - 1u
     }
@@ -2037,7 +2037,7 @@ mod raw {
 
     /// Form a slice from a *u8 buffer of the given length without copying.
     unsafe fn buf_as_slice<T>(buf: *u8, len: uint,
-                              f: fn(&&v: &str) -> T) -> T {
+                              f: fn(v: &str) -> T) -> T {
         let v = (buf, len + 1);
         assert is_utf8(::cast::reinterpret_cast(&v));
         f(::cast::transmute(move v))

trunk/src/rustc/back/link.rs

@@ -74,44 +74,14 @@ mod jit {
             m: ModuleRef,
             opt: c_int,
             stacks: bool) unsafe {
-        let manager = llvm::LLVMRustPrepareJIT(rusti::morestack_addr());
-
-        // We need to tell JIT 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| {
-            let path = cratepath.to_str();
-
-            debug!("linking: %s", path);
-
-            let _: () = str::as_c_str(
-                path,
-                |buf_t| {
-                    if !llvm::LLVMRustLoadCrate(manager, buf_t) {
-                        llvm_err(sess, ~"Could not link");
-                    }
-                    debug!("linked: %s", path);
-                });
-        }
-
-        // The execute function will return a void pointer
-        // to the _rust_main function. We can do closure
-        // magic here to turn it straight into a callable rust
-        // closure. It will also cleanup the memory manager
-        // for us.
-
-        let entry = llvm::LLVMRustExecuteJIT(manager,
-                                      pm, m, opt, stacks);
+        let ptr = llvm::LLVMRustJIT(rusti::morestack_addr(),
+                                    pm, m, opt, stacks);
 
-        if ptr::is_null(entry) {
+        if ptr::is_null(ptr) {
             llvm_err(sess, ~"Could not JIT");
         } else {
             let closure = Closure {
-                code: entry,
+                code: ptr,
                 env: ptr::null()
             };
             let func: fn(~[~str]) = cast::transmute(move closure);

trunk/src/rustc/lib/llvm.rs

@@ -990,19 +990,15 @@ extern mod llvm {
         call. */
     fn LLVMRustGetLastError() -> *c_char;
 
-    /** Prepare the JIT. Returns a memory manager that can load crates. */
-    fn LLVMRustPrepareJIT(__morestack: *()) -> *();
-
-    /** Load a crate into the memory manager. */
-    fn LLVMRustLoadCrate(MM: *(),
-                         Filename: *c_char) -> bool;
-
-    /** Execute the JIT engine. */
-    fn LLVMRustExecuteJIT(MM: *(),
-                          PM: PassManagerRef,
-                          M: ModuleRef,
-                          OptLevel: c_int,
-                          EnableSegmentedStacks: bool) -> *();
+    /** Load a shared library to resolve symbols against. */
+    fn LLVMRustLoadLibrary(Filename: *c_char) -> bool;
+
+    /** Create and execute the JIT engine. */
+    fn LLVMRustJIT(__morestack: *(),
+                   PM: PassManagerRef,
+                   M: ModuleRef,
+                   OptLevel: c_int,
+                   EnableSegmentedStacks: bool) -> *();
 
     /** Parses the bitcode in the given memory buffer. */
     fn LLVMRustParseBitcode(MemBuf: MemoryBufferRef) -> ModuleRef;

trunk/src/rustc/metadata/encoder.rs

@@ -1175,7 +1175,7 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
     //   vec::from_slice(metadata_encoding_version) +
 
     (do str::as_bytes(&~"rust\x00\x00\x00\x01") |bytes| {
-        vec::slice(bytes, 0, 8)
+        vec::slice(*bytes, 0, 8)
     }) + flate::deflate_bytes(wr.buf.check_out(|buf| buf))
 }
 

trunk/src/rustllvm/RustWrapper.cpp

@@ -20,7 +20,6 @@
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/ADT/Triple.h"
-#include "llvm/ADT/DenseSet.h"
 #include "llvm/Assembly/Parser.h"
 #include "llvm/Assembly/PrintModulePass.h"
 #include "llvm/Support/FormattedStream.h"
@@ -43,6 +42,7 @@
 #include "llvm-c/Core.h"
 #include "llvm-c/BitReader.h"
 #include "llvm-c/Object.h"
+#include <cstdlib>
 
 // Used by RustMCJITMemoryManager::getPointerToNamedFunction()
 // to get around glibc issues. See the function for more information.
@@ -53,7 +53,6 @@
 #endif
 
 using namespace llvm;
-using namespace llvm::sys;
 
 static const char *LLVMRustError;
 
@@ -101,6 +100,18 @@ void LLVMRustInitializeTargets() {
   LLVMInitializeX86AsmParser();
 }
 
+extern "C" bool
+LLVMRustLoadLibrary(const char* file) {
+  std::string err;
+
+  if(llvm::sys::DynamicLibrary::LoadLibraryPermanently(file, &err)) {
+    LLVMRustError = err.c_str();
+    return false;
+  }
+
+  return true;
+}
+
 // Custom memory manager for MCJITting. It needs special features
 // that the generic JIT memory manager doesn't entail. Based on
 // code from LLI, change where needed for Rust.
@@ -110,13 +121,10 @@ class RustMCJITMemoryManager : public JITMemoryManager {
   SmallVector<sys::MemoryBlock, 16> AllocatedCodeMem;
   SmallVector<sys::MemoryBlock, 16> FreeCodeMem;
   void* __morestack;
-  DenseSet<DynamicLibrary*> crates;
 
   RustMCJITMemoryManager(void* sym) : __morestack(sym) { }
   ~RustMCJITMemoryManager();
 
-  bool loadCrate(const char*, std::string*);
-
   virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                        unsigned SectionID);
 
@@ -189,19 +197,6 @@ class RustMCJITMemoryManager : public JITMemoryManager {
   }
 };
 
-bool RustMCJITMemoryManager::loadCrate(const char* file, std::string* err) {
-  DynamicLibrary crate = DynamicLibrary::getPermanentLibrary(file,
-                                                             err);
-
-  if(crate.isValid()) {
-    crates.insert(&crate);
-
-    return true;
-  }
-
-  return false;
-}
-
 uint8_t *RustMCJITMemoryManager::allocateDataSection(uintptr_t Size,
                                                     unsigned Alignment,
                                                     unsigned SectionID) {
@@ -281,19 +276,6 @@ void *RustMCJITMemoryManager::getPointerToNamedFunction(const std::string &Name,
   if (Name == "__morestack") return &__morestack;
 
   const char *NameStr = Name.c_str();
-
-  // Look through loaded crates for symbols.
-
-  for (DenseSet<DynamicLibrary*>::iterator I = crates.begin(),
-       E = crates.end(); I != E; ++I) {
-    void *Ptr = (*I)->getAddressOfSymbol(NameStr);
-
-    if (Ptr) return Ptr;
-  }
-
-  // Fallback to using any symbols LLVM has loaded (generally
-  // from the main program).
-
   void *Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(NameStr);
   if (Ptr) return Ptr;
 
@@ -311,48 +293,21 @@ RustMCJITMemoryManager::~RustMCJITMemoryManager() {
 }
 
 extern "C" void*
-LLVMRustPrepareJIT(void* __morestack) {
-  // An execution engine will take ownership of this later
-  // and clean it up for us.
-
-  return (void*) new RustMCJITMemoryManager(__morestack);
-}
-
-extern "C" bool
-LLVMRustLoadCrate(void* mem, const char* crate) {
-  RustMCJITMemoryManager* manager = (RustMCJITMemoryManager*) mem;
-  std::string Err;
-
-  assert(manager);
-
-  if(!manager->loadCrate(crate, &Err)) {
-    LLVMRustError = Err.c_str();
-    return false;
-  }
-
-  return true;
-}
-
-extern "C" void*
-LLVMRustExecuteJIT(void* mem,
-                   LLVMPassManagerRef PMR,
-                   LLVMModuleRef M,
-                   CodeGenOpt::Level OptLevel,
-                   bool EnableSegmentedStacks) {
+LLVMRustJIT(void* __morestack,
+            LLVMPassManagerRef PMR,
+            LLVMModuleRef M,
+            CodeGenOpt::Level OptLevel,
+            bool EnableSegmentedStacks) {
 
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
 
   std::string Err;
   TargetOptions Options;
-  Options.JITExceptionHandling = true;
   Options.JITEmitDebugInfo = true;
   Options.NoFramePointerElim = true;
   Options.EnableSegmentedStacks = EnableSegmentedStacks;
   PassManager *PM = unwrap<PassManager>(PMR);
-  RustMCJITMemoryManager* MM = (RustMCJITMemoryManager*) mem;
-
-  assert(MM);
 
   PM->add(createBasicAliasAnalysisPass());
   PM->add(createInstructionCombiningPass());
@@ -363,6 +318,7 @@ LLVMRustExecuteJIT(void* mem,
   PM->add(createPromoteMemoryToRegisterPass());
   PM->run(*unwrap(M));
 
+  RustMCJITMemoryManager* MM = new RustMCJITMemoryManager(__morestack);
   ExecutionEngine* EE = EngineBuilder(unwrap(M))
     .setTargetOptions(Options)
     .setJITMemoryManager(MM)

trunk/src/rustllvm/rustllvm.def.in

@@ -4,9 +4,8 @@ LLVMRustWriteOutputFile
 LLVMRustGetLastError
 LLVMRustConstSmallInt
 LLVMRustConstInt
-LLVMRustLoadCrate
-LLVMRustPrepareJIT
-LLVMRustExecuteJIT
+LLVMRustLoadLibrary
+LLVMRustJIT
 LLVMRustParseBitcode
 LLVMRustParseAssemblyFile
 LLVMRustPrintPassTimings