librustc: Disallow "unsafe" for external functions

16 files changed, 539 insertions, 623 deletions

diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs
index 24ca6fc2309..b9535091ed8 100644
--- a/src/libstd/cleanup.rs
+++ b/src/libstd/cleanup.rs
@@ -156,6 +156,6 @@ pub mod rustrt {
     extern {
         #[rust_stack]
         // FIXME (#4386): Unable to make following method private.
-        pub unsafe fn rust_get_task() -> *c_void;
+        pub fn rust_get_task() -> *c_void;
     }
 }
diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs
index 9a8db6990b6..2e27f82f6f6 100644
--- a/src/libstd/gc.rs
+++ b/src/libstd/gc.rs
@@ -66,10 +66,10 @@ pub mod rustrt {
     #[link_name = "rustrt"]
     extern {
         #[rust_stack]
-        pub unsafe fn rust_gc_metadata() -> *Word;
+        pub fn rust_gc_metadata() -> *Word;
 
-        pub unsafe fn rust_get_stack_segment() -> *StackSegment;
-        pub unsafe fn rust_get_c_stack() -> *StackSegment;
+        pub fn rust_get_stack_segment() -> *StackSegment;
+        pub fn rust_get_c_stack() -> *StackSegment;
     }
 }
 
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 153286a311a..606c958b408 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -77,9 +77,9 @@ pub mod rustrt {
     #[abi = "cdecl"]
     #[link_name = "rustrt"]
     extern {
-        pub unsafe fn rust_get_stdin() -> *libc::FILE;
-        pub unsafe fn rust_get_stdout() -> *libc::FILE;
-        pub unsafe fn rust_get_stderr() -> *libc::FILE;
+        pub fn rust_get_stdin() -> *libc::FILE;
+        pub fn rust_get_stdout() -> *libc::FILE;
+        pub fn rust_get_stderr() -> *libc::FILE;
     }
 }
 
diff --git a/src/libstd/libc.rs b/src/libstd/libc.rs
index aecf97f5756..f96d3ce263e 100644
--- a/src/libstd/libc.rs
+++ b/src/libstd/libc.rs
@@ -2400,19 +2400,19 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_char, c_int};
 
             extern {
-                pub unsafe fn isalnum(c: c_int) -> c_int;
-                pub unsafe fn isalpha(c: c_int) -> c_int;
-                pub unsafe fn iscntrl(c: c_int) -> c_int;
-                pub unsafe fn isdigit(c: c_int) -> c_int;
-                pub unsafe fn isgraph(c: c_int) -> c_int;
-                pub unsafe fn islower(c: c_int) -> c_int;
-                pub unsafe fn isprint(c: c_int) -> c_int;
-                pub unsafe fn ispunct(c: c_int) -> c_int;
-                pub unsafe fn isspace(c: c_int) -> c_int;
-                pub unsafe fn isupper(c: c_int) -> c_int;
-                pub unsafe fn isxdigit(c: c_int) -> c_int;
-                pub unsafe fn tolower(c: c_char) -> c_char;
-                pub unsafe fn toupper(c: c_char) -> c_char;
+                pub fn isalnum(c: c_int) -> c_int;
+                pub fn isalpha(c: c_int) -> c_int;
+                pub fn iscntrl(c: c_int) -> c_int;
+                pub fn isdigit(c: c_int) -> c_int;
+                pub fn isgraph(c: c_int) -> c_int;
+                pub fn islower(c: c_int) -> c_int;
+                pub fn isprint(c: c_int) -> c_int;
+                pub fn ispunct(c: c_int) -> c_int;
+                pub fn isspace(c: c_int) -> c_int;
+                pub fn isupper(c: c_int) -> c_int;
+                pub fn isxdigit(c: c_int) -> c_int;
+                pub fn tolower(c: c_char) -> c_char;
+                pub fn toupper(c: c_char) -> c_char;
             }
         }
 
@@ -2423,66 +2423,58 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_char, c_int, c_long, size_t};
 
             extern {
-                pub unsafe fn fopen(filename: *c_char, mode: *c_char)
-                                    -> *FILE;
-                pub unsafe fn freopen(filename: *c_char,
-                                      mode: *c_char,
-                                      file: *FILE)
-                                      -> *FILE;
-                pub unsafe fn fflush(file: *FILE) -> c_int;
-                pub unsafe fn fclose(file: *FILE) -> c_int;
-                pub unsafe fn remove(filename: *c_char) -> c_int;
-                pub unsafe fn rename(oldname: *c_char, newname: *c_char)
-                                     -> c_int;
-                pub unsafe fn tmpfile() -> *FILE;
-                pub unsafe fn setvbuf(stream: *FILE,
-                                      buffer: *c_char,
-                                      mode: c_int,
-                                      size: size_t)
-                                      -> c_int;
-                pub unsafe fn setbuf(stream: *FILE, buf: *c_char);
+                pub fn fopen(filename: *c_char, mode: *c_char) -> *FILE;
+                pub fn freopen(filename: *c_char, mode: *c_char, file: *FILE)
+                               -> *FILE;
+                pub fn fflush(file: *FILE) -> c_int;
+                pub fn fclose(file: *FILE) -> c_int;
+                pub fn remove(filename: *c_char) -> c_int;
+                pub fn rename(oldname: *c_char, newname: *c_char) -> c_int;
+                pub fn tmpfile() -> *FILE;
+                pub fn setvbuf(stream: *FILE,
+                               buffer: *c_char,
+                               mode: c_int,
+                               size: size_t)
+                               -> c_int;
+                pub fn setbuf(stream: *FILE, buf: *c_char);
                 // Omitted: printf and scanf variants.
-                pub unsafe fn fgetc(stream: *FILE) -> c_int;
+                pub fn fgetc(stream: *FILE) -> c_int;
                 #[fast_ffi]
-                pub unsafe fn fgets(buf: *mut c_char,
-                                    n: c_int,
-                                    stream: *FILE)
-                                    -> *c_char;
+                pub fn fgets(buf: *mut c_char, n: c_int, stream: *FILE)
+                             -> *c_char;
                 #[fast_ffi]
-                pub unsafe fn fputc(c: c_int, stream: *FILE) -> c_int;
+                pub fn fputc(c: c_int, stream: *FILE) -> c_int;
                 #[fast_ffi]
-                pub unsafe fn fputs(s: *c_char, stream: *FILE) -> *c_char;
+                pub fn fputs(s: *c_char, stream: *FILE) -> *c_char;
                 // Omitted: getc, getchar (might be macros).
 
                 // Omitted: gets, so ridiculously unsafe that it should not
                 // survive.
 
                 // Omitted: putc, putchar (might be macros).
-                pub unsafe fn puts(s: *c_char) -> c_int;
-                pub unsafe fn ungetc(c: c_int, stream: *FILE) -> c_int;
+                pub fn puts(s: *c_char) -> c_int;
+                pub fn ungetc(c: c_int, stream: *FILE) -> c_int;
                 #[fast_ffi]
-                pub unsafe fn fread(ptr: *mut c_void,
-                                    size: size_t,
-                                    nobj: size_t,
-                                    stream: *FILE)
-                                    -> size_t;
+                pub fn fread(ptr: *mut c_void,
+                             size: size_t,
+                             nobj: size_t,
+                             stream: *FILE)
+                             -> size_t;
                 #[fast_ffi]
-                pub unsafe fn fwrite(ptr: *c_void,
-                                     size: size_t,
-                                     nobj: size_t,
-                                     stream: *FILE)
-                                     -> size_t;
-                pub unsafe fn fseek(stream: *FILE,
-                                    offset: c_long,
-                                    whence: c_int)
-                                    -> c_int;
-                pub unsafe fn ftell(stream: *FILE) -> c_long;
-                pub unsafe fn rewind(stream: *FILE);
-                pub unsafe fn fgetpos(stream: *FILE, ptr: *fpos_t) -> c_int;
-                pub unsafe fn fsetpos(stream: *FILE, ptr: *fpos_t) -> c_int;
-                pub unsafe fn feof(stream: *FILE) -> c_int;
-                pub unsafe fn ferror(stream: *FILE) -> c_int;
-                pub unsafe fn perror(s: *c_char);
+                pub fn fwrite(ptr: *c_void,
+                              size: size_t,
+                              nobj: size_t,
+                              stream: *FILE)
+                              -> size_t;
+                pub fn fseek(stream: *FILE, offset: c_long, whence: c_int)
+                             -> c_int;
+                pub fn ftell(stream: *FILE) -> c_long;
+                pub fn rewind(stream: *FILE);
+                pub fn fgetpos(stream: *FILE, ptr: *fpos_t) -> c_int;
+                pub fn fsetpos(stream: *FILE, ptr: *fpos_t) -> c_int;
+                pub fn feof(stream: *FILE) -> c_int;
+                pub fn ferror(stream: *FILE) -> c_int;
+                pub fn perror(s: *c_char);
             }
         }
 
@@ -2495,33 +2487,32 @@ pub mod funcs {
             use libc::types::os::arch::c95::{size_t};
 
             extern {
-                pub unsafe fn abs(i: c_int) -> c_int;
-                pub unsafe fn labs(i: c_long) -> c_long;
+                pub fn abs(i: c_int) -> c_int;
+                pub fn labs(i: c_long) -> c_long;
                 // Omitted: div, ldiv (return pub type incomplete).
-                pub unsafe fn atof(s: *c_char) -> c_double;
-                pub unsafe fn atoi(s: *c_char) -> c_int;
-                pub unsafe fn strtod(s: *c_char, endp: **c_char) -> c_double;
-                pub unsafe fn strtol(s: *c_char, endp: **c_char, base: c_int)
-                                     -> c_long;
-                pub unsafe fn strtoul(s: *c_char, endp: **c_char, base: c_int)
-                                      -> c_ulong;
+                pub fn atof(s: *c_char) -> c_double;
+                pub fn atoi(s: *c_char) -> c_int;
+                pub fn strtod(s: *c_char, endp: **c_char) -> c_double;
+                pub fn strtol(s: *c_char, endp: **c_char, base: c_int)
+                              -> c_long;
+                pub fn strtoul(s: *c_char, endp: **c_char, base: c_int)
+                               -> c_ulong;
                 #[fast_ffi]
-                pub unsafe fn calloc(nobj: size_t, size: size_t) -> *c_void;
+                pub fn calloc(nobj: size_t, size: size_t) -> *c_void;
                 #[fast_ffi]
-                pub unsafe fn malloc(size: size_t) -> *c_void;
+                pub fn malloc(size: size_t) -> *c_void;
                 #[fast_ffi]
-                pub unsafe fn realloc(p: *mut c_void, size: size_t)
-                                      -> *mut c_void;
+                pub fn realloc(p: *mut c_void, size: size_t) -> *mut c_void;
                 #[fast_ffi]
-                pub unsafe fn free(p: *c_void);
-                pub unsafe fn abort() -> !;
-                pub unsafe fn exit(status: c_int) -> !;
+                pub fn free(p: *c_void);
+                pub fn abort() -> !;
+                pub fn exit(status: c_int) -> !;
                 // Omitted: atexit.
-                pub unsafe fn system(s: *c_char) -> c_int;
-                pub unsafe fn getenv(s: *c_char) -> *c_char;
+                pub fn system(s: *c_char) -> c_int;
+                pub fn getenv(s: *c_char) -> *c_char;
                 // Omitted: bsearch, qsort
-                pub unsafe fn rand() -> c_int;
-                pub unsafe fn srand(seed: c_uint);
+                pub fn rand() -> c_int;
+                pub fn srand(seed: c_uint);
             }
         }
 
@@ -2533,28 +2524,25 @@ pub mod funcs {
             use libc::types::os::arch::c95::{wchar_t};
 
             extern {
-                pub unsafe fn strcpy(dst: *c_char, src: *c_char) -> *c_char;
-                pub unsafe fn strncpy(dst: *c_char, src: *c_char, n: size_t)
-                                      -> *c_char;
-                pub unsafe fn strcat(s: *c_char, ct: *c_char) -> *c_char;
-                pub unsafe fn strncat(s: *c_char, ct: *c_char, n: size_t)
-                                      -> *c_char;
-                pub unsafe fn strcmp(cs: *c_char, ct: *c_char) -> c_int;
-                pub unsafe fn strncmp(cs: *c_char, ct: *c_char, n: size_t)
-                                      -> c_int;
-                pub unsafe fn strcoll(cs: *c_char, ct: *c_char) -> c_int;
-                pub unsafe fn strchr(cs: *c_char, c: c_int) -> *c_char;
-                pub unsafe fn strrchr(cs: *c_char, c: c_int) -> *c_char;
-                pub unsafe fn strspn(cs: *c_char, ct: *c_char) -> size_t;
-                pub unsafe fn strcspn(cs: *c_char, ct: *c_char) -> size_t;
-                pub unsafe fn strpbrk(cs: *c_char, ct: *c_char) -> *c_char;
-                pub unsafe fn strstr(cs: *c_char, ct: *c_char) -> *c_char;
-                pub unsafe fn strlen(cs: *c_char) -> size_t;
-                pub unsafe fn strerror(n: c_int) -> *c_char;
-                pub unsafe fn strtok(s: *c_char, t: *c_char) -> *c_char;
-                pub unsafe fn strxfrm(s: *c_char, ct: *c_char, n: size_t)
-                                      -> size_t;
-                pub unsafe fn wcslen(buf: *wchar_t) -> size_t;
+                pub fn strcpy(dst: *c_char, src: *c_char) -> *c_char;
+                pub fn strncpy(dst: *c_char, src: *c_char, n: size_t)
+                               -> *c_char;
+                pub fn strcat(s: *c_char, ct: *c_char) -> *c_char;
+                pub fn strncat(s: *c_char, ct: *c_char, n: size_t) -> *c_char;
+                pub fn strcmp(cs: *c_char, ct: *c_char) -> c_int;
+                pub fn strncmp(cs: *c_char, ct: *c_char, n: size_t) -> c_int;
+                pub fn strcoll(cs: *c_char, ct: *c_char) -> c_int;
+                pub fn strchr(cs: *c_char, c: c_int) -> *c_char;
+                pub fn strrchr(cs: *c_char, c: c_int) -> *c_char;
+                pub fn strspn(cs: *c_char, ct: *c_char) -> size_t;
+                pub fn strcspn(cs: *c_char, ct: *c_char) -> size_t;
+                pub fn strpbrk(cs: *c_char, ct: *c_char) -> *c_char;
+                pub fn strstr(cs: *c_char, ct: *c_char) -> *c_char;
+                pub fn strlen(cs: *c_char) -> size_t;
+                pub fn strerror(n: c_int) -> *c_char;
+                pub fn strtok(s: *c_char, t: *c_char) -> *c_char;
+                pub fn strxfrm(s: *c_char, ct: *c_char, n: size_t) -> size_t;
+                pub fn wcslen(buf: *wchar_t) -> size_t;
 
                 // Omitted: memcpy, memmove, memset (provided by LLVM)
 
@@ -2562,12 +2550,10 @@ pub mod funcs {
                 // in fact, because LLVM generates calls to them!
                 #[rust_stack]
                 #[inline]
-                pub unsafe fn memcmp(cx: *c_void, ct: *c_void, n: size_t)
-                                     -> c_int;
+                pub fn memcmp(cx: *c_void, ct: *c_void, n: size_t) -> c_int;
                 #[rust_stack]
                 #[inline]
-                pub unsafe fn memchr(cx: *c_void, c: c_int, n: size_t)
-                                     -> *c_void;
+                pub fn memchr(cx: *c_void, c: c_int, n: size_t) -> *c_void;
             }
         }
     }
@@ -2588,16 +2574,13 @@ pub mod funcs {
 
             extern {
                 #[link_name = "_chmod"]
-                pub unsafe fn chmod(path: *c_char, mode: c_int) -> c_int;
-
+                pub fn chmod(path: *c_char, mode: c_int) -> c_int;
                 #[link_name = "_mkdir"]
-                pub unsafe fn mkdir(path: *c_char) -> c_int;
-
+                pub fn mkdir(path: *c_char) -> c_int;
                 #[link_name = "_fstat64"]
-                pub unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
-
+                pub fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
                 #[link_name = "_stat64"]
-                pub unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
+                pub fn stat(path: *c_char, buf: *mut stat) -> c_int;
             }
         }
 
@@ -2609,17 +2592,14 @@ pub mod funcs {
 
             extern {
                 #[link_name = "_popen"]
-                pub unsafe fn popen(command: *c_char, mode: *c_char) -> *FILE;
-
+                pub fn popen(command: *c_char, mode: *c_char) -> *FILE;
                 #[link_name = "_pclose"]
-                pub unsafe fn pclose(stream: *FILE) -> c_int;
-
+                pub fn pclose(stream: *FILE) -> c_int;
                 #[link_name = "_fdopen"]
                 #[fast_ffi]
-                pub unsafe fn fdopen(fd: c_int, mode: *c_char) -> *FILE;
-
+                pub fn fdopen(fd: c_int, mode: *c_char) -> *FILE;
                 #[link_name = "_fileno"]
-                pub unsafe fn fileno(stream: *FILE) -> c_int;
+                pub fn fileno(stream: *FILE) -> c_int;
             }
         }
 
@@ -2629,11 +2609,10 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_int, c_char};
             extern {
                 #[link_name = "_open"]
-                pub unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
-                                   -> c_int;
-
+                pub fn open(path: *c_char, oflag: c_int, mode: c_int)
+                            -> c_int;
                 #[link_name = "_creat"]
-                pub unsafe fn creat(path: *c_char, mode: c_int) -> c_int;
+                pub fn creat(path: *c_char, mode: c_int) -> c_int;
             }
         }
 
@@ -2653,73 +2632,48 @@ pub mod funcs {
 
             extern {
                 #[link_name = "_access"]
-                pub unsafe fn access(path: *c_char, amode: c_int) -> c_int;
-
+                pub fn access(path: *c_char, amode: c_int) -> c_int;
                 #[link_name = "_chdir"]
-                pub unsafe fn chdir(dir: *c_char) -> c_int;
-
+                pub fn chdir(dir: *c_char) -> c_int;
                 #[link_name = "_close"]
-                pub unsafe fn close(fd: c_int) -> c_int;
-
+                pub fn close(fd: c_int) -> c_int;
                 #[link_name = "_dup"]
-                pub unsafe fn dup(fd: c_int) -> c_int;
-
+                pub fn dup(fd: c_int) -> c_int;
                 #[link_name = "_dup2"]
-                pub unsafe fn dup2(src: c_int, dst: c_int) -> c_int;
-
+                pub fn dup2(src: c_int, dst: c_int) -> c_int;
                 #[link_name = "_execv"]
-                pub unsafe fn execv(prog: *c_char, argv: **c_char)
-                                    -> intptr_t;
-
+                pub fn execv(prog: *c_char, argv: **c_char) -> intptr_t;
                 #[link_name = "_execve"]
-                pub unsafe fn execve(prog: *c_char,
-                                     argv: **c_char,
-                                     envp: **c_char)
-                                     -> c_int;
-
+                pub fn execve(prog: *c_char, argv: **c_char, envp: **c_char)
+                              -> c_int;
                 #[link_name = "_execvp"]
-                pub unsafe fn execvp(c: *c_char, argv: **c_char) -> c_int;
-
+                pub fn execvp(c: *c_char, argv: **c_char) -> c_int;
                 #[link_name = "_execvpe"]
-                pub unsafe fn execvpe(c: *c_char,
-                                      argv: **c_char,
-                                      envp: **c_char)
-                                      -> c_int;
-
+                pub fn execvpe(c: *c_char, argv: **c_char, envp: **c_char)
+                               -> c_int;
                 #[link_name = "_getcwd"]
-                pub unsafe fn getcwd(buf: *c_char, size: size_t) -> *c_char;
-
+                pub fn getcwd(buf: *c_char, size: size_t) -> *c_char;
                 #[link_name = "_getpid"]
-                pub unsafe fn getpid() -> c_int;
-
+                pub fn getpid() -> c_int;
                 #[link_name = "_isatty"]
-                pub unsafe fn isatty(fd: c_int) -> c_int;
-
+                pub fn isatty(fd: c_int) -> c_int;
                 #[link_name = "_lseek"]
-                pub unsafe fn lseek(fd: c_int, offset: c_long, origin: c_int)
-                                    -> c_long;
-
+                pub fn lseek(fd: c_int, offset: c_long, origin: c_int)
+                             -> c_long;
                 #[link_name = "_pipe"]
-                pub unsafe fn pipe(fds: *mut c_int,
-                                   psize: c_uint,
-                                   textmode: c_int)
-                                   -> c_int;
-
+                pub fn pipe(fds: *mut c_int, psize: c_uint, textmode: c_int)
+                            -> c_int;
                 #[link_name = "_read"]
                 #[fast_ffi]
-                pub unsafe fn read(fd: c_int, buf: *mut c_void, count: c_uint)
-                                   -> c_int;
-
+                pub fn read(fd: c_int, buf: *mut c_void, count: c_uint)
+                            -> c_int;
                 #[link_name = "_rmdir"]
-                pub unsafe fn rmdir(path: *c_char) -> c_int;
-
+                pub fn rmdir(path: *c_char) -> c_int;
                 #[link_name = "_unlink"]
-                pub unsafe fn unlink(c: *c_char) -> c_int;
-
+                pub fn unlink(c: *c_char) -> c_int;
                 #[link_name = "_write"]
                 #[fast_ffi]
-                pub unsafe fn write(fd: c_int, buf: *c_void, count: c_uint)
-                                    -> c_int;
+                pub fn write(fd: c_int, buf: *c_void, count: c_uint) -> c_int;
             }
         }
 
@@ -2741,29 +2695,29 @@ pub mod funcs {
             #[nolink]
             #[abi = "cdecl"]
             extern {
-                pub unsafe fn chmod(path: *c_char, mode: mode_t) -> c_int;
-                pub unsafe fn fchmod(fd: c_int, mode: mode_t) -> c_int;
+                pub fn chmod(path: *c_char, mode: mode_t) -> c_int;
+                pub fn fchmod(fd: c_int, mode: mode_t) -> c_int;
 
                 #[cfg(target_os = "linux")]
                 #[cfg(target_os = "freebsd")]
                 #[cfg(target_os = "android")]
-                pub unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
+                pub fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
 
                 #[cfg(target_os = "macos")]
                 #[link_name = "fstat64"]
-                pub unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
+                pub fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
 
-                pub unsafe fn mkdir(path: *c_char, mode: mode_t) -> c_int;
-                pub unsafe fn mkfifo(path: *c_char, mode: mode_t) -> c_int;
+                pub fn mkdir(path: *c_char, mode: mode_t) -> c_int;
+                pub fn mkfifo(path: *c_char, mode: mode_t) -> c_int;
 
                 #[cfg(target_os = "linux")]
                 #[cfg(target_os = "freebsd")]
                 #[cfg(target_os = "android")]
-                pub unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
+                pub fn stat(path: *c_char, buf: *mut stat) -> c_int;
 
                 #[cfg(target_os = "macos")]
                 #[link_name = "stat64"]
-                pub unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
+                pub fn stat(path: *c_char, buf: *mut stat) -> c_int;
             }
         }
 
@@ -2774,10 +2728,10 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_char, c_int};
 
             extern {
-                pub unsafe fn popen(command: *c_char, mode: *c_char) -> *FILE;
-                pub unsafe fn pclose(stream: *FILE) -> c_int;
-                pub unsafe fn fdopen(fd: c_int, mode: *c_char) -> *FILE;
-                pub unsafe fn fileno(stream: *FILE) -> c_int;
+                pub fn popen(command: *c_char, mode: *c_char) -> *FILE;
+                pub fn pclose(stream: *FILE) -> c_int;
+                pub fn fdopen(fd: c_int, mode: *c_char) -> *FILE;
+                pub fn fileno(stream: *FILE) -> c_int;
             }
         }
 
@@ -2788,10 +2742,10 @@ pub mod funcs {
             use libc::types::os::arch::posix88::mode_t;
 
             extern {
-                pub unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
-                                   -> c_int;
-                pub unsafe fn creat(path: *c_char, mode: mode_t) -> c_int;
-                pub unsafe fn fcntl(fd: c_int, cmd: c_int) -> c_int;
+                pub fn open(path: *c_char, oflag: c_int, mode: c_int)
+                            -> c_int;
+                pub fn creat(path: *c_char, mode: mode_t) -> c_int;
+                pub fn fcntl(fd: c_int, cmd: c_int) -> c_int;
             }
         }
 
@@ -2815,15 +2769,15 @@ pub mod funcs {
             }
 
             extern {
-                unsafe fn rust_opendir(dirname: *c_char) -> *DIR;
-                unsafe fn rust_readdir(dirp: *DIR) -> *dirent_t;
+                fn rust_opendir(dirname: *c_char) -> *DIR;
+                fn rust_readdir(dirp: *DIR) -> *dirent_t;
             }
 
             extern {
-                pub unsafe fn closedir(dirp: *DIR) -> c_int;
-                pub unsafe fn rewinddir(dirp: *DIR);
-                pub unsafe fn seekdir(dirp: *DIR, loc: c_long);
-                pub unsafe fn telldir(dirp: *DIR) -> c_long;
+                pub fn closedir(dirp: *DIR) -> c_int;
+                pub fn rewinddir(dirp: *DIR);
+                pub fn seekdir(dirp: *DIR, loc: c_long);
+                pub fn telldir(dirp: *DIR) -> c_long;
             }
         }
 
@@ -2837,62 +2791,55 @@ pub mod funcs {
             use libc::types::os::arch::posix88::{ssize_t, uid_t};
 
             extern {
-                pub unsafe fn access(path: *c_char, amode: c_int) -> c_int;
-                pub unsafe fn alarm(seconds: c_uint) -> c_uint;
-                pub unsafe fn chdir(dir: *c_char) -> c_int;
-                pub unsafe fn chown(path: *c_char, uid: uid_t, gid: gid_t)
-                                    -> c_int;
-                pub unsafe fn close(fd: c_int) -> c_int;
-                pub unsafe fn dup(fd: c_int) -> c_int;
-                pub unsafe fn dup2(src: c_int, dst: c_int) -> c_int;
-                pub unsafe fn execv(prog: *c_char, argv: **c_char) -> c_int;
-                pub unsafe fn execve(prog: *c_char,
-                                     argv: **c_char,
-                                     envp: **c_char)
-                                     -> c_int;
-                pub unsafe fn execvp(c: *c_char, argv: **c_char) -> c_int;
-                pub unsafe fn fork() -> pid_t;
-                pub unsafe fn fpathconf(filedes: c_int, name: c_int)
-                                        -> c_long;
-                pub unsafe fn getcwd(buf: *c_char, size: size_t) -> *c_char;
-                pub unsafe fn getegid() -> gid_t;
-                pub unsafe fn geteuid() -> uid_t;
-                pub unsafe fn getgid() -> gid_t ;
-                pub unsafe fn getgroups(ngroups_max: c_int,
-                                        groups: *mut gid_t)
-                                        -> c_int;
-                pub unsafe fn getlogin() -> *c_char;
-                pub unsafe fn getopt(argc: c_int,
-                                     argv: **c_char,
-                                     optstr: *c_char)
-                                     -> c_int;
-                pub unsafe fn getpgrp() -> pid_t;
-                pub unsafe fn getpid() -> pid_t;
-                pub unsafe fn getppid() -> pid_t;
-                pub unsafe fn getuid() -> uid_t;
-                pub unsafe fn isatty(fd: c_int) -> c_int;
-                pub unsafe fn link(src: *c_char, dst: *c_char) -> c_int;
-                pub unsafe fn lseek(fd: c_int, offset: off_t, whence: c_int)
-                                    -> off_t;
-                pub unsafe fn pathconf(path: *c_char, name: c_int) -> c_long;
-                pub unsafe fn pause() -> c_int;
-                pub unsafe fn pipe(fds: *mut c_int) -> c_int;
+                pub fn access(path: *c_char, amode: c_int) -> c_int;
+                pub fn alarm(seconds: c_uint) -> c_uint;
+                pub fn chdir(dir: *c_char) -> c_int;
+                pub fn chown(path: *c_char, uid: uid_t, gid: gid_t) -> c_int;
+                pub fn close(fd: c_int) -> c_int;
+                pub fn dup(fd: c_int) -> c_int;
+                pub fn dup2(src: c_int, dst: c_int) -> c_int;
+                pub fn execv(prog: *c_char, argv: **c_char) -> c_int;
+                pub fn execve(prog: *c_char, argv: **c_char, envp: **c_char)
+                              -> c_int;
+                pub fn execvp(c: *c_char, argv: **c_char) -> c_int;
+                pub fn fork() -> pid_t;
+                pub fn fpathconf(filedes: c_int, name: c_int) -> c_long;
+                pub fn getcwd(buf: *c_char, size: size_t) -> *c_char;
+                pub fn getegid() -> gid_t;
+                pub fn geteuid() -> uid_t;
+                pub fn getgid() -> gid_t ;
+                pub fn getgroups(ngroups_max: c_int, groups: *mut gid_t)
+                                 -> c_int;
+                pub fn getlogin() -> *c_char;
+                pub fn getopt(argc: c_int, argv: **c_char, optstr: *c_char)
+                              -> c_int;
+                pub fn getpgrp() -> pid_t;
+                pub fn getpid() -> pid_t;
+                pub fn getppid() -> pid_t;
+                pub fn getuid() -> uid_t;
+                pub fn isatty(fd: c_int) -> c_int;
+                pub fn link(src: *c_char, dst: *c_char) -> c_int;
+                pub fn lseek(fd: c_int, offset: off_t, whence: c_int)
+                             -> off_t;
+                pub fn pathconf(path: *c_char, name: c_int) -> c_long;
+                pub fn pause() -> c_int;
+                pub fn pipe(fds: *mut c_int) -> c_int;
                 #[fast_ffi]
-                pub unsafe fn read(fd: c_int, buf: *mut c_void, count: size_t)
-                                   -> ssize_t;
-                pub unsafe fn rmdir(path: *c_char) -> c_int;
-                pub unsafe fn setgid(gid: gid_t) -> c_int;
-                pub unsafe fn setpgid(pid: pid_t, pgid: pid_t) -> c_int;
-                pub unsafe fn setsid() -> pid_t;
-                pub unsafe fn setuid(uid: uid_t) -> c_int;
-                pub unsafe fn sleep(secs: c_uint) -> c_uint;
-                pub unsafe fn sysconf(name: c_int) -> c_long;
-                pub unsafe fn tcgetpgrp(fd: c_int) -> pid_t;
-                pub unsafe fn ttyname(fd: c_int) -> *c_char;
-                pub unsafe fn unlink(c: *c_char) -> c_int;
+                pub fn read(fd: c_int, buf: *mut c_void, count: size_t)
+                            -> ssize_t;
+                pub fn rmdir(path: *c_char) -> c_int;
+                pub fn setgid(gid: gid_t) -> c_int;
+                pub fn setpgid(pid: pid_t, pgid: pid_t) -> c_int;
+                pub fn setsid() -> pid_t;
+                pub fn setuid(uid: uid_t) -> c_int;
+                pub fn sleep(secs: c_uint) -> c_uint;
+                pub fn sysconf(name: c_int) -> c_long;
+                pub fn tcgetpgrp(fd: c_int) -> pid_t;
+                pub fn ttyname(fd: c_int) -> *c_char;
+                pub fn unlink(c: *c_char) -> c_int;
                 #[fast_ffi]
-                pub unsafe fn write(fd: c_int, buf: *c_void, count: size_t)
-                                    -> ssize_t;
+                pub fn write(fd: c_int, buf: *c_void, count: size_t)
+                             -> ssize_t;
             }
         }
 
@@ -2903,7 +2850,7 @@ pub mod funcs {
             use libc::types::os::arch::posix88::{pid_t};
 
             extern {
-                pub unsafe fn kill(pid: pid_t, sig: c_int) -> c_int;
+                pub fn kill(pid: pid_t, sig: c_int) -> c_int;
             }
         }
 
@@ -2915,32 +2862,28 @@ pub mod funcs {
             use libc::types::os::arch::posix88::{mode_t, off_t};
 
             extern {
-                pub unsafe fn mlock(addr: *c_void, len: size_t) -> c_int;
-                pub unsafe fn munlock(addr: *c_void, len: size_t) -> c_int;
-                pub unsafe fn mlockall(flags: c_int) -> c_int;
-                pub unsafe fn munlockall() -> c_int;
-
-                pub unsafe fn mmap(addr: *c_void,
-                                   len: size_t,
-                                   prot: c_int,
-                                   flags: c_int,
-                                   fd: c_int,
-                                   offset: off_t)
-                                   -> *mut c_void;
-                pub unsafe fn munmap(addr: *c_void, len: size_t) -> c_int;
-
-                pub unsafe fn mprotect(addr: *c_void,
-                                       len: size_t,
-                                       prot: c_int)
-                                       -> c_int;
-
-                pub unsafe fn msync(addr: *c_void, len: size_t, flags: c_int)
-                                    -> c_int;
-                pub unsafe fn shm_open(name: *c_char,
-                                       oflag: c_int,
-                                       mode: mode_t)
-                                       -> c_int;
-                pub unsafe fn shm_unlink(name: *c_char) -> c_int;
+                pub fn mlock(addr: *c_void, len: size_t) -> c_int;
+                pub fn munlock(addr: *c_void, len: size_t) -> c_int;
+                pub fn mlockall(flags: c_int) -> c_int;
+                pub fn munlockall() -> c_int;
+
+                pub fn mmap(addr: *c_void,
+                            len: size_t,
+                            prot: c_int,
+                            flags: c_int,
+                            fd: c_int,
+                            offset: off_t)
+                            -> *mut c_void;
+                pub fn munmap(addr: *c_void, len: size_t) -> c_int;
+
+                pub fn mprotect(addr: *c_void, len: size_t, prot: c_int)
+                                -> c_int;
+
+                pub fn msync(addr: *c_void, len: size_t, flags: c_int)
+                             -> c_int;
+                pub fn shm_open(name: *c_char, oflag: c_int, mode: mode_t)
+                                -> c_int;
+                pub fn shm_unlink(name: *c_char) -> c_int;
             }
         }
     }
@@ -2960,11 +2903,11 @@ pub mod funcs {
                 #[cfg(target_os = "linux")]
                 #[cfg(target_os = "freebsd")]
                 #[cfg(target_os = "android")]
-                pub unsafe fn lstat(path: *c_char, buf: *mut stat) -> c_int;
+                pub fn lstat(path: *c_char, buf: *mut stat) -> c_int;
 
                 #[cfg(target_os = "macos")]
                 #[link_name = "lstat64"]
-                pub unsafe fn lstat(path: *c_char, buf: *mut stat) -> c_int;
+                pub fn lstat(path: *c_char, buf: *mut stat) -> c_int;
             }
         }
 
@@ -2975,26 +2918,23 @@ pub mod funcs {
             use libc::types::os::arch::posix88::{ssize_t};
 
             extern {
-                pub unsafe fn readlink(path: *c_char,
-                                       buf: *mut c_char,
-                                       bufsz: size_t)
-                                       -> ssize_t;
+                pub fn readlink(path: *c_char,
+                                buf: *mut c_char,
+                                bufsz: size_t)
+                                -> ssize_t;
 
-                pub unsafe fn fsync(fd: c_int) -> c_int;
+                pub fn fsync(fd: c_int) -> c_int;
 
                 #[cfg(target_os = "linux")]
                 #[cfg(target_os = "android")]
-                pub unsafe fn fdatasync(fd: c_int) -> c_int;
+                pub fn fdatasync(fd: c_int) -> c_int;
 
-                pub unsafe fn setenv(name: *c_char,
-                                     val: *c_char,
-                                     overwrite: c_int)
-                                     -> c_int;
-                pub unsafe fn unsetenv(name: *c_char) -> c_int;
-                pub unsafe fn putenv(string: *c_char) -> c_int;
+                pub fn setenv(name: *c_char, val: *c_char, overwrite: c_int)
+                              -> c_int;
+                pub fn unsetenv(name: *c_char) -> c_int;
+                pub fn putenv(string: *c_char) -> c_int;
 
-                pub unsafe fn symlink(path1: *c_char, path2: *c_char)
-                                      -> c_int;
+                pub fn symlink(path1: *c_char, path2: *c_char) -> c_int;
             }
         }
 
@@ -3005,10 +2945,8 @@ pub mod funcs {
             use libc::types::os::arch::posix88::{pid_t};
 
             extern {
-                pub unsafe fn waitpid(pid: pid_t,
-                                      status: *mut c_int,
-                                      options: c_int)
-                                      -> pid_t;
+                pub fn waitpid(pid: pid_t, status: *mut c_int, options: c_int)
+                               -> pid_t;
             }
         }
 
@@ -3020,11 +2958,11 @@ pub mod funcs {
             use libc::types::os::common::posix01::{glob_t};
 
             extern {
-                pub unsafe fn glob(pattern: *c_char,
-                                   flags: c_int,
-                                   errfunc: *c_void, // XXX callback
-                                   pglob: *mut glob_t);
-                pub unsafe fn globfree(pglob: *mut glob_t);
+                pub fn glob(pattern: *c_char,
+                            flags: c_int,
+                            errfunc: *c_void, // XXX callback
+                            pglob: *mut glob_t);
+                pub fn globfree(pglob: *mut glob_t);
             }
         }
 
@@ -3035,10 +2973,10 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_int, size_t};
 
             extern {
-                pub unsafe fn posix_madvise(addr: *c_void,
-                                            len: size_t,
-                                            advice: c_int)
-                                            -> c_int;
+                pub fn posix_madvise(addr: *c_void,
+                                     len: size_t,
+                                     advice: c_int)
+                                     -> c_int;
             }
         }
     }
@@ -3079,33 +3017,28 @@ pub mod funcs {
 
         #[abi = "cdecl"]
         extern {
-            pub unsafe fn sysctl(name: *c_int,
-                                 namelen: c_uint,
-                                 oldp: *mut c_void,
-                                 oldlenp: *mut size_t,
-                                 newp: *c_void,
-                                 newlen: size_t)
-                                 -> c_int;
-
-            pub unsafe fn sysctlbyname(name: *c_char,
-                                       oldp: *mut c_void,
-                                       oldlenp: *mut size_t,
-                                       newp: *c_void,
-                                       newlen: size_t)
-                                       -> c_int;
-
-            pub unsafe fn sysctlnametomib(name: *c_char,
-                                          mibp: *mut c_int,
-                                          sizep: *mut size_t)
-                                          -> c_int;
-
-            pub unsafe fn getdtablesize() -> c_int;
-
-            pub unsafe fn madvise(addr: *c_void, len: size_t, advice: c_int)
-                                  -> c_int;
-
-            pub unsafe fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
-                                  -> c_int;
+            pub fn sysctl(name: *c_int,
+                          namelen: c_uint,
+                          oldp: *mut c_void,
+                          oldlenp: *mut size_t,
+                          newp: *c_void,
+                          newlen: size_t)
+                          -> c_int;
+            pub fn sysctlbyname(name: *c_char,
+                                oldp: *mut c_void,
+                                oldlenp: *mut size_t,
+                                newp: *c_void,
+                                newlen: size_t)
+                                -> c_int;
+            pub fn sysctlnametomib(name: *c_char,
+                                   mibp: *mut c_int,
+                                   sizep: *mut size_t)
+                                   -> c_int;
+            pub fn getdtablesize() -> c_int;
+            pub fn madvise(addr: *c_void, len: size_t, advice: c_int)
+                           -> c_int;
+            pub fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
+                           -> c_int;
         }
     }
 
@@ -3118,13 +3051,11 @@ pub mod funcs {
 
         #[abi = "cdecl"]
         extern {
-            pub unsafe fn getdtablesize() -> c_int;
-
-            pub unsafe fn madvise(addr: *c_void, len: size_t, advice: c_int)
-                                  -> c_int;
-
-            pub unsafe fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
-                                  -> c_int;
+            pub fn getdtablesize() -> c_int;
+            pub fn madvise(addr: *c_void, len: size_t, advice: c_int)
+                           -> c_int;
+            pub fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
+                           -> c_int;
         }
     }
 
@@ -3140,9 +3071,8 @@ pub mod funcs {
 
         #[abi = "cdecl"]
         extern {
-            pub unsafe fn _NSGetExecutablePath(buf: *mut c_char,
-                                               bufsize: *mut u32)
-                                               -> c_int;
+            pub fn _NSGetExecutablePath(buf: *mut c_char, bufsize: *mut u32)
+                                        -> c_int;
         }
     }
 
@@ -3173,118 +3103,107 @@ pub mod funcs {
 
             #[abi = "stdcall"]
             extern "stdcall" {
-                pub unsafe fn GetEnvironmentVariableW(n: LPCWSTR,
-                                                      v: LPWSTR,
-                                                      nsize: DWORD)
-                                                      -> DWORD;
-                pub unsafe fn SetEnvironmentVariableW(n: LPCWSTR, v: LPCWSTR)
-                                                      -> BOOL;
-                pub unsafe fn GetEnvironmentStringsA() -> LPTCH;
-                pub unsafe fn FreeEnvironmentStringsA(env_ptr: LPTCH) -> BOOL;
-
-                pub unsafe fn GetModuleFileNameW(hModule: HMODULE,
-                                                 lpFilename: LPWSTR,
-                                                 nSize: DWORD)
-                                                 -> DWORD;
-                pub unsafe fn CreateDirectoryW(lpPathName: LPCWSTR,
-                                               lpSecurityAttributes:
-                                               LPSECURITY_ATTRIBUTES)
-                                            -> BOOL;
-                pub unsafe fn CopyFileW(lpExistingFileName: LPCWSTR,
+                pub fn GetEnvironmentVariableW(n: LPCWSTR,
+                                               v: LPWSTR,
+                                               nsize: DWORD)
+                                               -> DWORD;
+                pub fn SetEnvironmentVariableW(n: LPCWSTR, v: LPCWSTR)
+                                               -> BOOL;
+                pub fn GetEnvironmentStringsA() -> LPTCH;
+                pub fn FreeEnvironmentStringsA(env_ptr: LPTCH) -> BOOL;
+                pub fn GetModuleFileNameW(hModule: HMODULE,
+                                          lpFilename: LPWSTR,
+                                          nSize: DWORD)
+                                          -> DWORD;
+                pub fn CreateDirectoryW(lpPathName: LPCWSTR,
+                                        lpSecurityAttributes:
+                                        LPSECURITY_ATTRIBUTES)
+                                        -> BOOL;
+                pub fn CopyFileW(lpExistingFileName: LPCWSTR,
                                         lpNewFileName: LPCWSTR,
                                         bFailIfExists: BOOL)
                                         -> BOOL;
-                pub unsafe fn DeleteFileW(lpPathName: LPCWSTR) -> BOOL;
-                pub unsafe fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
-                pub unsafe fn SetCurrentDirectoryW(lpPathName: LPCWSTR)
-                                                   -> BOOL;
-
-                pub unsafe fn GetLastError() -> DWORD;
-                pub unsafe fn FindFirstFileW(fileName: *u16,
-                                             findFileData: HANDLE)
-                                             -> HANDLE;
-                pub unsafe fn FindNextFileW(findFile: HANDLE,
-                                            findFileData: HANDLE)
-                                            -> BOOL;
-                pub unsafe fn FindClose(findFile: HANDLE) -> BOOL;
-                pub unsafe fn DuplicateHandle(hSourceProcessHandle: HANDLE,
-                                              hSourceHandle: HANDLE,
-                                              hTargetProcessHandle: HANDLE,
-                                              lpTargetHandle: LPHANDLE,
-                                              dwDesiredAccess: DWORD,
-                                              bInheritHandle: BOOL,
-                                              dwOptions: DWORD)
-                                              -> BOOL;
-                pub unsafe fn CloseHandle(hObject: HANDLE) -> BOOL;
-                pub unsafe fn OpenProcess(dwDesiredAccess: DWORD,
-                                          bInheritHandle: BOOL,
-                                          dwProcessId: DWORD)
-                                          -> HANDLE;
-                pub unsafe fn GetCurrentProcess() -> HANDLE;
-                pub unsafe fn CreateProcessA(lpApplicationName: LPCTSTR,
-                                             lpCommandLine: LPTSTR,
-                                             lpProcessAttributes:
-                                             LPSECURITY_ATTRIBUTES,
-                                             lpThreadAttributes:
-                                             LPSECURITY_ATTRIBUTES,
-                                             bInheritHandles: BOOL,
-                                             dwCreationFlags: DWORD,
-                                             lpEnvironment: LPVOID,
-                                             lpCurrentDirectory: LPCTSTR,
-                                             lpStartupInfo: LPSTARTUPINFO,
-                                             lpProcessInformation:
-                                             LPPROCESS_INFORMATION)
-                                             -> BOOL;
-                pub unsafe fn WaitForSingleObject(hHandle: HANDLE,
-                                                  dwMilliseconds: DWORD)
-                                                  -> DWORD;
-                pub unsafe fn TerminateProcess(hProcess: HANDLE,
-                                               uExitCode: c_uint)
-                                               -> BOOL;
-                pub unsafe fn GetExitCodeProcess(hProcess: HANDLE,
-                                                 lpExitCode: LPDWORD)
-                                                 -> BOOL;
-
-                pub unsafe fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
-                pub unsafe fn VirtualAlloc(lpAddress: LPVOID,
-                                           dwSize: SIZE_T,
-                                           flAllocationType: DWORD,
-                                           flProtect: DWORD)
-                                           -> LPVOID;
-                pub unsafe fn VirtualFree(lpAddress: LPVOID,
-                                          dwSize: SIZE_T,
-                                          dwFreeType: DWORD)
-                                          -> BOOL;
-                pub unsafe fn VirtualLock(lpAddress: LPVOID, dwSize: SIZE_T)
+                pub fn DeleteFileW(lpPathName: LPCWSTR) -> BOOL;
+                pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
+                pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;
+                pub fn GetLastError() -> DWORD;
+                pub fn FindFirstFileW(fileName: *u16, findFileData: HANDLE)
+                                      -> HANDLE;
+                pub fn FindNextFileW(findFile: HANDLE, findFileData: HANDLE)
+                                     -> BOOL;
+                pub fn FindClose(findFile: HANDLE) -> BOOL;
+                pub fn DuplicateHandle(hSourceProcessHandle: HANDLE,
+                                       hSourceHandle: HANDLE,
+                                       hTargetProcessHandle: HANDLE,
+                                       lpTargetHandle: LPHANDLE,
+                                       dwDesiredAccess: DWORD,
+                                       bInheritHandle: BOOL,
+                                       dwOptions: DWORD)
+                                       -> BOOL;
+                pub fn CloseHandle(hObject: HANDLE) -> BOOL;
+                pub fn OpenProcess(dwDesiredAccess: DWORD,
+                                   bInheritHandle: BOOL,
+                                   dwProcessId: DWORD)
+                                   -> HANDLE;
+                pub fn GetCurrentProcess() -> HANDLE;
+                pub fn CreateProcessA(lpApplicationName: LPCTSTR,
+                                      lpCommandLine: LPTSTR,
+                                      lpProcessAttributes:
+                                      LPSECURITY_ATTRIBUTES,
+                                      lpThreadAttributes:
+                                      LPSECURITY_ATTRIBUTES,
+                                      bInheritHandles: BOOL,
+                                      dwCreationFlags: DWORD,
+                                      lpEnvironment: LPVOID,
+                                      lpCurrentDirectory: LPCTSTR,
+                                      lpStartupInfo: LPSTARTUPINFO,
+                                      lpProcessInformation:
+                                      LPPROCESS_INFORMATION)
+                                      -> BOOL;
+                pub fn WaitForSingleObject(hHandle: HANDLE,
+                                           dwMilliseconds: DWORD)
+                                           -> DWORD;
+                pub fn TerminateProcess(hProcess: HANDLE, uExitCode: c_uint)
+                                        -> BOOL;
+                pub fn GetExitCodeProcess(hProcess: HANDLE,
+                                          lpExitCode: LPDWORD)
                                           -> BOOL;
-                pub unsafe fn VirtualUnlock(lpAddress: LPVOID, dwSize: SIZE_T)
-                                            -> BOOL;
-                pub unsafe fn VirtualProtect(lpAddress: LPVOID,
-                                             dwSize: SIZE_T,
-                                             flNewProtect: DWORD,
-                                             lpflOldProtect: LPDWORD)
-                                             -> BOOL;
-                pub unsafe fn VirtualQuery(lpAddress: LPCVOID,
-                                           lpBuffer:
-                                           LPMEMORY_BASIC_INFORMATION,
-                                           dwLength: SIZE_T)
-                                           -> SIZE_T;
-
-                pub unsafe fn CreateFileMappingW(hFile: HANDLE,
-                                                 lpAttributes:
-                                                 LPSECURITY_ATTRIBUTES,
-                                                 flProtect: DWORD,
-                                                 dwMaximumSizeHigh: DWORD,
-                                                 dwMaximumSizeLow: DWORD,
-                                                 lpName: LPCTSTR)
-                                                 -> HANDLE;
-                pub unsafe fn MapViewOfFile(hFileMappingObject: HANDLE,
-                                            dwDesiredAccess: DWORD,
-                                            dwFileOffsetHigh: DWORD,
-                                            dwFileOffsetLow: DWORD,
-                                            dwNumberOfBytesToMap: SIZE_T)
-                                            -> LPVOID;
-                pub unsafe fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL;
+                pub fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
+                pub fn VirtualAlloc(lpAddress: LPVOID,
+                                    dwSize: SIZE_T,
+                                    flAllocationType: DWORD,
+                                    flProtect: DWORD)
+                                    -> LPVOID;
+                pub fn VirtualFree(lpAddress: LPVOID,
+                                   dwSize: SIZE_T,
+                                   dwFreeType: DWORD)
+                                   -> BOOL;
+                pub fn VirtualLock(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL;
+                pub fn VirtualUnlock(lpAddress: LPVOID, dwSize: SIZE_T)
+                                     -> BOOL;
+                pub fn VirtualProtect(lpAddress: LPVOID,
+                                      dwSize: SIZE_T,
+                                      flNewProtect: DWORD,
+                                      lpflOldProtect: LPDWORD)
+                                      -> BOOL;
+                pub fn VirtualQuery(lpAddress: LPCVOID,
+                                    lpBuffer: LPMEMORY_BASIC_INFORMATION,
+                                    dwLength: SIZE_T)
+                                    -> SIZE_T;
+                pub fn CreateFileMappingW(hFile: HANDLE,
+                                          lpAttributes: LPSECURITY_ATTRIBUTES,
+                                          flProtect: DWORD,
+                                          dwMaximumSizeHigh: DWORD,
+                                          dwMaximumSizeLow: DWORD,
+                                          lpName: LPCTSTR)
+                                          -> HANDLE;
+                pub fn MapViewOfFile(hFileMappingObject: HANDLE,
+                                     dwDesiredAccess: DWORD,
+                                     dwFileOffsetHigh: DWORD,
+                                     dwFileOffsetLow: DWORD,
+                                     dwNumberOfBytesToMap: SIZE_T)
+                                     -> LPVOID;
+                pub fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL;
             }
         }
 
@@ -3295,10 +3214,10 @@ pub mod funcs {
             #[nolink]
             extern {
                 #[link_name = "_commit"]
-                pub unsafe fn commit(fd: c_int) -> c_int;
+                pub fn commit(fd: c_int) -> c_int;
 
                 #[link_name = "_get_osfhandle"]
-                pub unsafe fn get_osfhandle(fd: c_int) -> c_long;
+                pub fn get_osfhandle(fd: c_int) -> c_long;
             }
         }
     }
diff --git a/src/libstd/logging.rs b/src/libstd/logging.rs
index e3dae5308fe..6e11d14aea9 100644
--- a/src/libstd/logging.rs
+++ b/src/libstd/logging.rs
@@ -105,10 +105,10 @@ pub mod rustrt {
     use libc;
 
     extern {
-        pub unsafe fn rust_log_console_on();
-        pub unsafe fn rust_log_console_off();
-        pub unsafe fn rust_log_str(level: u32,
-                                   string: *libc::c_char,
-                                   size: libc::size_t);
+        pub fn rust_log_console_on();
+        pub fn rust_log_console_off();
+        pub fn rust_log_str(level: u32,
+                            string: *libc::c_char,
+                            size: libc::size_t);
     }
 }
diff --git a/src/libstd/num/cmath.rs b/src/libstd/num/cmath.rs
index f7aa3267d6d..38923c5bda4 100644
--- a/src/libstd/num/cmath.rs
+++ b/src/libstd/num/cmath.rs
@@ -22,83 +22,84 @@ pub mod c_double_utils {
     extern {
         // Alpabetically sorted by link_name
 
-        pub unsafe fn acos(n: c_double) -> c_double;
-        pub unsafe fn asin(n: c_double) -> c_double;
-        pub unsafe fn atan(n: c_double) -> c_double;
-        pub unsafe fn atan2(a: c_double, b: c_double) -> c_double;
-        pub unsafe fn cbrt(n: c_double) -> c_double;
-        pub unsafe fn ceil(n: c_double) -> c_double;
-        pub unsafe fn copysign(x: c_double, y: c_double) -> c_double;
-        pub unsafe fn cos(n: c_double) -> c_double;
-        pub unsafe fn cosh(n: c_double) -> c_double;
-        pub unsafe fn erf(n: c_double) -> c_double;
-        pub unsafe fn erfc(n: c_double) -> c_double;
-        pub unsafe fn exp(n: c_double) -> c_double;
+        pub fn acos(n: c_double) -> c_double;
+        pub fn asin(n: c_double) -> c_double;
+        pub fn atan(n: c_double) -> c_double;
+        pub fn atan2(a: c_double, b: c_double) -> c_double;
+        pub fn cbrt(n: c_double) -> c_double;
+        pub fn ceil(n: c_double) -> c_double;
+        pub fn copysign(x: c_double, y: c_double) -> c_double;
+        pub fn cos(n: c_double) -> c_double;
+        pub fn cosh(n: c_double) -> c_double;
+        pub fn erf(n: c_double) -> c_double;
+        pub fn erfc(n: c_double) -> c_double;
+        pub fn exp(n: c_double) -> c_double;
         // rename: for consistency with underscore usage elsewhere
-        #[link_name="expm1"] unsafe fn exp_m1(n: c_double) -> c_double;
-        pub unsafe fn exp2(n: c_double) -> c_double;
-        #[link_name="fabs"] unsafe fn abs(n: c_double) -> c_double;
+        #[link_name="expm1"]
+        fn exp_m1(n: c_double) -> c_double;
+        pub fn exp2(n: c_double) -> c_double;
+        #[link_name="fabs"]
+        fn abs(n: c_double) -> c_double;
         // rename: for clarity and consistency with add/sub/mul/div
         #[link_name="fdim"]
-        pub unsafe fn abs_sub(a: c_double, b: c_double) -> c_double;
-        pub unsafe fn floor(n: c_double) -> c_double;
+        pub fn abs_sub(a: c_double, b: c_double) -> c_double;
+        pub fn floor(n: c_double) -> c_double;
         // rename: for clarity and consistency with add/sub/mul/div
         #[link_name="fma"]
-        pub unsafe fn mul_add(a: c_double, b: c_double, c: c_double)
-                              -> c_double;
+        pub fn mul_add(a: c_double, b: c_double, c: c_double) -> c_double;
         #[link_name="fmax"]
-        pub unsafe fn fmax(a: c_double, b: c_double) -> c_double;
+        pub fn fmax(a: c_double, b: c_double) -> c_double;
         #[link_name="fmin"]
-        pub unsafe fn fmin(a: c_double, b: c_double) -> c_double;
+        pub fn fmin(a: c_double, b: c_double) -> c_double;
         #[link_name="nextafter"]
-        pub unsafe fn next_after(x: c_double, y: c_double) -> c_double;
-        pub unsafe fn frexp(n: c_double, value: &mut c_int) -> c_double;
-        pub unsafe fn hypot(x: c_double, y: c_double) -> c_double;
-        pub unsafe fn ldexp(x: c_double, n: c_int) -> c_double;
+        pub fn next_after(x: c_double, y: c_double) -> c_double;
+        pub fn frexp(n: c_double, value: &mut c_int) -> c_double;
+        pub fn hypot(x: c_double, y: c_double) -> c_double;
+        pub fn ldexp(x: c_double, n: c_int) -> c_double;
         #[cfg(unix)]
         #[link_name="lgamma_r"]
-        pub unsafe fn lgamma(n: c_double, sign: &mut c_int) -> c_double;
+        pub fn lgamma(n: c_double, sign: &mut c_int) -> c_double;
         #[cfg(windows)]
         #[link_name="__lgamma_r"]
-        pub unsafe fn lgamma(n: c_double, sign: &mut c_int) -> c_double;
+        pub fn lgamma(n: c_double, sign: &mut c_int) -> c_double;
         // renamed: ln seems more natural
         #[link_name="log"]
-        pub unsafe fn ln(n: c_double) -> c_double;
+        pub fn ln(n: c_double) -> c_double;
         // renamed: "logb" /often/ is confused for log2 by beginners
         #[link_name="logb"]
-        pub unsafe fn log_radix(n: c_double) -> c_double;
+        pub fn log_radix(n: c_double) -> c_double;
         // renamed: to be consitent with log as ln
         #[link_name="log1p"]
-        pub unsafe fn ln_1p(n: c_double) -> c_double;
-        pub unsafe fn log10(n: c_double) -> c_double;
-        pub unsafe fn log2(n: c_double) -> c_double;
+        pub fn ln_1p(n: c_double) -> c_double;
+        pub fn log10(n: c_double) -> c_double;
+        pub fn log2(n: c_double) -> c_double;
         #[link_name="ilogb"]
-        pub unsafe fn ilog_radix(n: c_double) -> c_int;
-        pub unsafe fn modf(n: c_double, iptr: &mut c_double) -> c_double;
-        pub unsafe fn pow(n: c_double, e: c_double) -> c_double;
+        pub fn ilog_radix(n: c_double) -> c_int;
+        pub fn modf(n: c_double, iptr: &mut c_double) -> c_double;
+        pub fn pow(n: c_double, e: c_double) -> c_double;
     // FIXME (#1379): enable when rounding modes become available
-    //    unsafe fn rint(n: c_double) -> c_double;
-        pub unsafe fn round(n: c_double) -> c_double;
+    //    fn rint(n: c_double) -> c_double;
+        pub fn round(n: c_double) -> c_double;
         // rename: for consistency with logradix
         #[link_name="scalbn"]
-        pub unsafe fn ldexp_radix(n: c_double, i: c_int) -> c_double;
-        pub unsafe fn sin(n: c_double) -> c_double;
-        pub unsafe fn sinh(n: c_double) -> c_double;
-        pub unsafe fn sqrt(n: c_double) -> c_double;
-        pub unsafe fn tan(n: c_double) -> c_double;
-        pub unsafe fn tanh(n: c_double) -> c_double;
-        pub unsafe fn tgamma(n: c_double) -> c_double;
-        pub unsafe fn trunc(n: c_double) -> c_double;
+        pub fn ldexp_radix(n: c_double, i: c_int) -> c_double;
+        pub fn sin(n: c_double) -> c_double;
+        pub fn sinh(n: c_double) -> c_double;
+        pub fn sqrt(n: c_double) -> c_double;
+        pub fn tan(n: c_double) -> c_double;
+        pub fn tanh(n: c_double) -> c_double;
+        pub fn tgamma(n: c_double) -> c_double;
+        pub fn trunc(n: c_double) -> c_double;
 
         // These are commonly only available for doubles
 
-        pub unsafe fn j0(n: c_double) -> c_double;
-        pub unsafe fn j1(n: c_double) -> c_double;
-        pub unsafe fn jn(i: c_int, n: c_double) -> c_double;
+        pub fn j0(n: c_double) -> c_double;
+        pub fn j1(n: c_double) -> c_double;
+        pub fn jn(i: c_int, n: c_double) -> c_double;
 
-        pub unsafe fn y0(n: c_double) -> c_double;
-        pub unsafe fn y1(n: c_double) -> c_double;
-        pub unsafe fn yn(i: c_int, n: c_double) -> c_double;
+        pub fn y0(n: c_double) -> c_double;
+        pub fn y1(n: c_double) -> c_double;
+        pub fn yn(i: c_int, n: c_double) -> c_double;
     }
 }
 
@@ -111,98 +112,98 @@ pub mod c_float_utils {
         // Alpabetically sorted by link_name
 
         #[link_name="acosf"]
-        pub unsafe fn acos(n: c_float) -> c_float;
+        pub fn acos(n: c_float) -> c_float;
         #[link_name="asinf"]
-        pub unsafe fn asin(n: c_float) -> c_float;
+        pub fn asin(n: c_float) -> c_float;
         #[link_name="atanf"]
-        pub unsafe fn atan(n: c_float) -> c_float;
+        pub fn atan(n: c_float) -> c_float;
         #[link_name="atan2f"]
-        pub unsafe fn atan2(a: c_float, b: c_float) -> c_float;
+        pub fn atan2(a: c_float, b: c_float) -> c_float;
         #[link_name="cbrtf"]
-        pub unsafe fn cbrt(n: c_float) -> c_float;
+        pub fn cbrt(n: c_float) -> c_float;
         #[link_name="ceilf"]
-        pub unsafe fn ceil(n: c_float) -> c_float;
+        pub fn ceil(n: c_float) -> c_float;
         #[link_name="copysignf"]
-        pub unsafe fn copysign(x: c_float, y: c_float) -> c_float;
+        pub fn copysign(x: c_float, y: c_float) -> c_float;
         #[link_name="cosf"]
-        pub unsafe fn cos(n: c_float) -> c_float;
+        pub fn cos(n: c_float) -> c_float;
         #[link_name="coshf"]
-        pub unsafe fn cosh(n: c_float) -> c_float;
+        pub fn cosh(n: c_float) -> c_float;
         #[link_name="erff"]
-        pub unsafe fn erf(n: c_float) -> c_float;
+        pub fn erf(n: c_float) -> c_float;
         #[link_name="erfcf"]
-        pub unsafe fn erfc(n: c_float) -> c_float;
+        pub fn erfc(n: c_float) -> c_float;
         #[link_name="expf"]
-        pub unsafe fn exp(n: c_float) -> c_float;
+        pub fn exp(n: c_float) -> c_float;
         #[link_name="expm1f"]
-        pub unsafe fn exp_m1(n: c_float) -> c_float;
+        pub fn exp_m1(n: c_float) -> c_float;
         #[link_name="exp2f"]
-        pub unsafe fn exp2(n: c_float) -> c_float;
+        pub fn exp2(n: c_float) -> c_float;
         #[link_name="fabsf"]
-        pub unsafe fn abs(n: c_float) -> c_float;
+        pub fn abs(n: c_float) -> c_float;
         #[link_name="fdimf"]
-        pub unsafe fn abs_sub(a: c_float, b: c_float) -> c_float;
+        pub fn abs_sub(a: c_float, b: c_float) -> c_float;
         #[link_name="floorf"]
-        pub unsafe fn floor(n: c_float) -> c_float;
+        pub fn floor(n: c_float) -> c_float;
         #[link_name="frexpf"]
-        pub unsafe fn frexp(n: c_float, value: &mut c_int) -> c_float;
+        pub fn frexp(n: c_float, value: &mut c_int) -> c_float;
         #[link_name="fmaf"]
-        pub unsafe fn mul_add(a: c_float, b: c_float, c: c_float) -> c_float;
+        pub fn mul_add(a: c_float, b: c_float, c: c_float) -> c_float;
         #[link_name="fmaxf"]
-        pub unsafe fn fmax(a: c_float, b: c_float) -> c_float;
+        pub fn fmax(a: c_float, b: c_float) -> c_float;
         #[link_name="fminf"]
-        pub unsafe fn fmin(a: c_float, b: c_float) -> c_float;
+        pub fn fmin(a: c_float, b: c_float) -> c_float;
         #[link_name="nextafterf"]
-        pub unsafe fn next_after(x: c_float, y: c_float) -> c_float;
+        pub fn next_after(x: c_float, y: c_float) -> c_float;
         #[link_name="hypotf"]
-        pub unsafe fn hypot(x: c_float, y: c_float) -> c_float;
+        pub fn hypot(x: c_float, y: c_float) -> c_float;
         #[link_name="ldexpf"]
-        pub unsafe fn ldexp(x: c_float, n: c_int) -> c_float;
+        pub fn ldexp(x: c_float, n: c_int) -> c_float;
 
         #[cfg(unix)]
         #[link_name="lgammaf_r"]
-        pub unsafe fn lgamma(n: c_float, sign: &mut c_int) -> c_float;
+        pub fn lgamma(n: c_float, sign: &mut c_int) -> c_float;
 
         #[cfg(windows)]
         #[link_name="__lgammaf_r"]
-        pub unsafe fn lgamma(n: c_float, sign: &mut c_int) -> c_float;
+        pub fn lgamma(n: c_float, sign: &mut c_int) -> c_float;
 
         #[link_name="logf"]
-        pub unsafe fn ln(n: c_float) -> c_float;
+        pub fn ln(n: c_float) -> c_float;
         #[link_name="logbf"]
-        pub unsafe fn log_radix(n: c_float) -> c_float;
+        pub fn log_radix(n: c_float) -> c_float;
         #[link_name="log1pf"]
-        pub unsafe fn ln_1p(n: c_float) -> c_float;
+        pub fn ln_1p(n: c_float) -> c_float;
         #[link_name="log2f"]
-        pub unsafe fn log2(n: c_float) -> c_float;
+        pub fn log2(n: c_float) -> c_float;
         #[link_name="log10f"]
-        pub unsafe fn log10(n: c_float) -> c_float;
+        pub fn log10(n: c_float) -> c_float;
         #[link_name="ilogbf"]
-        pub unsafe fn ilog_radix(n: c_float) -> c_int;
+        pub fn ilog_radix(n: c_float) -> c_int;
         #[link_name="modff"]
-        pub unsafe fn modf(n: c_float, iptr: &mut c_float) -> c_float;
+        pub fn modf(n: c_float, iptr: &mut c_float) -> c_float;
         #[link_name="powf"]
-        pub unsafe fn pow(n: c_float, e: c_float) -> c_float;
+        pub fn pow(n: c_float, e: c_float) -> c_float;
     // FIXME (#1379): enable when rounding modes become available
-    //    #[link_name="rintf"] unsafe fn rint(n: c_float) -> c_float;
+    //    #[link_name="rintf"] fn rint(n: c_float) -> c_float;
         #[link_name="roundf"]
-        pub unsafe fn round(n: c_float) -> c_float;
+        pub fn round(n: c_float) -> c_float;
         #[link_name="scalbnf"]
-        pub unsafe fn ldexp_radix(n: c_float, i: c_int) -> c_float;
+        pub fn ldexp_radix(n: c_float, i: c_int) -> c_float;
         #[link_name="sinf"]
-        pub unsafe fn sin(n: c_float) -> c_float;
+        pub fn sin(n: c_float) -> c_float;
         #[link_name="sinhf"]
-        pub unsafe fn sinh(n: c_float) -> c_float;
+        pub fn sinh(n: c_float) -> c_float;
         #[link_name="sqrtf"]
-        pub unsafe fn sqrt(n: c_float) -> c_float;
+        pub fn sqrt(n: c_float) -> c_float;
         #[link_name="tanf"]
-        pub unsafe fn tan(n: c_float) -> c_float;
+        pub fn tan(n: c_float) -> c_float;
         #[link_name="tanhf"]
-        pub unsafe fn tanh(n: c_float) -> c_float;
+        pub fn tanh(n: c_float) -> c_float;
         #[link_name="tgammaf"]
-        pub unsafe fn tgamma(n: c_float) -> c_float;
+        pub fn tgamma(n: c_float) -> c_float;
         #[link_name="truncf"]
-        pub unsafe fn trunc(n: c_float) -> c_float;
+        pub fn trunc(n: c_float) -> c_float;
     }
 }
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 8a1964783ae..f78f5812863 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -61,11 +61,11 @@ pub mod rustrt {
     use libc;
 
     extern {
-        pub unsafe fn rust_get_argc() -> c_int;
-        pub unsafe fn rust_get_argv() -> **c_char;
-        pub unsafe fn rust_path_is_dir(path: *libc::c_char) -> c_int;
-        pub unsafe fn rust_path_exists(path: *libc::c_char) -> c_int;
-        pub unsafe fn rust_set_exit_status(code: libc::intptr_t);
+        pub fn rust_get_argc() -> c_int;
+        pub fn rust_get_argv() -> **c_char;
+        pub fn rust_path_is_dir(path: *libc::c_char) -> c_int;
+        pub fn rust_path_exists(path: *libc::c_char) -> c_int;
+        pub fn rust_set_exit_status(code: libc::intptr_t);
     }
 }
 
@@ -201,7 +201,7 @@ pub fn env() -> ~[(~str,~str)] {
         #[cfg(unix)]
         unsafe fn get_env_pairs() -> ~[~str] {
             extern {
-                unsafe fn rust_env_pairs() -> **libc::c_char;
+                fn rust_env_pairs() -> **libc::c_char;
             }
             let environ = rust_env_pairs();
             if (environ as uint == 0) {
@@ -694,7 +694,7 @@ pub fn list_dir(p: &Path) -> ~[~str] {
             use libc::{dirent_t};
             use libc::{opendir, readdir, closedir};
             extern {
-                unsafe fn rust_list_dir_val(ptr: *dirent_t) -> *libc::c_char;
+                fn rust_list_dir_val(ptr: *dirent_t) -> *libc::c_char;
             }
             let input = p.to_str();
             let mut strings = ~[];
@@ -735,9 +735,8 @@ pub fn list_dir(p: &Path) -> ~[~str] {
 
             #[nolink]
             extern {
-                unsafe fn rust_list_dir_wfd_size() -> libc::size_t;
-                unsafe fn rust_list_dir_wfd_fp_buf(wfd: *libc::c_void)
-                    -> *u16;
+                fn rust_list_dir_wfd_size() -> libc::size_t;
+                fn rust_list_dir_wfd_fp_buf(wfd: *libc::c_void) -> *u16;
             }
             fn star(p: &Path) -> Path { p.push("*") }
             do as_utf16_p(star(p).to_str()) |path_ptr| {
@@ -964,7 +963,7 @@ pub fn errno() -> int {
     fn errno_location() -> *c_int {
         #[nolink]
         extern {
-            unsafe fn __error() -> *c_int;
+            fn __error() -> *c_int;
         }
         unsafe {
             __error()
@@ -976,7 +975,7 @@ pub fn errno() -> int {
     fn errno_location() -> *c_int {
         #[nolink]
         extern {
-            unsafe fn __errno_location() -> *c_int;
+            fn __errno_location() -> *c_int;
         }
         unsafe {
             __errno_location()
@@ -996,7 +995,7 @@ pub fn errno() -> uint {
     #[link_name = "kernel32"]
     #[abi = "stdcall"]
     extern "stdcall" {
-        unsafe fn GetLastError() -> DWORD;
+        fn GetLastError() -> DWORD;
     }
 
     unsafe {
@@ -1011,11 +1010,12 @@ pub fn last_os_error() -> ~str {
         #[cfg(target_os = "macos")]
         #[cfg(target_os = "android")]
         #[cfg(target_os = "freebsd")]
-        fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t) -> c_int {
+        fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t)
+                      -> c_int {
             #[nolink]
             extern {
-                unsafe fn strerror_r(errnum: c_int, buf: *mut c_char,
-                                     buflen: size_t) -> c_int;
+                fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t)
+                              -> c_int;
             }
             unsafe {
                 strerror_r(errnum, buf, buflen)
@@ -1029,8 +1029,10 @@ pub fn last_os_error() -> ~str {
         fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t) -> c_int {
             #[nolink]
             extern {
-                unsafe fn __xpg_strerror_r(errnum: c_int, buf: *mut c_char,
-                                           buflen: size_t) -> c_int;
+                fn __xpg_strerror_r(errnum: c_int,
+                                    buf: *mut c_char,
+                                    buflen: size_t)
+                                    -> c_int;
             }
             unsafe {
                 __xpg_strerror_r(errnum, buf, buflen)
@@ -1058,10 +1060,14 @@ pub fn last_os_error() -> ~str {
         #[link_name = "kernel32"]
         #[abi = "stdcall"]
         extern "stdcall" {
-            unsafe fn FormatMessageA(flags: DWORD, lpSrc: LPVOID,
-                                     msgId: DWORD, langId: DWORD,
-                                     buf: LPSTR, nsize: DWORD,
-                                     args: *c_void) -> DWORD;
+            fn FormatMessageA(flags: DWORD,
+                              lpSrc: LPVOID,
+                              msgId: DWORD,
+                              langId: DWORD,
+                              buf: LPSTR,
+                              nsize: DWORD,
+                              args: *c_void)
+                              -> DWORD;
         }
 
         static FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
diff --git a/src/libstd/pipes.rs b/src/libstd/pipes.rs
index a2ad2eb5e76..2819744c560 100644
--- a/src/libstd/pipes.rs
+++ b/src/libstd/pipes.rs
@@ -258,19 +258,17 @@ pub mod rustrt {
 
     extern {
         #[rust_stack]
-        pub unsafe fn rust_get_task() -> *rust_task;
+        pub fn rust_get_task() -> *rust_task;
         #[rust_stack]
-        pub unsafe fn rust_task_ref(task: *rust_task);
-        pub unsafe fn rust_task_deref(task: *rust_task);
+        pub fn rust_task_ref(task: *rust_task);
+        pub fn rust_task_deref(task: *rust_task);
 
         #[rust_stack]
-        pub unsafe fn task_clear_event_reject(task: *rust_task);
+        pub fn task_clear_event_reject(task: *rust_task);
 
-        pub unsafe fn task_wait_event(this: *rust_task,
-                                      killed: &mut *libc::c_void)
-                                   -> bool;
-        pub unsafe fn task_signal_event(target: *rust_task,
-                                        event: *libc::c_void);
+        pub fn task_wait_event(this: *rust_task, killed: &mut *libc::c_void)
+                               -> bool;
+        pub fn task_signal_event(target: *rust_task, event: *libc::c_void);
     }
 }
 
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 075e208ab82..20686e7a251 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -252,8 +252,8 @@ pub mod rustrt {
     use libc::size_t;
 
     extern {
-        pub unsafe fn rand_seed_size() -> size_t;
-        pub unsafe fn rand_gen_seed(buf: *mut u8, sz: size_t);
+        pub fn rand_seed_size() -> size_t;
+        pub fn rand_gen_seed(buf: *mut u8, sz: size_t);
     }
 }
 
@@ -1085,10 +1085,9 @@ mod test {
             pub enum rust_rng {}
 
             extern {
-                pub unsafe fn rand_new_seeded(buf: *u8, sz: size_t)
-                                              -> *rust_rng;
-                pub unsafe fn rand_next(rng: *rust_rng) -> u32;
-                pub unsafe fn rand_free(rng: *rust_rng);
+                pub fn rand_new_seeded(buf: *u8, sz: size_t) -> *rust_rng;
+                pub fn rand_next(rng: *rust_rng) -> u32;
+                pub fn rand_free(rng: *rust_rng);
             }
         }
 
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index cd8e8549211..e1e7ceacc38 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -92,7 +92,7 @@ pub unsafe fn local_free(ptr: *libc::c_char) {
 
             extern {
                 #[fast_ffi]
-                unsafe fn rust_upcall_free_noswitch(ptr: *libc::c_char);
+                fn rust_upcall_free_noswitch(ptr: *libc::c_char);
             }
         }
         _ => {
diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs
index ed0137d3b0f..9f6cf68245e 100644
--- a/src/libstd/rt/thread.rs
+++ b/src/libstd/rt/thread.rs
@@ -49,7 +49,7 @@ impl Drop for Thread {
 }
 
 extern {
-    pub unsafe fn rust_raw_thread_start(f: &(~fn())) -> *raw_thread;
-    pub unsafe fn rust_raw_thread_join(thread: *raw_thread);
-    pub unsafe fn rust_raw_thread_delete(thread: *raw_thread);
+    pub fn rust_raw_thread_start(f: &(~fn())) -> *raw_thread;
+    pub fn rust_raw_thread_join(thread: *raw_thread);
+    pub fn rust_raw_thread_delete(thread: *raw_thread);
 }
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index 8af5a6dfac7..65316d4092b 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -639,8 +639,8 @@ fn spawn_process_os(prog: &str, args: &[~str],
 
         #[abi = "cdecl"]
         extern {
-            pub unsafe fn rust_unset_sigprocmask();
-            pub unsafe fn rust_set_environ(envp: *c_void);
+            pub fn rust_unset_sigprocmask();
+            pub fn rust_set_environ(envp: *c_void);
         }
     }
 
diff --git a/src/libstd/sys.rs b/src/libstd/sys.rs
index 4ca5d82265f..51609709cdb 100644
--- a/src/libstd/sys.rs
+++ b/src/libstd/sys.rs
@@ -27,9 +27,7 @@ pub mod rustrt {
 
     extern {
         #[rust_stack]
-        pub unsafe fn rust_upcall_fail(expr: *c_char,
-                                       file: *c_char,
-                                       line: size_t);
+        pub fn rust_upcall_fail(expr: *c_char, file: *c_char, line: size_t);
     }
 }
 
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index e08297a1425..f7a943f8d2f 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -1078,12 +1078,12 @@ mod testrt {
 
     #[nolink]
     extern {
-        pub unsafe fn rust_dbg_lock_create() -> *libc::c_void;
-        pub unsafe fn rust_dbg_lock_destroy(lock: *libc::c_void);
-        pub unsafe fn rust_dbg_lock_lock(lock: *libc::c_void);
-        pub unsafe fn rust_dbg_lock_unlock(lock: *libc::c_void);
-        pub unsafe fn rust_dbg_lock_wait(lock: *libc::c_void);
-        pub unsafe fn rust_dbg_lock_signal(lock: *libc::c_void);
+        pub fn rust_dbg_lock_create() -> *libc::c_void;
+        pub fn rust_dbg_lock_destroy(lock: *libc::c_void);
+        pub fn rust_dbg_lock_lock(lock: *libc::c_void);
+        pub fn rust_dbg_lock_unlock(lock: *libc::c_void);
+        pub fn rust_dbg_lock_wait(lock: *libc::c_void);
+        pub fn rust_dbg_lock_signal(lock: *libc::c_void);
     }
 }
 
diff --git a/src/libstd/unstable/intrinsics.rs b/src/libstd/unstable/intrinsics.rs
index 5d6cd594f48..50d9c7e4ded 100644
--- a/src/libstd/unstable/intrinsics.rs
+++ b/src/libstd/unstable/intrinsics.rs
@@ -296,16 +296,16 @@ extern "rust-intrinsic" {
     /// `init` is unsafe because it returns a zeroed-out datum,
     /// which is unsafe unless T is POD. We don't have a POD
     /// kind yet. (See #4074).
-    pub unsafe fn init<T>() -> T;
+    pub fn init<T>() -> T;
 
     /// Create an uninitialized value.
-    pub unsafe fn uninit<T>() -> T;
+    pub fn uninit<T>() -> T;
 
     /// Move a value out of scope without running drop glue.
     ///
     /// `forget` is unsafe because the caller is responsible for
     /// ensuring the argument is deallocated already.
-    pub unsafe fn forget<T>(_: T) -> ();
+    pub fn forget<T>(_: T) -> ();
     pub fn transmute<T,U>(e: T) -> U;
 
     /// Returns `true` if a type requires drop glue.
diff --git a/src/libstd/unstable/lang.rs b/src/libstd/unstable/lang.rs
index 9bbc578d194..e0c4950b38e 100644
--- a/src/libstd/unstable/lang.rs
+++ b/src/libstd/unstable/lang.rs
@@ -28,17 +28,12 @@ pub mod rustrt {
 
     extern {
         #[rust_stack]
-        pub unsafe fn rust_upcall_malloc(td: *c_char, size: uintptr_t)
-                                         -> *c_char;
-
+        pub fn rust_upcall_malloc(td: *c_char, size: uintptr_t) -> *c_char;
         #[rust_stack]
-        pub unsafe fn rust_upcall_free(ptr: *c_char);
-
+        pub fn rust_upcall_free(ptr: *c_char);
         #[fast_ffi]
-        pub unsafe fn rust_upcall_malloc_noswitch(td: *c_char,
-                                                  size: uintptr_t)
-                                                  -> *c_char;
-
+        pub fn rust_upcall_malloc_noswitch(td: *c_char, size: uintptr_t)
+                                           -> *c_char;
         #[rust_stack]
         pub fn rust_try_get_task() -> *rust_task;
     }