Add new rustc_panic_abort_runtime attribute for libpanic_abort

Supersedes rust-lang#66311

This replaces the hack in `bootstrap`, allowing the special handling for
`libpanic_abort` to be encoded into the crate source itself, rather than
existing as special knowledge in the build system. This will allow Miri
(and any other users of Xargo) to correctly build `libpanic_abort`
without relying on `bootstrap` or custom wrapepr hacks.

The trickeist part of this PR is how we handle LLVM. The `emscripten`
target family requires the "-enable-emscripten-cxx-exceptions" flag
to be passed to LLVM when the panic strategy is set to "unwind".

Unfortunately, the location of this emscripten-specific check ends up
creating a circular dependency between LLVM and attribute resoltion.
When we check the panic strategy, we need to have already parsed crate
attributes, so that we determine if `rustc_panic_abort_runtime` was set.
However, attribute parsing requires LLVM to be initialized, so that we
can proerly handle cfg-gating of target-specific features. However, the
whole point of checking the panic strategy is to determinne which flags
to use during LLVM initialization!

To break this circular dependency, we explicitly set the
"-enable-emscripten-cxx-exceptions" in LLVM's argument-parsing framework
(using public but poorly-documented APIs). While this approach is
unfortunate, it only affects emscripten, and only modifies a
command-line flag which is never used until much later (when we create a
`PassManager`).

src/bootstrap/bin/rustc.rs

@@ -94,14 +94,22 @@ fn main() {
         // other crate intentionally as this is the only crate for now that we
         // ship with panic=abort.
         //
+        // This hack is being replaced with a new "rustc_panic_abort_runtime"
+        // attribute, which moves the special-casing out of `bootstrap` and
+        // into the compiler itself. Until this change makes its way into
+        // the bootstrap compiler, we still need this hack when building
+        // stage0. Once the boostrap compiler is updated, we can remove
+        // this check entirely.
+        // cfg(bootstrap): (Added to make this show up when searching for "cfg(bootstrap)")
+        //
         // This... is a bit of a hack how we detect this. Ideally this
         // information should be encoded in the crate I guess? Would likely
         // require an RFC amendment to RFC 1513, however.
         //
         // `compiler_builtins` are unconditionally compiled with panic=abort to
         // workaround undefined references to `rust_eh_unwind_resume` generated
         // otherwise, see issue https://github.com/rust-lang/rust/issues/43095.
-        if crate_name == Some("panic_abort") ||
+        if (crate_name == Some("panic_abort") && stage == "0") ||
            crate_name == Some("compiler_builtins") && stage != "0" {
             cmd.arg("-C").arg("panic=abort");
         }

src/libpanic_abort/lib.rs

@@ -8,6 +8,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/",
        issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/")]
 #![panic_runtime]
+#![cfg_attr(not(bootstrap), rustc_panic_abort_runtime)]
 
 #![allow(unused_features)]
 

src/librustc_codegen_llvm/lib.rs

@@ -202,6 +202,10 @@ impl CodegenBackend for LlvmCodegenBackend {
         llvm_util::init(sess); // Make sure llvm is inited
     }
 
+    fn after_expansion(&self, sess: &Session) {
+        llvm_util::late_init(sess);
+    }
+
     fn print(&self, req: PrintRequest, sess: &Session) {
         match req {
             PrintRequest::RelocationModels => {

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -1871,4 +1871,5 @@ extern "C" {
                              bytecode: *const c_char,
                              bytecode_len: usize) -> bool;
     pub fn LLVMRustLinkerFree(linker: &'a mut Linker<'a>);
+    pub fn LLVMRustEnableEmscriptenCXXExceptions();
 }

src/librustc_codegen_llvm/llvm_util.rs

@@ -45,6 +45,13 @@ fn require_inited() {
     }
 }
 
+pub(crate) fn late_init(sess: &Session) {
+    if sess.target.target.target_os == "emscripten" &&
+        sess.panic_strategy() == PanicStrategy::Unwind {
+        unsafe { llvm::LLVMRustEnableEmscriptenCXXExceptions(); }
+    }
+}
+
 unsafe fn configure_llvm(sess: &Session) {
     let n_args = sess.opts.cg.llvm_args.len();
     let mut llvm_c_strs = Vec::with_capacity(n_args + 1);
@@ -95,11 +102,6 @@ unsafe fn configure_llvm(sess: &Session) {
             }
         }
 
-        if sess.target.target.target_os == "emscripten" &&
-            sess.panic_strategy() == PanicStrategy::Unwind {
-            add("-enable-emscripten-cxx-exceptions", false);
-        }
-
         // HACK(eddyb) LLVM inserts `llvm.assume` calls to preserve align attributes
         // during inlining. Unfortunately these may block other optimizations.
         add("-preserve-alignment-assumptions-during-inlining=false", false);

src/librustc_codegen_utils/codegen_backend.rs

@@ -21,6 +21,7 @@ pub use rustc_data_structures::sync::MetadataRef;
 
 pub trait CodegenBackend {
     fn init(&self, _sess: &Session) {}
+    fn after_expansion(&self, _sess: &Session) {}
     fn print(&self, _req: PrintRequest, _sess: &Session) {}
     fn target_features(&self, _sess: &Session) -> Vec<Symbol> { vec![] }
     fn print_passes(&self) {}

src/librustc_feature/builtin_attrs.rs

@@ -379,6 +379,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     rustc_attr!(rustc_allocator, Whitelisted, template!(Word), IMPL_DETAIL),
     rustc_attr!(rustc_allocator_nounwind, Whitelisted, template!(Word), IMPL_DETAIL),
     gated!(alloc_error_handler, Normal, template!(Word), experimental!(alloc_error_handler)),
+    rustc_attr!(rustc_panic_abort_runtime, Whitelisted, template!(Word), IMPL_DETAIL),
     gated!(
         default_lib_allocator, Whitelisted, template!(Word), allocator_internals,
         experimental!(default_lib_allocator),

src/librustc_interface/passes.rs

@@ -2,8 +2,8 @@ use crate::interface::{Compiler, Result};
 use crate::util;
 use crate::proc_macro_decls;
 
-use log::{info, warn, log_enabled};
 use rustc::arena::Arena;
+use log::{debug, info, warn, log_enabled};
 use rustc::dep_graph::DepGraph;
 use rustc::hir;
 use rustc::hir::lowering::lower_crate;
@@ -39,7 +39,7 @@ use syntax::early_buffered_lints::BufferedEarlyLint;
 use syntax_expand::base::ExtCtxt;
 use syntax::mut_visit::MutVisitor;
 use syntax::util::node_count::NodeCounter;
-use syntax::symbol::Symbol;
+use syntax::symbol::{sym, Symbol};
 use syntax_pos::FileName;
 use syntax_ext;
 
@@ -112,6 +112,7 @@ declare_box_region_type!(
 ///
 /// Returns `None` if we're aborting after handling -W help.
 pub fn configure_and_expand(
+    codegen_backend: Lrc<Box<dyn CodegenBackend>>,
     sess: Lrc<Session>,
     lint_store: Lrc<lint::LintStore>,
     metadata_loader: Box<MetadataLoaderDyn>,
@@ -123,15 +124,16 @@ pub fn configure_and_expand(
     // item, much like we do for macro expansion. In other words, the hash reflects not just
     // its contents but the results of name resolution on those contents. Hopefully we'll push
     // this back at some point.
-    let crate_name = crate_name.to_string();
+    let crate_name_inner = crate_name.to_string();
+    let sess_inner = sess.clone();
     let (result, resolver) = BoxedResolver::new(static move || {
-        let sess = &*sess;
         let resolver_arenas = Resolver::arenas();
         let res = configure_and_expand_inner(
-            sess,
+            &**codegen_backend,
+            &sess_inner,
             &lint_store,
             krate,
-            &crate_name,
+            &crate_name_inner,
             &resolver_arenas,
             &*metadata_loader,
         );
@@ -227,6 +229,7 @@ pub fn register_plugins<'a>(
 }
 
 fn configure_and_expand_inner<'a>(
+    codegen_backend: &dyn CodegenBackend,
     sess: &'a Session,
     lint_store: &'a lint::LintStore,
     mut krate: ast::Crate,
@@ -346,6 +349,14 @@ fn configure_and_expand_inner<'a>(
         krate
     });
 
+    let force_panic_abort = krate.attrs.iter().any(|attr| {
+        attr.check_name(sym::rustc_panic_abort_runtime)
+    });
+    debug!("Setting force_panic_abort for crate `{}`: {}", crate_name, force_panic_abort);
+    sess.force_panic_abort.set(force_panic_abort);
+
+    codegen_backend.after_expansion(sess);
+
     time(sess, "maybe building test harness", || {
         syntax_ext::test_harness::inject(
             &sess.parse_sess,

src/librustc_interface/queries.rs

@@ -186,6 +186,7 @@ impl<'tcx> Queries<'tcx> {
             let crate_name = self.crate_name()?.peek().clone();
             let (krate, lint_store) = self.register_plugins()?.take();
             passes::configure_and_expand(
+                self.codegen_backend().clone(),
                 self.session().clone(),
                 lint_store.clone(),
                 self.codegen_backend().metadata_loader(),

src/librustc_session/session.rs

@@ -125,6 +125,11 @@ pub struct Session {
     /// false positives about a job server in our environment.
     pub jobserver: Client,
 
+    /// Whether or not to force the panic strategy for this
+    /// crate to be PanicStrategy::Abort. Only used
+    /// for 'libpanic_abort'
+    pub force_panic_abort: Once<bool>,
+
     /// Cap lint level specified by a driver specifically.
     pub driver_lint_caps: FxHashMap<lint::LintId, lint::Level>,
 
@@ -543,6 +548,10 @@ impl Session {
     /// Returns the panic strategy for this compile session. If the user explicitly selected one
     /// using '-C panic', use that, otherwise use the panic strategy defined by the target.
     pub fn panic_strategy(&self) -> PanicStrategy {
+        if *self.force_panic_abort.get() {
+            return PanicStrategy::Abort
+        }
+
         self.opts
             .cg
             .panic
@@ -1164,6 +1173,7 @@ fn build_session_(
         print_fuel_crate,
         print_fuel,
         jobserver: jobserver::client(),
+        force_panic_abort: Once::new(),
         driver_lint_caps,
         trait_methods_not_found: Lock::new(Default::default()),
         confused_type_with_std_module: Lock::new(Default::default()),

src/libsyntax_pos/symbol.rs

@@ -630,6 +630,7 @@ symbols! {
         rustc_object_lifetime_default,
         rustc_on_unimplemented,
         rustc_outlives,
+        rustc_panic_abort_runtime,
         rustc_paren_sugar,
         rustc_partition_codegened,
         rustc_partition_reused,

src/rustllvm/RustWrapper.cpp

@@ -1537,3 +1537,34 @@ extern "C" LLVMValueRef
 LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
     return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS),unwrap(RHS)));
 }
+
+extern "C" void
+LLVMRustEnableEmscriptenCXXExceptions() {
+    // This is a little sketchy. Ideally, we would just pass
+    // '-enable-emscripten-cxx-exceptions' along with all
+    // of our other LLVM arguments when we initialize LLVM.
+    // Unfortunately, whether or not we pass this flag depends
+    // on the crate panic strategy. Determining the crate
+    // panic strategy requires us to have paresed crate arributes
+    // (so that we can have special handling for `libpanic_abort`).
+    // Parsing crate attributes actually requires us to have initialized
+    // LLVM, so that we can handle cfg-gating involving LLVM target
+    // features.
+    //
+    // We break this circular dependency by manually enabling
+    // "enable-emscripten-cxx-exceptions" after we've initialized
+    // LLVM. The methods involved are not well-documented - however,
+    // the flag we are modifiying ("enable-emscripten-cxx-exceptions")
+    // is only used in one place, and only when a PassManger is created.
+    // Thus, enabling it later than normal should have no visible effects.
+    //
+    // If this logic ever becomes incorrect (e.g. due to an LLVM upgrade),
+    // it should cause panic-related tests to start failing under emscripten,
+    // since they require this flag for proper unwinding support.
+    StringMap<cl::Option*> &Map = cl::getRegisteredOptions();
+    Map["enable-emscripten-cxx-exceptions"]->addOccurrence(
+        0,
+        StringRef("enable-emscripten-cxx-exceptions"),
+        StringRef("")
+    );
+}