std: Migrate to the new libc

* Delete `sys::unix::{c, sync}` as these are now all folded into libc itself
* Update all references to use `libc` as a result.
* Update all references to the new flat namespace.
* Moves all windows bindings into sys::c

Author: alexcrichton

mk/crates.mk

@@ -174,3 +174,6 @@ $(foreach crate,$(TOOLS),$(eval $(call RUST_TOOL,$(crate))))
 ifdef CFG_DISABLE_ELF_TLS
 RUSTFLAGS_std := --cfg no_elf_tls
 endif
+
+CRATEFILE_libc := $(SREL)src/liblibc/src/lib.rs
+RUSTFLAGS_libc := --cfg stdbuild

mk/tests.mk

@@ -22,7 +22,7 @@ $(eval $(call RUST_CRATE,coretest))
 DEPS_collectionstest :=
 $(eval $(call RUST_CRATE,collectionstest))
 
-TEST_TARGET_CRATES = $(filter-out core rustc_unicode alloc_system \
+TEST_TARGET_CRATES = $(filter-out core rustc_unicode alloc_system libc \
 		     		  alloc_jemalloc,$(TARGET_CRATES)) \
 			collectionstest coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
@@ -283,6 +283,7 @@ tidy-binaries:
 		| grep '^$(S)src/compiler-rt' -v \
 		| grep '^$(S)src/libbacktrace' -v \
 		| grep '^$(S)src/rust-installer' -v \
+		| grep '^$(S)src/liblibc' -v \
 		| xargs $(CFG_PYTHON) $(S)src/etc/check-binaries.py
 
 .PHONY: tidy-errors

src/etc/tidy.py

@@ -108,7 +108,8 @@ def interesting_file(f):
             'src/rustllvm',
             'src/rt/valgrind',
             'src/rt/msvc',
-            'src/rust-installer'
+            'src/rust-installer',
+            'src/liblibc',
         }
 
         if any(d in dirpath for d in skippable_dirs):

src/liballoc_jemalloc/lib.rs

@@ -14,6 +14,7 @@
 #![staged_api]
 #![no_std]
 #![cfg_attr(not(stage0), allocator)]
+#![cfg_attr(stage0, allow(improper_ctypes))]
 #![unstable(feature = "alloc_jemalloc",
             reason = "this library is unlikely to be stabilized in its current \
                       form or name",

src/liballoc_system/lib.rs

@@ -14,6 +14,7 @@
 #![staged_api]
 #![no_std]
 #![cfg_attr(not(stage0), allocator)]
+#![cfg_attr(stage0, allow(improper_ctypes))]
 #![unstable(feature = "alloc_system",
             reason = "this library is unlikely to be stabilized in its current \
                       form or name",
@@ -141,10 +142,16 @@ mod imp {
 }
 
 #[cfg(windows)]
+#[allow(bad_style)]
 mod imp {
-    use libc::{BOOL, DWORD, HANDLE, LPVOID, SIZE_T};
     use MIN_ALIGN;
 
+    type LPVOID = *mut u8;
+    type HANDLE = LPVOID;
+    type SIZE_T = usize;
+    type DWORD = u32;
+    type BOOL = i32;
+
     extern "system" {
         fn GetProcessHeap() -> HANDLE;
         fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;

src/libflate/lib.rs

@@ -29,6 +29,7 @@
 #![feature(staged_api)]
 #![feature(unique)]
 #![cfg_attr(test, feature(rustc_private, rand, vec_push_all))]
+#![cfg_attr(stage0, allow(improper_ctypes))]
 
 #[cfg(test)]
 #[macro_use]

src/librustc/util/common.rs

@@ -96,25 +96,30 @@ fn get_resident() -> Option<usize> {
 }
 
 #[cfg(windows)]
+#[cfg_attr(stage0, allow(improper_ctypes))]
 fn get_resident() -> Option<usize> {
-    use libc::{BOOL, DWORD, HANDLE, SIZE_T, GetCurrentProcess};
+    type BOOL = i32;
+    type DWORD = u32;
+    type HANDLE = *mut u8;
+    use libc::size_t;
     use std::mem;
     #[repr(C)] #[allow(non_snake_case)]
     struct PROCESS_MEMORY_COUNTERS {
         cb: DWORD,
         PageFaultCount: DWORD,
-        PeakWorkingSetSize: SIZE_T,
-        WorkingSetSize: SIZE_T,
-        QuotaPeakPagedPoolUsage: SIZE_T,
-        QuotaPagedPoolUsage: SIZE_T,
-        QuotaPeakNonPagedPoolUsage: SIZE_T,
-        QuotaNonPagedPoolUsage: SIZE_T,
-        PagefileUsage: SIZE_T,
-        PeakPagefileUsage: SIZE_T,
+        PeakWorkingSetSize: size_t,
+        WorkingSetSize: size_t,
+        QuotaPeakPagedPoolUsage: size_t,
+        QuotaPagedPoolUsage: size_t,
+        QuotaPeakNonPagedPoolUsage: size_t,
+        QuotaNonPagedPoolUsage: size_t,
+        PagefileUsage: size_t,
+        PeakPagefileUsage: size_t,
     }
     type PPROCESS_MEMORY_COUNTERS = *mut PROCESS_MEMORY_COUNTERS;
     #[link(name = "psapi")]
     extern "system" {
+        fn GetCurrentProcess() -> HANDLE;
         fn GetProcessMemoryInfo(Process: HANDLE,
                                 ppsmemCounters: PPROCESS_MEMORY_COUNTERS,
                                 cb: DWORD) -> BOOL;

src/librustc_llvm/lib.rs

@@ -16,6 +16,8 @@
 #![allow(dead_code)]
 #![allow(trivial_casts)]
 
+#![cfg_attr(stage0, allow(improper_ctypes))]
+
 #![crate_name = "rustc_llvm"]
 #![unstable(feature = "rustc_private", issue = "27812")]
 #![staged_api]

src/librustc_trans/back/msvc/registry.rs

@@ -13,8 +13,14 @@ use std::ffi::{OsString, OsStr};
 use std::os::windows::prelude::*;
 use std::ops::RangeFrom;
 use std::ptr;
-use libc::{DWORD, LPCWSTR, LONG, LPDWORD, LPBYTE, ERROR_SUCCESS};
-use libc::c_void;
+use libc::{c_void, c_long};
+
+type DWORD = u32;
+type LPCWSTR = *const u16;
+type LONG = c_long;
+type LPDWORD = *mut DWORD;
+type LPBYTE = *mut u8;
+
 
 const HKEY_LOCAL_MACHINE: HKEY = 0x80000002 as HKEY;
 const KEY_WOW64_32KEY: REGSAM = 0x0200;
@@ -27,6 +33,7 @@ const KEY_ENUMERATE_SUB_KEYS: REGSAM = 0x0008;
 const KEY_NOTIFY: REGSAM = 0x0010;
 const SYNCHRONIZE: REGSAM = 0x00100000;
 const REG_SZ: DWORD = 1;
+const ERROR_SUCCESS: i32 = 0;
 const ERROR_NO_MORE_ITEMS: DWORD = 259;
 
 enum __HKEY__ {}

src/librustdoc/flock.rs

@@ -121,7 +121,7 @@ mod imp {
             let buf = CString::new(os.as_bytes()).unwrap();
             let fd = unsafe {
                 libc::open(buf.as_ptr(), libc::O_RDWR | libc::O_CREAT,
-                           libc::S_IRWXU)
+                           libc::S_IRWXU as libc::c_int)
             };
             assert!(fd > 0, "failed to open lockfile: {}",
                     io::Error::last_os_error());
@@ -164,77 +164,55 @@ mod imp {
 }
 
 #[cfg(windows)]
+#[allow(bad_style)]
 mod imp {
-    use libc;
     use std::io;
     use std::mem;
-    use std::ffi::OsStr;
     use std::os::windows::prelude::*;
+    use std::os::windows::raw::HANDLE;
     use std::path::Path;
-    use std::ptr;
-
-    const LOCKFILE_EXCLUSIVE_LOCK: libc::DWORD = 0x00000002;
+    use std::fs::{File, OpenOptions};
+
+    type DWORD = u32;
+    type LPOVERLAPPED = *mut OVERLAPPED;
+    type BOOL = i32;
+    const LOCKFILE_EXCLUSIVE_LOCK: DWORD = 0x00000002;
+
+    #[repr(C)]
+    struct OVERLAPPED {
+        Internal: usize,
+        InternalHigh: usize,
+        Pointer: *mut u8,
+        hEvent: *mut u8,
+    }
 
-    #[allow(non_snake_case)]
     extern "system" {
-        fn LockFileEx(hFile: libc::HANDLE,
-                      dwFlags: libc::DWORD,
-                      dwReserved: libc::DWORD,
-                      nNumberOfBytesToLockLow: libc::DWORD,
-                      nNumberOfBytesToLockHigh: libc::DWORD,
-                      lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
-        fn UnlockFileEx(hFile: libc::HANDLE,
-                        dwReserved: libc::DWORD,
-                        nNumberOfBytesToLockLow: libc::DWORD,
-                        nNumberOfBytesToLockHigh: libc::DWORD,
-                        lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
+        fn LockFileEx(hFile: HANDLE,
+                      dwFlags: DWORD,
+                      dwReserved: DWORD,
+                      nNumberOfBytesToLockLow: DWORD,
+                      nNumberOfBytesToLockHigh: DWORD,
+                      lpOverlapped: LPOVERLAPPED) -> BOOL;
     }
 
     pub struct Lock {
-        handle: libc::HANDLE,
+        _file: File,
     }
 
     impl Lock {
         pub fn new(p: &Path) -> Lock {
-            let os: &OsStr = p.as_ref();
-            let mut p_16: Vec<_> = os.encode_wide().collect();
-            p_16.push(0);
-            let handle = unsafe {
-                libc::CreateFileW(p_16.as_ptr(),
-                                  libc::FILE_GENERIC_READ |
-                                    libc::FILE_GENERIC_WRITE,
-                                  libc::FILE_SHARE_READ |
-                                    libc::FILE_SHARE_DELETE |
-                                    libc::FILE_SHARE_WRITE,
-                                  ptr::null_mut(),
-                                  libc::CREATE_ALWAYS,
-                                  libc::FILE_ATTRIBUTE_NORMAL,
-                                  ptr::null_mut())
-            };
-            if handle == libc::INVALID_HANDLE_VALUE {
-                panic!("create file error: {}", io::Error::last_os_error());
-            }
-            let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
+            let f = OpenOptions::new().read(true).write(true).create(true)
+                                      .open(p).unwrap();
             let ret = unsafe {
-                LockFileEx(handle, LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0,
+                let mut overlapped: OVERLAPPED = mem::zeroed();
+                LockFileEx(f.as_raw_handle(), LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0,
                            &mut overlapped)
             };
             if ret == 0 {
                 let err = io::Error::last_os_error();
-                unsafe { libc::CloseHandle(handle); }
                 panic!("could not lock `{}`: {}", p.display(), err);
             }
-            Lock { handle: handle }
-        }
-    }
-
-    impl Drop for Lock {
-        fn drop(&mut self) {
-            let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
-            unsafe {
-                UnlockFileEx(self.handle, 0, 100, 0, &mut overlapped);
-                libc::CloseHandle(self.handle);
-            }
+            Lock { _file: f }
         }
     }
 }