---

yaml
---
r: 142845
b: refs/heads/try2
c: e56b369
h: refs/heads/master
i:
  142843: 1fea808
v: v3

Author: dotdash

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 51cb98443cfd053f3d2bdb26465fdb0c9d3a0f74
+refs/heads/try2: e56b3691c87c24fc335fa8a293f1bf2e13a01ad9
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/dist.mk

@@ -19,9 +19,7 @@ PKG_FILES := \
     $(S)LICENSE-APACHE                         \
     $(S)LICENSE-MIT                            \
     $(S)AUTHORS.txt                            \
-    $(S)CONTRIBUTING.md                        \
     $(S)README.md                              \
-    $(S)RELEASES.txt                           \
     $(S)configure $(S)Makefile.in              \
     $(S)man                                    \
     $(S)doc                                    \

branches/try2/mk/install.mk

@@ -183,11 +183,7 @@ uninstall:
         do rm -f $$i ; \
         done
 	$(Q)rm -Rf $(PHL)/rustc
-	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rust.1
 	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rustc.1
-	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rustdoc.1
-	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rusti.1
-	$(Q)rm -f $(PREFIX_ROOT)/share/man/man1/rustpkg.1
 
 # target platform specific variables
 # for arm-linux-androidabi

branches/try2/src/libextra/bitv.rs

@@ -718,6 +718,38 @@ impl Set<uint> for BitvSet {
         *value < self.bitv.storage.len() * uint::bits && self.bitv.get(*value)
     }
 
+    fn insert(&mut self, value: uint) -> bool {
+        if self.contains(&value) {
+            return false;
+        }
+        let nbits = self.capacity();
+        if value >= nbits {
+            let newsize = num::max(value, nbits * 2) / uint::bits + 1;
+            assert!(newsize > self.bitv.storage.len());
+            self.bitv.storage.grow(newsize, &0);
+        }
+        self.size += 1;
+        self.bitv.set(value, true);
+        return true;
+    }
+
+    fn remove(&mut self, value: &uint) -> bool {
+        if !self.contains(value) {
+            return false;
+        }
+        self.size -= 1;
+        self.bitv.set(*value, false);
+
+        // Attempt to truncate our storage
+        let mut i = self.bitv.storage.len();
+        while i > 1 && self.bitv.storage[i - 1] == 0 {
+            i -= 1;
+        }
+        self.bitv.storage.truncate(i);
+
+        return true;
+    }
+
     fn is_disjoint(&self, other: &BitvSet) -> bool {
         for self.intersection(other) |_| {
             return false;
@@ -784,40 +816,6 @@ impl Set<uint> for BitvSet {
     }
 }
 
-impl MutableSet<uint> for BitvSet {
-    fn insert(&mut self, value: uint) -> bool {
-        if self.contains(&value) {
-            return false;
-        }
-        let nbits = self.capacity();
-        if value >= nbits {
-            let newsize = num::max(value, nbits * 2) / uint::bits + 1;
-            assert!(newsize > self.bitv.storage.len());
-            self.bitv.storage.grow(newsize, &0);
-        }
-        self.size += 1;
-        self.bitv.set(value, true);
-        return true;
-    }
-
-    fn remove(&mut self, value: &uint) -> bool {
-        if !self.contains(value) {
-            return false;
-        }
-        self.size -= 1;
-        self.bitv.set(*value, false);
-
-        // Attempt to truncate our storage
-        let mut i = self.bitv.storage.len();
-        while i > 1 && self.bitv.storage[i - 1] == 0 {
-            i -= 1;
-        }
-        self.bitv.storage.truncate(i);
-
-        return true;
-    }
-}
-
 impl BitvSet {
     /// Visits each of the words that the two bit vectors (self and other)
     /// both have in common. The three yielded arguments are (bit location,

branches/try2/src/libextra/smallintmap.rs

@@ -17,7 +17,8 @@
 
 
 use std::cmp;
-use std::iterator::{Iterator,IteratorUtil,ZipIterator,Counter,EnumerateIterator,FilterMapIterator};
+use std::container::{Container, Mutable, Map, Set};
+use std::iterator::*;
 use std::uint;
 use std::util::replace;
 use std::vec::{VecIterator,VecMutIterator,VecRevIterator,VecMutRevIterator};
@@ -67,9 +68,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
             None
         }
     }
-}
 
-impl<V> MutableMap<uint, V> for SmallIntMap<V> {
     /// Return a mutable reference to the value corresponding to the key
     fn find_mut<'a>(&'a mut self, key: &uint) -> Option<&'a mut V> {
         if *key < self.v.len() {
@@ -350,6 +349,14 @@ impl Set<uint> for SmallIntSet {
     /// Return true if the set contains a value
     fn contains(&self, value: &uint) -> bool { self.map.contains_key(value) }
 
+    /// Add a value to the set. Return true if the value was not already
+    /// present in the set.
+    fn insert(&mut self, value: uint) -> bool { self.map.insert(value, ()) }
+
+    /// Remove a value from the set. Return true if the value was
+    /// present in the set.
+    fn remove(&mut self, value: &uint) -> bool { self.map.remove(value) }
+
     /// Return true if the set has no elements in common with `other`.
     /// This is equivalent to checking for an empty uintersection.
     fn is_disjoint(&self, other: &SmallIntSet) -> bool {
@@ -405,16 +412,6 @@ impl Set<uint> for SmallIntSet {
     }
 }
 
-impl MutableSet<uint> for SmallIntSet {
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
-    fn insert(&mut self, value: uint) -> bool { self.map.insert(value, ()) }
-
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
-    fn remove(&mut self, value: &uint) -> bool { self.map.remove(value) }
-}
-
 impl SmallIntSet {
     /// Create an empty SmallIntSet
     pub fn new() -> SmallIntSet { SmallIntSet{map: SmallIntMap::new()} }

branches/try2/src/libextra/treemap.rs

@@ -124,9 +124,7 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
             }
         }
     }
-}
 
-impl<K: TotalOrd, V> MutableMap<K, V> for TreeMap<K, V> {
     /// Return a mutable reference to the value corresponding to the key
     #[inline]
     fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V> {
@@ -295,6 +293,16 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
         self.map.contains_key(value)
     }
 
+    /// Add a value to the set. Return true if the value was not already
+    /// present in the set.
+    #[inline]
+    fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
+
+    /// Remove a value from the set. Return true if the value was
+    /// present in the set.
+    #[inline]
+    fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
+
     /// Return true if the set has no elements in common with `other`.
     /// This is equivalent to checking for an empty intersection.
     fn is_disjoint(&self, other: &TreeSet<T>) -> bool {
@@ -467,18 +475,6 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
     }
 }
 
-impl<T: TotalOrd> MutableSet<T> for TreeSet<T> {
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
-    #[inline]
-    fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
-
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
-    #[inline]
-    fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
-}
-
 impl<T: TotalOrd> TreeSet<T> {
     /// Create an empty TreeSet
     #[inline]

branches/try2/src/librustc/back/link.rs

@@ -101,30 +101,15 @@ pub mod jit {
     use back::link::llvm_err;
     use driver::session::Session;
     use lib::llvm::llvm;
-    use lib::llvm::{ModuleRef, ContextRef, ExecutionEngineRef};
+    use lib::llvm::{ModuleRef, ContextRef};
     use metadata::cstore;
 
     use std::cast;
-    use std::local_data;
+    use std::ptr;
+    use std::str;
+    use std::sys;
     use std::unstable::intrinsics;
 
-    struct LLVMJITData {
-        ee: ExecutionEngineRef,
-        llcx: ContextRef
-    }
-
-    pub trait Engine {}
-    impl Engine for LLVMJITData {}
-
-    impl Drop for LLVMJITData {
-        fn drop(&self) {
-            unsafe {
-                llvm::LLVMDisposeExecutionEngine(self.ee);
-                llvm::LLVMContextDispose(self.llcx);
-            }
-        }
-    }
-
     pub fn exec(sess: Session,
                 c: ContextRef,
                 m: ModuleRef,
@@ -145,7 +130,7 @@ pub mod jit {
 
                 debug!("linking: %s", path);
 
-                do path.as_c_str |buf_t| {
+                do str::as_c_str(path) |buf_t| {
                     if !llvm::LLVMRustLoadCrate(manager, buf_t) {
                         llvm_err(sess, ~"Could not link");
                     }
@@ -164,7 +149,7 @@ pub mod jit {
             // Next, we need to get a handle on the _rust_main function by
             // looking up it's corresponding ValueRef and then requesting that
             // the execution engine compiles the function.
-            let fun = do "_rust_main".as_c_str |entry| {
+            let fun = do str::as_c_str("_rust_main") |entry| {
                 llvm::LLVMGetNamedFunction(m, entry)
             };
             if fun.is_null() {
@@ -178,45 +163,20 @@ pub mod jit {
             // closure
             let code = llvm::LLVMGetPointerToGlobal(ee, fun);
             assert!(!code.is_null());
-            let func: extern "Rust" fn() = cast::transmute(code);
+            let closure = sys::Closure {
+                code: code,
+                env: ptr::null()
+            };
+            let func: &fn() = cast::transmute(closure);
             func();
 
-            // Currently there is no method of re-using the executing engine
-            // from LLVM in another call to the JIT. While this kinda defeats
-            // the purpose of having a JIT in the first place, there isn't
-            // actually much code currently which would re-use data between
-            // different invocations of this. Additionally, the compilation
-            // model currently isn't designed to support this scenario.
-            //
-            // We can't destroy the engine/context immediately here, however,
-            // because of annihilation. The JIT code contains drop glue for any
-            // types defined in the crate we just ran, and if any of those boxes
-            // are going to be dropped during annihilation, the drop glue must
-            // be run. Hence, we need to transfer ownership of this jit engine
-            // to the caller of this function. To be convenient for now, we
-            // shove it into TLS and have someone else remove it later on.
-            let data = ~LLVMJITData { ee: ee, llcx: c };
-            set_engine(data as ~Engine);
+            // Sadly, there currently is no interface to re-use this execution
+            // engine, so it's disposed of here along with the context to
+            // prevent leaks.
+            llvm::LLVMDisposeExecutionEngine(ee);
+            llvm::LLVMContextDispose(c);
         }
     }
-
-    // The stage1 compiler won't work, but that doesn't really matter. TLS
-    // changed only very recently to allow storage of owned values.
-    fn engine_key(_: ~Engine) {}
-
-    #[cfg(not(stage0))]
-    fn set_engine(engine: ~Engine) {
-        unsafe { local_data::set(engine_key, engine) }
-    }
-    #[cfg(stage0)]
-    fn set_engine(_: ~Engine) {}
-
-    #[cfg(not(stage0))]
-    pub fn consume_engine() -> Option<~Engine> {
-        unsafe { local_data::pop(engine_key) }
-    }
-    #[cfg(stage0)]
-    pub fn consume_engine() -> Option<~Engine> { None }
 }
 
 pub mod write {

branches/try2/src/librustc/middle/trans/glue.rs

@@ -230,7 +230,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext,
                                field: uint,
                                ti: @mut tydesc_info) {
     let _icx = push_ctxt("lazily_emit_tydesc_glue");
-    let llfnty = Type::glue_fn();
+    let llfnty = Type::glue_fn(type_of::type_of(ccx, ti.ty).ptr_to());
 
     if lazily_emit_simplified_tydesc_glue(ccx, field, ti) {
         return;
@@ -323,7 +323,20 @@ pub fn call_tydesc_glue_full(bcx: block,
       }
     };
 
-    let llrawptr = PointerCast(bcx, v, Type::i8p());
+    // When static type info is available, avoid casting parameter unless the
+    // glue is using a simplified type, because the function already has the
+    // right type. Otherwise cast to generic pointer.
+    let llrawptr = if static_ti.is_none() || static_glue_fn.is_none() {
+        PointerCast(bcx, v, Type::i8p())
+    } else {
+        let ty = static_ti.get().ty;
+        let simpl = simplified_glue_type(ccx.tcx, field, ty);
+        if simpl != ty {
+            PointerCast(bcx, v, type_of(ccx, simpl).ptr_to())
+        } else {
+            v
+        }
+    };
 
     let llfn = {
         match static_glue_fn {
@@ -709,13 +722,14 @@ pub fn make_generic_glue_inner(ccx: @mut CrateContext,
     // requirement since in many contexts glue is invoked indirectly and
     // the caller has no idea if it's dealing with something that can be
     // passed by value.
+    //
+    // llfn is expected be declared to take a parameter of the appropriate
+    // type, so we don't need to explicitly cast the function parameter.
 
     let bcx = top_scope_block(fcx, None);
     let lltop = bcx.llbb;
     let rawptr0_arg = fcx.arg_pos(0u);
     let llrawptr0 = unsafe { llvm::LLVMGetParam(llfn, rawptr0_arg as c_uint) };
-    let llty = type_of(ccx, t);
-    let llrawptr0 = PointerCast(bcx, llrawptr0, llty.ptr_to());
     let bcx = helper(bcx, llrawptr0, t);
 
     finish_fn(fcx, lltop, bcx);

branches/try2/src/librustc/middle/trans/type_.rs

@@ -187,20 +187,20 @@ impl Type {
             None => ()
         }
 
-        let ty = Type::glue_fn();
+        let ty = Type::glue_fn(Type::i8p());
         cx.tn.associate_type("glue_fn", &ty);
 
         return ty;
     }
 
-    pub fn glue_fn() -> Type {
-        Type::func([ Type::nil().ptr_to(), Type::i8p() ],
+    pub fn glue_fn(t: Type) -> Type {
+        Type::func([ Type::nil().ptr_to(), t ],
             &Type::void())
     }
 
     pub fn tydesc(arch: Architecture) -> Type {
         let mut tydesc = Type::named_struct("tydesc");
-        let glue_fn_ty = Type::glue_fn().ptr_to();
+        let glue_fn_ty = Type::glue_fn(Type::i8p()).ptr_to();
 
         let int_ty = Type::int(arch);