fix_bugs

Author: ColoCarletti

executor/programs/rust/pure_commit/src/main.rs

@@ -1,9 +1,8 @@
-// Minimal Rust program that proves on main:
-// - no_std, no_main (no Rust std runtime)
-// - no allocator (no TLSF init)
-// - no syscalls crate (no Print/Panic ecalls)
-// - Only uses Commit (64) and Halt (93) ecalls, both of which have
-//   receivers on the Ecall bus.
+// Minimal Rust guest program: no_std, no_main, no allocator, no syscalls crate.
+// Uses only raw inline `asm!("ecall")` for Commit (64) and Halt (93).
+// Serves as a control case in the prover test suite (`test_pure_commit_rust`):
+// verifies that Rust can compile to a provable ELF when the heap allocator is
+// bypassed, independent of the Rust-std startup path.
 #![no_std]
 #![no_main]
 

executor/tests/asm.rs

@@ -21,17 +21,6 @@ fn run_program(elf_path: &str) {
     );
 }
 
-#[test]
-fn test_debug_commit_sum_count() {
-    let elf_data = std::fs::read("./program_artifacts/rust/commit_sum.elf").unwrap();
-    let program = Elf::load(&elf_data).unwrap();
-    let executor = Executor::new(&program, vec![3u8, 5u8]).unwrap();
-    let result = executor.run().unwrap();
-    eprintln!("Instructions: {}", result.logs.len());
-    eprintln!("Output: {:?}", result.return_values.memory_values);
-    assert_eq!(result.return_values.memory_values, vec![8u8]);
-}
-
 /// Test that the memory-mapped private input region is readable by guest programs.
 /// The ASM program reads from 0xFF000000 and commits 8 bytes of data.
 #[test]

executor/tests/ethrex_empty_block.bin

@@ -493,8 +493,12 @@ pub fn prove(elf_bytes: &[u8]) -> Result<VmProof, Error> {
 
 /// Prove an ELF binary execution with a private input.
 ///
-/// The `private_input` bytes are passed to the executor; the guest program
-/// retrieves them via the `GetPrivateInputs` syscall.
+/// The `private_input` bytes are pre-loaded at `PRIVATE_INPUT_START_INDEX`
+/// (`0xFF000000`) as an initial memory segment (4-byte LE length prefix +
+/// data). The guest reads them via normal RISC-V loads — see
+/// `syscalls::syscalls::get_private_input`. The bytes are also included in
+/// the returned `VmProof` so the verifier can reconstruct the matching PAGE
+/// preprocessed commitments.
 pub fn prove_with_input(elf_bytes: &[u8], private_input: Vec<u8>) -> Result<VmProof, Error> {
     prove_with_options(
         elf_bytes,

prover/src/lib.rs

@@ -181,8 +181,14 @@ impl ShiftOperation {
         let left = !self.direction;
         let right = self.direction;
 
-        // is_negative = MSB of in[3]
-        let is_negative = (self.in_halves[3] >> 15) & 1 == 1;
+        // is_negative is the MSB of in[3] BUT gated by `signed`. The SHIFT
+        // AIR constrains IS_NEGATIVE via the MSB16 bus (SHIFT-C14) only when
+        // `signed = 1` — for `signed = 0` IS_NEGATIVE is free, so we set it
+        // to zero. This makes `extension = 65535 * is_negative = 0` for SRL,
+        // so the extension contribution in `compute_shifted_half` naturally
+        // vanishes (zero fill) — matching RISC-V SRL semantics regardless of
+        // the top-bit value of the input.
+        let is_negative = self.signed && (self.in_halves[3] >> 15) & 1 == 1;
         let extension: u16 = if is_negative { 0xFFFF } else { 0 };
 
         // bit_shift
@@ -642,7 +648,11 @@ impl ShiftConstraint {
         let left = &mu - &dir; // μ - direction
         let right = dir;
 
-        // extension = 65535 * is_negative
+        // extension = 65535 * is_negative (virtual; matches SHIFT-C7 HWSL send).
+        // The IS_NEGATIVE column is only constrained by MSB16 when signed=1
+        // (SHIFT-C14's bus send is gated by SIGNED). For SRL (signed=0) the
+        // trace sets IS_NEGATIVE=0 explicitly so extension=0 → x[4]=0 → no
+        // spurious extension bleed into `shifted`.
         let is_neg = step.get_main_evaluation_element(0, cols::IS_NEGATIVE);
         let extension = is_neg * FieldElement::<F>::from(65535u64);
 

prover/src/tables/shift.rs

@@ -1343,19 +1343,14 @@ fn collect_byte_check_ops_for_padding(num_padding_rows: usize) -> Vec<BitwiseOpe
     ops
 }
 
-/// Collects IS_BYTE lookups from PAGE data (init and fini values).
-///
-/// Each PAGE byte generates 2 IS_BYTE lookups:
-/// - C1: IS_BYTE[init] for initialization range check
-/// - C2: IS_BYTE[fini] for finalization range check
-///
-/// This must be called BEFORE bitwise multiplicities are updated.
-/// Build a page_base → init_data map from the ELF segments and the private input region.
+/// Build a `page_base → init_data` map from the ELF segments and the private
+/// input region.
 ///
-/// The private input is laid out at `PRIVATE_INPUT_START_INDEX` as a 4-byte LE length
-/// prefix followed by the raw bytes (matching `Memory::store_private_inputs` and
-/// `MemoryState::add_private_input`). Both the prover (trace generation) and verifier
-/// (page config reconstruction) call this so they agree on PAGE init values exactly.
+/// The private input is laid out at `PRIVATE_INPUT_START_INDEX` as a 4-byte LE
+/// length prefix followed by the raw bytes (matching
+/// `Memory::store_private_inputs` and `MemoryState::add_private_input`). Both
+/// the prover (trace generation) and verifier (page config reconstruction) call
+/// this so they agree on PAGE init values exactly.
 fn build_init_page_data(elf: &Elf, private_input: &[u8]) -> HashMap<u64, Vec<u8>> {
     use executor::vm::memory::PRIVATE_INPUT_START_INDEX;
     let page_size = page::DEFAULT_PAGE_SIZE;
@@ -1400,6 +1395,13 @@ fn build_init_page_data(elf: &Elf, private_input: &[u8]) -> HashMap<u64, Vec<u8>
     init_page_data
 }
 
+/// Collects IS_BYTE lookups from PAGE data (init and fini values).
+///
+/// Each PAGE byte generates 2 IS_BYTE lookups:
+/// - C1: IS_BYTE[init] for initialization range check
+/// - C2: IS_BYTE[fini] for finalization range check
+///
+/// This must be called BEFORE bitwise multiplicities are updated.
 fn collect_bitwise_from_page(
     elf: &Elf,
     memory_state: &MemoryState,
@@ -1694,11 +1696,13 @@ impl Traces {
         }
     }
 
-    /// Extract page configurations from ELF only (deterministic from binary).
+    /// Extract page configurations for the deterministic portion of memory:
+    /// ELF segments and the private-input region at `PRIVATE_INPUT_START_INDEX`.
     ///
-    /// Returns PageConfigs for pages covered by ELF segments, with their
-    /// init data populated. Used by the verifier to reconstruct the ELF
-    /// portion of the PAGE table layout.
+    /// Returns PageConfigs for every page covered by an ELF segment or by the
+    /// private-input bytes, with init data populated. Used by the verifier to
+    /// reconstruct these pages (runtime-only pages like stack/heap come from
+    /// `page_configs_from_elf_and_runtime`).
     pub fn page_configs_from_elf(elf: &Elf, private_input: &[u8]) -> Vec<PageConfig> {
         let page_size = page::DEFAULT_PAGE_SIZE;
         let init_page_data = build_init_page_data(elf, private_input);

prover/src/tables/trace_builder.rs

@@ -668,7 +668,15 @@ impl DecodeEntry {
             }
 
             Instruction::CSR { .. } => {
-                // CSR instructions not yet supported in prover
+                // CSR instructions are executed as no-ops by the VM (see
+                // `executor/src/vm/instruction/execution.rs` Instruction::CSR arm
+                // returning `dst_val: 0, src1/2_val: 0`). Mirror that here by
+                // treating them as `ADDI x0, x0, 0` — same pattern as `Fence`.
+                // This sets `op_add=true` so CM54's "1 - pad" (sum of ALU flags)
+                // multiplicity is non-zero and the CPU's PC-update Memw sender
+                // fires to match the MEMW_R PC row that
+                // `collect_register_ops_from_cpu` unconditionally emits.
+                entry.op_add = true;
             }
 
             Instruction::EcallEbreak => {

prover/src/tables/types.rs

@@ -1981,14 +1981,7 @@ fn test_verify_rejects_tampered_private_input() {
 
 /// End-to-end test: prove+verify a Rust program (commit_sum) with private input.
 /// commit_sum reads input[0] + input[1] and commits the u8 sum.
-///
-/// NOTE: currently ignored because Rust std programs hit a pre-existing
-/// Memory/Shift bus imbalance (likely from `init_allocator`'s TLSF heap setup).
-/// This is unrelated to the private input handling — confirmed by running the
-/// ASM tests above (`test_prove_private_input_xpage` etc.) which exercise the
-/// full memory-mapped private input path and verify correctly.
 #[test]
-#[ignore = "Blocked on pre-existing Rust std allocator bus imbalance (not private-input related)"]
 fn test_prove_commit_sum() {
     let workspace_root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
         .parent()
@@ -2006,6 +1999,28 @@ fn test_prove_commit_sum() {
     assert_eq!(proof.public_output, vec![8u8]); // 3 + 5
 }
 
+/// Regression test: a minimal Rust std program that uses `init_allocator()`
+/// and `String::from("Hello World") + commit`. Exercises the full stack:
+/// TLSF heap init, SRL on high-bit-set values (fixed in `shift::compute_aux`)
+/// and CSR instructions (fixed in `DecodeEntry::from(Instruction::CSR)`).
+#[test]
+fn test_prove_allocator_minimal_reproducer() {
+    let _ = env_logger::builder().is_test(true).try_init();
+    let workspace_root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .to_path_buf();
+    let elf_bytes =
+        std::fs::read(workspace_root.join("executor/program_artifacts/rust/allocator.elf"))
+            .unwrap();
+    let proof = crate::prove(&elf_bytes).expect("prove should succeed");
+    assert!(
+        crate::verify(&proof, &elf_bytes).expect("verify should not error"),
+        "allocator.elf should verify"
+    );
+    assert_eq!(proof.public_output, b"Hello World");
+}
+
 /// Minimal Rust program that proves on main: no_std, no_main,
 /// no syscalls crate → only Commit + Halt ecalls (both have receivers).
 /// Demonstrates that Rust CAN prove when it avoids Print/Panic.