Byte copy speedup

src/libcargo/cargo.rc

@@ -35,6 +35,7 @@
 #[allow(non_camel_case_types)];
 #[allow(deprecated_mode)];
 #[allow(deprecated_pattern)];
+#[allow(deprecated_self)];
 
 extern mod core(vers = "0.6");
 extern mod std(vers = "0.6");

src/libcore/core.rc

@@ -52,6 +52,7 @@ Implicitly, all crates behave as if they included the following prologue:
 #[warn(deprecated_pattern)];
 #[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
+#[allow(deprecated_self)];
 
 /* The Prelude. */
 

src/libcore/gc.rs

@@ -40,6 +40,7 @@ with destructors.
 #[forbid(deprecated_pattern)];
 
 use cast;
+use container::{Container, Mutable, Map, Set};
 use io;
 use libc::{size_t, uintptr_t};
 use option::{None, Option, Some};

src/libcore/hashmap.rs

@@ -16,7 +16,6 @@
 
 use cmp::Eq;
 use hash::Hash;
-use prelude::*;
 use to_bytes::IterBytes;
 
 /// Open addressing with linear probing.
@@ -36,13 +35,13 @@ pub mod linear {
 
     const INITIAL_CAPACITY: uint = 32u; // 2^5
 
-    struct Bucket<K: Eq Hash, V> {
+    struct Bucket<K,V> {
         hash: uint,
         key: K,
         value: V,
     }
 
-    pub struct LinearMap<K: Eq Hash, V> {
+    pub struct LinearMap<K,V> {
         k0: u64,
         k1: u64,
         resize_at: uint,
@@ -424,7 +423,7 @@ pub mod linear {
         pure fn ne(&self, other: &LinearMap<K, V>) -> bool { !self.eq(other) }
     }
 
-    pub struct LinearSet<T: Hash IterBytes Eq> {
+    pub struct LinearSet<T> {
         priv map: LinearMap<T, ()>
     }
 
@@ -479,6 +478,7 @@ pub mod linear {
 
 #[test]
 pub mod test {
+    use container::{Container, Mutable, Map, Set};
     use option::{None, Some};
     use hashmap::linear::LinearMap;
     use hashmap::linear;

src/libcore/io.rs

@@ -1111,7 +1111,7 @@ pub mod fsync {
 
 
     // Artifacts that need to fsync on destruction
-    pub struct Res<t: Copy> {
+    pub struct Res<t> {
         arg: Arg<t>,
     }
 

src/libcore/libc.rs

@@ -1123,10 +1123,23 @@ pub mod funcs {
             unsafe fn strerror(n: c_int) -> *c_char;
             unsafe fn strtok(s: *c_char, t: *c_char) -> *c_char;
             unsafe fn strxfrm(s: *c_char, ct: *c_char, n: size_t) -> size_t;
+
+            // These are fine to execute on the Rust stack. They must be, in
+            // fact, because LLVM generates calls to them!
+            #[rust_stack]
+            #[inline(always)]
             unsafe fn memcpy(s: *c_void, ct: *c_void, n: size_t) -> *c_void;
+            #[rust_stack]
+            #[inline(always)]
             unsafe fn memmove(s: *c_void, ct: *c_void, n: size_t) -> *c_void;
+            #[rust_stack]
+            #[inline(always)]
             unsafe fn memcmp(cx: *c_void, ct: *c_void, n: size_t) -> c_int;
+            #[rust_stack]
+            #[inline(always)]
             unsafe fn memchr(cx: *c_void, c: c_int, n: size_t) -> *c_void;
+            #[rust_stack]
+            #[inline(always)]
             unsafe fn memset(s: *c_void, c: c_int, n: size_t) -> *c_void;
         }
     }

src/libcore/num.rs

@@ -23,6 +23,11 @@ pub trait Num {
     static pure fn from_int(n: int) -> self;
 }
 
+pub trait IntConvertible {
+    pure fn to_int(&self) -> int;
+    static pure fn from_int(n: int) -> self;
+}
+
 pub trait Zero {
     static pure fn zero() -> self;
 }

src/libcore/oldcomm.rs

@@ -68,7 +68,7 @@ use vec;
  * transmitted. If a port value is copied, both copies refer to the same
  * port.  Ports may be associated with multiple `chan`s.
  */
-pub enum Port<T: Owned> {
+pub enum Port<T> {
     Port_(@PortPtr<T>)
 }
 
@@ -84,7 +84,7 @@ pub enum Port<T: Owned> {
  * data will be silently dropped.  Channels may be duplicated and
  * themselves transmitted over other channels.
  */
-pub enum Chan<T: Owned> {
+pub enum Chan<T> {
     Chan_(port_id)
 }
 
@@ -120,7 +120,7 @@ pub fn listen<T: Owned, U>(f: fn(Chan<T>) -> U) -> U {
     f(po.chan())
 }
 
-struct PortPtr<T:Owned> {
+struct PortPtr<T> {
   po: *rust_port,
   drop {
     unsafe {
@@ -238,7 +238,7 @@ fn peek_chan<T: Owned>(ch: Chan<T>) -> bool {
 }
 
 /// Receive on a raw port pointer
-fn recv_<T: Owned>(p: *rust_port) -> T {
+fn recv_<T>(p: *rust_port) -> T {
     unsafe {
         let yield = 0;
         let yieldp = ptr::addr_of(&yield);