---

yaml
---
r: 212891
b: refs/heads/master
c: 7d04623
h: refs/heads/master
i:
  212889: c1b1ed8
  212887: df9afea
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 328df8ebf9dc35d48c7aa829425413af3fc3a08c
+refs/heads/master: 7d046230338e117c8a7c85bb4d542f2787d5ef9d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/configure

@@ -521,6 +521,7 @@ fi
 DEFAULT_BUILD="${CFG_CPUTYPE}-${CFG_OSTYPE}"
 
 CFG_SRC_DIR="$(abs_path $(dirname $0))/"
+CFG_SRC_DIR_RELATIVE="$(dirname $0)/"
 CFG_BUILD_DIR="$(pwd)/"
 CFG_SELF="$0"
 CFG_CONFIGURE_ARGS="$@"
@@ -1558,6 +1559,7 @@ done
 step_msg "writing configuration"
 
 putvar CFG_SRC_DIR
+putvar CFG_SRC_DIR_RELATIVE
 putvar CFG_BUILD_DIR
 putvar CFG_OSTYPE
 putvar CFG_CPUTYPE

trunk/mk/cfg/x86_64-unknown-linux-musl.mk

@@ -3,6 +3,7 @@ CC_x86_64-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc
 CXX_x86_64-unknown-linux-musl=notaprogram
 CPP_x86_64-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc -E
 AR_x86_64-unknown-linux-musl=$(AR)
+CFG_INSTALL_ONLY_RLIB_x86_64-unknown-linux-musl = 1
 CFG_LIB_NAME_x86_64-unknown-linux-musl=lib$(1).so
 CFG_STATIC_LIB_NAME_x86_64-unknown-linux-musl=lib$(1).a
 CFG_LIB_GLOB_x86_64-unknown-linux-musl=lib$(1)-*.so

trunk/mk/crates.mk

@@ -134,7 +134,7 @@ DOC_CRATES := std alloc collections core libc rustc_unicode
 #
 # $(1) is the crate to generate variables for
 define RUST_CRATE
-CRATEFILE_$(1) := $$(S)src/lib$(1)/lib.rs
+CRATEFILE_$(1) := $$(SREL)src/lib$(1)/lib.rs
 RSINPUTS_$(1) := $$(call rwildcard,$(S)src/lib$(1)/,*.rs)
 RUST_DEPS_$(1) := $$(filter-out native:%,$$(DEPS_$(1)))
 NATIVE_DEPS_$(1) := $$(patsubst native:%,%,$$(filter native:%,$$(DEPS_$(1))))

trunk/mk/main.mk

@@ -322,6 +322,7 @@ $(foreach host,$(CFG_HOST), \
 # exported
 
 export CFG_SRC_DIR
+export CFG_SRC_DIR_RELATIVE
 export CFG_BUILD_DIR
 ifdef CFG_VER_DATE
 export CFG_VER_DATE

trunk/mk/reconfig.mk

@@ -34,4 +34,4 @@ Makefile config.mk: config.stamp
 
 config.stamp: $(S)configure $(S)Makefile.in $(S)src/snapshots.txt
 	@$(call E, cfg: reconfiguring)
-	$(S)configure $(CFG_CONFIGURE_ARGS)
+	$(SREL)configure $(CFG_CONFIGURE_ARGS)

trunk/mk/util.mk

@@ -20,3 +20,4 @@ print-%:
 	@echo $*=$($*)
 
 S := $(CFG_SRC_DIR)
+SREL := $(CFG_SRC_DIR_RELATIVE)

trunk/src/liballoc/heap.rs

@@ -345,47 +345,94 @@ mod imp {
           not(jemalloc),
           windows))]
 mod imp {
-    use libc::{c_void, size_t};
-    use libc;
+    use core::mem::size_of;
+    use libc::{BOOL, DWORD, HANDLE, LPVOID, SIZE_T, INVALID_HANDLE_VALUE};
+    use libc::{WriteFile};
     use super::MIN_ALIGN;
 
-    extern {
-        fn _aligned_malloc(size: size_t, align: size_t) -> *mut c_void;
-        fn _aligned_realloc(block: *mut c_void, size: size_t,
-                            align: size_t) -> *mut c_void;
-        fn _aligned_free(ptr: *mut c_void);
+    extern "system" {
+        fn GetProcessHeap() -> HANDLE;
+        fn GetStdHandle(nStdHandle: DWORD) -> HANDLE;
+        fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;
+        fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;
+        fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;
+        fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) -> BOOL;
+    }
+
+    #[repr(C)] #[allow(non_snake_case)]
+    struct HEAP_SUMMARY {
+        cb: DWORD,
+        cbAllocated: SIZE_T,
+        cbCommitted: SIZE_T,
+        cbReserved: SIZE_T,
+        cbMaxReserve: SIZE_T,
+    }
+    #[allow(non_camel_case_types)]
+    type LPHEAP_SUMMARY = *mut HEAP_SUMMARY;
+
+    #[repr(C)]
+    struct Header(*mut u8);
+
+    const HEAP_REALLOC_IN_PLACE_ONLY: DWORD = 0x00000010;
+    const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32;
+
+    #[inline]
+    unsafe fn get_header<'a>(ptr: *mut u8) -> &'a mut Header {
+        &mut *(ptr as *mut Header).offset(-1)
+    }
+
+    #[inline]
+    unsafe fn align_ptr(ptr: *mut u8, align: usize) -> *mut u8 {
+        let aligned = ptr.offset((align - (ptr as usize & (align - 1))) as isize);
+        *get_header(aligned) = Header(ptr);
+        aligned
     }
 
     #[inline]
     pub unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
         if align <= MIN_ALIGN {
-            libc::malloc(size as size_t) as *mut u8
+            HeapAlloc(GetProcessHeap(), 0, size as SIZE_T) as *mut u8
         } else {
-            _aligned_malloc(size as size_t, align as size_t) as *mut u8
+            let ptr = HeapAlloc(GetProcessHeap(), 0, (size + align) as SIZE_T) as *mut u8;
+            if ptr.is_null() { return ptr }
+            align_ptr(ptr, align)
         }
     }
 
     #[inline]
     pub unsafe fn reallocate(ptr: *mut u8, _old_size: usize, size: usize, align: usize) -> *mut u8 {
         if align <= MIN_ALIGN {
-            libc::realloc(ptr as *mut c_void, size as size_t) as *mut u8
+            HeapReAlloc(GetProcessHeap(), 0, ptr as LPVOID, size as SIZE_T) as *mut u8
         } else {
-            _aligned_realloc(ptr as *mut c_void, size as size_t, align as size_t) as *mut u8
+            let header = get_header(ptr);
+            let new = HeapReAlloc(GetProcessHeap(), 0, header.0 as LPVOID,
+                                  (size + align) as SIZE_T) as *mut u8;
+            if new.is_null() { return new }
+            align_ptr(new, align)
         }
     }
 
     #[inline]
-    pub unsafe fn reallocate_inplace(_ptr: *mut u8, old_size: usize, _size: usize,
-                                     _align: usize) -> usize {
-        old_size
+    pub unsafe fn reallocate_inplace(ptr: *mut u8, old_size: usize, size: usize,
+                                     align: usize) -> usize {
+        if align <= MIN_ALIGN {
+            let new = HeapReAlloc(GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, ptr as LPVOID,
+                                  size as SIZE_T) as *mut u8;
+            if new.is_null() { old_size } else { size }
+        } else {
+            old_size
+        }
     }
 
     #[inline]
     pub unsafe fn deallocate(ptr: *mut u8, _old_size: usize, align: usize) {
         if align <= MIN_ALIGN {
-            libc::free(ptr as *mut libc::c_void)
+            let err = HeapFree(GetProcessHeap(), 0, ptr as LPVOID);
+            debug_assert!(err != 0);
         } else {
-            _aligned_free(ptr as *mut c_void)
+            let header = get_header(ptr);
+            let err = HeapFree(GetProcessHeap(), 0, header.0 as LPVOID);
+            debug_assert!(err != 0);
         }
     }
 
@@ -394,7 +441,45 @@ mod imp {
         size
     }
 
-    pub fn stats_print() {}
+    pub fn stats_print() {
+        use core::fmt::{Error, Result, Write};
+        use core::ptr::null_mut;
+        use core::raw::Repr;
+        use core::result::Result::{Ok, Err};
+        struct Console(HANDLE);
+        impl Write for Console {
+            fn write_str(&mut self, s: &str) -> Result {
+                let repr = s.repr();
+                let mut written = 0;
+                let err = unsafe { WriteFile(self.0, repr.data as LPVOID, repr.len as DWORD,
+                                             &mut written, null_mut()) };
+                if written as usize != repr.len { return Err(Error) }
+                if err == 0 { return Err(Error) }
+                Ok(())
+            }
+        }
+        let mut hs = HEAP_SUMMARY {
+            cb: size_of::<HEAP_SUMMARY>() as DWORD,
+            cbAllocated: 0,
+            cbCommitted: 0,
+            cbReserved: 0,
+            cbMaxReserve: 0,
+        };
+        let err = unsafe { HeapSummary(GetProcessHeap(), 0, &mut hs) };
+        assert!(err != 0);
+        let handle = unsafe { GetStdHandle(STD_OUTPUT_HANDLE) };
+        if handle.is_null() || handle == INVALID_HANDLE_VALUE { panic!("Failed to open stdout") }
+        let mut out = Console(handle);
+        writeln!(&mut out, "Allocated: {}", hs.cbAllocated).unwrap();
+        writeln!(&mut out, "Committed: {}", hs.cbCommitted).unwrap();
+        writeln!(&mut out, "Reserved: {}", hs.cbReserved).unwrap();
+        writeln!(&mut out, "MaxReserve: {}", hs.cbMaxReserve).unwrap();
+    }
+
+    #[test]
+    fn alignment_header_size() {
+        assert!(size_of::<Header>() <= MIN_ALIGN);
+    }
 }
 
 #[cfg(test)]

trunk/src/libcore/fmt/mod.rs

@@ -72,7 +72,7 @@ pub trait Write {
     ///
     /// # Errors
     ///
-    /// This function will return an instance of `FormatError` on error.
+    /// This function will return an instance of `Error` on error.
     #[stable(feature = "rust1", since = "1.0.0")]
     fn write_str(&mut self, s: &str) -> Result;
 
@@ -85,7 +85,7 @@ pub trait Write {
     ///
     /// # Errors
     ///
-    /// This function will return an instance of `FormatError` on error.
+    /// This function will return an instance of `Error` on error.
     #[stable(feature = "fmt_write_char", since = "1.1.0")]
     fn write_char(&mut self, c: char) -> Result {
         let mut utf_8 = [0u8; 4];