nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-02 07:22:42 +00:00
Code Issues Packages Projects Releases Wiki Activity
d03456183e
rust/src/test/run-pass/out-of-stack.rs

55 lines
1.7 KiB
Rust
Raw Normal View History

std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
// Copyright 2012-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.
Disable stack overflow test on android, which seems to be failing spuriously. cc https://github.com/rust-lang/rust/issues/20004
2014-12-19 02:56:28 +00:00
// ignore-android: FIXME (#20004)
test: Ignore out-of-stack for MUSL Stack overflow detection does not currently work with MUSL, so this test needs to be disabled.
2015-05-02 00:55:08 +00:00
// ignore-musl
Disable stack overflow test on android, which seems to be failing spuriously. cc https://github.com/rust-lang/rust/issues/20004
2014-12-19 02:56:28 +00:00
test: Fix fallout in run-pass tests
2015-04-10 18:12:43 +00:00
#![feature(asm)]
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
test: Fix fallout in run-pass tests
2015-04-10 18:12:43 +00:00
use std::process::Command;
Replace some uses of deprecated os functions This commit mostly replaces some of the uses of os::args with env::args.
2015-02-16 14:04:02 +00:00
use std::env;
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
// lifted from the test module
test: avoid infinite loop in out-of-stack.rs This fixes #13238. It avoids an infinite loop when compiling the tests with `-g`. Without this change, the debuginfo on `black_box` prevents the method from being inlined, which allows llvm to convert `silent_recurse` into a tail-call. This then loops forever instead of consuming all the stack like it is supposed to. This patch forces inlining `black_box`, which triggers the right error.
2014-04-02 05:07:37 +00:00
// Inlining to avoid llvm turning the recursive functions into tail calls,
// which doesn't consume stack.
#[inline(always)]
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } }
fn silent_recurse() {
Remove all `i` suffixes
2015-01-25 21:05:03 +00:00
let buf = [0; 1000];
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
black_box(buf);
silent_recurse();
}
fn loud_recurse() {
println!("hello!");
loud_recurse();
test/run-pass/out-of-stack: prevent tco We really do *not* want TCO to kick in. If it does, we'll never blow the stack, and never trigger the condition the test is checking for. To that end, do a meaningless alloc that serves only to get a destructor to run. The addition of nocapture/noalias seems to have let LLVM do more TCO, which hurt this testcase.
2014-03-27 11:54:41 +00:00
black_box(()); // don't optimize this into a tail call. please.
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
}
fn main() {
Replace some uses of deprecated os functions This commit mostly replaces some of the uses of os::args with env::args.
2015-02-16 14:04:02 +00:00
let args: Vec<String> = env::args().collect();
cleanup: replace `as[_mut]_slice()` calls with deref coercions
2015-02-02 02:53:25 +00:00
if args.len() > 1 && args[1] == "silent" {
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
silent_recurse();
cleanup: replace `as[_mut]_slice()` calls with deref coercions
2015-02-02 02:53:25 +00:00
} else if args.len() > 1 && args[1] == "loud" {
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
loud_recurse();
} else {
cleanup: replace `as[_mut]_slice()` calls with deref coercions
2015-02-02 02:53:25 +00:00
let silent = Command::new(&args[0]).arg("silent").output().unwrap();
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
assert!(!silent.status.success());
test: Fix fallout in run-pass tests
2015-04-10 18:12:43 +00:00
let error = String::from_utf8_lossy(&silent.stderr);
cleanup: s/`v.slice*()`/`&v[a..b]`/g + remove redundant `as_slice()` calls
2015-01-27 02:21:15 +00:00
assert!(error.contains("has overflowed its stack"));
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
cleanup: replace `as[_mut]_slice()` calls with deref coercions
2015-02-02 02:53:25 +00:00
let loud = Command::new(&args[0]).arg("loud").output().unwrap();
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
assert!(!loud.status.success());
test: Fix fallout in run-pass tests
2015-04-10 18:12:43 +00:00
let error = String::from_utf8_lossy(&silent.stderr);
cleanup: s/`v.slice*()`/`&v[a..b]`/g + remove redundant `as_slice()` calls
2015-01-27 02:21:15 +00:00
assert!(error.contains("has overflowed its stack"));
std: Tweak stack overflow printing for robustness The printing of the error message on stack overflow had two sometimes false assumptions previously. The first is that a local task was always available (it called Local::take) and the second is that it used println! instead of manually writing. The first assumption isn't necessarily true because while stack overflow will likely only be detected in situations that a local task is available, it's not guaranteed to always be in TLS. For example, during a println! call a task may be blocking, causing it to be unavailable. By using Local::try_take(), we can be resilient against these occurrences. The second assumption could lead to odd behavior because the stdout logger can be overwritten to run arbitrary code. Currently this should be possible, but the utility is much diminished because a stack overflow translates to an abort() instead of a failure.
2014-02-20 05:01:50 +00:00
}
}
Reference in New Issue Copy Permalink