rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-08 23:18:40 +00:00
|
|
|
use std::env;
|
|
|
|
|
|
|
|
fn main() {
|
2017-02-23 15:49:54 +00:00
|
|
|
println!("cargo:rerun-if-changed=build.rs");
|
2016-09-25 15:59:12 +00:00
|
|
|
let target = env::var("TARGET").expect("TARGET was not set");
|
rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-08 23:18:40 +00:00
|
|
|
|
2019-07-07 22:45:04 +00:00
|
|
|
// FIXME: the not(bootstrap) part is needed because of the issue addressed by #62286,
|
|
|
|
// and could be removed once that change is in beta.
|
|
|
|
if cfg!(all(not(bootstrap), feature = "llvm-libunwind")) &&
|
2019-03-11 02:27:59 +00:00
|
|
|
(target.contains("linux") ||
|
|
|
|
target.contains("fuchsia")) {
|
|
|
|
// Build the unwinding from libunwind C/C++ source code.
|
2019-07-07 22:45:04 +00:00
|
|
|
#[cfg(all(not(bootstrap), feature = "llvm-libunwind"))]
|
2019-03-11 02:27:59 +00:00
|
|
|
llvm_libunwind::compile();
|
|
|
|
} else if target.contains("linux") {
|
2018-01-12 23:22:06 +00:00
|
|
|
if target.contains("musl") {
|
2017-08-22 21:24:29 +00:00
|
|
|
// musl is handled in lib.rs
|
rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-08 23:18:40 +00:00
|
|
|
} else if !target.contains("android") {
|
|
|
|
println!("cargo:rustc-link-lib=gcc_s");
|
|
|
|
}
|
|
|
|
} else if target.contains("freebsd") {
|
|
|
|
println!("cargo:rustc-link-lib=gcc_s");
|
|
|
|
} else if target.contains("rumprun") {
|
|
|
|
println!("cargo:rustc-link-lib=unwind");
|
|
|
|
} else if target.contains("netbsd") {
|
|
|
|
println!("cargo:rustc-link-lib=gcc_s");
|
|
|
|
} else if target.contains("openbsd") {
|
2017-11-26 09:08:25 +00:00
|
|
|
println!("cargo:rustc-link-lib=c++abi");
|
2017-02-11 17:24:33 +00:00
|
|
|
} else if target.contains("solaris") {
|
|
|
|
println!("cargo:rustc-link-lib=gcc_s");
|
rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-08 23:18:40 +00:00
|
|
|
} else if target.contains("dragonfly") {
|
|
|
|
println!("cargo:rustc-link-lib=gcc_pic");
|
2019-05-27 14:38:21 +00:00
|
|
|
} else if target.contains("pc-windows-gnu") {
|
2017-03-24 18:01:45 +00:00
|
|
|
println!("cargo:rustc-link-lib=static-nobundle=gcc_eh");
|
|
|
|
println!("cargo:rustc-link-lib=static-nobundle=pthread");
|
2019-05-27 14:38:21 +00:00
|
|
|
} else if target.contains("uwp-windows-gnu") {
|
|
|
|
println!("cargo:rustc-link-lib=unwind");
|
2016-10-18 20:43:18 +00:00
|
|
|
} else if target.contains("fuchsia") {
|
|
|
|
println!("cargo:rustc-link-lib=unwind");
|
2017-04-22 01:47:36 +00:00
|
|
|
} else if target.contains("haiku") {
|
|
|
|
println!("cargo:rustc-link-lib=gcc_s");
|
2017-08-04 04:13:44 +00:00
|
|
|
} else if target.contains("redox") {
|
|
|
|
println!("cargo:rustc-link-lib=gcc");
|
2017-12-26 22:32:42 +00:00
|
|
|
} else if target.contains("cloudabi") {
|
|
|
|
println!("cargo:rustc-link-lib=unwind");
|
rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-08 23:18:40 +00:00
|
|
|
}
|
|
|
|
}
|
2019-03-11 02:27:59 +00:00
|
|
|
|
2019-07-07 22:45:04 +00:00
|
|
|
#[cfg(all(not(bootstrap), feature = "llvm-libunwind"))]
|
2019-03-11 02:27:59 +00:00
|
|
|
mod llvm_libunwind {
|
|
|
|
use std::env;
|
|
|
|
use std::path::Path;
|
|
|
|
|
|
|
|
/// Compile the libunwind C/C++ source code.
|
|
|
|
pub fn compile() {
|
|
|
|
let target_env = env::var("CARGO_CFG_TARGET_ENV").unwrap();
|
|
|
|
let target_vendor = env::var("CARGO_CFG_TARGET_VENDOR").unwrap();
|
|
|
|
let cfg = &mut cc::Build::new();
|
|
|
|
|
|
|
|
cfg.cpp(true);
|
|
|
|
cfg.cpp_set_stdlib(None);
|
|
|
|
cfg.warnings(false);
|
|
|
|
|
|
|
|
if target_env == "msvc" {
|
|
|
|
// Don't pull in extra libraries on MSVC
|
|
|
|
cfg.flag("/Zl");
|
|
|
|
cfg.flag("/EHsc");
|
|
|
|
cfg.define("_CRT_SECURE_NO_WARNINGS", None);
|
|
|
|
cfg.define("_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS", None);
|
|
|
|
} else {
|
|
|
|
cfg.flag("-std=c99");
|
|
|
|
cfg.flag("-std=c++11");
|
|
|
|
cfg.flag("-nostdinc++");
|
2019-05-20 19:27:15 +00:00
|
|
|
cfg.flag("-fno-exceptions");
|
2019-03-11 02:27:59 +00:00
|
|
|
cfg.flag("-fno-rtti");
|
|
|
|
cfg.flag("-fstrict-aliasing");
|
2019-05-20 19:27:15 +00:00
|
|
|
cfg.flag("-funwind-tables");
|
2019-03-11 02:27:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let mut unwind_sources = vec![
|
|
|
|
"Unwind-EHABI.cpp",
|
|
|
|
"Unwind-seh.cpp",
|
|
|
|
"Unwind-sjlj.c",
|
|
|
|
"UnwindLevel1-gcc-ext.c",
|
|
|
|
"UnwindLevel1.c",
|
|
|
|
"UnwindRegistersRestore.S",
|
|
|
|
"UnwindRegistersSave.S",
|
|
|
|
"libunwind.cpp",
|
|
|
|
];
|
|
|
|
|
|
|
|
if target_vendor == "apple" {
|
|
|
|
unwind_sources.push("Unwind_AppleExtras.cpp");
|
|
|
|
}
|
|
|
|
|
|
|
|
let root = Path::new("../llvm-project/libunwind");
|
|
|
|
cfg.include(root.join("include"));
|
|
|
|
for src in unwind_sources {
|
|
|
|
cfg.file(root.join("src").join(src));
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg.compile("unwind");
|
|
|
|
}
|
|
|
|
}
|