auto merge of #5962 : pcwalton/rust/shootout, r=pcwalton

r? @brson

3 files changed, 75 insertions, 14 deletions

diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 4a3447700bc..7b479bc7578 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -59,10 +59,13 @@ pub mod reader {
     use ebml::{EsVec, EsVecElt, EsVecLen, TaggedDoc};
     use serialize;
 
+    use core::cast::transmute;
     use core::int;
     use core::io;
     use core::prelude::*;
+    use core::ptr::offset;
     use core::str;
+    use core::unstable::intrinsics::bswap32;
     use core::vec;
 
     // ebml reading
@@ -78,7 +81,8 @@ pub mod reader {
         next: uint
     }
 
-    fn vuint_at(data: &[u8], start: uint) -> Res {
+    #[inline(never)]
+    fn vuint_at_slow(data: &[u8], start: uint) -> Res {
         let a = data[start];
         if a & 0x80u8 != 0u8 {
             return Res {val: (a & 0x7fu8) as uint, next: start + 1u};
@@ -87,18 +91,63 @@ pub mod reader {
             return Res {val: ((a & 0x3fu8) as uint) << 8u |
                         (data[start + 1u] as uint),
                     next: start + 2u};
-        } else if a & 0x20u8 != 0u8 {
+        }
+        if a & 0x20u8 != 0u8 {
             return Res {val: ((a & 0x1fu8) as uint) << 16u |
                         (data[start + 1u] as uint) << 8u |
                         (data[start + 2u] as uint),
                     next: start + 3u};
-        } else if a & 0x10u8 != 0u8 {
+        }
+        if a & 0x10u8 != 0u8 {
             return Res {val: ((a & 0x0fu8) as uint) << 24u |
                         (data[start + 1u] as uint) << 16u |
                         (data[start + 2u] as uint) << 8u |
                         (data[start + 3u] as uint),
                     next: start + 4u};
-        } else { error!("vint too big"); fail!(); }
+        }
+        fail!(~"vint too big");
+    }
+
+    #[cfg(target_arch = "x86")]
+    #[cfg(target_arch = "x86_64")]
+    pub fn vuint_at(data: &[u8], start: uint) -> Res {
+        if data.len() - start < 4 {
+            return vuint_at_slow(data, start);
+        }
+
+        unsafe {
+            let (ptr, _): (*u8, uint) = transmute(data);
+            let ptr = offset(ptr, start);
+            let ptr: *i32 = transmute(ptr);
+            let val = bswap32(*ptr);
+            let val: u32 = transmute(val);
+            if (val & 0x80000000) != 0 {
+                Res {
+                    val: ((val >> 24) & 0x7f) as uint,
+                    next: start + 1
+                }
+            } else if (val & 0x40000000) != 0 {
+                Res {
+                    val: ((val >> 16) & 0x3fff) as uint,
+                    next: start + 2
+                }
+            } else if (val & 0x20000000) != 0 {
+                Res {
+                    val: ((val >> 8) & 0x1fffff) as uint,
+                    next: start + 3
+                }
+            } else {
+                Res {
+                    val: (val & 0x0fffffff) as uint,
+                    next: start + 4
+                }
+            }
+        }
+    }
+
+    #[cfg(target_arch = "arm")]
+    pub fn vuint_at(data: &[u8], start: uint) -> Res {
+        vuint_at_slow(data, start)
     }
 
     pub fn Doc(data: @~[u8]) -> Doc {
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 6bf97843fa1..ef4932d667a 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -222,7 +222,11 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
                         };
                         match connect_result {
                             0i32 => {
-                                debug!("tcp_connect successful");
+                                debug!("tcp_connect successful: \
+                                        stream %x,
+                                        socket data %x",
+                                       stream_handle_ptr as uint,
+                                       socket_data_ptr as uint);
                                 // reusable data that we'll have for the
                                 // duration..
                                 uv::ll::set_data_for_uv_handle(
@@ -556,13 +560,21 @@ pub fn accept(new_conn: TcpNewConnection)
                             server_handle_ptr as *libc::c_void,
                             client_stream_handle_ptr as *libc::c_void) {
                             0i32 => {
-                                debug!(
-                                    "successfully accepted client \
-                                      connection");
+                                debug!("successfully accepted client \
+                                        connection: \
+                                        stream %x, \
+                                        socket data %x",
+                                       client_stream_handle_ptr as uint,
+                                       client_socket_data_ptr as uint);
                                 uv::ll::set_data_for_uv_handle(
                                     client_stream_handle_ptr,
                                     client_socket_data_ptr
                                     as *libc::c_void);
+                                let ptr = uv::ll::get_data_for_uv_handle(
+                                    client_stream_handle_ptr);
+                                debug!("ptrs: %x %x",
+                                       client_socket_data_ptr as uint,
+                                       ptr as uint);
                                 result_ch.send(None);
                             }
                             _ => {
@@ -1268,14 +1280,15 @@ impl ToTcpErr for uv::ll::uv_err_data {
 }
 
 extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
-                    nread: libc::ssize_t,
-                    buf: uv::ll::uv_buf_t) {
+                         nread: libc::ssize_t,
+                         buf: uv::ll::uv_buf_t) {
     unsafe {
-        debug!("entering on_tcp_read_cb stream: %? nread: %?",
-                        stream, nread);
+        debug!("entering on_tcp_read_cb stream: %x nread: %?",
+                        stream as uint, nread);
         let loop_ptr = uv::ll::get_loop_for_uv_handle(stream);
         let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream)
             as *TcpSocketData;
+        debug!("socket data is %x", socket_data_ptr as uint);
         match nread as int {
           // incoming err.. probably eof
           -1 => {
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index ab3074e49dd..98d76c6b9aa 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -1156,8 +1156,7 @@ pub unsafe fn set_data_for_uv_loop(loop_ptr: *libc::c_void,
 pub unsafe fn get_data_for_uv_handle<T>(handle: *T) -> *libc::c_void {
     return rustrt::rust_uv_get_data_for_uv_handle(handle as *libc::c_void);
 }
-pub unsafe fn set_data_for_uv_handle<T, U>(handle: *T,
-                    data: *U) {
+pub unsafe fn set_data_for_uv_handle<T, U>(handle: *T, data: *U) {
     rustrt::rust_uv_set_data_for_uv_handle(handle as *libc::c_void,
                                            data as *libc::c_void);
 }