librustc: Make all external functions unsafe. r=tjc

src/libstd/arena.rs

@@ -57,7 +57,9 @@ extern mod rusti {
 
 extern mod rustrt {
     #[rust_stack]
-    fn rust_call_tydesc_glue(root: *u8, tydesc: *TypeDesc, field: size_t);
+    unsafe fn rust_call_tydesc_glue(root: *u8,
+                                    tydesc: *TypeDesc,
+                                    field: size_t);
 }
 // This probably belongs somewhere else. Needs to be kept in sync with
 // changes to glue...

src/libstd/dbg.rs

@@ -18,33 +18,47 @@ use core::sys;
 #[abi = "cdecl"]
 extern mod rustrt {
     #[legacy_exports];
-    fn debug_tydesc(td: *sys::TypeDesc);
-    fn debug_opaque(td: *sys::TypeDesc, x: *());
-    fn debug_box(td: *sys::TypeDesc, x: *());
-    fn debug_tag(td: *sys::TypeDesc, x: *());
-    fn debug_fn(td: *sys::TypeDesc, x: *());
-    fn debug_ptrcast(td: *sys::TypeDesc, x: *()) -> *();
-    fn rust_dbg_breakpoint();
+    unsafe fn debug_tydesc(td: *sys::TypeDesc);
+    unsafe fn debug_opaque(td: *sys::TypeDesc, x: *());
+    unsafe fn debug_box(td: *sys::TypeDesc, x: *());
+    unsafe fn debug_tag(td: *sys::TypeDesc, x: *());
+    unsafe fn debug_fn(td: *sys::TypeDesc, x: *());
+    unsafe fn debug_ptrcast(td: *sys::TypeDesc, x: *()) -> *();
+    unsafe fn rust_dbg_breakpoint();
 }
 
 pub fn debug_tydesc<T>() {
-    rustrt::debug_tydesc(sys::get_type_desc::<T>());
+    unsafe {
+        rustrt::debug_tydesc(sys::get_type_desc::<T>());
+    }
 }
 
 pub fn debug_opaque<T>(x: T) {
-    rustrt::debug_opaque(sys::get_type_desc::<T>(), ptr::addr_of(&x) as *());
+    unsafe {
+        rustrt::debug_opaque(sys::get_type_desc::<T>(),
+                             ptr::addr_of(&x) as *());
+    }
 }
 
 pub fn debug_box<T>(x: @T) {
-    rustrt::debug_box(sys::get_type_desc::<T>(), ptr::addr_of(&x) as *());
+    unsafe {
+        rustrt::debug_box(sys::get_type_desc::<T>(),
+                          ptr::addr_of(&x) as *());
+    }
 }
 
 pub fn debug_tag<T>(x: T) {
-    rustrt::debug_tag(sys::get_type_desc::<T>(), ptr::addr_of(&x) as *());
+    unsafe {
+        rustrt::debug_tag(sys::get_type_desc::<T>(),
+                          ptr::addr_of(&x) as *());
+    }
 }
 
 pub fn debug_fn<T>(x: T) {
-    rustrt::debug_fn(sys::get_type_desc::<T>(), ptr::addr_of(&x) as *());
+    unsafe {
+        rustrt::debug_fn(sys::get_type_desc::<T>(),
+                         ptr::addr_of(&x) as *());
+    }
 }
 
 pub unsafe fn ptr_cast<T, U>(x: @T) -> @U {
@@ -55,7 +69,9 @@ pub unsafe fn ptr_cast<T, U>(x: @T) -> @U {
 
 /// Triggers a debugger breakpoint
 pub fn breakpoint() {
-    rustrt::rust_dbg_breakpoint();
+    unsafe {
+        rustrt::rust_dbg_breakpoint();
+    }
 }
 
 #[test]

src/libstd/net_tcp.rs

@@ -33,9 +33,10 @@ use core::vec;
 
 #[nolink]
 extern mod rustrt {
-    fn rust_uv_current_kernel_malloc(size: libc::c_uint) -> *libc::c_void;
-    fn rust_uv_current_kernel_free(mem: *libc::c_void);
-    fn rust_uv_helper_uv_tcp_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_current_kernel_malloc(size: libc::c_uint)
+                                         -> *libc::c_void;
+    unsafe fn rust_uv_current_kernel_free(mem: *libc::c_void);
+    unsafe fn rust_uv_helper_uv_tcp_t_size() -> libc::c_uint;
 }
 
 /**

src/libstd/rl.rs

@@ -18,13 +18,13 @@ use core::task;
 
 extern mod rustrt {
     #[legacy_exports];
-    fn linenoise(prompt: *c_char) -> *c_char;
-    fn linenoiseHistoryAdd(line: *c_char) -> c_int;
-    fn linenoiseHistorySetMaxLen(len: c_int) -> c_int;
-    fn linenoiseHistorySave(file: *c_char) -> c_int;
-    fn linenoiseHistoryLoad(file: *c_char) -> c_int;
-    fn linenoiseSetCompletionCallback(callback: *u8);
-    fn linenoiseAddCompletion(completions: *(), line: *c_char);
+    unsafe fn linenoise(prompt: *c_char) -> *c_char;
+    unsafe fn linenoiseHistoryAdd(line: *c_char) -> c_int;
+    unsafe fn linenoiseHistorySetMaxLen(len: c_int) -> c_int;
+    unsafe fn linenoiseHistorySave(file: *c_char) -> c_int;
+    unsafe fn linenoiseHistoryLoad(file: *c_char) -> c_int;
+    unsafe fn linenoiseSetCompletionCallback(callback: *u8);
+    unsafe fn linenoiseAddCompletion(completions: *(), line: *c_char);
 }
 
 /// Add a line to history

src/libstd/test.rs

@@ -39,7 +39,7 @@ use core::vec;
 #[abi = "cdecl"]
 extern mod rustrt {
     #[legacy_exports];
-    fn rust_sched_threads() -> size_t;
+    unsafe fn rust_sched_threads() -> size_t;
 }
 
 // The name of a test. By convention this follows the rules for rust
@@ -335,9 +335,11 @@ const sched_overcommit : uint = 1u;
 const sched_overcommit : uint = 4u;
 
 fn get_concurrency() -> uint {
-    let threads = rustrt::rust_sched_threads() as uint;
-    if threads == 1u { 1u }
-    else { threads * sched_overcommit }
+    unsafe {
+        let threads = rustrt::rust_sched_threads() as uint;
+        if threads == 1u { 1u }
+        else { threads * sched_overcommit }
+    }
 }
 
 #[allow(non_implicitly_copyable_typarams)]

src/libstd/time.rs

@@ -23,16 +23,16 @@ use core::str;
 #[abi = "cdecl"]
 extern mod rustrt {
     #[legacy_exports]
-    fn get_time(sec: &mut i64, nsec: &mut i32);
+    unsafe fn get_time(sec: &mut i64, nsec: &mut i32);
 
-    fn precise_time_ns(ns: &mut u64);
+    unsafe fn precise_time_ns(ns: &mut u64);
 
-    fn rust_tzset();
+    unsafe fn rust_tzset();
     // FIXME: The i64 values can be passed by-val when #2064 is fixed.
-    fn rust_gmtime(&&sec: i64, &&nsec: i32, &&result: Tm);
-    fn rust_localtime(&&sec: i64, &&nsec: i32, &&result: Tm);
-    fn rust_timegm(&&tm: Tm, sec: &mut i64);
-    fn rust_mktime(&&tm: Tm, sec: &mut i64);
+    unsafe fn rust_gmtime(&&sec: i64, &&nsec: i32, &&result: Tm);
+    unsafe fn rust_localtime(&&sec: i64, &&nsec: i32, &&result: Tm);
+    unsafe fn rust_timegm(&&tm: Tm, sec: &mut i64);
+    unsafe fn rust_mktime(&&tm: Tm, sec: &mut i64);
 }
 
 /// A record specifying a time value in seconds and nanoseconds.
@@ -58,10 +58,12 @@ impl Timespec : Eq {
  * nanoseconds since 1970-01-01T00:00:00Z.
  */
 pub fn get_time() -> Timespec {
-    let mut sec = 0i64;
-    let mut nsec = 0i32;
-    rustrt::get_time(&mut sec, &mut nsec);
-    return Timespec::new(sec, nsec);
+    unsafe {
+        let mut sec = 0i64;
+        let mut nsec = 0i32;
+        rustrt::get_time(&mut sec, &mut nsec);
+        return Timespec::new(sec, nsec);
+    }
 }
 
 
@@ -70,9 +72,11 @@ pub fn get_time() -> Timespec {
  * in nanoseconds since an unspecified epoch.
  */
 pub fn precise_time_ns() -> u64 {
-    let mut ns = 0u64;
-    rustrt::precise_time_ns(&mut ns);
-    ns
+    unsafe {
+        let mut ns = 0u64;
+        rustrt::precise_time_ns(&mut ns);
+        ns
+    }
 }
 
 
@@ -85,7 +89,9 @@ pub fn precise_time_s() -> float {
 }
 
 pub fn tzset() {
-    rustrt::rust_tzset();
+    unsafe {
+        rustrt::rust_tzset();
+    }
 }
 
 #[auto_encode]
@@ -142,10 +148,12 @@ pub pure fn empty_tm() -> Tm {
 
 /// Returns the specified time in UTC
 pub fn at_utc(clock: Timespec) -> Tm {
-    let mut Timespec { sec, nsec } = clock;
-    let mut tm = empty_tm();
-    rustrt::rust_gmtime(sec, nsec, tm);
-    move tm
+    unsafe {
+        let mut Timespec { sec, nsec } = clock;
+        let mut tm = empty_tm();
+        rustrt::rust_gmtime(sec, nsec, tm);
+        move tm
+    }
 }
 
 /// Returns the current time in UTC
@@ -155,10 +163,12 @@ pub fn now_utc() -> Tm {
 
 /// Returns the specified time in the local timezone
 pub fn at(clock: Timespec) -> Tm {
-    let mut Timespec { sec, nsec } = clock;
-    let mut tm = empty_tm();
-    rustrt::rust_localtime(sec, nsec, tm);
-    move tm
+    unsafe {
+        let mut Timespec { sec, nsec } = clock;
+        let mut tm = empty_tm();
+        rustrt::rust_localtime(sec, nsec, tm);
+        move tm
+    }
 }
 
 /// Returns the current time in the local timezone
@@ -183,13 +193,15 @@ pub pure fn strftime(format: &str, tm: &Tm) -> ~str {
 impl Tm {
     /// Convert time to the seconds from January 1, 1970
     fn to_timespec() -> Timespec {
-        let mut sec = 0i64;
-        if self.tm_gmtoff == 0_i32 {
-            rustrt::rust_timegm(self, &mut sec);
-        } else {
-            rustrt::rust_mktime(self, &mut sec);
+        unsafe {
+            let mut sec = 0i64;
+            if self.tm_gmtoff == 0_i32 {
+                rustrt::rust_timegm(self, &mut sec);
+            } else {
+                rustrt::rust_mktime(self, &mut sec);
+            }
+            Timespec::new(sec, self.tm_nsec)
         }
-        Timespec::new(sec, self.tm_nsec)
     }
 
     /// Convert time to the local timezone

src/libstd/unicode.rs

@@ -160,13 +160,13 @@ pub mod icu {
     #[link_name = "icuuc"]
     #[abi = "cdecl"]
     pub extern mod libicu {
-        pure fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
-        pure fn u_isdigit(c: UChar32) -> UBool;
-        pure fn u_islower(c: UChar32) -> UBool;
-        pure fn u_isspace(c: UChar32) -> UBool;
-        pure fn u_isupper(c: UChar32) -> UBool;
-        pure fn u_tolower(c: UChar32) -> UChar32;
-        pure fn u_toupper(c: UChar32) -> UChar32;
+        unsafe fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
+        unsafe fn u_isdigit(c: UChar32) -> UBool;
+        unsafe fn u_islower(c: UChar32) -> UBool;
+        unsafe fn u_isspace(c: UChar32) -> UBool;
+        unsafe fn u_isupper(c: UChar32) -> UBool;
+        unsafe fn u_tolower(c: UChar32) -> UChar32;
+        unsafe fn u_toupper(c: UChar32) -> UChar32;
     }
 }
 

src/libstd/uv_global_loop.rs

@@ -27,7 +27,7 @@ use core::task;
 use core::vec;
 
 extern mod rustrt {
-    fn rust_uv_get_kernel_global_chan_ptr() -> *libc::uintptr_t;
+    unsafe fn rust_uv_get_kernel_global_chan_ptr() -> *libc::uintptr_t;
 }
 
 /**

src/libstd/uv_ll.rs

@@ -581,127 +581,142 @@ pub mod uv_ll_struct_stubgen {
 #[nolink]
 extern mod rustrt {
     // libuv public API
-    fn rust_uv_loop_new() -> *libc::c_void;
-    fn rust_uv_loop_delete(lp: *libc::c_void);
-    fn rust_uv_loop_refcount(loop_ptr: *libc::c_void) -> libc::c_int;
-    fn rust_uv_run(loop_handle: *libc::c_void);
-    fn rust_uv_close(handle: *libc::c_void, cb: *u8);
-    fn rust_uv_async_send(handle: *uv_async_t);
-    fn rust_uv_async_init(loop_handle: *libc::c_void,
+    unsafe fn rust_uv_loop_new() -> *libc::c_void;
+    unsafe fn rust_uv_loop_delete(lp: *libc::c_void);
+    unsafe fn rust_uv_loop_refcount(loop_ptr: *libc::c_void) -> libc::c_int;
+    unsafe fn rust_uv_run(loop_handle: *libc::c_void);
+    unsafe fn rust_uv_close(handle: *libc::c_void, cb: *u8);
+    unsafe fn rust_uv_async_send(handle: *uv_async_t);
+    unsafe fn rust_uv_async_init(loop_handle: *libc::c_void,
                           async_handle: *uv_async_t,
                           cb: *u8) -> libc::c_int;
-    fn rust_uv_tcp_init(
+    unsafe fn rust_uv_tcp_init(
         loop_handle: *libc::c_void,
         handle_ptr: *uv_tcp_t) -> libc::c_int;
     // FIXME ref #2604 .. ?
-    fn rust_uv_buf_init(out_buf: *uv_buf_t, base: *u8,
+    unsafe fn rust_uv_buf_init(out_buf: *uv_buf_t, base: *u8,
                         len: libc::size_t);
-    fn rust_uv_last_error(loop_handle: *libc::c_void) -> uv_err_t;
+    unsafe fn rust_uv_last_error(loop_handle: *libc::c_void) -> uv_err_t;
     // FIXME ref #2064
-    fn rust_uv_strerror(err: *uv_err_t) -> *libc::c_char;
+    unsafe fn rust_uv_strerror(err: *uv_err_t) -> *libc::c_char;
     // FIXME ref #2064
-    fn rust_uv_err_name(err: *uv_err_t) -> *libc::c_char;
-    fn rust_uv_ip4_addr(ip: *u8, port: libc::c_int)
+    unsafe fn rust_uv_err_name(err: *uv_err_t) -> *libc::c_char;
+    unsafe fn rust_uv_ip4_addr(ip: *u8, port: libc::c_int)
         -> sockaddr_in;
-    fn rust_uv_ip6_addr(ip: *u8, port: libc::c_int)
+    unsafe fn rust_uv_ip6_addr(ip: *u8, port: libc::c_int)
         -> sockaddr_in6;
-    fn rust_uv_ip4_name(src: *sockaddr_in, dst: *u8, size: libc::size_t)
-        -> libc::c_int;
-    fn rust_uv_ip6_name(src: *sockaddr_in6, dst: *u8, size: libc::size_t)
-        -> libc::c_int;
-    fn rust_uv_ip4_port(src: *sockaddr_in) -> libc::c_uint;
-    fn rust_uv_ip6_port(src: *sockaddr_in6) -> libc::c_uint;
+    unsafe fn rust_uv_ip4_name(src: *sockaddr_in,
+                               dst: *u8,
+                               size: libc::size_t)
+                            -> libc::c_int;
+    unsafe fn rust_uv_ip6_name(src: *sockaddr_in6,
+                               dst: *u8,
+                               size: libc::size_t)
+                            -> libc::c_int;
+    unsafe fn rust_uv_ip4_port(src: *sockaddr_in) -> libc::c_uint;
+    unsafe fn rust_uv_ip6_port(src: *sockaddr_in6) -> libc::c_uint;
     // FIXME ref #2064
-    fn rust_uv_tcp_connect(connect_ptr: *uv_connect_t,
-                           tcp_handle_ptr: *uv_tcp_t,
-                           ++after_cb: *u8,
-                           ++addr: *sockaddr_in) -> libc::c_int;
+    unsafe fn rust_uv_tcp_connect(connect_ptr: *uv_connect_t,
+                                  tcp_handle_ptr: *uv_tcp_t,
+                                  ++after_cb: *u8,
+                                  ++addr: *sockaddr_in) -> libc::c_int;
     // FIXME ref #2064
-    fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t,
-                        ++addr: *sockaddr_in) -> libc::c_int;
+    unsafe fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t,
+                               ++addr: *sockaddr_in) -> libc::c_int;
     // FIXME ref #2064
-    fn rust_uv_tcp_connect6(connect_ptr: *uv_connect_t,
-                           tcp_handle_ptr: *uv_tcp_t,
-                           ++after_cb: *u8,
-                           ++addr: *sockaddr_in6) -> libc::c_int;
+    unsafe fn rust_uv_tcp_connect6(connect_ptr: *uv_connect_t,
+                                   tcp_handle_ptr: *uv_tcp_t,
+                                   ++after_cb: *u8,
+                                   ++addr: *sockaddr_in6) -> libc::c_int;
     // FIXME ref #2064
-    fn rust_uv_tcp_bind6(tcp_server: *uv_tcp_t,
-                        ++addr: *sockaddr_in6) -> libc::c_int;
-    fn rust_uv_tcp_getpeername(tcp_handle_ptr: *uv_tcp_t,
-                               ++name: *sockaddr_in) -> libc::c_int;
-    fn rust_uv_tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t,
-                                ++name: *sockaddr_in6) ->libc::c_int;
-    fn rust_uv_listen(stream: *libc::c_void, backlog: libc::c_int,
-                      cb: *u8) -> libc::c_int;
-    fn rust_uv_accept(server: *libc::c_void, client: *libc::c_void)
-        -> libc::c_int;
-    fn rust_uv_write(req: *libc::c_void, stream: *libc::c_void,
-             ++buf_in: *uv_buf_t, buf_cnt: libc::c_int,
-             cb: *u8) -> libc::c_int;
-    fn rust_uv_read_start(stream: *libc::c_void, on_alloc: *u8,
-                          on_read: *u8) -> libc::c_int;
-    fn rust_uv_read_stop(stream: *libc::c_void) -> libc::c_int;
-    fn rust_uv_timer_init(loop_handle: *libc::c_void,
-                          timer_handle: *uv_timer_t) -> libc::c_int;
-    fn rust_uv_timer_start(
+    unsafe fn rust_uv_tcp_bind6(tcp_server: *uv_tcp_t,
+                                ++addr: *sockaddr_in6) -> libc::c_int;
+    unsafe fn rust_uv_tcp_getpeername(tcp_handle_ptr: *uv_tcp_t,
+                                      ++name: *sockaddr_in) -> libc::c_int;
+    unsafe fn rust_uv_tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t,
+                                       ++name: *sockaddr_in6) ->libc::c_int;
+    unsafe fn rust_uv_listen(stream: *libc::c_void,
+                             backlog: libc::c_int,
+                             cb: *u8) -> libc::c_int;
+    unsafe fn rust_uv_accept(server: *libc::c_void, client: *libc::c_void)
+                          -> libc::c_int;
+    unsafe fn rust_uv_write(req: *libc::c_void,
+                            stream: *libc::c_void,
+                            ++buf_in: *uv_buf_t,
+                            buf_cnt: libc::c_int,
+                            cb: *u8)
+                         -> libc::c_int;
+    unsafe fn rust_uv_read_start(stream: *libc::c_void,
+                                 on_alloc: *u8,
+                                 on_read: *u8)
+                              -> libc::c_int;
+    unsafe fn rust_uv_read_stop(stream: *libc::c_void) -> libc::c_int;
+    unsafe fn rust_uv_timer_init(loop_handle: *libc::c_void,
+                                 timer_handle: *uv_timer_t)
+                              -> libc::c_int;
+    unsafe fn rust_uv_timer_start(
         timer_handle: *uv_timer_t,
         cb: *u8,
         timeout: libc::c_uint,
         repeat: libc::c_uint) -> libc::c_int;
-    fn rust_uv_timer_stop(handle: *uv_timer_t) -> libc::c_int;
+    unsafe fn rust_uv_timer_stop(handle: *uv_timer_t) -> libc::c_int;
 
-    fn rust_uv_getaddrinfo(loop_ptr: *libc::c_void,
-                           handle: *uv_getaddrinfo_t,
-                           cb: *u8,
-                           node_name_ptr: *u8,
-                           service_name_ptr: *u8,
-                           // should probably only pass ptr::null()
-                           hints: *addrinfo) -> libc::c_int;
-    fn rust_uv_freeaddrinfo(res: *addrinfo);
+    unsafe fn rust_uv_getaddrinfo(loop_ptr: *libc::c_void,
+                                  handle: *uv_getaddrinfo_t,
+                                  cb: *u8,
+                                  node_name_ptr: *u8,
+                                  service_name_ptr: *u8,
+                                  // should probably only pass ptr::null()
+                                  hints: *addrinfo)
+                               -> libc::c_int;
+    unsafe fn rust_uv_freeaddrinfo(res: *addrinfo);
 
     // data accessors/helpers for rust-mapped uv structs
-    fn rust_uv_helper_get_INADDR_NONE() -> u32;
-    fn rust_uv_is_ipv4_addrinfo(input: *addrinfo) -> bool;
-    fn rust_uv_is_ipv6_addrinfo(input: *addrinfo) -> bool;
-    fn rust_uv_get_next_addrinfo(input: *addrinfo) -> *addrinfo;
-    fn rust_uv_addrinfo_as_sockaddr_in(input: *addrinfo) -> *sockaddr_in;
-    fn rust_uv_addrinfo_as_sockaddr_in6(input: *addrinfo) -> *sockaddr_in6;
-    fn rust_uv_malloc_buf_base_of(sug_size: libc::size_t) -> *u8;
-    fn rust_uv_free_base_of_buf(++buf: uv_buf_t);
-    fn rust_uv_get_stream_handle_from_connect_req(
+    unsafe fn rust_uv_helper_get_INADDR_NONE() -> u32;
+    unsafe fn rust_uv_is_ipv4_addrinfo(input: *addrinfo) -> bool;
+    unsafe fn rust_uv_is_ipv6_addrinfo(input: *addrinfo) -> bool;
+    unsafe fn rust_uv_get_next_addrinfo(input: *addrinfo) -> *addrinfo;
+    unsafe fn rust_uv_addrinfo_as_sockaddr_in(input: *addrinfo)
+                                           -> *sockaddr_in;
+    unsafe fn rust_uv_addrinfo_as_sockaddr_in6(input: *addrinfo)
+                                            -> *sockaddr_in6;
+    unsafe fn rust_uv_malloc_buf_base_of(sug_size: libc::size_t) -> *u8;
+    unsafe fn rust_uv_free_base_of_buf(++buf: uv_buf_t);
+    unsafe fn rust_uv_get_stream_handle_from_connect_req(
         connect_req: *uv_connect_t)
         -> *uv_stream_t;
-    fn rust_uv_get_stream_handle_from_write_req(
+    unsafe fn rust_uv_get_stream_handle_from_write_req(
         write_req: *uv_write_t)
         -> *uv_stream_t;
-    fn rust_uv_get_loop_for_uv_handle(handle: *libc::c_void)
+    unsafe fn rust_uv_get_loop_for_uv_handle(handle: *libc::c_void)
         -> *libc::c_void;
-    fn rust_uv_get_data_for_uv_loop(loop_ptr: *libc::c_void) -> *libc::c_void;
-    fn rust_uv_set_data_for_uv_loop(loop_ptr: *libc::c_void,
-                                    data: *libc::c_void);
-    fn rust_uv_get_data_for_uv_handle(handle: *libc::c_void)
-        -> *libc::c_void;
-    fn rust_uv_set_data_for_uv_handle(handle: *libc::c_void,
-                                      data: *libc::c_void);
-    fn rust_uv_get_data_for_req(req: *libc::c_void) -> *libc::c_void;
-    fn rust_uv_set_data_for_req(req: *libc::c_void,
-                                data: *libc::c_void);
-    fn rust_uv_get_base_from_buf(++buf: uv_buf_t) -> *u8;
-    fn rust_uv_get_len_from_buf(++buf: uv_buf_t) -> libc::size_t;
+    unsafe fn rust_uv_get_data_for_uv_loop(loop_ptr: *libc::c_void)
+                                        -> *libc::c_void;
+    unsafe fn rust_uv_set_data_for_uv_loop(loop_ptr: *libc::c_void,
+                                           data: *libc::c_void);
+    unsafe fn rust_uv_get_data_for_uv_handle(handle: *libc::c_void)
+                                          -> *libc::c_void;
+    unsafe fn rust_uv_set_data_for_uv_handle(handle: *libc::c_void,
+                                             data: *libc::c_void);
+    unsafe fn rust_uv_get_data_for_req(req: *libc::c_void) -> *libc::c_void;
+    unsafe fn rust_uv_set_data_for_req(req: *libc::c_void,
+                                       data: *libc::c_void);
+    unsafe fn rust_uv_get_base_from_buf(++buf: uv_buf_t) -> *u8;
+    unsafe fn rust_uv_get_len_from_buf(++buf: uv_buf_t) -> libc::size_t;
 
     // sizeof testing helpers
-    fn rust_uv_helper_uv_tcp_t_size() -> libc::c_uint;
-    fn rust_uv_helper_uv_connect_t_size() -> libc::c_uint;
-    fn rust_uv_helper_uv_buf_t_size() -> libc::c_uint;
-    fn rust_uv_helper_uv_write_t_size() -> libc::c_uint;
-    fn rust_uv_helper_uv_err_t_size() -> libc::c_uint;
-    fn rust_uv_helper_sockaddr_in_size() -> libc::c_uint;
-    fn rust_uv_helper_sockaddr_in6_size() -> libc::c_uint;
-    fn rust_uv_helper_uv_async_t_size() -> libc::c_uint;
-    fn rust_uv_helper_uv_timer_t_size() -> libc::c_uint;
-    fn rust_uv_helper_uv_getaddrinfo_t_size() -> libc::c_uint;
-    fn rust_uv_helper_addrinfo_size() -> libc::c_uint;
-    fn rust_uv_helper_addr_in_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_uv_tcp_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_uv_connect_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_uv_buf_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_uv_write_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_uv_err_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_sockaddr_in_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_sockaddr_in6_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_uv_async_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_uv_timer_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_uv_getaddrinfo_t_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_addrinfo_size() -> libc::c_uint;
+    unsafe fn rust_uv_helper_addr_in_size() -> libc::c_uint;
 }
 
 pub unsafe fn loop_new() -> *libc::c_void {