Cleanup - Move test helpers to test_utils crate

benches/elf_loader.rs

@@ -13,11 +13,11 @@ extern crate test_utils;
 use solana_sbpf::{
     elf::Executable,
     program::{BuiltinFunction, BuiltinProgram, FunctionRegistry},
-    syscalls,
-    vm::{Config, TestContextObject},
+    vm::Config,
 };
 use std::{fs::File, io::Read, sync::Arc};
 use test::Bencher;
+use test_utils::{syscalls, TestContextObject};
 
 fn loader() -> Arc<BuiltinProgram<TestContextObject>> {
     let mut function_registry = FunctionRegistry::<BuiltinFunction<TestContextObject>>::default();

benches/jit_compile.rs

@@ -9,12 +9,10 @@
 extern crate solana_sbpf;
 extern crate test;
 
-use solana_sbpf::{
-    elf::Executable, program::BuiltinProgram, verifier::RequisiteVerifier, vm::TestContextObject,
-};
+use solana_sbpf::{elf::Executable, program::BuiltinProgram, verifier::RequisiteVerifier};
 use std::{fs::File, io::Read, sync::Arc};
 use test::Bencher;
-use test_utils::create_vm;
+use test_utils::{create_vm, TestContextObject};
 
 #[bench]
 fn bench_init_vm(bencher: &mut Bencher) {

benches/vm_execution.rs

@@ -16,12 +16,10 @@ use solana_sbpf::{
     program::{FunctionRegistry, SBPFVersion},
     vm::Config,
 };
-use solana_sbpf::{
-    elf::Executable, program::BuiltinProgram, verifier::RequisiteVerifier, vm::TestContextObject,
-};
+use solana_sbpf::{elf::Executable, program::BuiltinProgram, verifier::RequisiteVerifier};
 use std::{fs::File, io::Read, sync::Arc};
 use test::Bencher;
-use test_utils::create_vm;
+use test_utils::{create_vm, TestContextObject};
 
 #[bench]
 fn bench_init_interpreter_start(bencher: &mut Bencher) {

cli/src/main.rs

@@ -8,9 +8,10 @@ use solana_sbpf::{
     program::{BuiltinProgram, FunctionRegistry},
     static_analysis::Analysis,
     verifier::RequisiteVerifier,
-    vm::{Config, DynamicAnalysis, EbpfVm, TestContextObject},
+    vm::{Config, DynamicAnalysis, EbpfVm},
 };
 use std::{fs::File, io::Read, path::Path, sync::Arc};
+use test_utils::TestContextObject;
 
 fn main() {
     let matches = App::new("Solana BPF CLI")

examples/disassemble.rs

@@ -9,9 +9,9 @@ use solana_sbpf::{
     elf::Executable,
     program::{BuiltinProgram, FunctionRegistry, SBPFVersion},
     static_analysis::Analysis,
-    vm::TestContextObject,
 };
 use std::sync::Arc;
+use test_utils::TestContextObject;
 
 // Simply disassemble a program into human-readable instructions.
 fn main() {

examples/to_json.rs

@@ -15,9 +15,9 @@ use solana_sbpf::{
     elf::Executable,
     program::{BuiltinProgram, FunctionRegistry, SBPFVersion},
     static_analysis::Analysis,
-    vm::TestContextObject,
 };
 use std::sync::Arc;
+use test_utils::TestContextObject;
 // Turn a program into a JSON string.
 //
 // Relies on `json` crate.

fuzz/fuzz_targets/dumb.rs

@@ -10,9 +10,8 @@ use solana_sbpf::{
     memory_region::MemoryRegion,
     program::{BuiltinFunction, BuiltinProgram, FunctionRegistry, SBPFVersion},
     verifier::{RequisiteVerifier, Verifier},
-    vm::TestContextObject,
 };
-use test_utils::create_vm;
+use test_utils::{create_vm, TestContextObject};
 
 use crate::common::ConfigTemplate;
 

fuzz/fuzz_targets/smart.rs

@@ -12,9 +12,8 @@ use solana_sbpf::{
     memory_region::MemoryRegion,
     program::{BuiltinFunction, BuiltinProgram, FunctionRegistry, SBPFVersion},
     verifier::{RequisiteVerifier, Verifier},
-    vm::TestContextObject,
 };
-use test_utils::create_vm;
+use test_utils::{create_vm, TestContextObject};
 
 use crate::common::ConfigTemplate;
 

fuzz/fuzz_targets/smart_jit_diff.rs

@@ -10,9 +10,8 @@ use solana_sbpf::{
     memory_region::MemoryRegion,
     program::{BuiltinFunction, BuiltinProgram, FunctionRegistry, SBPFVersion},
     verifier::{RequisiteVerifier, Verifier},
-    vm::TestContextObject,
 };
-use test_utils::create_vm;
+use test_utils::{create_vm, TestContextObject};
 
 use crate::common::ConfigTemplate;
 

fuzz/fuzz_targets/smarter_jit_diff.rs

@@ -10,9 +10,8 @@ use solana_sbpf::{
     memory_region::MemoryRegion,
     program::{BuiltinFunction, BuiltinProgram, FunctionRegistry, SBPFVersion},
     verifier::{RequisiteVerifier, Verifier},
-    vm::TestContextObject,
 };
-use test_utils::create_vm;
+use test_utils::{create_vm, TestContextObject};
 
 use crate::common::ConfigTemplate;
 

fuzz/fuzz_targets/verify_semantic_aware.rs

@@ -7,8 +7,8 @@ use solana_sbpf::{
     insn_builder::IntoBytes,
     program::{BuiltinFunction, FunctionRegistry, SBPFVersion},
     verifier::{RequisiteVerifier, Verifier},
-    vm::TestContextObject,
 };
+use test_utils::TestContextObject;
 
 use crate::common::ConfigTemplate;
 

src/assembler.rs

@@ -293,7 +293,8 @@ fn resolve_label(
 /// # Examples
 ///
 /// ```
-/// use solana_sbpf::{assembler::assemble, program::BuiltinProgram, vm::{Config, TestContextObject}};
+/// use solana_sbpf::{assembler::assemble, program::BuiltinProgram, vm::Config};
+/// use test_utils::TestContextObject;
 /// let executable = assemble::<TestContextObject>(
 ///    "add64 r1, 0x605
 ///     mov64 r2, 0x32

src/lib.rs

@@ -11,6 +11,7 @@
 
 //! Virtual machine for SBPF programs.
 #![warn(missing_docs)]
+#![allow(clippy::literal_string_with_formatting_args)]
 #![deny(clippy::arithmetic_side_effects)]
 #![deny(clippy::ptr_as_ptr)]
 
@@ -31,7 +32,6 @@ pub mod ebpf;
 pub mod elf;
 pub mod elf_parser;
 pub mod error;
-pub mod fuzz;
 pub mod insn_builder;
 pub mod interpreter;
 #[cfg(all(feature = "jit", not(target_os = "windows"), target_arch = "x86_64"))]
@@ -41,7 +41,6 @@ mod memory_management;
 pub mod memory_region;
 pub mod program;
 pub mod static_analysis;
-pub mod syscalls;
 pub mod verifier;
 pub mod vm;
 #[cfg(all(feature = "jit", not(target_os = "windows"), target_arch = "x86_64"))]

src/static_analysis.rs

@@ -7,7 +7,7 @@ use crate::{
     elf::Executable,
     error::EbpfError,
     program::SBPFVersion,
-    vm::{ContextObject, DynamicAnalysis, TestContextObject},
+    vm::{ContextObject, DynamicAnalysis},
 };
 use rustc_demangle::demangle;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
@@ -124,10 +124,22 @@ impl Default for CfgNode {
     }
 }
 
+struct DummyContextObject {}
+
+impl ContextObject for DummyContextObject {
+    fn trace(&mut self, _state: [u64; 12]) {}
+
+    fn consume(&mut self, _amount: u64) {}
+
+    fn get_remaining(&self) -> u64 {
+        0
+    }
+}
+
 /// Result of the executable analysis
 pub struct Analysis<'a> {
     /// The program which is analyzed
-    executable: &'a Executable<TestContextObject>,
+    executable: &'a Executable<DummyContextObject>,
     /// Plain list of instructions as they occur in the executable
     pub instructions: Vec<ebpf::Insn>,
     /// Functions in the executable
@@ -182,7 +194,7 @@ impl<'a> Analysis<'a> {
         let mut result = Self {
             // Removes the generic ContextObject which is safe because we are not going to execute the program
             executable: unsafe {
-                std::mem::transmute::<&Executable<C>, &Executable<TestContextObject>>(executable)
+                std::mem::transmute::<&Executable<C>, &Executable<DummyContextObject>>(executable)
             },
             instructions,
             functions,

src/vm.rs

@@ -19,7 +19,7 @@ use crate::{
     interpreter::Interpreter,
     memory_region::MemoryMapping,
     program::{BuiltinFunction, BuiltinProgram, FunctionRegistry, SBPFVersion},
-    static_analysis::{Analysis, TraceLogEntry},
+    static_analysis::Analysis,
 };
 use std::{collections::BTreeMap, fmt::Debug};
 
@@ -137,51 +137,6 @@ pub trait ContextObject {
     fn get_remaining(&self) -> u64;
 }
 
-/// Simple instruction meter for testing
-#[derive(Debug, Clone, Default)]
-pub struct TestContextObject {
-    /// Contains the register state at every instruction in order of execution
-    pub trace_log: Vec<TraceLogEntry>,
-    /// Maximal amount of instructions which still can be executed
-    pub remaining: u64,
-}
-
-impl ContextObject for TestContextObject {
-    fn trace(&mut self, state: [u64; 12]) {
-        self.trace_log.push(state);
-    }
-
-    fn consume(&mut self, amount: u64) {
-        self.remaining = self.remaining.saturating_sub(amount);
-    }
-
-    fn get_remaining(&self) -> u64 {
-        self.remaining
-    }
-}
-
-impl TestContextObject {
-    /// Initialize with instruction meter
-    pub fn new(remaining: u64) -> Self {
-        Self {
-            trace_log: Vec::new(),
-            remaining,
-        }
-    }
-
-    /// Compares an interpreter trace and a JIT trace.
-    ///
-    /// The log of the JIT can be longer because it only validates the instruction meter at branches.
-    pub fn compare_trace_log(interpreter: &Self, jit: &Self) -> bool {
-        let interpreter = interpreter.trace_log.as_slice();
-        let mut jit = jit.trace_log.as_slice();
-        if jit.len() > interpreter.len() {
-            jit = &jit[0..interpreter.len()];
-        }
-        interpreter == jit
-    }
-}
-
 /// Statistic of taken branches (from a recorded trace)
 pub struct DynamicAnalysis {
     /// Maximal edge counter value
@@ -263,8 +218,9 @@ pub enum RuntimeEnvironmentSlot {
 ///     memory_region::{MemoryMapping, MemoryRegion},
 ///     program::{BuiltinProgram, FunctionRegistry, SBPFVersion},
 ///     verifier::RequisiteVerifier,
-///     vm::{Config, EbpfVm, TestContextObject},
+///     vm::{Config, EbpfVm},
 /// };
+/// use test_utils::TestContextObject;
 ///
 /// let prog = &[
 ///     0x9d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit