add rustc option -Zpacked-stack

this enables packed-stack just as -mpacked-stack in clang and gcc.
packed-stack is needed on s390x for kernel development.

Co-authored-by: Ralf Jung <post@ralfj.de>

Author: fneddy

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -301,6 +301,18 @@ fn stackprotector_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll A
     Some(sspattr.create_attr(cx.llcx))
 }
 
+fn packed_stack_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll Attribute> {
+    if sess.target.arch != Arch::S390x {
+        return None;
+    }
+
+    if sess.opts.unstable_opts.packed_stack {
+        Some(llvm::CreateAttrString(cx.llcx, "packed-stack"))
+    } else {
+        None
+    }
+}
+
 pub(crate) fn target_cpu_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> &'ll Attribute {
     let target_cpu = llvm_util::target_cpu(sess);
     llvm::CreateAttrStringValue(cx.llcx, "target-cpu", target_cpu)
@@ -519,6 +531,9 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     if let Some(align) = codegen_fn_attrs.alignment {
         llvm::set_alignment(llfn, align);
     }
+    if let Some(packed_stack) = packed_stack_attr(cx, sess) {
+        to_add.push(packed_stack);
+    }
     to_add.extend(patchable_function_entry_attrs(
         cx,
         sess,

compiler/rustc_interface/src/errors.rs

@@ -114,6 +114,13 @@ pub struct IgnoringOutDir;
 #[diag("can't use option `-o` or `--emit` to write multiple output types to stdout")]
 pub struct MultipleOutputTypesToStdout;
 
+#[derive(Diagnostic)]
+#[diag("packedstack with backchain needs softfloat")]
+#[note(
+    "enabling both `-Zpacked-stack` and the `backchain` target feature is incompatible with the default s390x ABI. Switch to s390x-unknown-none-softfloat if you need both attributes"
+)]
+pub struct PackedStackBackchainNeedsSoftfloat;
+
 #[derive(Diagnostic)]
 #[diag(
     "target feature `{$feature}` must be {$enabled} to ensure that the ABI of the current target can be implemented correctly"

compiler/rustc_interface/src/interface.rs

@@ -493,7 +493,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
             }
             sess.lint_store = Some(Arc::new(lint_store));
 
-            util::check_abi_required_features(&sess);
+            util::check_abi_required_features_and_target_constraints(&sess);
 
             let compiler = Compiler {
                 sess,

compiler/rustc_interface/src/util.rs

@@ -25,7 +25,7 @@ use rustc_session::{EarlyDiagCtxt, Session, filesearch};
 use rustc_span::edition::Edition;
 use rustc_span::source_map::SourceMapInputs;
 use rustc_span::{SessionGlobals, Symbol, sym};
-use rustc_target::spec::Target;
+use rustc_target::spec::{Arch, Target};
 use tracing::info;
 
 use crate::errors;
@@ -72,7 +72,10 @@ pub(crate) fn add_configuration(
 
 /// Ensures that all target features required by the ABI are present.
 /// Must be called after `unstable_target_features` has been populated!
-pub(crate) fn check_abi_required_features(sess: &Session) {
+/// Also enforces other, target-specific constraints on how target features can be combined.
+/// (Those checks can only be done once the `Session` is mostly constructed, so there's
+/// no earlier place we can put them.)
+pub(crate) fn check_abi_required_features_and_target_constraints(sess: &Session) {
     let abi_feature_constraints = sess.target.abi_required_features();
     // We check this against `unstable_target_features` as that is conveniently already
     // back-translated to rustc feature names, taking into account `-Ctarget-cpu` and `-Ctarget-feature`.
@@ -96,6 +99,16 @@ pub(crate) fn check_abi_required_features(sess: &Session) {
             sess.dcx().emit_warn(errors::AbiRequiredTargetFeature { feature, enabled: "disabled" });
         }
     }
+
+    // we need to have access to the complete constructed `target` and the session options.
+    // this is the first place in the `run_compiler` flow where all this is available
+    if sess.target.arch == Arch::S390x
+        && sess.opts.unstable_opts.packed_stack
+        && sess.unstable_target_features.contains(&Symbol::intern(&"backchain"))
+        && !sess.unstable_target_features.contains(&Symbol::intern(&"soft-float"))
+    {
+        sess.dcx().emit_err(errors::PackedStackBackchainNeedsSoftfloat);
+    }
 }
 
 pub static STACK_SIZE: OnceLock<usize> = OnceLock::new();

compiler/rustc_session/src/errors.rs

@@ -541,3 +541,7 @@ pub(crate) struct UnexpectedBuiltinCfg {
 #[derive(Diagnostic)]
 #[diag("ThinLTO is not supported by the codegen backend")]
 pub(crate) struct ThinLtoNotSupportedByBackend;
+
+#[derive(Diagnostic)]
+#[diag("`-Zpacked-stack` is only supported on s390x")]
+pub(crate) struct UnsupportedPackedStack;

compiler/rustc_session/src/options.rs

@@ -2536,6 +2536,8 @@ options! {
         "pass `-install_name @rpath/...` to the macOS linker (default: no)"),
     packed_bundled_libs: bool = (false, parse_bool, [TRACKED],
         "change rlib format to store native libraries as archives"),
+    packed_stack: bool = (false, parse_bool, [TRACKED],
+        "use packed stack frames (s390x only) (default: no)"),
     panic_abort_tests: bool = (false, parse_bool, [TRACKED],
         "support compiling tests with panic=abort (default: no)"),
     panic_in_drop: PanicStrategy = (PanicStrategy::Unwind, parse_panic_strategy, [TRACKED],

compiler/rustc_session/src/session.rs

@@ -1361,6 +1361,12 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
             sess.dcx().emit_warn(errors::SoftFloatIgnored);
         }
     }
+
+    if sess.opts.unstable_opts.packed_stack {
+        if sess.target.arch != Arch::S390x {
+            sess.dcx().emit_err(errors::UnsupportedPackedStack);
+        }
+    }
 }
 
 /// Holds data on the current incremental compilation session, if there is one.

tests/assembly-llvm/s390x-packedstack-toggle.rs

@@ -0,0 +1,37 @@
+//@ add-minicore
+//@ revisions: enable-packedstack default-packedstack
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3 --crate-type=lib --target=s390x-unknown-linux-gnu -Cforce-unwind-tables=no
+//@ needs-llvm-components: systemz
+//@[enable-packedstack] compile-flags: -Zpacked-stack
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+extern "C" {
+    fn extern_func() -> i32;
+}
+
+// CHECK-LABEL: test_packedstack
+#[no_mangle]
+extern "C" fn test_packedstack() -> i32 {
+    // test the creation of call stack with and without packed-stack
+
+    // without packed-stack we always reserve a least the maximal space of 160 bytes
+    // default-packedstack: stmg %r14, %r15, 112(%r15)
+    // default-packedstack-NEXT: aghi %r15, -160
+    // default-packedstack-NEXT: brasl %r14, extern_func
+
+    // with packed-stack only the actually needed registers are reserved on the stack
+    // enable-packedstack: stmg %r14, %r15, 144(%r15)
+    // enable-packedstack-NEXT: aghi %r15, -16
+    // enable-packedstack-NEXT: brasl %r14, extern_func
+    unsafe {
+        extern_func();
+    }
+    1
+    // CHECK: br %r{{.*}}
+}

tests/codegen-llvm/packedstack.rs

@@ -0,0 +1,16 @@
+//@ add-minicore
+//@ compile-flags: -Copt-level=3 --crate-type=lib --target=s390x-unknown-linux-gnu -Zpacked-stack
+//@ needs-llvm-components: systemz
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+
+pub fn test_packedstack() {
+    // CHECK: @test_packedstack() unnamed_addr #0
+}
+// CHECK: attributes #0 = { {{.*}}"packed-stack"{{.*}} }

tests/ui/target-feature/packedstack-combinations.need_softfloat.stderr

@@ -0,0 +1,10 @@
+warning: unstable feature specified for `-Ctarget-feature`: `backchain`
+   |
+   = note: this feature is not stably supported; its behavior can change in the future
+
+error: packedstack with backchain needs softfloat
+   |
+   = note: enabling both `-Zpacked-stack` and the `backchain` target feature is incompatible with the default s390x ABI. Switch to s390x-unknown-none-softfloat if you need both attributes
+
+error: aborting due to 1 previous error; 1 warning emitted
+