Add SBPFv1 tests to the CI pipeline (#5126)

* Add SBPFv1 to the CI pipeline

* Tune instruction count

* Check upper bound instead of fixed number of instructions

* Verify zeroed stack with dynamic stack frames

* Use constants to estimate length of zeroed bytes

* Remove comment

(cherry picked from commit b704875)

# Conflicts:
#	programs/sbf/tests/programs.rs

Author: LucasSte

ci/test-stable.sh

@@ -55,9 +55,12 @@ test-stable-sbf)
   # Install the platform tools
   _ platform-tools-sdk/sbf/scripts/install.sh
 
-  # SBF program tests
+  # SBPFv0 program tests
   _ make -C programs/sbf test-v0
 
+  # SBPFv1 program tests
+  _ make -C programs/sbf clean-all test-v1
+
   exit 0
   ;;
 test-docs)

programs/sbf/Makefile

@@ -2,13 +2,27 @@ SBF_SDK_PATH := ../../platform-tools-sdk/sbf
 SRC_DIR := c/src
 OUT_DIR := target/deploy
 
-test-v0: all rust-v0
+clean-all: clean
+	cargo clean
+
+test:
 	SBF_OUT_DIR=$(OUT_DIR) cargo test --features="sbf_rust,sbf_c" $(TEST_ARGS)
 
+test-v1:
+	SBPF_CPU=v1 $(MAKE) all ; \
+	$(MAKE) rust-v1 ; \
+	$(MAKE) test
+
+test-v0: all rust-v0 test
+
 rust-v0:
 	cargo +solana build --release --target sbpf-solana-solana --workspace ; \
 	cp -r target/sbpf-solana-solana/release/* target/deploy
 
-.PHONY: rust
+rust-v1:
+	cargo +solana build --release --target sbpfv1-solana-solana --workspace --features dynamic-frames ; \
+	cp -r target/sbpfv1-solana-solana/release/* target/deploy
+
+.PHONY: rust-v0
 
 include $(SBF_SDK_PATH)/c/sbf.mk

programs/sbf/rust/invoke/Cargo.toml

@@ -19,3 +19,6 @@ crate-type = ["cdylib"]
 
 [lints]
 workspace = true
+
+[features]
+dynamic-frames = []

programs/sbf/rust/invoke/src/lib.rs

@@ -3,6 +3,8 @@
 #![allow(unreachable_code)]
 #![allow(clippy::arithmetic_side_effects)]
 
+#[cfg(feature = "dynamic-frames")]
+use solana_program::program_memory::sol_memcmp;
 use {
     solana_program::{
         account_info::AccountInfo,
@@ -1456,19 +1458,36 @@ fn process_instruction<'a>(
             heap[8..pos].fill(42);
 
             // Check that the stack is zeroed too.
-            //
+            let stack = unsafe {
+                slice::from_raw_parts_mut(
+                    MM_STACK_START as *mut u8,
+                    MAX_CALL_DEPTH * STACK_FRAME_SIZE,
+                )
+            };
+
+            #[cfg(not(feature = "dynamic-frames"))]
             // We don't know in which frame we are now, so we skip a few (10) frames at the start
             // which might have been used by the current call stack. We check that the memory for
             // the 10..MAX_CALL_DEPTH frames is zeroed. Then we write a sentinel value, and in the
             // next nested invocation check that it's been zeroed.
-            let stack =
-                unsafe { slice::from_raw_parts_mut(MM_STACK_START as *mut u8, 0x100000000) };
+            //
+            // When we don't have dynamic stack frames, the stack grows from lower addresses
+            // to higher addresses, so we compare accordingly.
             for i in 10..MAX_CALL_DEPTH {
                 let stack = &mut stack[i * STACK_FRAME_SIZE..][..STACK_FRAME_SIZE];
                 assert!(stack == &ZEROS[..STACK_FRAME_SIZE], "stack not zeroed");
                 stack.fill(42);
             }
 
+            #[cfg(feature = "dynamic-frames")]
+            // When we have dynamic frames, the stack grows from the higher addresses, so we
+            // compare from zero until the beginning of a function frame.
+            {
+                const ZEROED_BYTES_LENGTH: usize = (MAX_CALL_DEPTH - 2) * STACK_FRAME_SIZE;
+                assert_eq!(sol_memcmp(stack, &ZEROS, ZEROED_BYTES_LENGTH), 0);
+                stack[..ZEROED_BYTES_LENGTH].fill(42);
+            }
+
             // Recurse to check that the stack and heap are zeroed.
             //
             // We recurse until we go over max CPI depth and error out. Stack and heap allocations

programs/sbf/tests/programs.rs

@@ -1266,6 +1266,7 @@ fn assert_instruction_count() {
     #[cfg(feature = "sbf_c")]
     {
         programs.extend_from_slice(&[
+<<<<<<< HEAD
             ("alloc", 19332),
             ("sbf_to_sbf", 316),
             ("multiple_static", 210),
@@ -1277,13 +1278,27 @@ fn assert_instruction_count() {
             ("sanity++", 2296),
             ("secp256k1_recover", 25483),
             ("sha", 1447),
+=======
+            ("alloc", 14575),
+            ("sbf_to_sbf", 313),
+            ("multiple_static", 208),
+            ("noop", 5),
+            ("noop++", 5),
+            ("relative_call", 210),
+            ("return_data", 982),
+            ("sanity", 2377),
+            ("sanity++", 2277),
+            ("secp256k1_recover", 25483),
+            ("sha", 1355),
+>>>>>>> b704875fb (Add SBPFv1 tests to the CI pipeline (#5126))
             ("struct_pass", 108),
             ("struct_ret", 122),
         ]);
     }
     #[cfg(feature = "sbf_rust")]
     {
         programs.extend_from_slice(&[
+<<<<<<< HEAD
             ("solana_sbf_rust_128bit", 969),
             ("solana_sbf_rust_alloc", 5077),
             ("solana_sbf_rust_custom_heap", 304),
@@ -1298,6 +1313,22 @@ fn assert_instruction_count() {
             ("solana_sbf_rust_sanity", 51325),
             ("solana_sbf_rust_secp256k1_recover", 89388),
             ("solana_sbf_rust_sha", 22855),
+=======
+            ("solana_sbf_rust_128bit", 955),
+            ("solana_sbf_rust_alloc", 4784),
+            ("solana_sbf_rust_custom_heap", 270),
+            ("solana_sbf_rust_dep_crate", 2),
+            ("solana_sbf_rust_iter", 1514),
+            ("solana_sbf_rust_many_args", 1289),
+            ("solana_sbf_rust_mem", 1207),
+            ("solana_sbf_rust_membuiltins", 292),
+            ("solana_sbf_rust_noop", 275),
+            ("solana_sbf_rust_param_passing", 108),
+            ("solana_sbf_rust_rand", 264),
+            ("solana_sbf_rust_sanity", 50084),
+            ("solana_sbf_rust_secp256k1_recover", 89217),
+            ("solana_sbf_rust_sha", 22850),
+>>>>>>> b704875fb (Add SBPFv1 tests to the CI pipeline (#5126))
         ]);
     }
 
@@ -1698,7 +1729,11 @@ fn test_program_sbf_invoke_in_same_tx_as_deployment() {
                 // Asserting the instruction number as an upper bound, since the quantity of
                 // instructions depends on the program size, which in turn depends on the SBPF
                 // versions.
+<<<<<<< HEAD
                 assert!(instr_no <= 41);
+=======
+                assert!(instr_no <= 38);
+>>>>>>> b704875fb (Add SBPFv1 tests to the CI pipeline (#5126))
                 assert_eq!(ty, InstructionError::UnsupportedProgramId);
             } else {
                 panic!("Invalid error type");