baf227ea0c
### Integration Tests
This commit introduces some new fixtures to the `run-make-fulldeps`
test suite.
* c-unwind-abi-catch-panic: Exercise unwinding a panic. This
catches a panic across an FFI boundary and downcasts it into
an integer.
* c-unwind-abi-catch-lib-panic: This is similar to the previous
`*catch-panic` test, however in this case the Rust code that
panics resides in a separate crate.
### Add `rust_eh_personality` to `#[no_std]` alloc tests
This commit addresses some test failures that now occur in the
following two tests:
* no_std-alloc-error-handler-custom.rs
* no_std-alloc-error-handler-default.rs
Each test now defines a `rust_eh_personality` extern function, in
the same manner as shown in the "Writing an executable without
stdlib" section of the `lang_items` documentation here:
https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib
Without this change, these tests would fail to compile due to a
linking error explaining that there was an "undefined reference
to `rust_eh_personality'."
### Updated hash
* update 32-bit hash in `impl1` test
### Panics
This commit uses `panic!` macro invocations that return a string,
rather than using an integer as a panic payload.
Doing so avoids the following warnings that were observed during
rollup for the `*-msvc-1` targets:
```
warning: panic message is not a string literal
--> panic.rs:10:16
|
10 | panic!(x); // That is too big!
| ^
|
= note: `#[warn(non_fmt_panic)]` on by default
= note: this is no longer accepted in Rust 2021
help: add a "{}" format string to Display the message
|
10 | panic!("{}", x); // That is too big!
| ^^^^^
help: or use std::panic::panic_any instead
|
10 | std::panic::panic_any(x); // That is too big!
| ^^^^^^^^^^^^^^^^^^^^^
warning: 1 warning emitted
```
See: https://github.com/rust-lang-ci/rust/runs/1992118428
As these errors imply, panicking without a format string will be
disallowed in Rust 2021, per #78500.
103 lines
3.1 KiB
Rust
103 lines
3.1 KiB
Rust
// run-pass
|
|
// ignore-android no libc
|
|
// ignore-emscripten no libc
|
|
// ignore-sgx no libc
|
|
// ignore-wasm32 no libc
|
|
// only-linux
|
|
// compile-flags:-C panic=abort
|
|
// aux-build:helper.rs
|
|
|
|
#![feature(start, rustc_private, new_uninit, panic_info_message, lang_items)]
|
|
#![feature(alloc_error_handler)]
|
|
#![no_std]
|
|
|
|
extern crate alloc;
|
|
extern crate libc;
|
|
|
|
// ARM targets need these symbols
|
|
#[no_mangle]
|
|
pub fn __aeabi_unwind_cpp_pr0() {}
|
|
|
|
#[no_mangle]
|
|
pub fn __aeabi_unwind_cpp_pr1() {}
|
|
|
|
use core::ptr::null_mut;
|
|
use core::alloc::{GlobalAlloc, Layout};
|
|
use alloc::boxed::Box;
|
|
|
|
extern crate helper;
|
|
|
|
struct MyAllocator;
|
|
|
|
#[alloc_error_handler]
|
|
fn my_oom(layout: Layout) -> !
|
|
{
|
|
use alloc::fmt::write;
|
|
unsafe {
|
|
let size = layout.size();
|
|
let mut s = alloc::string::String::new();
|
|
write(&mut s, format_args!("My OOM: failed to allocate {} bytes!\n", size)).unwrap();
|
|
let s = s.as_str();
|
|
libc::write(libc::STDERR_FILENO, s as *const _ as _, s.len());
|
|
libc::exit(0)
|
|
}
|
|
}
|
|
|
|
unsafe impl GlobalAlloc for MyAllocator {
|
|
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
|
|
if layout.size() < 4096 {
|
|
libc::malloc(layout.size()) as _
|
|
} else {
|
|
null_mut()
|
|
}
|
|
}
|
|
unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {}
|
|
}
|
|
|
|
#[global_allocator]
|
|
static A: MyAllocator = MyAllocator;
|
|
|
|
#[panic_handler]
|
|
fn panic(panic_info: &core::panic::PanicInfo) -> ! {
|
|
unsafe {
|
|
if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
|
|
const PSTR: &str = "panic occurred: ";
|
|
const CR: &str = "\n";
|
|
libc::write(libc::STDERR_FILENO, PSTR as *const _ as _, PSTR.len());
|
|
libc::write(libc::STDERR_FILENO, s as *const _ as _, s.len());
|
|
libc::write(libc::STDERR_FILENO, CR as *const _ as _, CR.len());
|
|
}
|
|
if let Some(args) = panic_info.message() {
|
|
let mut s = alloc::string::String::new();
|
|
alloc::fmt::write(&mut s, *args).unwrap();
|
|
let s = s.as_str();
|
|
const PSTR: &str = "panic occurred: ";
|
|
const CR: &str = "\n";
|
|
libc::write(libc::STDERR_FILENO, PSTR as *const _ as _, PSTR.len());
|
|
libc::write(libc::STDERR_FILENO, s as *const _ as _, s.len());
|
|
libc::write(libc::STDERR_FILENO, CR as *const _ as _, CR.len());
|
|
} else {
|
|
const PSTR: &str = "panic occurred\n";
|
|
libc::write(libc::STDERR_FILENO, PSTR as *const _ as _, PSTR.len());
|
|
}
|
|
libc::exit(1)
|
|
}
|
|
}
|
|
|
|
// Because we are compiling this code with `-C panic=abort`, this wouldn't normally be needed.
|
|
// However, `core` and `alloc` are both compiled with `-C panic=unwind`, which means that functions
|
|
// in these libaries will refer to `rust_eh_personality` if LLVM can not *prove* the contents won't
|
|
// unwind. So, for this test case we will define the symbol.
|
|
#[lang = "eh_personality"]
|
|
extern fn rust_eh_personality() {}
|
|
|
|
#[derive(Debug)]
|
|
struct Page([[u64; 32]; 16]);
|
|
|
|
#[start]
|
|
pub fn main(_argc: isize, _argv: *const *const u8) -> isize {
|
|
let zero = Box::<Page>::new_zeroed();
|
|
let zero = unsafe { zero.assume_init() };
|
|
helper::work_with(&zero);
|
|
1
|
|
}
|