---

yaml
---
r: 137631
b: refs/heads/master
c: 0075c27
h: refs/heads/master
i:
  137629: 040220b
  137627: a5f85dd
  137623: d65edbb
  137615: 44462f6
  137599: 1aa336c
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
+refs/heads/master: 0075c2762626d42a2b3036e0664f1372e1b143f4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: cd53dac86b43e0b46f06ab265b71526242a2fc5e

trunk/man/rustc.1

@@ -125,8 +125,8 @@ is invoked.
 Selects a target processor. If the value is 'help', then a list of available
 CPUs is printed.
 .TP
-\fBtarget-feature\fR='+feature1,-feature2'
-A comma-separated list of features to enable or disable for the target. A
+\fBtarget-feature\fR='+feature1 -feature2'
+A space-separated list of features to enable or disable for the target. A
 preceding '+' enables a feature while a preceding '-' disables it. Available
 features can be discovered through target-cpu=help.
 .TP

trunk/src/libcollections/vec.rs

@@ -1734,7 +1734,7 @@ impl<T> MutableSeq<T> for Vec<T> {
             let size = max(old_size, 2 * mem::size_of::<T>()) * 2;
             if old_size > size { fail!("capacity overflow") }
             unsafe {
-                self.ptr = alloc_or_realloc(self.ptr, self.cap * mem::size_of::<T>(), size);
+                self.ptr = alloc_or_realloc(self.ptr, old_size, size);
             }
             self.cap = max(self.cap, 2) * 2;
         }
@@ -1758,7 +1758,6 @@ impl<T> MutableSeq<T> for Vec<T> {
             }
         }
     }
-
 }
 
 /// An iterator that moves out of a vector.

trunk/src/librustc/driver/config.rs

@@ -390,8 +390,6 @@ cgoptions!(
         "divide crate into N units to optimize in parallel"),
     remark: Passes = (SomePasses(Vec::new()), parse_passes,
         "print remarks for these optimization passes (space separated, or \"all\")"),
-    no_stack_check: bool = (false, parse_bool,
-        "disable checks for stack exhaustion (a memory-safety hazard!)"),
 )
 
 pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions

trunk/src/librustc/lint/builtin.rs

@@ -571,7 +571,6 @@ impl LintPass for UnusedAttribute {
             "no_builtins",
             "no_mangle",
             "no_split_stack",
-            "no_stack_check",
             "packed",
             "static_assert",
             "thread_local",

trunk/src/librustc/middle/trans/base.rs

@@ -204,7 +204,7 @@ pub fn decl_fn(ccx: &CrateContext, name: &str, cc: llvm::CallConv,
     // Function addresses in Rust are never significant, allowing functions to be merged.
     llvm::SetUnnamedAddr(llfn, true);
 
-    if ccx.is_split_stack_supported() && !ccx.sess().opts.cg.no_stack_check {
+    if ccx.is_split_stack_supported() {
         set_split_stack(llfn);
     }
 
@@ -245,7 +245,7 @@ fn get_extern_rust_fn(ccx: &CrateContext, fn_ty: ty::t, name: &str, did: ast::De
     let f = decl_rust_fn(ccx, fn_ty, name);
 
     csearch::get_item_attrs(&ccx.sess().cstore, did, |attrs| {
-        set_llvm_fn_attrs(ccx, attrs.as_slice(), f)
+        set_llvm_fn_attrs(attrs.as_slice(), f)
     });
 
     ccx.externs().borrow_mut().insert(name.to_string(), f);
@@ -450,7 +450,7 @@ pub fn set_inline_hint(f: ValueRef) {
     llvm::SetFunctionAttribute(f, llvm::InlineHintAttribute)
 }
 
-pub fn set_llvm_fn_attrs(ccx: &CrateContext, attrs: &[ast::Attribute], llfn: ValueRef) {
+pub fn set_llvm_fn_attrs(attrs: &[ast::Attribute], llfn: ValueRef) {
     use syntax::attr::*;
     // Set the inline hint if there is one
     match find_inline_attr(attrs) {
@@ -460,24 +460,16 @@ pub fn set_llvm_fn_attrs(ccx: &CrateContext, attrs: &[ast::Attribute], llfn: Val
         InlineNone   => { /* fallthrough */ }
     }
 
-    for attr in attrs.iter() {
-        let mut used = true;
-        match attr.name().get() {
-            "no_stack_check" => unset_split_stack(llfn),
-            "no_split_stack" => {
-                unset_split_stack(llfn);
-                ccx.sess().span_warn(attr.span,
-                                     "no_split_stack is a deprecated synonym for no_stack_check");
-            }
-            "cold" => unsafe {
-                llvm::LLVMAddFunctionAttribute(llfn,
-                                               llvm::FunctionIndex as c_uint,
-                                               llvm::ColdAttribute as uint64_t)
-            },
-            _ => used = false,
-        }
-        if used {
-            attr::mark_used(attr);
+    // Add the no-split-stack attribute if requested
+    if contains_name(attrs, "no_split_stack") {
+        unset_split_stack(llfn);
+    }
+
+    if contains_name(attrs, "cold") {
+        unsafe {
+            llvm::LLVMAddFunctionAttribute(llfn,
+                                           llvm::FunctionIndex as c_uint,
+                                           llvm::ColdAttribute as uint64_t)
         }
     }
 }
@@ -2740,7 +2732,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
                                                                    sym,
                                                                    i.id)
                     };
-                    set_llvm_fn_attrs(ccx, i.attrs.as_slice(), llfn);
+                    set_llvm_fn_attrs(i.attrs.as_slice(), llfn);
                     llfn
                 }
 
@@ -2882,7 +2874,7 @@ fn register_method(ccx: &CrateContext, id: ast::NodeId,
     let sym = exported_name(ccx, id, mty, m.attrs.as_slice());
 
     let llfn = register_fn(ccx, m.span, sym, id, mty);
-    set_llvm_fn_attrs(ccx, m.attrs.as_slice(), llfn);
+    set_llvm_fn_attrs(m.attrs.as_slice(), llfn);
     llfn
 }
 

trunk/src/librustc/middle/trans/foreign.rs

@@ -640,7 +640,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
                id, t.repr(tcx));
 
         let llfn = base::decl_internal_rust_fn(ccx, t, ps.as_slice());
-        base::set_llvm_fn_attrs(ccx, attrs, llfn);
+        base::set_llvm_fn_attrs(attrs, llfn);
         base::trans_fn(ccx, decl, body, llfn, param_substs, id, []);
         llfn
     }

trunk/src/librustc/middle/trans/monomorphize.rs

@@ -149,7 +149,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
     };
     let setup_lldecl = |lldecl, attrs: &[ast::Attribute]| {
         base::update_linkage(ccx, lldecl, None, base::OriginalTranslation);
-        set_llvm_fn_attrs(ccx, attrs, lldecl);
+        set_llvm_fn_attrs(attrs, lldecl);
 
         let is_first = !ccx.available_monomorphizations().borrow().contains(&s);
         if is_first {

trunk/src/librustrt/thread.rs

@@ -39,9 +39,9 @@ static DEFAULT_STACK_SIZE: uint = 1024 * 1024;
 
 // This is the starting point of rust os threads. The first thing we do
 // is make sure that we don't trigger __morestack (also why this has a
-// no_stack_check annotation), and then we extract the main function
+// no_split_stack annotation), and then we extract the main function
 // and invoke it.
-#[no_stack_check]
+#[no_split_stack]
 extern fn thread_start(main: *mut libc::c_void) -> imp::rust_thread_return {
     unsafe {
         stack::record_os_managed_stack_bounds(0, uint::MAX);

trunk/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs renamed to trunk/src/test/debuginfo/function-prologue-stepping-no-split-stack.rs

@@ -11,7 +11,7 @@
 // ignore-android: FIXME(#10381)
 
 // This test case checks if function arguments already have the correct value when breaking at the
-// beginning of a function. Functions with the #[no_stack_check] attribute have the same prologue as
+// beginning of a function. Functions with the #[no_split_stack] attribute have the same prologue as
 // regular C functions compiled with GCC or Clang and therefore are better handled by GDB. As a
 // consequence, and as opposed to regular Rust functions, we can set the breakpoints via the
 // function name (and don't have to fall back on using line numbers). For LLDB this shouldn't make
@@ -246,7 +246,7 @@
 
 #![allow(unused_variable)]
 
-#[no_stack_check]
+#[no_split_stack]
 fn immediate_args(a: int, b: bool, c: f64) {
     ()
 }
@@ -262,42 +262,42 @@ struct BigStruct {
     h: u64
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn non_immediate_args(a: BigStruct, b: BigStruct) {
     ()
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn binding(a: i64, b: u64, c: f64) {
     let x = 0i;
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn assignment(mut a: u64, b: u64, c: f64) {
     a = b;
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn function_call(x: u64, y: u64, z: f64) {
     std::io::stdio::print("Hi!")
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn identifier(x: u64, y: u64, z: f64) -> u64 {
     x
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn return_expr(x: u64, y: u64, z: f64) -> u64 {
     return x;
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn arithmetic_expr(x: u64, y: u64, z: f64) -> u64 {
     x + y
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn if_expr(x: u64, y: u64, z: f64) -> u64 {
     if x + y < 1000 {
         x
@@ -306,15 +306,15 @@ fn if_expr(x: u64, y: u64, z: f64) -> u64 {
     }
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn while_expr(mut x: u64, y: u64, z: u64) -> u64 {
     while x + y < 1000 {
         x += z
     }
     return x;
 }
 
-#[no_stack_check]
+#[no_split_stack]
 fn loop_expr(mut x: u64, y: u64, z: u64) -> u64 {
     loop {
         x += z;

trunk/src/test/run-make/no-stack-check/Makefile

@@ -25,7 +25,7 @@ extern "rust-intrinsic" { fn transmute<T, U>(t: T) -> U; }
 #[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
 
 #[start]
-#[no_stack_check]
+#[no_split_stack]
 fn main(_: int, _: *const *const u8) -> int {
     unsafe {
         let (ptr, _): (*const u8, uint) = transmute("Hello!\0");