---

yaml
---
r: 155116
b: refs/heads/try2
c: 84b3737
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 396f9106173b941e880a0f311bc2d1429a68c983
+refs/heads/try2: 84b37374bf31b463c36f70123e870f52db19c740
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/liballoc/heap.rs

@@ -86,18 +86,19 @@ pub fn stats_print() {
     imp::stats_print();
 }
 
-// The compiler never calls `exchange_free` on Box<ZeroSizeType>, so zero-size
-// allocations can point to this `static`. It would be incorrect to use a null
-// pointer, due to enums assuming types like unique pointers are never null.
-pub static mut EMPTY: uint = 12345;
+/// An arbitrary non-null address to represent zero-size allocations.
+///
+/// This preserves the non-null invariant for types like `Box<T>`. The address may overlap with
+/// non-zero-size memory allocations.
+pub static EMPTY: *mut () = 0x1 as *mut ();
 
 /// The allocator for unique pointers.
 #[cfg(not(test))]
 #[lang="exchange_malloc"]
 #[inline]
 unsafe fn exchange_malloc(size: uint, align: uint) -> *mut u8 {
     if size == 0 {
-        &EMPTY as *const uint as *mut u8
+        EMPTY as *mut u8
     } else {
         allocate(size, align)
     }

branches/try2/src/libcollections/vec.rs

@@ -12,7 +12,7 @@
 
 use core::prelude::*;
 
-use alloc::heap::{allocate, reallocate, deallocate};
+use alloc::heap::{EMPTY, allocate, reallocate, deallocate};
 use core::cmp::max;
 use core::default::Default;
 use core::fmt;
@@ -26,10 +26,6 @@ use {Mutable, MutableSeq};
 use slice::{MutableOrdSlice, MutableSliceAllocating, CloneableVector};
 use slice::{Items, MutItems};
 
-
-#[doc(hidden)]
-pub static PTR_MARKER: u8 = 0;
-
 /// An owned, growable vector.
 ///
 /// # Examples
@@ -122,7 +118,7 @@ impl<T> Vec<T> {
         // non-null value which is fine since we never call deallocate on the ptr
         // if cap is 0. The reason for this is because the pointer of a slice
         // being NULL would break the null pointer optimization for enums.
-        Vec { len: 0, cap: 0, ptr: &PTR_MARKER as *const _ as *mut T }
+        Vec { len: 0, cap: 0, ptr: EMPTY as *mut T }
     }
 
     /// Constructs a new, empty `Vec` with the specified capacity.
@@ -155,7 +151,7 @@ impl<T> Vec<T> {
     #[inline]
     pub fn with_capacity(capacity: uint) -> Vec<T> {
         if mem::size_of::<T>() == 0 {
-            Vec { len: 0, cap: uint::MAX, ptr: &PTR_MARKER as *const _ as *mut T }
+            Vec { len: 0, cap: uint::MAX, ptr: EMPTY as *mut T }
         } else if capacity == 0 {
             Vec::new()
         } else {

branches/try2/src/libsyntax/owned_slice.rs

@@ -12,6 +12,7 @@ use std::fmt;
 use std::default::Default;
 use std::hash;
 use std::{mem, raw, ptr, slice, vec};
+use std::rt::heap::EMPTY;
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
 /// A non-growable owned slice. This would preferably become `~[T]`
@@ -81,10 +82,9 @@ impl<T> OwnedSlice<T> {
     }
 
     pub fn as_slice<'a>(&'a self) -> &'a [T] {
-        static PTR_MARKER: u8 = 0;
         let ptr = if self.data.is_null() {
             // length zero, i.e. this will never be read as a T.
-            &PTR_MARKER as *const u8 as *const T
+            EMPTY as *const T
         } else {
             self.data as *const T
         };