Add span_bug for locals larger than 1GB

use ilog2
Update compiler/rustc_codegen_ssa/messages.ftl
Co-authored-by: Michael Goulet <michael@errs.io>
Run test only on 64 bit

Author: iSwapna

compiler/rustc_codegen_ssa/messages.ftl

@@ -32,6 +32,8 @@ codegen_ssa_copy_path_buf = unable to copy {$source_file} to {$output_path}: {$e
 
 codegen_ssa_create_temp_dir = couldn't create a temp dir: {$error}
 
+codegen_ssa_dangerous_stack_allocation = dangerous stack allocation of size: {$output} exceeds most system architecture limits
+
 codegen_ssa_dlltool_fail_import_library =
     Dlltool could not create import library with {$dlltool_path} {$dlltool_args}:
     {$stdout}

compiler/rustc_codegen_ssa/src/errors.rs

@@ -429,6 +429,14 @@ pub(crate) struct CheckInstalledVisualStudio;
 #[diag(codegen_ssa_insufficient_vs_code_product)]
 pub(crate) struct InsufficientVSCodeProduct;
 
+#[derive(Diagnostic)]
+#[diag(codegen_ssa_dangerous_stack_allocation)]
+pub struct DangerousStackAllocation {
+    #[primary_span]
+    pub span: Span,
+    pub output: String,
+}
+
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_processing_dymutil_failed)]
 #[note]

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -10,8 +10,8 @@ use rustc_middle::{bug, mir, span_bug};
 use rustc_target::callconv::{FnAbi, PassMode};
 use tracing::{debug, instrument};
 
-use crate::base;
 use crate::traits::*;
+use crate::{base, errors};
 
 mod analyze;
 mod block;
@@ -30,6 +30,8 @@ use self::debuginfo::{FunctionDebugContext, PerLocalVarDebugInfo};
 use self::operand::{OperandRef, OperandValue};
 use self::place::PlaceRef;
 
+const MIN_DANGEROUS_SIZE: u64 = 1024 * 1024 * 1024 * 1; // 1 GB
+
 // Used for tracking the state of generated basic blocks.
 enum CachedLlbb<T> {
     /// Nothing created yet.
@@ -245,6 +247,14 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             let layout = start_bx.layout_of(fx.monomorphize(decl.ty));
             assert!(!layout.ty.has_erasable_regions());
 
+            if layout.size.bytes() >= MIN_DANGEROUS_SIZE {
+                let (size_quantity, size_unit) = human_readable_bytes(layout.size.bytes());
+                cx.tcx().dcx().emit_warn(errors::DangerousStackAllocation {
+                    span: decl.source_info.span,
+                    output: format!("{:.2} {}", size_quantity, size_unit),
+                });
+            }
+
             if local == mir::RETURN_PLACE {
                 match fx.fn_abi.ret.mode {
                     PassMode::Indirect { .. } => {
@@ -310,6 +320,14 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     }
 }
 
+/// Formats a number of bytes into a human readable SI-prefixed size.
+/// Returns a tuple of `(quantity, units)`.
+pub fn human_readable_bytes(bytes: u64) -> (u64, &'static str) {
+    static UNITS: [&str; 7] = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"];
+    let i = ((bytes.checked_ilog2().unwrap_or(0) / 10) as usize).min(UNITS.len() - 1);
+    (bytes >> (10 * i), UNITS[i])
+}
+
 /// Produces, for each argument, a `Value` pointing at the
 /// argument's value. As arguments are places, these are always
 /// indirect.

tests/ui/codegen/large-stack-size-issue-83060.rs

@@ -0,0 +1,20 @@
+// This test checks that allocating a stack size of 1GB or more results in a warning
+//@build-pass
+//@ only-64bit
+
+fn func() {
+    const CAP: usize = std::u32::MAX as usize;
+    let mut x: [u8; CAP>>1] = [0; CAP>>1];
+    //~^ warning: dangerous stack allocation of size: 1 GiB exceeds most system architecture limits
+    x[2] = 123;
+    println!("{}", x[2]);
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(3 * 1024 * 1024 * 1024)
+        .spawn(func)
+        .unwrap()
+        .join()
+        .unwrap();
+}

tests/ui/codegen/large-stack-size-issue-83060.stderr

@@ -0,0 +1,8 @@
+warning: dangerous stack allocation of size: 1 GiB exceeds most system architecture limits
+  --> $DIR/large-stack-size-issue-83060.rs:7:9
+   |
+LL |     let mut x: [u8; CAP>>1] = [0; CAP>>1];
+   |         ^^^^^
+
+warning: 1 warning emitted
+