Make AllocErr a zero-size unit struct

Author: SimonSapin

src/liballoc/alloc.rs

@@ -16,7 +16,7 @@
             issue = "32838")]
 
 use core::intrinsics::{min_align_of_val, size_of_val};
-use core::mem::{self, ManuallyDrop};
+use core::mem;
 use core::usize;
 
 #[doc(inline)]
@@ -86,12 +86,12 @@ pub const Heap: Global = Global;
 unsafe impl Alloc for Global {
     #[inline]
     unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
-        let mut err = ManuallyDrop::new(mem::uninitialized::<AllocErr>());
+        let mut err = AllocErr;
         let ptr = __rust_alloc(layout.size(),
                                layout.align(),
-                               &mut *err as *mut AllocErr as *mut u8);
+                               &mut err as *mut AllocErr as *mut u8);
         if ptr.is_null() {
-            Err(ManuallyDrop::into_inner(err))
+            Err(AllocErr)
         } else {
             Ok(ptr)
         }
@@ -129,15 +129,15 @@ unsafe impl Alloc for Global {
                       new_layout: Layout)
                       -> Result<*mut u8, AllocErr>
     {
-        let mut err = ManuallyDrop::new(mem::uninitialized::<AllocErr>());
+        let mut err = AllocErr;
         let ptr = __rust_realloc(ptr,
                                  layout.size(),
                                  layout.align(),
                                  new_layout.size(),
                                  new_layout.align(),
-                                 &mut *err as *mut AllocErr as *mut u8);
+                                 &mut err as *mut AllocErr as *mut u8);
         if ptr.is_null() {
-            Err(ManuallyDrop::into_inner(err))
+            Err(AllocErr)
         } else {
             mem::forget(err);
             Ok(ptr)
@@ -146,27 +146,27 @@ unsafe impl Alloc for Global {
 
     #[inline]
     unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
-        let mut err = ManuallyDrop::new(mem::uninitialized::<AllocErr>());
+        let mut err = AllocErr;
         let ptr = __rust_alloc_zeroed(layout.size(),
                                       layout.align(),
-                                      &mut *err as *mut AllocErr as *mut u8);
+                                      &mut err as *mut AllocErr as *mut u8);
         if ptr.is_null() {
-            Err(ManuallyDrop::into_inner(err))
+            Err(AllocErr)
         } else {
             Ok(ptr)
         }
     }
 
     #[inline]
     unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, AllocErr> {
-        let mut err = ManuallyDrop::new(mem::uninitialized::<AllocErr>());
+        let mut err = AllocErr;
         let mut size = 0;
         let ptr = __rust_alloc_excess(layout.size(),
                                       layout.align(),
                                       &mut size,
-                                      &mut *err as *mut AllocErr as *mut u8);
+                                      &mut err as *mut AllocErr as *mut u8);
         if ptr.is_null() {
-            Err(ManuallyDrop::into_inner(err))
+            Err(AllocErr)
         } else {
             Ok(Excess(ptr, size))
         }
@@ -177,17 +177,17 @@ unsafe impl Alloc for Global {
                              ptr: *mut u8,
                              layout: Layout,
                              new_layout: Layout) -> Result<Excess, AllocErr> {
-        let mut err = ManuallyDrop::new(mem::uninitialized::<AllocErr>());
+        let mut err = AllocErr;
         let mut size = 0;
         let ptr = __rust_realloc_excess(ptr,
                                         layout.size(),
                                         layout.align(),
                                         new_layout.size(),
                                         new_layout.align(),
                                         &mut size,
-                                        &mut *err as *mut AllocErr as *mut u8);
+                                        &mut err as *mut AllocErr as *mut u8);
         if ptr.is_null() {
-            Err(ManuallyDrop::into_inner(err))
+            Err(AllocErr)
         } else {
             Ok(Excess(ptr, size))
         }

src/liballoc/raw_vec.rs

@@ -760,7 +760,7 @@ mod tests {
             unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
                 let size = layout.size();
                 if size > self.fuel {
-                    return Err(AllocErr::Unsupported { details: "fuel exhausted" });
+                    return Err(AllocErr);
                 }
                 match Global.alloc(layout) {
                     ok @ Ok(_) => { self.fuel -= size; ok }

src/liballoc_jemalloc/lib.rs

@@ -30,8 +30,6 @@ extern crate libc;
 pub use contents::*;
 #[cfg(not(dummy_jemalloc))]
 mod contents {
-    use core::ptr;
-
     use core::alloc::{Alloc, AllocErr, Layout};
     use alloc_system::System;
     use libc::{c_int, c_void, size_t};
@@ -106,14 +104,9 @@ mod contents {
     #[rustc_std_internal_symbol]
     pub unsafe extern fn __rde_alloc(size: usize,
                                      align: usize,
-                                     err: *mut u8) -> *mut u8 {
+                                     _err: *mut u8) -> *mut u8 {
         let flags = align_to_flags(align, size);
         let ptr = mallocx(size as size_t, flags) as *mut u8;
-        if ptr.is_null() {
-            let layout = Layout::from_size_align_unchecked(size, align);
-            ptr::write(err as *mut AllocErr,
-                       AllocErr::Exhausted { request: layout });
-        }
         ptr
     }
 
@@ -155,39 +148,27 @@ mod contents {
                                        old_align: usize,
                                        new_size: usize,
                                        new_align: usize,
-                                       err: *mut u8) -> *mut u8 {
+                                       _err: *mut u8) -> *mut u8 {
         if new_align != old_align {
-            ptr::write(err as *mut AllocErr,
-                       AllocErr::Unsupported { details: "can't change alignments" });
             return 0 as *mut u8
         }
 
         let flags = align_to_flags(new_align, new_size);
         let ptr = rallocx(ptr as *mut c_void, new_size, flags) as *mut u8;
-        if ptr.is_null() {
-            let layout = Layout::from_size_align_unchecked(new_size, new_align);
-            ptr::write(err as *mut AllocErr,
-                       AllocErr::Exhausted { request: layout });
-        }
         ptr
     }
 
     #[no_mangle]
     #[rustc_std_internal_symbol]
     pub unsafe extern fn __rde_alloc_zeroed(size: usize,
                                             align: usize,
-                                            err: *mut u8) -> *mut u8 {
+                                            _err: *mut u8) -> *mut u8 {
         let ptr = if align <= MIN_ALIGN && align <= size {
             calloc(size as size_t, 1) as *mut u8
         } else {
             let flags = align_to_flags(align, size) | MALLOCX_ZERO;
             mallocx(size as size_t, flags) as *mut u8
         };
-        if ptr.is_null() {
-            let layout = Layout::from_size_align_unchecked(size, align);
-            ptr::write(err as *mut AllocErr,
-                       AllocErr::Exhausted { request: layout });
-        }
         ptr
     }
 

src/liballoc_system/lib.rs

@@ -133,17 +133,15 @@ mod platform {
                 #[cfg(target_os = "macos")]
                 {
                     if layout.align() > (1 << 31) {
-                        return Err(AllocErr::Unsupported {
-                            details: "requested alignment too large"
-                        })
+                        return Err(AllocErr)
                     }
                 }
                 aligned_malloc(&layout)
             };
             if !ptr.is_null() {
                 Ok(ptr)
             } else {
-                Err(AllocErr::Exhausted { request: layout })
+                Err(AllocErr)
             }
         }
 
@@ -156,7 +154,7 @@ mod platform {
                 if !ptr.is_null() {
                     Ok(ptr)
                 } else {
-                    Err(AllocErr::Exhausted { request: layout })
+                    Err(AllocErr)
                 }
             } else {
                 let ret = self.alloc(layout.clone());
@@ -178,17 +176,15 @@ mod platform {
                           old_layout: Layout,
                           new_layout: Layout) -> Result<*mut u8, AllocErr> {
             if old_layout.align() != new_layout.align() {
-                return Err(AllocErr::Unsupported {
-                    details: "cannot change alignment on `realloc`",
-                })
+                return Err(AllocErr)
             }
 
             if new_layout.align() <= MIN_ALIGN  && new_layout.align() <= new_layout.size(){
                 let ptr = libc::realloc(ptr as *mut libc::c_void, new_layout.size());
                 if !ptr.is_null() {
                     Ok(ptr as *mut u8)
                 } else {
-                    Err(AllocErr::Exhausted { request: new_layout })
+                    Err(AllocErr)
                 }
             } else {
                 let res = self.alloc(new_layout.clone());
@@ -342,7 +338,7 @@ mod platform {
             }
         };
         if ptr.is_null() {
-            Err(AllocErr::Exhausted { request: layout })
+            Err(AllocErr)
         } else {
             Ok(ptr as *mut u8)
         }
@@ -382,9 +378,7 @@ mod platform {
                           old_layout: Layout,
                           new_layout: Layout) -> Result<*mut u8, AllocErr> {
             if old_layout.align() != new_layout.align() {
-                return Err(AllocErr::Unsupported {
-                    details: "cannot change alignment on `realloc`",
-                })
+                return Err(AllocErr)
             }
 
             if new_layout.align() <= MIN_ALIGN {
@@ -395,7 +389,7 @@ mod platform {
                 if !ptr.is_null() {
                     Ok(ptr as *mut u8)
                 } else {
-                    Err(AllocErr::Exhausted { request: new_layout })
+                    Err(AllocErr)
                 }
             } else {
                 let res = self.alloc(new_layout.clone());
@@ -505,7 +499,7 @@ mod platform {
         if !ptr.is_null() {
             Ok(ptr)
         } else {
-            Err(AllocErr::Unsupported { details: "" })
+            Err(AllocErr)
         }
     }
 

src/libcore/alloc.rs

@@ -320,50 +320,12 @@ impl Layout {
 /// something wrong when combining the given input arguments with this
 /// allocator.
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub enum AllocErr {
-    /// Error due to hitting some resource limit or otherwise running
-    /// out of memory. This condition strongly implies that *some*
-    /// series of deallocations would allow a subsequent reissuing of
-    /// the original allocation request to succeed.
-    Exhausted { request: Layout },
-
-    /// Error due to allocator being fundamentally incapable of
-    /// satisfying the original request. This condition implies that
-    /// such an allocation request will never succeed on the given
-    /// allocator, regardless of environment, memory pressure, or
-    /// other contextual conditions.
-    ///
-    /// For example, an allocator that does not support requests for
-    /// large memory blocks might return this error variant.
-    Unsupported { details: &'static str },
-}
-
-impl AllocErr {
-    #[inline]
-    pub fn invalid_input(details: &'static str) -> Self {
-        AllocErr::Unsupported { details: details }
-    }
-    #[inline]
-    pub fn is_memory_exhausted(&self) -> bool {
-        if let AllocErr::Exhausted { .. } = *self { true } else { false }
-    }
-    #[inline]
-    pub fn is_request_unsupported(&self) -> bool {
-        if let AllocErr::Unsupported { .. } = *self { true } else { false }
-    }
-    #[inline]
-    pub fn description(&self) -> &str {
-        match *self {
-            AllocErr::Exhausted { .. } => "allocator memory exhausted",
-            AllocErr::Unsupported { .. } => "unsupported allocator request",
-        }
-    }
-}
+pub struct AllocErr;
 
 // (we need this for downstream impl of trait Error)
 impl fmt::Display for AllocErr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.description())
+        f.write_str("memory allocation failed")
     }
 }
 
@@ -592,12 +554,8 @@ pub unsafe trait Alloc {
     /// aborting.
     ///
     /// `oom` is meant to be used by clients unable to cope with an
-    /// unsatisfied allocation request (signaled by an error such as
-    /// `AllocErr::Exhausted`), and wish to abandon computation rather
-    /// than attempt to recover locally. Such clients should pass the
-    /// signaling error value back into `oom`, where the allocator
-    /// may incorporate that error value into its diagnostic report
-    /// before aborting.
+    /// unsatisfied allocation request, and wish to abandon
+    /// computation rather than attempt to recover locally.
     ///
     /// Implementations of the `oom` method are discouraged from
     /// infinitely regressing in nested calls to `oom`. In
@@ -963,7 +921,7 @@ pub unsafe trait Alloc {
         if k.size() > 0 {
             unsafe { self.alloc(k).map(|p| NonNull::new_unchecked(p as *mut T)) }
         } else {
-            Err(AllocErr::invalid_input("zero-sized type invalid for alloc_one"))
+            Err(AllocErr)
         }
     }
 
@@ -1036,7 +994,7 @@ pub unsafe trait Alloc {
                         })
                 }
             }
-            _ => Err(AllocErr::invalid_input("invalid layout for alloc_array")),
+            _ => Err(AllocErr),
         }
     }
 
@@ -1084,7 +1042,7 @@ pub unsafe trait Alloc {
                     .map(|p| NonNull::new_unchecked(p as *mut T))
             }
             _ => {
-                Err(AllocErr::invalid_input("invalid layout for realloc_array"))
+                Err(AllocErr)
             }
         }
     }
@@ -1118,7 +1076,7 @@ pub unsafe trait Alloc {
                 Ok(self.dealloc(raw_ptr, k.clone()))
             }
             _ => {
-                Err(AllocErr::invalid_input("invalid layout for dealloc_array"))
+                Err(AllocErr)
             }
         }
     }