---

yaml
---
r: 129518
b: refs/heads/snap-stage3
c: 5ad7afc
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 566b470e138e929e8a93d613372db1ba177c494f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 3e94401a6411001c7495a13dcbb289cb3935994f
+refs/heads/snap-stage3: 5ad7afc2d7e2671000f41a19bed73fef82475e47
 refs/heads/try: 80b45ddbd351f0a4a939c3a3c4e20b4defec4b35
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/liballoc/heap.rs

@@ -208,6 +208,7 @@ mod imp {
 
 #[cfg(not(jemalloc), unix)]
 mod imp {
+    use core::cmp;
     use core::mem;
     use core::ptr;
     use libc;
@@ -248,7 +249,7 @@ mod imp {
     pub unsafe fn reallocate(ptr: *mut u8, size: uint, align: uint,
                              old_size: uint) -> *mut u8 {
         let new_ptr = allocate(size, align);
-        ptr::copy_memory(new_ptr, ptr as *const u8, old_size);
+        ptr::copy_memory(new_ptr, ptr as *const u8, cmp::min(size, old_size));
         deallocate(ptr, old_size, align);
         return new_ptr;
     }

branches/snap-stage3/src/libcore/str.rs

@@ -1717,6 +1717,13 @@ pub trait StrSlice<'a> {
     fn utf16_units(&self) -> Utf16CodeUnits<'a>;
 }
 
+#[inline(never)]
+fn slice_error_fail(s: &str, begin: uint, end: uint) -> ! {
+    assert!(begin <= end);
+    fail!("index {} and/or {} in `{}` do not lie on character boundary",
+          begin, end, s);
+}
+
 impl<'a> StrSlice<'a> for &'a str {
     #[inline]
     fn contains<'a>(&self, needle: &'a str) -> bool {
@@ -1820,22 +1827,34 @@ impl<'a> StrSlice<'a> for &'a str {
 
     #[inline]
     fn slice(&self, begin: uint, end: uint) -> &'a str {
-        assert!(self.is_char_boundary(begin) && self.is_char_boundary(end),
-                "index {} and/or {} in `{}` do not lie on character boundary", begin,
-                end, *self);
-        unsafe { raw::slice_bytes(*self, begin, end) }
+        // is_char_boundary checks that the index is in [0, .len()]
+        if begin <= end &&
+           self.is_char_boundary(begin) &&
+           self.is_char_boundary(end) {
+            unsafe { raw::slice_unchecked(*self, begin, end) }
+        } else {
+            slice_error_fail(*self, begin, end)
+        }
     }
 
     #[inline]
     fn slice_from(&self, begin: uint) -> &'a str {
-        self.slice(begin, self.len())
+        // is_char_boundary checks that the index is in [0, .len()]
+        if self.is_char_boundary(begin) {
+            unsafe { raw::slice_unchecked(*self, begin, self.len()) }
+        } else {
+            slice_error_fail(*self, begin, self.len())
+        }
     }
 
     #[inline]
     fn slice_to(&self, end: uint) -> &'a str {
-        assert!(self.is_char_boundary(end), "index {} in `{}` does not lie on \
-                a character boundary", end, *self);
-        unsafe { raw::slice_bytes(*self, 0, end) }
+        // is_char_boundary checks that the index is in [0, .len()]
+        if self.is_char_boundary(end) {
+            unsafe { raw::slice_unchecked(*self, 0, end) }
+        } else {
+            slice_error_fail(*self, 0, end)
+        }
     }
 
     fn slice_chars(&self, begin: uint, end: uint) -> &'a str {
@@ -1910,9 +1929,10 @@ impl<'a> StrSlice<'a> for &'a str {
     #[inline]
     fn is_char_boundary(&self, index: uint) -> bool {
         if index == self.len() { return true; }
-        if index > self.len() { return false; }
-        let b = self.as_bytes()[index];
-        return b < 128u8 || b >= 192u8;
+        match self.as_bytes().get(index) {
+            None => false,
+            Some(&b) => b < 128u8 || b >= 192u8,
+        }
     }
 
     #[inline]

branches/snap-stage3/src/librustc/back/link.rs

@@ -536,6 +536,13 @@ pub mod write {
         llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(builder, fpm);
         llvm::LLVMPassManagerBuilderPopulateModulePassManager(builder, mpm);
         llvm::LLVMPassManagerBuilderDispose(builder);
+
+        match opt {
+            llvm::CodeGenLevelDefault | llvm::CodeGenLevelAggressive => {
+                "mergefunc".with_c_str(|s| llvm::LLVMRustAddPass(mpm, s));
+            }
+            _ => {}
+        };
     }
 }
 

branches/snap-stage3/src/libstd/macros.rs

@@ -96,7 +96,7 @@ macro_rules! fail(
 macro_rules! assert(
     ($cond:expr) => (
         if !$cond {
-            fail!("assertion failed: {:s}", stringify!($cond))
+            fail!(concat!("assertion failed: ", stringify!($cond)))
         }
     );
     ($cond:expr, $($arg:expr),+) => (

branches/snap-stage3/src/test/run-pass/cast-in-array-size.rs

@@ -0,0 +1,19 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+// issues #10618 and #16382
+static SIZE: int = 25;
+
+fn main() {
+    let _a: [bool, ..1 as uint];
+    let _b: [int, ..SIZE as uint] = [1, ..SIZE as uint];
+    let _c: [bool, ..'\n' as uint] = [true, ..'\n' as uint];
+}

branches/snap-stage3/src/test/run-pass/realloc-16687.rs

@@ -0,0 +1,167 @@
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// alloc::heap::reallocate test.
+//
+// Ideally this would be revised to use no_std, but for now it serves
+// well enough to reproduce (and illustrate) the bug from #16687.
+
+extern crate alloc;
+
+use alloc::heap;
+use std::ptr;
+
+fn main() {
+    unsafe {
+        assert!(test_triangle());
+    }
+}
+
+unsafe fn test_triangle() -> bool {
+    static COUNT : uint = 16;
+    let mut ascend = Vec::from_elem(COUNT, ptr::mut_null());
+    let ascend = ascend.as_mut_slice();
+    static ALIGN : uint = 1;
+
+    // Checks that `ascend` forms triangle of acending size formed
+    // from pairs of rows (where each pair of rows is equally sized),
+    // and the elements of the triangle match their row-pair index.
+    unsafe fn sanity_check(ascend: &[*mut u8]) {
+        for i in range(0u, COUNT / 2) {
+            let (p0, p1, size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
+            for j in range(0u, size) {
+                assert_eq!(*p0.offset(j as int), i as u8);
+                assert_eq!(*p1.offset(j as int), i as u8);
+            }
+        }
+    }
+
+    static PRINT : bool = false;
+
+    unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
+        if PRINT { println!("allocate(size={:u} align={:u})", size, align); }
+
+        let ret = heap::allocate(size, align);
+
+        if PRINT { println!("allocate(size={:u} align={:u}) ret: 0x{:010x}",
+                            size, align, ret as uint);
+        }
+
+        ret
+    }
+    unsafe fn reallocate(ptr: *mut u8, size: uint, align: uint,
+                             old_size: uint) -> *mut u8 {
+        if PRINT {
+            println!("reallocate(ptr=0x{:010x} size={:u} align={:u} old_size={:u})",
+                     ptr as uint, size, align, old_size);
+        }
+
+        let ret = heap::reallocate(ptr, size, align, old_size);
+
+        if PRINT {
+            println!("reallocate(ptr=0x{:010x} size={:u} align={:u} old_size={:u}) \
+                      ret: 0x{:010x}",
+                     ptr as uint, size, align, old_size, ret as uint);
+        }
+        ret
+    }
+
+    fn idx_to_size(i: uint) -> uint { (i+1) * 10 }
+
+    // Allocate pairs of rows that form a triangle shape.  (Hope is
+    // that at least two rows will be allocated near each other, so
+    // that we trigger the bug (a buffer overrun) in an observable
+    // way.)
+    for i in range(0u, COUNT / 2) {
+        let size = idx_to_size(i);
+        ascend[2*i]   = allocate(size, ALIGN);
+        ascend[2*i+1] = allocate(size, ALIGN);
+    }
+
+    // Initialize each pair of rows to distinct value.
+    for i in range(0u, COUNT / 2) {
+        let (p0, p1, size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
+        for j in range(0, size) {
+            *p0.offset(j as int) = i as u8;
+            *p1.offset(j as int) = i as u8;
+        }
+    }
+
+    sanity_check(ascend.as_slice());
+    test_1(ascend);
+    test_2(ascend);
+    test_3(ascend);
+    test_4(ascend);
+
+    return true;
+
+    // Test 1: turn the triangle into a square (in terms of
+    // allocation; initialized portion remains a triangle) by
+    // realloc'ing each row from top to bottom, and checking all the
+    // rows as we go.
+    unsafe fn test_1(ascend: &mut [*mut u8]) {
+        let new_size = idx_to_size(COUNT-1);
+        for i in range(0u, COUNT / 2) {
+            let (p0, p1, old_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
+            assert!(old_size < new_size);
+
+            ascend[2*i] = reallocate(p0, new_size, ALIGN, old_size);
+            sanity_check(ascend.as_slice());
+
+            ascend[2*i+1] = reallocate(p1, new_size, ALIGN, old_size);
+            sanity_check(ascend.as_slice());
+        }
+    }
+
+    // Test 2: turn the square back into a triangle, top to bottom.
+    unsafe fn test_2(ascend: &mut [*mut u8]) {
+        let old_size = idx_to_size(COUNT-1);
+        for i in range(0u, COUNT / 2) {
+            let (p0, p1, new_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
+            assert!(new_size < old_size);
+
+            ascend[2*i] = reallocate(p0, new_size, ALIGN, old_size);
+            sanity_check(ascend.as_slice());
+
+            ascend[2*i+1] = reallocate(p1, new_size, ALIGN, old_size);
+            sanity_check(ascend.as_slice());
+        }
+    }
+
+    // Test 3: turn triangle into a square, bottom to top.
+    unsafe fn test_3(ascend: &mut [*mut u8]) {
+        let new_size = idx_to_size(COUNT-1);
+        for i in range(0u, COUNT / 2).rev() {
+            let (p0, p1, old_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
+            assert!(old_size < new_size);
+
+            ascend[2*i+1] = reallocate(p1, new_size, ALIGN, old_size);
+            sanity_check(ascend.as_slice());
+
+            ascend[2*i] = reallocate(p0, new_size, ALIGN, old_size);
+            sanity_check(ascend.as_slice());
+        }
+    }
+
+    // Test 4: turn the square back into a triangle, bottom to top.
+    unsafe fn test_4(ascend: &mut [*mut u8]) {
+        let old_size = idx_to_size(COUNT-1);
+        for i in range(0u, COUNT / 2).rev() {
+            let (p0, p1, new_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
+            assert!(new_size < old_size);
+
+            ascend[2*i+1] = reallocate(p1, new_size, ALIGN, old_size);
+            sanity_check(ascend.as_slice());
+
+            ascend[2*i] = reallocate(p0, new_size, ALIGN, old_size);
+            sanity_check(ascend.as_slice());
+        }
+    }
+}