constant memory overspill handling

- if constant memory overspill, automatically move that static to global and throw a warning intead of failing
- statics are packed in first-come-first-serve order, user can manually overrides this

Author: PMQ9

crates/cuda_builder/src/lib.rs

@@ -201,6 +201,14 @@ pub struct CudaBuilder {
     /// Exceeding the limit may cause `IllegalAddress` runtime
     /// errors (CUDA error code: `700`).
     ///
+    /// Statics are placed on a first-come-first-served basis in the order the
+    /// codegen encounters them. When the cumulative size would exceed the 64KB
+    /// limit, the overflowing static is automatically spilled to global memory
+    /// with a compile-time warning. Subsequent smaller statics may still fit
+    /// and will continue to be placed in constant memory. This means the
+    /// codegen does not optimize for the "best" packing — it simply fills
+    /// constant memory in encounter order.
+    ///
     /// The default is `false`, which places all statics in global memory. This avoids
     /// such errors but may reduce performance and use more general memory. When set to
     /// `false`, you can still annotate `static` variables with
@@ -210,6 +218,8 @@ pub struct CudaBuilder {
     /// Use [`place_static`](Self::place_static) and
     /// [`crate_memory_space`](Self::crate_memory_space) to override placement for
     /// individual statics or entire crates (including third-party crates).
+    /// These overrides let you prioritize performance-critical statics for
+    /// constant memory regardless of encounter order.
     pub use_constant_memory_space: bool,
     /// Per-static memory placement overrides. Keys are Rust path strings
     /// (e.g., `"my_crate::module::MY_STATIC"`). These take priority over per-crate
@@ -370,6 +380,14 @@ impl CudaBuilder {
     /// Exceeding the limit may cause `IllegalAddress` runtime
     /// errors (CUDA error code: `700`).
     ///
+    /// Statics are placed on a first-come-first-served basis in the order the
+    /// codegen encounters them. When the cumulative size would exceed the 64KB
+    /// limit, the overflowing static is automatically spilled to global memory
+    /// with a compile-time warning. Subsequent smaller statics may still fit
+    /// and will continue to be placed in constant memory. This means the
+    /// codegen does not optimize for the "best" packing — it simply fills
+    /// constant memory in encounter order.
+    ///
     /// If `false`, all statics are placed in global memory. This avoids such errors but
     /// may reduce performance and use more general memory. You can still annotate
     /// `static` variables with `#[cuda_std::address_space(constant)]` to place them in
@@ -378,6 +396,8 @@ impl CudaBuilder {
     /// Use [`place_static`](Self::place_static) and
     /// [`crate_memory_space`](Self::crate_memory_space) to override placement for
     /// individual statics or entire crates.
+    /// These overrides let you prioritize performance-critical statics for
+    /// constant memory regardless of encounter order.
     pub fn use_constant_memory_space(mut self, use_constant_memory_space: bool) -> Self {
         self.use_constant_memory_space = use_constant_memory_space;
         self

crates/rustc_codegen_nvvm/src/context.rs

@@ -366,37 +366,27 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
         }
 
         // Check if adding this static would exceed the cumulative limit
+        // Auto-spill to global memory with a warning instead of failing
         if new_usage > CONSTANT_MEMORY_SIZE_LIMIT_BYTES {
             let def_id = instance.def_id();
             let span = self.tcx.def_span(def_id);
-            let mut diag = self.tcx.sess.dcx().struct_span_err(
-                span,
-                format!(
-                    "cannot place static `{instance}` ({size_bytes} bytes) in constant memory: \
-                    cumulative constant memory usage would be {new_usage} bytes, exceeding the {} byte limit",
-                    CONSTANT_MEMORY_SIZE_LIMIT_BYTES
-                ),
-            );
-            diag.span_label(
+            let remaining = CONSTANT_MEMORY_SIZE_LIMIT_BYTES.saturating_sub(current_usage);
+            let mut diag = self.tcx.sess.dcx().struct_span_warn(
                 span,
                 format!(
-                    "this static would cause total usage to exceed {} bytes",
+                    "constant memory overflow: static `{instance}` ({size_bytes} bytes) does not fit in remaining \
+                    constant memory ({remaining} bytes free of {} bytes total)",
                     CONSTANT_MEMORY_SIZE_LIMIT_BYTES
                 ),
             );
+            diag.span_label(span, "automatically placed in global memory");
             diag.note(format!(
-                "current constant memory usage: {current_usage} bytes"
+                "current constant memory usage: {current_usage} / {} bytes",
+                CONSTANT_MEMORY_SIZE_LIMIT_BYTES
             ));
-            diag.note(format!("static size: {size_bytes} bytes"));
-            diag.note(format!("would result in: {new_usage} bytes total"));
-
-            diag.help("move this or other statics to global memory using `#[cuda_std::address_space(global)]` or `.place_static(\"path\", MemorySpace::Global)` in build.rs");
-            diag.help("reduce the total size of static data");
-            diag.help("disable automatic constant memory placement by setting `.use_constant_memory_space(false)` on `CudaBuilder` in build.rs");
-
+            diag.help("use `.place_static(\"path\", MemorySpace::Constant)` in build.rs to prioritize specific statics for constant memory");
             diag.emit();
-            self.tcx.sess.dcx().abort_if_errors();
-            unreachable!()
+            return AddressSpace(1);
         }
 
                 // If successfully placed in constant memory: update cumulative usage

tests/compiletests/ui/lang/consts/constant_memory_overflow.rs

@@ -1,5 +1,5 @@
-// Test that automatic constant memory placement fails when exceeding the 64KB limit
-// This test creates multiple large static arrays that together exceed the limit
+// Test that automatic constant memory placement spills to global with a warning
+// when exceeding the 64KB limit
 
 // compile-flags: -Cllvm-args=--use-constant-memory-space
 

tests/compiletests/ui/lang/consts/constant_memory_overflow.stderr

@@ -1,15 +1,20 @@
-error: cannot place static `BIG_ARRAY_2` (35840 bytes) in constant memory: cumulative constant memory usage would be 71680 bytes, exceeding the 65536 byte limit
+warning: constant memory overflow: static `BIG_ARRAY_2` (35840 bytes) does not fit in remaining constant memory (29696 bytes free of 65536 bytes total)
   --> $DIR/constant_memory_overflow.rs:15:1
    |
 LL | static BIG_ARRAY_2: [u32; ARRAY_SIZE] = [222u32; ARRAY_SIZE];
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this static would cause total usage to exceed 65536 bytes
-   |
-   = note: current constant memory usage: 35840 bytes
-   = note: static size: 35840 bytes
-   = note: would result in: 71680 bytes total
-   = help: move this or other statics to global memory using `#[cuda_std::address_space(global)]`
-   = help: reduce the total size of static data
-   = help: disable automatic constant memory placement by setting `.use_constant_memory_space(false)` on `CudaBuilder` in build.rs
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ automatically placed in global memory
+   |
+   = note: current constant memory usage: 35840 / 65536 bytes
+   = help: use `.place_static("path", MemorySpace::Constant)` in build.rs to prioritize specific statics for constant memory
+
+warning: constant memory overflow: static `BIG_ARRAY_3` (35840 bytes) does not fit in remaining constant memory (29696 bytes free of 65536 bytes total)
+  --> $DIR/constant_memory_overflow.rs:16:1
+   |
+LL | static BIG_ARRAY_3: [u32; ARRAY_SIZE] = [333u32; ARRAY_SIZE];
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ automatically placed in global memory
+   |
+   = note: current constant memory usage: 35840 / 65536 bytes
+   = help: use `.place_static("path", MemorySpace::Constant)` in build.rs to prioritize specific statics for constant memory
 
-error: aborting due to 1 previous error
+warning: 2 warnings emitted