skip PCS of range table #789: merge master

Cargo.toml

@@ -1,11 +1,11 @@
 [workspace]
-exclude = ["examples"]
 members = [
   "ceno_emul",
   "ceno_host",
   "ceno_rt",
   "ceno_zkvm",
   "examples-builder",
+  "examples",
   "mpcs",
   "multilinear_extensions",
   "poseidon",

ceno_emul/Cargo.toml

@@ -11,6 +11,7 @@ version.workspace = true
 
 [dependencies]
 anyhow.workspace = true
+ceno_rt = { path = "../ceno_rt" }
 elf = "0.7"
 itertools.workspace = true
 num-derive.workspace = true

ceno_emul/src/elf.rs

@@ -18,7 +18,7 @@ extern crate alloc;
 
 use alloc::collections::BTreeMap;
 
-use crate::{addr::WORD_SIZE, disassemble::transpile, rv32im::Instruction};
+use crate::{CENO_PLATFORM, addr::WORD_SIZE, disassemble::transpile, rv32im::Instruction};
 use anyhow::{Context, Result, anyhow, bail};
 use elf::{
     ElfBytes,
@@ -40,6 +40,17 @@ pub struct Program {
     pub image: BTreeMap<u32, u32>,
 }
 
+impl From<&[Instruction]> for Program {
+    fn from(insn_codes: &[Instruction]) -> Program {
+        Self {
+            entry: CENO_PLATFORM.pc_base(),
+            base_address: CENO_PLATFORM.pc_base(),
+            instructions: insn_codes.to_vec(),
+            image: Default::default(),
+        }
+    }
+}
+
 impl Program {
     /// Create program
     pub fn new(
@@ -55,6 +66,7 @@ impl Program {
             image,
         }
     }
+
     /// Initialize a RISC Zero Program from an appropriate ELF file
     pub fn load_elf(input: &[u8], max_mem: u32) -> Result<Program> {
         let mut instructions: Vec<u32> = Vec::new();

ceno_emul/src/platform.rs

@@ -1,4 +1,5 @@
-use std::{collections::BTreeSet, ops::Range};
+use core::fmt::{self, Formatter};
+use std::{collections::BTreeSet, fmt::Display, ops::Range};
 
 use crate::addr::{Addr, RegIdx};
 
@@ -19,6 +20,26 @@ pub struct Platform {
     pub unsafe_ecall_nop: bool,
 }
 
+impl Display for Platform {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let prog_data: Option<Range<Addr>> = match (self.prog_data.first(), self.prog_data.last()) {
+            (Some(first), Some(last)) => Some(*first..*last),
+            _ => None,
+        };
+        write!(
+            f,
+            "Platform {{ rom: {:?}, prog_data: {:?}, stack: {:?}, heap: {:?}, public_io: {:?}, hints: {:?}, unsafe_ecall_nop: {} }}",
+            self.rom,
+            prog_data,
+            self.stack,
+            self.heap,
+            self.public_io,
+            self.hints,
+            self.unsafe_ecall_nop
+        )
+    }
+}
+
 pub const CENO_PLATFORM: Platform = Platform {
     rom: 0x2000_0000..0x3000_0000,
     prog_data: BTreeSet::new(),

ceno_emul/src/syscalls.rs

@@ -6,7 +6,7 @@ pub mod keccak_permute;
 // Using the same function codes as sp1:
 // https://github.com/succinctlabs/sp1/blob/013c24ea2fa15a0e7ed94f7d11a7ada4baa39ab9/crates/core/executor/src/syscalls/code.rs
 
-pub const KECCAK_PERMUTE: u32 = 0x00_01_01_09;
+pub use ceno_rt::syscalls::KECCAK_PERMUTE;
 
 /// Trace the inputs and effects of a syscall.
 pub fn handle_syscall(vm: &VMState, function_code: u32) -> Result<SyscallEffects> {

ceno_host/src/lib.rs

@@ -99,14 +99,19 @@ impl Items {
     }
 }
 
-impl From<&CenoStdin> for Vec<u32> {
-    fn from(stdin: &CenoStdin) -> Vec<u32> {
+impl From<&CenoStdin> for Vec<u8> {
+    fn from(stdin: &CenoStdin) -> Vec<u8> {
         let mut items = Items::default();
         for item in &stdin.items {
             items.append(Item::from(item));
         }
-        items
-            .finalise()
+        items.finalise()
+    }
+}
+
+impl From<&CenoStdin> for Vec<u32> {
+    fn from(stdin: &CenoStdin) -> Vec<u32> {
+        Vec::<u8>::from(stdin)
             .into_iter()
             .tuples()
             .map(|(a, b, c, d)| u32::from_le_bytes([a, b, c, d]))