From 53ddb72ac127bed340ae551c2a4dfec464dc099e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ole=20Kr=C3=BCger?= Date: Thu, 3 Apr 2025 12:55:06 +0100 Subject: [PATCH] RISC-V: Prefer `new` over `allocate` with `bind` --- src/riscv/lib/src/interpreter/branching.rs | 17 ++- src/riscv/lib/src/interpreter/integer.rs | 15 ++- src/riscv/lib/src/interpreter/load_store.rs | 7 +- src/riscv/lib/src/interpreter/rv32a.rs | 8 +- src/riscv/lib/src/interpreter/rv32c.rs | 7 +- src/riscv/lib/src/interpreter/rv32i.rs | 16 ++- src/riscv/lib/src/interpreter/rv32m.rs | 7 +- src/riscv/lib/src/interpreter/rv64a.rs | 2 - src/riscv/lib/src/interpreter/rv64c.rs | 8 +- src/riscv/lib/src/interpreter/rv64d.rs | 8 +- src/riscv/lib/src/interpreter/rv64dc.rs | 7 +- src/riscv/lib/src/interpreter/rv64f.rs | 8 +- src/riscv/lib/src/interpreter/rv64i.rs | 7 +- src/riscv/lib/src/interpreter/rv64m.rs | 7 +- src/riscv/lib/src/interpreter/rv64priv.rs | 6 +- src/riscv/lib/src/jit.rs | 18 ++-- src/riscv/lib/src/machine_state.rs | 101 ++++++------------ .../lib/src/machine_state/block_cache.rs | 54 +++++++--- .../src/machine_state/block_cache/bcall.rs | 10 +- .../src/machine_state/block_cache/metrics.rs | 14 --- .../lib/src/machine_state/csregisters.rs | 9 +- .../lib/src/machine_state/memory/buddy.rs | 9 +- .../lib/src/machine_state/memory/state.rs | 5 +- src/riscv/lib/src/machine_state/registers.rs | 7 +- src/riscv/lib/src/pvm/common.rs | 25 ++--- src/riscv/lib/src/pvm/linux.rs | 83 +++++--------- src/riscv/lib/src/state_backend.rs | 50 ++------- src/riscv/lib/src/state_backend/layout.rs | 15 ++- .../lib/src/state_backend/owned_backend.rs | 13 +-- src/riscv/lib/src/state_backend/region.rs | 49 +++------ 30 files changed, 227 insertions(+), 365 deletions(-) diff --git a/src/riscv/lib/src/interpreter/branching.rs b/src/riscv/lib/src/interpreter/branching.rs index 49c677810006..12a9049410be 100644 --- a/src/riscv/lib/src/interpreter/branching.rs +++ b/src/riscv/lib/src/interpreter/branching.rs @@ -234,7 +234,6 @@ mod tests { use proptest::prelude::*; use crate::backend_test; - use crate::create_state; use crate::instruction_context::Predicate; use crate::interpreter::branching::run_j_absolute; use crate::interpreter::branching::run_jal; @@ -243,11 +242,11 @@ mod tests { use crate::interpreter::branching::run_jalr_imm; use crate::interpreter::branching::run_jr_imm; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::ProgramCounterUpdate; use crate::machine_state::memory::M4K; use crate::machine_state::registers::nz; use crate::parser::instruction::InstrWidth; + use crate::state::NewState; backend_test!(test_jalr, F, { let ipc_imm_irs1_rs1_rd_fpc_frd = [ @@ -273,7 +272,7 @@ mod tests { ), ]; for (init_pc, imm, init_rs1, rs1, rd, res_pc, res_rd) in ipc_imm_irs1_rs1_rd_fpc_frd { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // TEST JalrImm state.hart.pc.write(init_pc); @@ -336,7 +335,7 @@ mod tests { ]; for (init_pc, imm, res, rd) in pc_imm_res_rd { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); state.hart.pc.write(init_pc); super::run_add_immediate_to_pc(&mut state, imm, rd); @@ -392,7 +391,7 @@ mod tests { let next_pcu = ProgramCounterUpdate::Next(InstrWidth::Uncompressed); let init_pcu = ProgramCounterUpdate::Set(init_pc); - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // BEQ: different test_branch!(state, Predicate::Equal, imm, nz::t1, r1_val, nz::t2, r2_val, width, init_pc, &next_pcu); @@ -438,7 +437,7 @@ mod tests { let next_pcu = ProgramCounterUpdate::Next(InstrWidth::Uncompressed); let init_pcu = ProgramCounterUpdate::Set(init_pc); - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // lhs < rhs test_branch!(state, Predicate::LessThanSigned, imm, nz::t1, 0, nz::t2, 1, width, init_pc, &branch_pcu); @@ -478,7 +477,7 @@ mod tests { let width = InstrWidth::Uncompressed; let next_pcu = ProgramCounterUpdate::Next(InstrWidth::Uncompressed); - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // lhs < 0 test_branch_compare_zero!(state, Predicate::LessThanSigned, imm, nz::t1, -1_i64 as u64, width, init_pc, &branch_pcu); @@ -515,7 +514,7 @@ mod tests { let next_pcu = ProgramCounterUpdate::Next(InstrWidth::Uncompressed); let pc_update_init_pcu = ProgramCounterUpdate::Set(init_pc); - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // lhs < rhs test_branch!(state, Predicate::LessThanUnsigned, imm, nz::t1, r1_val, nz::t2, r2_val, width, init_pc, &branch_pcu); @@ -566,7 +565,7 @@ mod tests { let next_pcu = ProgramCounterUpdate::Next(InstrWidth::Uncompressed); let init_pcu = ProgramCounterUpdate::Set(init_pc); - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // BEQZ if r1_val == 0 { diff --git a/src/riscv/lib/src/interpreter/integer.rs b/src/riscv/lib/src/interpreter/integer.rs index bc594501dd8f..4109360a2b5a 100644 --- a/src/riscv/lib/src/interpreter/integer.rs +++ b/src/riscv/lib/src/interpreter/integer.rs @@ -358,10 +358,8 @@ mod tests { use super::*; use crate::backend_test; - use crate::create_state; use crate::instruction_context::Shift; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::memory::M4K; use crate::machine_state::registers::a0; use crate::machine_state::registers::a1; @@ -370,6 +368,7 @@ mod tests { use crate::machine_state::registers::t0; use crate::machine_state::registers::t1; use crate::machine_state::registers::t3; + use crate::state::NewState; backend_test!(test_negate, F, { let rs2val_rd_res = [ @@ -379,7 +378,7 @@ mod tests { ]; for (rs2, rd, res) in rs2val_rd_res { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); state.hart.xregisters.write_nz(nz::a0, rs2); run_neg(&mut state, rd, nz::a0); @@ -398,7 +397,7 @@ mod tests { ]; for (imm, rs1, res) in imm_rs1_res { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); state.hart.xregisters.write_nz(nz::a3, rs1); state.hart.xregisters.write_nz(nz::a4, imm as u64); @@ -431,7 +430,7 @@ mod tests { ]; for (imm, rs1, rd, res) in imm_rs1_rd_res { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); state.hart.xregisters.write_nz(nz::a0, rs1); state.hart.xregisters.write_nz(nz::t0, imm as u64); @@ -455,7 +454,7 @@ mod tests { v1 in any::(), v2 in any::())| { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); state.hart.xregisters.write(t0, v1 as u64); state.hart.xregisters.write(a0, v2 as u64); run_sub_word(&mut state, t0, a0, nz::a1); @@ -470,7 +469,7 @@ mod tests { }); backend_test!(test_set_less_than, F, { - let mut core = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut core = MachineCoreState::::new(&mut F::manager()); let v1_v2_exp_expu = [ (0, 0, 0, 0), @@ -548,7 +547,7 @@ mod tests { } backend_test!(test_shift, F, { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // imm = 0 test_both_shift_instr!(state, Shift::Left, t0, 0, a0, 0x1234_ABEF, a1, 0x1234_ABEF); diff --git a/src/riscv/lib/src/interpreter/load_store.rs b/src/riscv/lib/src/interpreter/load_store.rs index 4858fdb94894..9fa2bc907850 100644 --- a/src/riscv/lib/src/interpreter/load_store.rs +++ b/src/riscv/lib/src/interpreter/load_store.rs @@ -64,14 +64,13 @@ mod test { use proptest::proptest; use crate::backend_test; - use crate::create_state; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::memory::M4K; use crate::machine_state::registers::a2; use crate::machine_state::registers::a3; use crate::machine_state::registers::a4; use crate::machine_state::registers::nz; + use crate::state::NewState; backend_test!(test_run_li, F, { let imm_rdrs1_res = [ @@ -81,7 +80,7 @@ mod test { ]; for (imm, rd_rs1, res) in imm_rdrs1_res { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); super::run_li(&mut state, imm, rd_rs1); assert_eq!(state.hart.xregisters.read_nz(rd_rs1), res); } @@ -89,7 +88,7 @@ mod test { backend_test!(test_lui, F, { proptest!(|(imm in any::())| { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); state.hart.xregisters.write(a2, 0); state.hart.xregisters.write(a4, 0); diff --git a/src/riscv/lib/src/interpreter/rv32a.rs b/src/riscv/lib/src/interpreter/rv32a.rs index d91707533d4a..4f572cb21c0d 100644 --- a/src/riscv/lib/src/interpreter/rv32a.rs +++ b/src/riscv/lib/src/interpreter/rv32a.rs @@ -228,12 +228,10 @@ mod test { use proptest::prelude::*; use crate::backend_test; - use crate::create_state; use crate::interpreter::atomics::SC_FAILURE; use crate::interpreter::atomics::SC_SUCCESS; use crate::interpreter::integer::run_addi; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::registers::a0; use crate::machine_state::registers::a1; use crate::machine_state::registers::a2; @@ -244,8 +242,9 @@ mod test { backend_test!($name, F, { use $crate::machine_state::registers::nz; use $crate::machine_state::memory::M4K; + use $crate::state::NewState; - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( @@ -289,8 +288,9 @@ mod test { ($instr: ident, $f: expr, $align: expr, $t: ident) => { backend_test!($instr, F, { use $crate::machine_state::memory::M4K; + use $crate::state::NewState; - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( diff --git a/src/riscv/lib/src/interpreter/rv32c.rs b/src/riscv/lib/src/interpreter/rv32c.rs index 48eab8e3b09c..f544a28ca737 100644 --- a/src/riscv/lib/src/interpreter/rv32c.rs +++ b/src/riscv/lib/src/interpreter/rv32c.rs @@ -47,13 +47,12 @@ where #[cfg(test)] mod tests { use crate::backend_test; - use crate::create_state; use crate::interpreter::branching::run_j; use crate::interpreter::branching::run_jr; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::memory::M4K; use crate::machine_state::registers::nz; + use crate::state::NewState; backend_test!(test_run_j, F, { let test_case = [ @@ -64,7 +63,7 @@ mod tests { (u64::MAX - 1, 100, 98_i64 as u64), ]; for (init_pc, imm, res_pc) in test_case { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); state.hart.pc.write(init_pc); let new_pc = run_j(&mut state, imm); @@ -86,7 +85,7 @@ mod tests { ), ]; for (init_pc, init_rs1, rs1, res_pc) in scenarios { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // Test C.JR // save program counter and value for rs1. diff --git a/src/riscv/lib/src/interpreter/rv32i.rs b/src/riscv/lib/src/interpreter/rv32i.rs index 23e0970bb025..7001992e09a2 100644 --- a/src/riscv/lib/src/interpreter/rv32i.rs +++ b/src/riscv/lib/src/interpreter/rv32i.rs @@ -91,19 +91,16 @@ mod tests { use proptest::proptest; use crate::backend_test; - use crate::create_state; use crate::interpreter::integer::run_and; use crate::interpreter::integer::run_andi; use crate::interpreter::integer::run_or; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::csregisters::CSRRepr; use crate::machine_state::csregisters::CSRegister; use crate::machine_state::csregisters::xstatus::MPPValue; use crate::machine_state::csregisters::xstatus::MStatus; use crate::machine_state::csregisters::xstatus::SPPValue; use crate::machine_state::hart_state::HartState; - use crate::machine_state::hart_state::HartStateLayout; use crate::machine_state::memory::Address; use crate::machine_state::memory::M4K; use crate::machine_state::mode::Mode; @@ -116,11 +113,12 @@ mod tests { use crate::machine_state::registers::t2; use crate::machine_state::registers::t3; use crate::parser::instruction::FenceSet; + use crate::state::NewState; use crate::traps::Exception; backend_test!(test_bitwise, F, { proptest!(|(val in any::(), imm in any::())| { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // The sign-extension of an immediate on 12 bits has bits 31:11 equal the sign-bit let prefix_mask = 0xFFFF_FFFF_FFFF_F800; @@ -156,7 +154,7 @@ mod tests { backend_test!(test_bitwise_reg, F, { // TODO: RV-512: move to integer.rs once all are supported. proptest!(|(v1 in any::(), v2 in any::())| { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); state.hart.xregisters.write(a0, v1); state.hart.xregisters.write(t3, v2); @@ -185,14 +183,14 @@ mod tests { }); backend_test!(test_ebreak, F, { - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let state = MachineCoreState::::new(&mut F::manager()); let ret_val = state.hart.run_ebreak(); assert_eq!(ret_val, Exception::Breakpoint); }); backend_test!(test_fence, F, { - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( @@ -214,7 +212,7 @@ mod tests { }); backend_test!(test_ecall, F, { - let mut state = create_state!(HartState, F); + let mut state = HartState::new(&mut F::manager()); let mode_exc = [ (Mode::User, Exception::EnvCallFromUMode), @@ -235,7 +233,7 @@ mod tests { mepc in any::
(), sepc in any::
(), )| { - let mut state = create_state!(HartState, F); + let mut state = HartState::new(&mut F::manager()); // 4-byte align let mepc = mepc & !0b11; diff --git a/src/riscv/lib/src/interpreter/rv32m.rs b/src/riscv/lib/src/interpreter/rv32m.rs index 07318ccc9627..7c7bcd14acb0 100644 --- a/src/riscv/lib/src/interpreter/rv32m.rs +++ b/src/riscv/lib/src/interpreter/rv32m.rs @@ -132,20 +132,19 @@ mod test { use proptest::proptest; use crate::backend_test; - use crate::create_state; use crate::machine_state::registers::XRegisters; - use crate::machine_state::registers::XRegistersLayout; use crate::machine_state::registers::a0; use crate::machine_state::registers::a1; use crate::machine_state::registers::a2; use crate::machine_state::registers::a3; + use crate::state::NewState; backend_test!(test_div_rem_invariant, F, { proptest!(|( r1_val in any::(), r2_val in any::(), )| { - let mut state = create_state!(XRegisters, F); + let mut state = XRegisters::new(&mut F::manager()); state.write(a0, r1_val); state.write(a1, r2_val); @@ -165,7 +164,7 @@ mod test { r1_val in any::(), r2_val in any::(), )| { - let mut state = create_state!(XRegisters, F); + let mut state = XRegisters::new(&mut F::manager()); state.write(a0, r1_val); state.write(a1, r2_val); diff --git a/src/riscv/lib/src/interpreter/rv64a.rs b/src/riscv/lib/src/interpreter/rv64a.rs index 29f0deefd299..87b6f2864bdd 100644 --- a/src/riscv/lib/src/interpreter/rv64a.rs +++ b/src/riscv/lib/src/interpreter/rv64a.rs @@ -228,12 +228,10 @@ mod test { use proptest::prelude::*; use crate::backend_test; - use crate::create_state; use crate::interpreter::atomics::SC_FAILURE; use crate::interpreter::atomics::SC_SUCCESS; use crate::interpreter::integer::run_addi; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::registers::a0; use crate::machine_state::registers::a1; use crate::machine_state::registers::a2; diff --git a/src/riscv/lib/src/interpreter/rv64c.rs b/src/riscv/lib/src/interpreter/rv64c.rs index bf694d2abf15..7057cf4399d7 100644 --- a/src/riscv/lib/src/interpreter/rv64c.rs +++ b/src/riscv/lib/src/interpreter/rv64c.rs @@ -54,16 +54,14 @@ mod tests { use proptest::proptest; use crate::backend_test; - use crate::create_state; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::hart_state::HartState; - use crate::machine_state::hart_state::HartStateLayout; use crate::machine_state::memory::M4K; use crate::machine_state::registers::a3; use crate::machine_state::registers::a4; use crate::machine_state::registers::nz; use crate::machine_state::registers::t0; + use crate::state::NewState; use crate::traps::Exception; backend_test!(test_caddiw, F, { @@ -71,7 +69,7 @@ mod tests { imm in any::(), reg_val in any::())| { - let mut state = create_state!(HartState, F); + let mut state = HartState::new(&mut F::manager()); state.xregisters.write_nz(nz::a0, reg_val as u64); state.xregisters.run_caddiw(imm, nz::a0); @@ -86,7 +84,7 @@ mod tests { }); backend_test!(test_run_cldsp_clwsp, F, { - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( diff --git a/src/riscv/lib/src/interpreter/rv64d.rs b/src/riscv/lib/src/interpreter/rv64d.rs index 158c006560bf..12d91fca5926 100644 --- a/src/riscv/lib/src/interpreter/rv64d.rs +++ b/src/riscv/lib/src/interpreter/rv64d.rs @@ -551,24 +551,22 @@ mod tests { use crate::backend_test; use crate::bits::Bits64; - use crate::create_state; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::csregisters::CSRegister; use crate::machine_state::csregisters::xstatus::ExtensionValue; use crate::machine_state::csregisters::xstatus::MStatus; use crate::machine_state::hart_state::HartState; - use crate::machine_state::hart_state::HartStateLayout; use crate::machine_state::memory::M4K; use crate::machine_state::registers::fa2; use crate::machine_state::registers::fa3; use crate::machine_state::registers::parse_fregister; use crate::machine_state::registers::parse_xregister; use crate::machine_state::registers::t0; + use crate::state::NewState; use crate::traps::Exception; backend_test!(test_fmv_d, F, { - let state = create_state!(HartState, HartStateLayout, F); + let state = HartState::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( @@ -596,7 +594,7 @@ mod tests { }); backend_test!(test_load_store, F, { - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( diff --git a/src/riscv/lib/src/interpreter/rv64dc.rs b/src/riscv/lib/src/interpreter/rv64dc.rs index e067a91f2b1d..b978fee93259 100644 --- a/src/riscv/lib/src/interpreter/rv64dc.rs +++ b/src/riscv/lib/src/interpreter/rv64dc.rs @@ -76,9 +76,7 @@ mod test { use crate::backend_test; use crate::bits::Bits64; - use crate::create_state; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::csregisters::CSRegister; use crate::machine_state::csregisters::xstatus::ExtensionValue; use crate::machine_state::csregisters::xstatus::MStatus; @@ -88,6 +86,7 @@ mod test { use crate::machine_state::registers::fa3; use crate::machine_state::registers::parse_xregister; use crate::machine_state::registers::sp; + use crate::state::NewState; use crate::traps::Exception; const ZERO_OFFSET: i64 = 0; @@ -97,7 +96,7 @@ mod test { const OUT_OF_BOUNDS_OFFSET: i64 = MC::TOTAL_BYTES as i64; backend_test!(test_cfsd_cfld, F, { - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, MC); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( @@ -137,7 +136,7 @@ mod test { }); backend_test!(test_cfsdsp_cfldsp, F, { - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, MC); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( diff --git a/src/riscv/lib/src/interpreter/rv64f.rs b/src/riscv/lib/src/interpreter/rv64f.rs index 077da7b28d66..a04bc32de5e5 100644 --- a/src/riscv/lib/src/interpreter/rv64f.rs +++ b/src/riscv/lib/src/interpreter/rv64f.rs @@ -562,20 +562,18 @@ mod tests { use super::f32_to_fvalue; use crate::backend_test; use crate::bits::Bits64; - use crate::create_state; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::csregisters::CSRegister; use crate::machine_state::csregisters::xstatus::ExtensionValue; use crate::machine_state::csregisters::xstatus::MStatus; use crate::machine_state::hart_state::HartState; - use crate::machine_state::hart_state::HartStateLayout; use crate::machine_state::memory::M4K; use crate::machine_state::registers::fa1; use crate::machine_state::registers::fa4; use crate::machine_state::registers::parse_fregister; use crate::machine_state::registers::parse_xregister; use crate::machine_state::registers::t0; + use crate::state::NewState; use crate::traps::Exception; backend_test!(test_fmv_f, F, { @@ -585,7 +583,7 @@ mod tests { rs1_f in (1_u8..31).prop_map(u5::new).prop_map(parse_fregister), rs2 in (1_u8..31).prop_map(u5::new).prop_map(parse_xregister), )| { - let mut state = create_state!(HartState, HartStateLayout, F); + let mut state = HartState::new(&mut F::manager()); // Turn fs on let mstatus = MStatus::from_bits(0u64).with_fs(ExtensionValue::Dirty); @@ -616,7 +614,7 @@ mod tests { }); backend_test!(test_load_store, F, { - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( diff --git a/src/riscv/lib/src/interpreter/rv64i.rs b/src/riscv/lib/src/interpreter/rv64i.rs index 68b262d964cb..21dfe7a0ecd3 100644 --- a/src/riscv/lib/src/interpreter/rv64i.rs +++ b/src/riscv/lib/src/interpreter/rv64i.rs @@ -316,9 +316,7 @@ mod tests { use proptest::proptest; use crate::backend_test; - use crate::create_state; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::memory::M4K; use crate::machine_state::registers::a0; use crate::machine_state::registers::a1; @@ -331,6 +329,7 @@ mod tests { use crate::machine_state::registers::t2; use crate::machine_state::registers::t3; use crate::machine_state::registers::t4; + use crate::state::NewState; use crate::traps::Exception; macro_rules! test_shift_instr { @@ -388,7 +387,7 @@ mod tests { } backend_test!(test_shift_w, F, { - let mut state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); // imm = 0 test_both_shift_instr!( @@ -533,7 +532,7 @@ mod tests { }); backend_test!(test_load_store, F, { - let state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let state = MachineCoreState::::new(&mut F::manager()); let state_cell = std::cell::RefCell::new(state); proptest!(|( diff --git a/src/riscv/lib/src/interpreter/rv64m.rs b/src/riscv/lib/src/interpreter/rv64m.rs index 51ca9225ad9b..b67e983597c1 100644 --- a/src/riscv/lib/src/interpreter/rv64m.rs +++ b/src/riscv/lib/src/interpreter/rv64m.rs @@ -105,20 +105,19 @@ mod test { use proptest::proptest; use crate::backend_test; - use crate::create_state; use crate::machine_state::registers::XRegisters; - use crate::machine_state::registers::XRegistersLayout; use crate::machine_state::registers::a0; use crate::machine_state::registers::a1; use crate::machine_state::registers::a2; use crate::machine_state::registers::a3; + use crate::state::NewState; backend_test!(test_div_rem_invariant, F, { proptest!(|( r1_val in any::(), r2_val in any::(), )| { - let mut state = create_state!(XRegisters, F); + let mut state = XRegisters::new(&mut F::manager()); state.write(a0, r1_val); state.write(a1, r2_val); @@ -138,7 +137,7 @@ mod test { r1_val in any::(), r2_val in any::(), )| { - let mut state = create_state!(XRegisters, F); + let mut state = XRegisters::new(&mut F::manager()); state.write(a0, r1_val); state.write(a1, r2_val); diff --git a/src/riscv/lib/src/interpreter/rv64priv.rs b/src/riscv/lib/src/interpreter/rv64priv.rs index 07e70da2bdd4..a6675f36c073 100644 --- a/src/riscv/lib/src/interpreter/rv64priv.rs +++ b/src/riscv/lib/src/interpreter/rv64priv.rs @@ -135,9 +135,7 @@ where #[cfg(test)] mod tests { use crate::backend_test; - use crate::create_state; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::csregisters::CSRRepr; use crate::machine_state::csregisters::CSRegister; use crate::machine_state::csregisters::xstatus; @@ -145,11 +143,11 @@ mod tests { use crate::machine_state::mode::Mode; use crate::machine_state::registers::a0; use crate::machine_state::registers::t0; + use crate::state::NewState; use crate::traps::Exception; backend_test!(test_sfence, F, { - type L = MachineCoreStateLayout; - let mut state = create_state!(MachineCoreState, L, F, M4K); + let mut state = MachineCoreState::::new(&mut F::manager()); let run_test = |state: &mut MachineCoreState<_, _>, mode: Mode, diff --git a/src/riscv/lib/src/jit.rs b/src/riscv/lib/src/jit.rs index bbdd42f9229c..50af5a94568e 100644 --- a/src/riscv/lib/src/jit.rs +++ b/src/riscv/lib/src/jit.rs @@ -280,13 +280,10 @@ mod tests { use super::*; use crate::backend_test; - use crate::create_state; use crate::instruction_context::LoadStoreWidth; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::block_cache::bcall::BCall; use crate::machine_state::block_cache::bcall::Block; - use crate::machine_state::block_cache::bcall::BlockLayout; use crate::machine_state::block_cache::bcall::Interpreted; use crate::machine_state::block_cache::bcall::InterpretedBlockBuilder; use crate::machine_state::memory::M4K; @@ -298,6 +295,7 @@ mod tests { use crate::machine_state::registers::nz; use crate::parser::instruction::InstrWidth; use crate::parser::instruction::InstrWidth::*; + use crate::state::NewState; use crate::state_backend::FnManagerIdent; use crate::state_backend::ManagerRead; use crate::state_backend::test_helpers::TestBackendFactory; @@ -341,17 +339,17 @@ mod tests { interpreted_bb: &mut InterpretedBlockBuilder, ) { // Create the states for the interpreted and jitted runs. - let mut interpreted = - create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut manager = F::manager(); + let mut interpreted = MachineCoreState::::new(&mut manager); interpreted.main_memory.set_all_readable_writeable(); - let mut jitted = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); + let mut jitted = MachineCoreState::::new(&mut manager); jitted.main_memory.set_all_readable_writeable(); let hash = super::Hash::blake2b_hash(&self.instructions).unwrap(); // Create the block of instructions. - let mut block = create_state!(Interpreted, BlockLayout, F, M4K); + let mut block = Interpreted::::new(&mut manager); block.start_block(); for instr in self.instructions.iter() { block.push_instr(*instr); @@ -1594,11 +1592,13 @@ mod tests { let success: &[I] = &[I::new_nop(Compressed)]; let success_hash = super::Hash::blake2b_hash(success).unwrap(); + let mut manager = F::manager(); + for failure in failure_scenarios.iter() { let mut jit = JIT::::new().unwrap(); - let mut jitted = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); - let mut block = create_state!(Interpreted, BlockLayout, F, M4K); + let mut jitted = MachineCoreState::::new(&mut manager); + let mut block = Interpreted::::new(&mut manager); let failure_hash = super::Hash::blake2b_hash(failure).unwrap(); block.start_block(); diff --git a/src/riscv/lib/src/machine_state.rs b/src/riscv/lib/src/machine_state.rs index f11494bf691c..d46d35edb8e7 100644 --- a/src/riscv/lib/src/machine_state.rs +++ b/src/riscv/lib/src/machine_state.rs @@ -725,7 +725,6 @@ mod tests { use super::registers::XRegister; use crate::backend_test; use crate::bits::u16; - use crate::create_state; use crate::default::ConstDefault; use crate::machine_state::DefaultCacheLayouts; use crate::machine_state::TestCacheLayouts; @@ -762,13 +761,10 @@ mod tests { use crate::traps::TrapContext; backend_test!(test_step, F, { - let state = create_state!( - MachineState, - MachineStateLayout, - F, - M4K, - DefaultCacheLayouts, - Interpreted, || InterpretedBlockBuilder); + let state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let state_cell = std::cell::RefCell::new(state); @@ -813,13 +809,10 @@ mod tests { }); backend_test!(test_step_env_exc, F, { - let state = create_state!( - MachineState, - MachineStateLayout, - F, - M4K, - DefaultCacheLayouts, - Interpreted, || InterpretedBlockBuilder); + let state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let state_cell = std::cell::RefCell::new(state); @@ -854,13 +847,10 @@ mod tests { }); backend_test!(test_step_exc_mm, F, { - let state = create_state!( - MachineState, - MachineStateLayout, - F, - M4K, - DefaultCacheLayouts, - Interpreted, || InterpretedBlockBuilder); + let state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let state_cell = std::cell::RefCell::new(state); @@ -899,13 +889,10 @@ mod tests { }); backend_test!(test_step_exc_us, F, { - let state = create_state!( - MachineState, - MachineStateLayout, - F, - M4K, - DefaultCacheLayouts, - Interpreted, || InterpretedBlockBuilder); + let state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let state_cell = std::cell::RefCell::new(state); @@ -983,15 +970,11 @@ mod tests { // Configure the machine state. let base_state = { - let mut state = create_state!( - MachineState, - LocalLayout, - F, - M4K, - TestCacheLayouts, - BlockRunner, - || InterpretedBlockBuilder + let mut state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, ); + state.reset(); state.core.main_memory.set_all_readable_writeable(); @@ -1244,14 +1227,9 @@ mod tests { // Configure the state backend. let base_state = { - let mut state = create_state!( - MachineState, - LocalLayout, - F, - M1M, - TestCacheLayouts, - BlockRunner, - || InterpretedBlockBuilder + let mut state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, ); state.reset(); state.core.main_memory.set_all_readable_writeable(); @@ -1334,13 +1312,10 @@ mod tests { // Ensure that cloning the machine state does not result in a stack overflow backend_test!(test_machine_state_cloneable, F, { - let state = create_state!( - MachineState, - MachineStateLayout, - F, - M1M, - DefaultCacheLayouts, - Interpreted, || InterpretedBlockBuilder); + let state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let second = state.clone(); @@ -1351,13 +1326,10 @@ mod tests { }); backend_test!(test_block_cache_crossing_pages_creates_new_block, F, { - let mut state = create_state!( - MachineState, - MachineStateLayout, - F, - M8K, - DefaultCacheLayouts, - Interpreted, || InterpretedBlockBuilder); + let mut state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let uncompressed_bytes = 0x5307b3; @@ -1513,13 +1485,10 @@ mod tests { let block_b_addr = phys_addr + 128; - let mut state = create_state!( - MachineState, - MachineStateLayout, - F, - M8K, - DefaultCacheLayouts, - Interpreted, || InterpretedBlockBuilder); + let mut state = MachineState::, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); state.core.main_memory.set_all_readable_writeable(); diff --git a/src/riscv/lib/src/machine_state/block_cache.rs b/src/riscv/lib/src/machine_state/block_cache.rs index 34bb656f037f..1948bb6488f7 100644 --- a/src/riscv/lib/src/machine_state/block_cache.rs +++ b/src/riscv/lib/src/machine_state/block_cache.rs @@ -904,12 +904,9 @@ fn run_instr( mod tests { use super::*; use crate::backend_test; - use crate::create_state; use crate::default::ConstDefault; use crate::machine_state::MachineCoreState; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::MachineState; - use crate::machine_state::MachineStateLayout; use crate::machine_state::TestCacheLayouts; use crate::machine_state::address_translation::PAGE_SIZE; use crate::machine_state::block_cache::bcall::Interpreted; @@ -933,7 +930,10 @@ mod tests { // writing CACHE_INSTR to the block cache creates new block backend_test!(test_writing_full_block_fetchable_uncompressed, F, { - let mut state = create_state!(BlockCache, TestLayout, F, TestLayout, Interpreted, M4K, || InterpretedBlockBuilder); + let mut state = BlockCache::, _, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let uncompressed = Instruction::try_from(TaggedInstruction { opcode: OpCode::Sd, @@ -959,7 +959,10 @@ mod tests { }); backend_test!(test_writing_full_block_fetchable_compressed, F, { - let mut state = create_state!(BlockCache, TestLayout, F, TestLayout, Interpreted, M4K, || InterpretedBlockBuilder); + let mut state = BlockCache::, _, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let compressed = Instruction::try_from(TaggedInstruction { opcode: OpCode::Li, @@ -987,7 +990,10 @@ mod tests { // writing instructions immediately creates block backend_test!(test_writing_half_block_fetchable_compressed, F, { - let mut state = create_state!(BlockCache, TestLayout, F, TestLayout, Interpreted, M4K, || InterpretedBlockBuilder); + let mut state = BlockCache::, _, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let compressed = Instruction::try_from(TaggedInstruction { opcode: OpCode::Li, @@ -1014,7 +1020,10 @@ mod tests { }); backend_test!(test_writing_two_blocks_fetchable_compressed, F, { - let mut state = create_state!(BlockCache, TestLayout, F, TestLayout, Interpreted, M4K, || InterpretedBlockBuilder); + let mut state = BlockCache::, _, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let compressed = Instruction::try_from(TaggedInstruction { opcode: OpCode::Li, @@ -1046,7 +1055,10 @@ mod tests { // writing across pages offset two blocks next to each other backend_test!(test_crossing_page_exactly_creates_new_block, F, { - let mut state = create_state!(BlockCache, TestLayout, F, TestLayout, Interpreted, M4K, || InterpretedBlockBuilder); + let mut state = BlockCache::, _, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let compressed = Instruction::try_from(TaggedInstruction { opcode: OpCode::Li, @@ -1077,8 +1089,12 @@ mod tests { }); backend_test!(test_partial_block_executes, F, { - let mut core_state = create_state!(MachineCoreState, MachineCoreStateLayout, F, M4K); - let mut block_state = create_state!(BlockCache, TestLayout, F, TestLayout, Interpreted, M4K, || InterpretedBlockBuilder); + let mut manager = F::manager(); + let mut core_state = MachineCoreState::::new(&mut manager); + let mut block_state = BlockCache::, _, _>::new( + &mut manager, + InterpretedBlockBuilder, + ); let addiw = Instruction::try_from(TaggedInstruction { opcode: OpCode::AddWordImmediate, @@ -1150,7 +1166,10 @@ mod tests { }); backend_test!(test_concat_blocks_suitable, F, { - let mut state = create_state!(BlockCache, TestLayout, F, TestLayout, Interpreted, M4K, || InterpretedBlockBuilder); + let mut state = BlockCache::, _, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let uncompressed = Instruction::try_from(TaggedInstruction { opcode: OpCode::Sd, @@ -1188,7 +1207,10 @@ mod tests { }); backend_test!(test_concat_blocks_too_big, F, { - let mut state = create_state!(BlockCache, TestLayout, F, TestLayout, Interpreted, M4K, || InterpretedBlockBuilder); + let mut state = BlockCache::, _, _>::new( + &mut F::manager(), + InterpretedBlockBuilder, + ); let uncompressed = Instruction::try_from(TaggedInstruction { opcode: OpCode::Sd, @@ -1264,7 +1286,7 @@ mod tests { }; let mut block: BlockCache, M4K, Owned> = - BlockCache::bind(Owned::allocate::(), InterpretedBlockBuilder); + BlockCache::new(&mut Owned, InterpretedBlockBuilder); // The initial block cache should not return any blocks. check_block(&mut block); @@ -1290,10 +1312,8 @@ mod tests { /// be empty, which causes the step function to loop indefinitely when it runs the block. #[test] fn test_run_addr_zero() { - type StateLayout = MachineStateLayout; - let mut state: MachineState, Owned> = - MachineState::bind(Owned::allocate::(), InterpretedBlockBuilder); + MachineState::new(&mut Owned, InterpretedBlockBuilder); // Encoding of ECALL instruction const ECALL: u32 = 0b1110011; @@ -1317,7 +1337,7 @@ mod tests { type Layout = super::Layout; let mut block_cache: BlockCache, M4K, Owned> = - BlockCache::bind(Owned::allocate::(), InterpretedBlockBuilder); + BlockCache::new(&mut Owned, InterpretedBlockBuilder); // Fetching empty block fails assert!(block_cache.get_block(0).is_none()); diff --git a/src/riscv/lib/src/machine_state/block_cache/bcall.rs b/src/riscv/lib/src/machine_state/block_cache/bcall.rs index b2c53a9729f2..bad45f9c29d4 100644 --- a/src/riscv/lib/src/machine_state/block_cache/bcall.rs +++ b/src/riscv/lib/src/machine_state/block_cache/bcall.rs @@ -540,16 +540,15 @@ pub(super) fn block_hash( mod test { use super::Block; use super::BlockHash; - use super::BlockLayout; use super::InlineJit; use super::Interpreted; use crate::backend_test; - use crate::create_state; use crate::machine_state::block_cache::metrics::BlockMetrics; use crate::machine_state::instruction::Instruction; use crate::machine_state::memory::M4K; use crate::machine_state::registers::nz; use crate::parser::instruction::InstrWidth; + use crate::state::NewState; use crate::state_backend::test_helpers::TestBackendFactory; macro_rules! run_in_block_impl { @@ -557,8 +556,9 @@ mod test { type M = ::Manager; // use block metrics, since interpreted has no hash - let $block_name = - &mut BlockMetrics::wrap(create_state!(Interpreted, BlockLayout, $F, M4K)); + let $block_name = &mut >> as NewState>>::new( + &mut <$F>::manager(), + ); let $bb_name = &mut > as Block>>::BlockBuilder::default(); { @@ -566,7 +566,7 @@ mod test { } // use jit, which has the hash - let $block_name = &mut create_state!(InlineJit, BlockLayout, $F, M4K); + let $block_name = &mut InlineJit::::new(&mut <$F>::manager()); let $bb_name = &mut > as Block>>::BlockBuilder::default(); diff --git a/src/riscv/lib/src/machine_state/block_cache/metrics.rs b/src/riscv/lib/src/machine_state/block_cache/metrics.rs index 6feeb476e6e2..9b67ebbd771d 100644 --- a/src/riscv/lib/src/machine_state/block_cache/metrics.rs +++ b/src/riscv/lib/src/machine_state/block_cache/metrics.rs @@ -279,20 +279,6 @@ pub struct BlockMetrics { block_hash: BlockHash, } -impl BlockMetrics { - /// Wrap a block with metrics. - /// - /// Since BlockMetrics doesn't take a `M: ManagerBase` as a type-parameter, - /// we can't use it with `create_state!`. - #[cfg(test)] - pub(super) fn wrap(block: B) -> Self { - Self { - block, - block_hash: BlockHash::Dirty, - } - } -} - impl, M: ManagerBase> NewState for BlockMetrics { fn new(manager: &mut M) -> Self where diff --git a/src/riscv/lib/src/machine_state/csregisters.rs b/src/riscv/lib/src/machine_state/csregisters.rs index eb35eecd12ef..d91acf48aec4 100644 --- a/src/riscv/lib/src/machine_state/csregisters.rs +++ b/src/riscv/lib/src/machine_state/csregisters.rs @@ -1689,15 +1689,14 @@ mod tests { use crate::backend_test; use crate::bits::Bits64; - use crate::create_state; use crate::machine_state::csregisters::CSRRepr; use crate::machine_state::csregisters::CSRegister; use crate::machine_state::csregisters::CSRegisters; - use crate::machine_state::csregisters::CSRegistersLayout; use crate::machine_state::csregisters::Exception; use crate::machine_state::csregisters::values::CSRValue; use crate::machine_state::csregisters::xstatus::MStatus; use crate::machine_state::mode::Mode; + use crate::state::NewState; use crate::traps::Interrupt; use crate::traps::TrapContext; @@ -1913,7 +1912,7 @@ mod tests { } backend_test!(test_write_read, F, { - let mut csrs = create_state!(CSRegisters, CSRegistersLayout, F); + let mut csrs = CSRegisters::new(&mut F::manager()); // write to MBE, SXL, UXL, MPP, MPIE, XS, SPP (through mstatus) csrs.write( @@ -2023,7 +2022,7 @@ mod tests { }); backend_test!(test_xip_xie, F, { - let mut csrs = create_state!(CSRegisters, CSRegistersLayout, F); + let mut csrs = CSRegisters::new(&mut F::manager()); let mtip: u64 = 1 << Interrupt::MachineTimer.exception_code(); let msip: u64 = 1 << Interrupt::MachineSoftware.exception_code(); @@ -2042,7 +2041,7 @@ mod tests { }); backend_test!(test_fcsr, F, { - let mut csrs = create_state!(CSRegisters, CSRegistersLayout, F); + let mut csrs = CSRegisters::new(&mut F::manager()); // check starting values assert_eq!(0, csrs.read::(CSRegister::fcsr)); diff --git a/src/riscv/lib/src/machine_state/memory/buddy.rs b/src/riscv/lib/src/machine_state/memory/buddy.rs index 7ff48c0dcf9f..091ffbbd1226 100644 --- a/src/riscv/lib/src/machine_state/memory/buddy.rs +++ b/src/riscv/lib/src/machine_state/memory/buddy.rs @@ -128,7 +128,8 @@ mod tests { backend_test!(buddy_alloc_only, F, { type BuddyHeapLayout = BuddyLayoutProxy<{ 1024 * 1024 }>; - let mut state = BuddyHeapLayout::bind(F::allocate::()); + let mut manager = F::manager(); + let mut state = ::Buddy::new(&mut manager); state.deep_refresh(); let total_pages = state.longest_free_sequence(); @@ -153,7 +154,8 @@ mod tests { backend_test!(buddy_alloc_dealloc, F, { type BuddyHeapLayout = BuddyLayoutProxy<{ 1024 * 1024 }>; - let mut state = BuddyHeapLayout::bind(F::allocate::()); + let mut manager = F::manager(); + let mut state = ::Buddy::new(&mut manager); state.deep_refresh(); let total_pages = state.longest_free_sequence(); @@ -188,7 +190,8 @@ mod tests { backend_test!(buddy_alloc_fixed, F, { type BuddyHeapLayout = BuddyLayoutProxy<{ 1024 * 1024 }>; - let mut state = BuddyHeapLayout::bind(F::allocate::()); + let mut manager = F::manager(); + let mut state = ::Buddy::new(&mut manager); state.deep_refresh(); // Create a distribution of allocation sizes that when used together would allocate all diff --git a/src/riscv/lib/src/machine_state/memory/state.rs b/src/riscv/lib/src/machine_state/memory/state.rs index a4f2982dce85..5ef587ea4671 100644 --- a/src/riscv/lib/src/machine_state/memory/state.rs +++ b/src/riscv/lib/src/machine_state/memory/state.rs @@ -368,6 +368,7 @@ pub mod tests { use crate::backend_test; use crate::machine_state::memory::M4K; use crate::machine_state::memory::MemoryConfig; + use crate::state::NewState; use crate::state_backend::owned_backend::Owned; #[test] @@ -390,8 +391,8 @@ pub mod tests { } backend_test!(test_endianess, F, { - let space = F::allocate::<::Layout>(); - let mut memory = M4K::bind(space); + let mut manager = F::manager(); + let mut memory = <::State<_>>::new(&mut manager); memory .write_instruction_unchecked(0, 0x1122334455667788u64) diff --git a/src/riscv/lib/src/machine_state/registers.rs b/src/riscv/lib/src/machine_state/registers.rs index 816ee0bc212a..9c4a5199cd4b 100644 --- a/src/riscv/lib/src/machine_state/registers.rs +++ b/src/riscv/lib/src/machine_state/registers.rs @@ -650,10 +650,9 @@ mod tests { use super::*; use crate::backend_test; - use crate::create_state; backend_test!(test_zero, F, { - let mut registers = create_state!(XRegisters, XRegistersLayout, F); + let mut registers = XRegisters::new(&mut F::manager()); // x0 should always read 0. assert_eq!(registers.read(x0), 0); @@ -669,7 +668,7 @@ mod tests { ]; backend_test!(test_arbitrary_register, F, { - let mut registers = create_state!(XRegisters, XRegistersLayout, F); + let mut registers = XRegisters::new(&mut F::manager()); // Initialise the registers with something. for reg in NONZERO_REGISTERS { @@ -695,7 +694,7 @@ mod tests { }); backend_test!(test_try_read_u32, F, { - let mut registers = create_state!(XRegisters, XRegistersLayout, F); + let mut registers = XRegisters::new(&mut F::manager()); // Reading an integer that is too large should fail registers.write(x1, 1 << 32); diff --git a/src/riscv/lib/src/pvm/common.rs b/src/riscv/lib/src/pvm/common.rs index dbb8203e84a9..a9d4ebc5c026 100644 --- a/src/riscv/lib/src/pvm/common.rs +++ b/src/riscv/lib/src/pvm/common.rs @@ -534,7 +534,6 @@ mod tests { use super::*; use crate::backend_test; - use crate::create_state; use crate::machine_state::TestCacheLayouts; use crate::machine_state::block_cache::bcall::InterpretedBlockBuilder; use crate::machine_state::memory; @@ -556,12 +555,10 @@ mod tests { #[test] fn test_read_input() { type MC = M1M; - type L = PvmLayout; type B = bcall::Interpreted; // Setup PVM - let space = Owned::allocate::(); - let mut pvm = Pvm::::bind(space, InterpretedBlockBuilder); + let mut pvm = Pvm::::new(&mut Owned, InterpretedBlockBuilder); pvm.reset(); pvm.machine_state .core @@ -662,15 +659,13 @@ mod tests { #[cfg(not(feature = "supervisor"))] fn test_write_debug() { type MC = M1M; - type L = PvmLayout; type B = bcall::Interpreted; let mut buffer = Vec::new(); let mut hooks = PvmHooks::new(|c| buffer.push(c)); // Setup PVM - let space = Owned::allocate::(); - let mut pvm = Pvm::::bind(space, InterpretedBlockBuilder); + let mut pvm = Pvm::::new(&mut Owned, InterpretedBlockBuilder); pvm.reset(); pvm.machine_state .core @@ -716,15 +711,13 @@ mod tests { written: [u8; WRITTEN_SIZE], )|{ type MC = M1M; - type L = PvmLayout; type B = bcall::Interpreted; let mut buffer = Vec::new(); let mut hooks = PvmHooks::new(|c| buffer.push(c)); // Setup PVM - let space = Owned::allocate::(); - let mut pvm = Pvm::::bind(space, InterpretedBlockBuilder); + let mut pvm = Pvm::::new(&mut Owned, InterpretedBlockBuilder); pvm.reset(); pvm.machine_state .core @@ -771,13 +764,11 @@ mod tests { backend_test!(test_reveal, F, { type MC = M1M; - type L = PvmLayout; type B = bcall::Interpreted::Manager>; // Setup PVM - let mut pvm = create_state!(Pvm, L, F, MC, TestCacheLayouts, B, || { - InterpretedBlockBuilder - }); + let mut pvm = + Pvm::, _>::new(&mut F::manager(), InterpretedBlockBuilder); pvm.reset(); pvm.machine_state .core @@ -848,13 +839,11 @@ mod tests { backend_test!(test_reveal_insufficient_buffer_size, F, { type MC = M1M; - type L = PvmLayout; type B = bcall::Interpreted::Manager>; // Setup PVM - let mut pvm = create_state!(Pvm, L, F, MC, TestCacheLayouts, B, || { - InterpretedBlockBuilder - }); + let mut pvm = + Pvm::, _>::new(&mut F::manager(), InterpretedBlockBuilder); pvm.reset(); pvm.machine_state .core diff --git a/src/riscv/lib/src/pvm/linux.rs b/src/riscv/lib/src/pvm/linux.rs index aba59a6a7e20..8deb4568f7fb 100644 --- a/src/riscv/lib/src/pvm/linux.rs +++ b/src/riscv/lib/src/pvm/linux.rs @@ -926,8 +926,6 @@ mod tests { use super::*; use crate::backend_test; - use crate::create_state; - use crate::machine_state::MachineCoreStateLayout; use crate::machine_state::memory::M4K; /// Default handler for the `on_tezos` parameter of [`SupervisorState::handle_system_call`] @@ -947,14 +945,9 @@ mod tests { type MemLayout = M4K; const MEM_BYTES: usize = MemLayout::TOTAL_BYTES; - let mut machine_state = create_state!( - MachineCoreState, - MachineCoreStateLayout, - F, - MemLayout - ); - - let mut supervisor_state = create_state!(SupervisorState, SupervisorStateLayout, F); + let mut manager = F::manager(); + let mut machine_state = MachineCoreState::::new(&mut manager); + let mut supervisor_state = SupervisorState::new(&mut manager); machine_state .hart @@ -981,12 +974,8 @@ mod tests { backend_test!(ppoll_init_fds, F, { type MemLayout = M4K; - let mut machine_state = create_state!( - MachineCoreState, - MachineCoreStateLayout, - F, - MemLayout - ); + let mut manager = F::manager(); + let mut machine_state = MachineCoreState::::new(&mut manager); machine_state.reset(); // Make sure everything is readable and writable. Otherwise, we'd get access faults. @@ -996,7 +985,7 @@ mod tests { .unwrap(); for fd in [0i32, 1, 2] { - let mut supervisor_state = create_state!(SupervisorState, SupervisorStateLayout, F); + let mut supervisor_state = SupervisorState::new(&mut manager); let base_address = 0x10; machine_state.main_memory.write(base_address, fd).unwrap(); @@ -1040,12 +1029,8 @@ mod tests { backend_test!(rt_sigaction_no_handler, F, { type MemLayout = M4K; - let mut machine_state = create_state!( - MachineCoreState, - MachineCoreStateLayout, - F, - MemLayout - ); + let mut manager = F::manager(); + let mut machine_state = MachineCoreState::::new(&mut manager); machine_state.reset(); // Make sure everything is readable and writable. Otherwise, we'd get access faults. @@ -1054,7 +1039,7 @@ mod tests { .protect_pages(0, MemLayout::TOTAL_BYTES, Permissions::ReadWrite) .unwrap(); - let mut supervisor_state = create_state!(SupervisorState, SupervisorStateLayout, F); + let mut supervisor_state = SupervisorState::new(&mut manager); // System call number machine_state @@ -1098,13 +1083,9 @@ mod tests { backend_test!(sigaltstack_zero_parameter, F, { type MemLayout = M4K; - let mut machine_state = create_state!( - MachineCoreState, - MachineCoreStateLayout, - F, - MemLayout - ); - let mut supervisor_state = create_state!(SupervisorState, SupervisorStateLayout, F); + let mut manager = F::manager(); + let mut machine_state = MachineCoreState::::new(&mut manager); + let mut supervisor_state = SupervisorState::new(&mut manager); // System call number machine_state @@ -1128,13 +1109,9 @@ mod tests { backend_test!(rt_sigaction_zero_parameter, F, { type MemLayout = M4K; - let mut machine_state = create_state!( - MachineCoreState, - MachineCoreStateLayout, - F, - MemLayout - ); - let mut supervisor_state = create_state!(SupervisorState, SupervisorStateLayout, F); + let mut manager = F::manager(); + let mut machine_state = MachineCoreState::::new(&mut manager); + let mut supervisor_state = SupervisorState::new(&mut manager); // System call number machine_state @@ -1165,13 +1142,9 @@ mod tests { backend_test!(rt_sigprocmask_zero_parameter, F, { type MemLayout = M4K; - let mut machine_state = create_state!( - MachineCoreState, - MachineCoreStateLayout, - F, - MemLayout - ); - let mut supervisor_state = create_state!(SupervisorState, SupervisorStateLayout, F); + let mut manager = F::manager(); + let mut machine_state = MachineCoreState::::new(&mut manager); + let mut supervisor_state = SupervisorState::new(&mut manager); // System call number machine_state @@ -1202,12 +1175,8 @@ mod tests { backend_test!(clock_gettime_fills_with_zeros, F, { type MemLayout = M4K; - let mut machine_state = create_state!( - MachineCoreState, - MachineCoreStateLayout, - F, - MemLayout - ); + let mut manager = F::manager(); + let mut machine_state = MachineCoreState::::new(&mut manager); machine_state.reset(); // Make sure everything is readable and writable. Otherwise, we'd get access faults. @@ -1216,7 +1185,7 @@ mod tests { .protect_pages(0, MemLayout::TOTAL_BYTES, Permissions::ReadWrite) .unwrap(); - let mut supervisor_state = create_state!(SupervisorState, SupervisorStateLayout, F); + let mut supervisor_state = SupervisorState::new(&mut manager); // System call number machine_state @@ -1265,12 +1234,8 @@ mod tests { backend_test!(gettimeofday_fills_with_zeros, F, { type MemLayout = M4K; - let mut machine_state = create_state!( - MachineCoreState, - MachineCoreStateLayout, - F, - MemLayout - ); + let mut manager = F::manager(); + let mut machine_state = MachineCoreState::::new(&mut manager); machine_state.reset(); // Make sure everything is readable and writable. Otherwise, we'd get access faults. @@ -1279,7 +1244,7 @@ mod tests { .protect_pages(0, MemLayout::TOTAL_BYTES, Permissions::ReadWrite) .unwrap(); - let mut supervisor_state = create_state!(SupervisorState, SupervisorStateLayout, F); + let mut supervisor_state = SupervisorState::new(&mut manager); // System call number machine_state diff --git a/src/riscv/lib/src/state_backend.rs b/src/riscv/lib/src/state_backend.rs index ab69d094293c..96e485f18208 100644 --- a/src/riscv/lib/src/state_backend.rs +++ b/src/riscv/lib/src/state_backend.rs @@ -409,6 +409,7 @@ pub type RefVerifierAlloc<'a, L> = AllocatedOf() -> AllocatedOf; + /// Construct a manager. + fn manager() -> Self::Manager; } /// Copy the allocated space by serialising and deserialising it. @@ -485,6 +487,7 @@ pub mod tests { use self::owned_backend::Owned; use super::*; use crate::backend_test; + use crate::state::NewState; /// Run `f` twice against two different randomised backends and see if the /// resulting backend state is the same afterwards. @@ -496,53 +499,20 @@ pub mod tests { // TODO: RV-46: This test will be re-introduced but customised for initialisation testing. } - /// Given a `State`, optionally its `StateLayout`, - /// a [`TestBackendFactory`] type, a `backend` created with `create_backend!` macro, - /// create the location and return the created `State`. - #[macro_export] - macro_rules! create_state { - // For an extra generic in the state (MachineState for example) - ($State:tt, $StateLayout:ty, $Factory:ty $(, $ExtraGenerics:ty)* $(, || $arg: expr)*) => { - { - let new_state = - $State::< - $($ExtraGenerics,)* - <$Factory as $crate::state_backend::test_helpers::TestBackendFactory>::Manager, - >::bind( - <$Factory as $crate::state_backend::test_helpers::TestBackendFactory>::allocate::<$StateLayout>(), - $($arg,)* - ); - - new_state - } - }; - - ($State:tt, $Factory:ty) => { - create_state!($State, paste::paste!([<$State Layout>]), $Factory) - }; - } - backend_test!(test_example, F, { struct Example { first: Cell, second: Cells, } - type ExampleLayout = (Atom, Array); - - impl Example { - fn bind(space: AllocatedOf) -> Self { - Example { - first: space.0, - second: space.1, - } - } - } - let first_value: u64 = rand::random(); let second_value: [u32; 4] = rand::random(); - let mut instance = create_state!(Example, ExampleLayout, F); + let mut manager = F::manager(); + let mut instance = Example { + first: Cell::new(&mut manager), + second: Cells::new(&mut manager), + }; instance.first.write(first_value); assert_eq!(instance.first.read(), first_value); diff --git a/src/riscv/lib/src/state_backend/layout.rs b/src/riscv/lib/src/state_backend/layout.rs index cd9cc6ca2df8..4d9c6b7ef857 100644 --- a/src/riscv/lib/src/state_backend/layout.rs +++ b/src/riscv/lib/src/state_backend/layout.rs @@ -382,6 +382,9 @@ mod tests { use super::*; use crate::backend_test; use crate::default::ConstDefault; + use crate::state::NewState; + use crate::state_backend::Cell; + use crate::state_backend::Cells; use crate::state_backend::CommitmentLayout; use crate::state_backend::FnManagerIdent; use crate::state_backend::ProofLayout; @@ -399,13 +402,16 @@ mod tests { // Test that the Atom layout initialises the underlying Cell correctly. backend_test!(test_cell_init, F, { - assert_eq!(F::allocate::>().read(), MyFoo::DEFAULT); + assert_eq!( + Cell::::new(&mut F::manager()).read(), + MyFoo::DEFAULT + ); }); // Test that the Array layout initialises the underlying Cells correctly. backend_test!(test_cells_init, F, { assert_eq!( - F::allocate::>().read_all(), + Cells::::new(&mut F::manager()).read_all(), [MyFoo::DEFAULT; 1337] ); }); @@ -420,7 +426,10 @@ mod tests { } fn inner(bar: u64, qux: [u8; 64]) { - let mut foo = Owned::allocate::(); + let mut foo = AllocatedOf:: { + bar: Cell::new(&mut Owned), + qux: Cells::new(&mut Owned), + }; foo.bar.write(bar); foo.qux.write_all(&qux); diff --git a/src/riscv/lib/src/state_backend/owned_backend.rs b/src/riscv/lib/src/state_backend/owned_backend.rs index 9b978c141520..25f412d401b5 100644 --- a/src/riscv/lib/src/state_backend/owned_backend.rs +++ b/src/riscv/lib/src/state_backend/owned_backend.rs @@ -11,11 +11,9 @@ use std::mem::MaybeUninit; use serde::ser::SerializeTuple; -use super::AllocatedOf; use super::Elem; use super::EnrichedValue; use super::EnrichedValueLinked; -use super::Layout; use super::ManagerAlloc; use super::ManagerBase; use super::ManagerClone; @@ -30,13 +28,6 @@ use super::StaticCopy; #[derive(Clone, Copy, Debug)] pub struct Owned; -impl Owned { - /// Allocate regions for the given layout. - pub fn allocate() -> AllocatedOf { - L::allocate(&mut Self) - } -} - impl ManagerBase for Owned { type Region = [E; LEN]; @@ -364,8 +355,8 @@ pub mod test_helpers { impl TestBackendFactory for OwnedTestBackendFactory { type Manager = Owned; - fn allocate() -> AllocatedOf { - Owned::allocate::() + fn manager() -> Self::Manager { + Owned } } diff --git a/src/riscv/lib/src/state_backend/region.rs b/src/riscv/lib/src/state_backend/region.rs index 3b381daa65b4..fd247e403695 100644 --- a/src/riscv/lib/src/state_backend/region.rs +++ b/src/riscv/lib/src/state_backend/region.rs @@ -674,14 +674,12 @@ pub(crate) mod tests { use crate::backend_test; use crate::default::ConstDefault; - use crate::state_backend::Array; + use crate::state::NewState; + use crate::state_backend::Cell; + use crate::state_backend::Cells; use crate::state_backend::DynCells; use crate::state_backend::Elem; use crate::state_backend::FnManagerIdent; - use crate::state_backend::ManagerAlloc; - use crate::state_backend::ManagerBase; - use crate::state_backend::layout::Atom; - use crate::state_backend::layout::Layout; /// Dummy type that helps us implement custom normalisation via [Elem] #[repr(C, packed)] @@ -733,9 +731,10 @@ pub(crate) mod tests { backend_test!(test_region_overlap, F, { const LEN: usize = 64; - type OurLayout = (Array, Array); - let (mut array1, mut array2) = F::allocate::(); + let mut manager = F::manager(); + let mut array1: Cells = Cells::new(&mut manager); + let mut array2: Cells = Cells::new(&mut manager); // Allocate two consecutive arrays // let mut array1 = manager.allocate_region(array1_place); @@ -776,8 +775,9 @@ pub(crate) mod tests { }); backend_test!(test_cell_overlap, F, { - type OurLayout = (Atom<[u64; 4]>, Atom<[u64; 4]>); - let (mut cell1, mut cell2) = F::allocate::(); + let mut manager = F::manager(); + let mut cell1: Cell<[u64; 4], _> = Cell::new(&mut manager); + let mut cell2: Cell<[u64; 4], _> = Cell::new(&mut manager); // Cell should be zero-initialised. assert_eq!(cell1.read(), [0; 4]); @@ -807,17 +807,8 @@ pub(crate) mod tests { { const LEN: usize = 8; - struct FlipperLayout; - - impl Layout for FlipperLayout { - type Allocated = DynCells; - - fn allocate(backend: &mut M) -> Self::Allocated { - DynCells::bind(backend.allocate_dyn_region()) - } - } - - let mut state = F::allocate::(); + let mut manager = F::manager(); + let mut state = DynCells::::new(&mut manager); // This should panic because we are trying to write an element at the address which // corresponds to the end of the buffer. @@ -826,18 +817,9 @@ pub(crate) mod tests { ); backend_test!(test_dynregion_stored_format, F, { - struct FlipperLayout; - - impl Layout for FlipperLayout { - type Allocated = DynCells<1024, B>; - - fn allocate(backend: &mut B) -> Self::Allocated { - DynCells::bind(backend.allocate_dyn_region()) - } - } - // Writing to one item of the region must convert to stored format. - let mut region = F::allocate::(); + let mut manager = F::manager(); + let mut region = DynCells::<1024, _>::new(&mut manager); region.write(0, Flipper { a: 13, b: 37 }); assert_eq!(region.read::(0), Flipper { a: 13, b: 37 }); @@ -867,10 +849,9 @@ pub(crate) mod tests { }); backend_test!(test_region_stored_format, F, { - type FlipperLayout = Array; - // Writing to one item of the region must convert to stored format. - let mut region = F::allocate::(); + let mut manager = F::manager(); + let mut region = Cells::::new(&mut manager); region.write(0, Flipper { a: 13, b: 37 }); assert_eq!(region.read(0), Flipper { a: 13, b: 37 }); -- GitLab