Space efficient custom_panic

sdk/define-syscall/src/definitions.rs

@@ -31,6 +31,7 @@ define_syscall!(fn sol_remaining_compute_units() -> u64);
 define_syscall!(fn sol_alt_bn128_compression(op: u64, input: *const u8, input_size: u64, result: *mut u8) -> u64);
 define_syscall!(fn sol_get_sysvar(sysvar_id_addr: *const u8, result: *mut u8, offset: u64, length: u64) -> u64);
 define_syscall!(fn sol_get_epoch_stake(vote_address: *const u8) -> u64);
+define_syscall!(fn sol_panic_(filename: *const u8, filename_len: u64, line: u64, column: u64));
 
 // these are to be deprecated once they are superceded by sol_get_sysvar
 define_syscall!(fn sol_get_clock_sysvar(addr: *mut u8) -> u64);

sdk/program-entrypoint/src/lib.rs

@@ -279,6 +279,44 @@ macro_rules! custom_panic_default {
     };
 }
 
+/// This is a more space efficient implementation of custom panic.
+/// It is about 1kb in size and depends on the unstable feature `panic_info_message`,
+/// which is going to be stabilized in Rust 1.84.
+///
+/// It works just like the default custom panic, except that dynamic generated error
+/// messages are not shown. For instance, trying to access an index out of bounds of a vector
+/// would give us `index Y is out of bounds for length X`. As the length is only know at runtime
+/// time, this message is elided.
+///
+/// All messages known at compile time are correctly displayed, e.g. `called unwrap in a None`,
+/// file names, line and column numbers.
+#[macro_export]
+macro_rules! custom_panic_space_efficient {
+    () => {
+        #[cfg(all(not(feature = "custom-panic"), target_os = "solana"))]
+        #[no_mangle]
+        fn custom_panic(info: &core::panic::PanicInfo<'_>) {
+            if let Some(Some(mm)) = info.message().map(|mes| mes.as_str()) {
+                let mes = mm.as_bytes();
+                unsafe {
+                    solana_program::syscalls::sol_log_(mes.as_ptr(), mes.len() as u64);
+                }
+            }
+
+            if let Some(loc) = info.location() {
+                unsafe {
+                    solana_program::syscalls::sol_panic_(
+                        loc.file().as_ptr(),
+                        loc.file().len() as u64,
+                        loc.line() as u64,
+                        loc.column() as u64,
+                    );
+                }
+            }
+        }
+    };
+}
+
 /// The bump allocator used as the default rust heap when running programs.
 pub struct BumpAllocator {
     pub start: usize,

sdk/program/src/syscalls/definitions.rs

@@ -11,7 +11,7 @@ pub use solana_define_syscall::definitions::{
     sol_curve_group_op, sol_curve_multiscalar_mul, sol_curve_pairing_map, sol_curve_validate_point,
     sol_get_clock_sysvar, sol_get_epoch_rewards_sysvar, sol_get_epoch_schedule_sysvar,
     sol_get_epoch_stake, sol_get_fees_sysvar, sol_get_last_restart_slot, sol_get_rent_sysvar,
-    sol_get_sysvar, sol_keccak256, sol_remaining_compute_units,
+    sol_get_sysvar, sol_keccak256, sol_panic_, sol_remaining_compute_units,
 };
 #[cfg(target_feature = "static-syscalls")]
 pub use solana_define_syscall::sys_hash;