Removes the generic parameter "V: Verifier" from Executable.

solana-labs · Aug 21, 2023 · 8020fe2 · 8020fe2
1 parent 91f8af8
commit 8020fe2
Show file tree

Hide file tree

Showing 21 changed files with 115 additions and 160 deletions.
diff --git a/benches/elf_loader.rs b/benches/elf_loader.rs
@@ -13,7 +13,6 @@ extern crate test_utils;
 use solana_rbpf::{
     elf::{Executable, FunctionRegistry},
     syscalls,
-    verifier::TautologyVerifier,
     vm::{BuiltinFunction, BuiltinProgram, Config, TestContextObject},
 };
 use std::{fs::File, io::Read, sync::Arc};
@@ -36,9 +35,7 @@ fn bench_load_sbpfv1(bencher: &mut Bencher) {
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
     let loader = loader();
-    bencher.iter(|| {
-        Executable::<TautologyVerifier, TestContextObject>::from_elf(&elf, loader.clone()).unwrap()
-    });
+    bencher.iter(|| Executable::<TestContextObject>::from_elf(&elf, loader.clone()).unwrap());
 }
 
 #[bench]
@@ -47,7 +44,5 @@ fn bench_load_sbpfv2(bencher: &mut Bencher) {
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
     let loader = loader();
-    bencher.iter(|| {
-        Executable::<TautologyVerifier, TestContextObject>::from_elf(&elf, loader.clone()).unwrap()
-    });
+    bencher.iter(|| Executable::<TestContextObject>::from_elf(&elf, loader.clone()).unwrap());
 }
diff --git a/benches/jit_compile.rs b/benches/jit_compile.rs
@@ -11,7 +11,7 @@ extern crate test;
 
 use solana_rbpf::{
     elf::Executable,
-    verifier::{RequisiteVerifier, TautologyVerifier},
+    verifier::RequisiteVerifier,
     vm::{BuiltinProgram, TestContextObject},
 };
 use std::{fs::File, io::Read, sync::Arc};
@@ -23,13 +23,11 @@ fn bench_init_vm(bencher: &mut Bencher) {
     let mut file = File::open("tests/elfs/relative_call.so").unwrap();
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
-    let executable = Executable::<TautologyVerifier, TestContextObject>::from_elf(
-        &elf,
-        Arc::new(BuiltinProgram::new_mock()),
-    )
-    .unwrap();
+    let executable =
+        Executable::<TestContextObject>::from_elf(&elf, Arc::new(BuiltinProgram::new_mock()))
+            .unwrap();
     let verified_executable =
-        Executable::<RequisiteVerifier, TestContextObject>::verified(executable).unwrap();
+        Executable::<TestContextObject>::verified::<RequisiteVerifier>(executable).unwrap();
     bencher.iter(|| {
         let mut context_object = TestContextObject::default();
         create_vm!(
@@ -50,12 +48,10 @@ fn bench_jit_compile(bencher: &mut Bencher) {
     let mut file = File::open("tests/elfs/relative_call.so").unwrap();
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
-    let executable = Executable::<TautologyVerifier, TestContextObject>::from_elf(
-        &elf,
-        Arc::new(BuiltinProgram::new_mock()),
-    )
-    .unwrap();
+    let executable =
+        Executable::<TestContextObject>::from_elf(&elf, Arc::new(BuiltinProgram::new_mock()))
+            .unwrap();
     let mut verified_executable =
-        Executable::<RequisiteVerifier, TestContextObject>::verified(executable).unwrap();
+        Executable::<TestContextObject>::verified::<RequisiteVerifier>(executable).unwrap();
     bencher.iter(|| verified_executable.jit_compile().unwrap());
 }
diff --git a/benches/vm_execution.rs b/benches/vm_execution.rs
@@ -13,7 +13,7 @@ use solana_rbpf::{
     ebpf,
     elf::{Executable, FunctionRegistry},
     memory_region::MemoryRegion,
-    verifier::{RequisiteVerifier, TautologyVerifier},
+    verifier::RequisiteVerifier,
     vm::{BuiltinProgram, Config, TestContextObject},
 };
 use std::{fs::File, io::Read, sync::Arc};
@@ -25,13 +25,11 @@ fn bench_init_interpreter_start(bencher: &mut Bencher) {
     let mut file = File::open("tests/elfs/rodata_section.so").unwrap();
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
-    let executable = Executable::<TautologyVerifier, TestContextObject>::from_elf(
-        &elf,
-        Arc::new(BuiltinProgram::new_mock()),
-    )
-    .unwrap();
+    let executable =
+        Executable::<TestContextObject>::from_elf(&elf, Arc::new(BuiltinProgram::new_mock()))
+            .unwrap();
     let verified_executable =
-        Executable::<RequisiteVerifier, TestContextObject>::verified(executable).unwrap();
+        Executable::<TestContextObject>::verified::<RequisiteVerifier>(executable).unwrap();
     let mut context_object = TestContextObject::default();
     create_vm!(
         vm,
@@ -54,13 +52,11 @@ fn bench_init_jit_start(bencher: &mut Bencher) {
     let mut file = File::open("tests/elfs/rodata_section.so").unwrap();
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
-    let executable = Executable::<TautologyVerifier, TestContextObject>::from_elf(
-        &elf,
-        Arc::new(BuiltinProgram::new_mock()),
-    )
-    .unwrap();
+    let executable =
+        Executable::<TestContextObject>::from_elf(&elf, Arc::new(BuiltinProgram::new_mock()))
+            .unwrap();
     let mut verified_executable =
-        Executable::<RequisiteVerifier, TestContextObject>::verified(executable).unwrap();
+        Executable::<TestContextObject>::verified::<RequisiteVerifier>(executable).unwrap();
     verified_executable.jit_compile().unwrap();
     let mut context_object = TestContextObject::default();
     create_vm!(
@@ -95,7 +91,7 @@ fn bench_jit_vs_interpreter(
     )
     .unwrap();
     let mut verified_executable =
-        Executable::<RequisiteVerifier, TestContextObject>::verified(executable).unwrap();
+        Executable::<TestContextObject>::verified::<RequisiteVerifier>(executable).unwrap();
     verified_executable.jit_compile().unwrap();
     let mut context_object = TestContextObject::default();
     let mem_region = MemoryRegion::new_writable(mem, ebpf::MM_INPUT_START);

diff --git a/cli/src/main.rs b/cli/src/main.rs
@@ -6,7 +6,7 @@ use solana_rbpf::{
     elf::{Executable, FunctionRegistry},
     memory_region::{MemoryMapping, MemoryRegion},
     static_analysis::Analysis,
-    verifier::{RequisiteVerifier, TautologyVerifier},
+    verifier::{RequisiteVerifier},
     vm::{BuiltinProgram, Config, DynamicAnalysis, EbpfVm, TestContextObject},
 };
 use std::{fs::File, io::Read, path::Path, sync::Arc};
@@ -112,15 +112,15 @@ fn main() {
             let mut file = File::open(Path::new(matches.value_of("elf").unwrap())).unwrap();
             let mut elf = Vec::new();
             file.read_to_end(&mut elf).unwrap();
-            Executable::<TautologyVerifier, TestContextObject>::from_elf(&elf, loader)
+            Executable::<TestContextObject>::from_elf(&elf, loader)
                 .map_err(|err| format!("Executable constructor failed: {err:?}"))
         }
     }
     .unwrap();
 
     #[allow(unused_mut)]
     let verified_executable =
-        Executable::<RequisiteVerifier, TestContextObject>::verified(executable).unwrap();
+        Executable::<TestContextObject>::verified::<RequisiteVerifier>(executable).unwrap();
 
     let mut mem = match matches.value_of("input").unwrap().parse::<usize>() {
         Ok(allocate) => vec![0u8; allocate],

diff --git a/examples/disassemble.rs b/examples/disassemble.rs
@@ -8,7 +8,6 @@ extern crate solana_rbpf;
 use solana_rbpf::{
     elf::{Executable, FunctionRegistry, SBPFVersion},
     static_analysis::Analysis,
-    verifier::TautologyVerifier,
     vm::{BuiltinProgram, TestContextObject},
 };
 use std::sync::Arc;
@@ -32,7 +31,7 @@ fn main() {
         0x00, 0x00, 0x00, 0x00, 0x00,
     ];
     let loader = Arc::new(BuiltinProgram::new_mock());
-    let executable = Executable::<TautologyVerifier, TestContextObject>::from_text_bytes(
+    let executable = Executable::<TestContextObject>::from_text_bytes(
         program,
         loader,
         SBPFVersion::V2,

diff --git a/examples/to_json.rs b/examples/to_json.rs
@@ -14,7 +14,6 @@ extern crate solana_rbpf;
 use solana_rbpf::{
     elf::{Executable, FunctionRegistry, SBPFVersion},
     static_analysis::Analysis,
-    verifier::TautologyVerifier,
     vm::{BuiltinProgram, TestContextObject},
 };
 use std::sync::Arc;
@@ -28,7 +27,7 @@ use std::sync::Arc;
 // * Print integers as integers, and not as strings containing their hexadecimal representation
 //   (just replace the relevant `format!()` calls by the commented values.
 fn to_json(program: &[u8]) -> String {
-    let executable = Executable::<TautologyVerifier, TestContextObject>::from_text_bytes(
+    let executable = Executable::<TestContextObject>::from_text_bytes(
         program,
         Arc::new(BuiltinProgram::new_mock()),
         SBPFVersion::V2,

diff --git a/fuzz/fuzz_targets/dumb.rs b/fuzz/fuzz_targets/dumb.rs
@@ -8,7 +8,7 @@ use solana_rbpf::{
     ebpf,
     elf::{Executable, FunctionRegistry, SBPFVersion},
     memory_region::MemoryRegion,
-    verifier::{RequisiteVerifier, TautologyVerifier, Verifier},
+    verifier::{RequisiteVerifier, Verifier},
     vm::{BuiltinProgram, TestContextObject},
 };
 use test_utils::create_vm;
@@ -33,7 +33,7 @@ fuzz_target!(|data: DumbFuzzData| {
         return;
     }
     let mut mem = data.mem;
-    let executable = Executable::<TautologyVerifier, TestContextObject>::from_text_bytes(
+    let executable = Executable::<TestContextObject>::from_text_bytes(
         &prog,
         std::sync::Arc::new(BuiltinProgram::new_loader(config, FunctionRegistry::default())),
         SBPFVersion::V2,

diff --git a/fuzz/fuzz_targets/smart.rs b/fuzz/fuzz_targets/smart.rs
@@ -10,7 +10,7 @@ use solana_rbpf::{
     elf::{Executable, FunctionRegistry, SBPFVersion},
     insn_builder::{Arch, IntoBytes},
     memory_region::MemoryRegion,
-    verifier::{RequisiteVerifier, TautologyVerifier, Verifier},
+    verifier::{RequisiteVerifier, Verifier},
     vm::{BuiltinProgram, TestContextObject},
 };
 use test_utils::create_vm;
@@ -37,7 +37,7 @@ fuzz_target!(|data: FuzzData| {
         return;
     }
     let mut mem = data.mem;
-    let executable = Executable::<TautologyVerifier, TestContextObject>::from_text_bytes(
+    let executable = Executable::<TestContextObject>::from_text_bytes(
         prog.into_bytes(),
         std::sync::Arc::new(BuiltinProgram::new_loader(config, FunctionRegistry::default())),
         SBPFVersion::V2,

diff --git a/fuzz/fuzz_targets/smart_jit_diff.rs b/fuzz/fuzz_targets/smart_jit_diff.rs
@@ -8,7 +8,7 @@ use solana_rbpf::{
     elf::{Executable, FunctionRegistry, SBPFVersion},
     insn_builder::{Arch, Instruction, IntoBytes},
     memory_region::MemoryRegion,
-    verifier::{RequisiteVerifier, TautologyVerifier, Verifier},
+    verifier::{RequisiteVerifier, Verifier},
     vm::{BuiltinProgram, TestContextObject},
 };
 use test_utils::create_vm;
@@ -45,7 +45,7 @@ fuzz_target!(|data: FuzzData| {
     }
     let mut interp_mem = data.mem.clone();
     let mut jit_mem = data.mem;
-    let mut executable = Executable::<TautologyVerifier, TestContextObject>::from_text_bytes(
+    let mut executable = Executable::<TestContextObject>::from_text_bytes(
         prog.into_bytes(),
         std::sync::Arc::new(BuiltinProgram::new_loader(config, FunctionRegistry::default())),
         SBPFVersion::V2,

diff --git a/fuzz/fuzz_targets/smarter_jit_diff.rs b/fuzz/fuzz_targets/smarter_jit_diff.rs
@@ -9,7 +9,7 @@ use solana_rbpf::{
     insn_builder::IntoBytes,
     memory_region::MemoryRegion,
     static_analysis::Analysis,
-    verifier::{RequisiteVerifier, TautologyVerifier, Verifier},
+    verifier::{RequisiteVerifier, Verifier},
     vm::{
         BuiltinProgram, ContextObject, TestContextObject,
     },
@@ -28,7 +28,7 @@ struct FuzzData {
     mem: Vec<u8>,
 }
 
-fn dump_insns<V: Verifier, C: ContextObject>(verified_executable: &Executable<V, C>) {
+fn dump_insns<C: ContextObject>(verified_executable: &Executable<C>) {
     let analysis = Analysis::from_executable(verified_executable).unwrap();
     eprint!("Using the following disassembly");
     analysis.disassemble(&mut std::io::stderr().lock()).unwrap();
@@ -44,7 +44,7 @@ fuzz_target!(|data: FuzzData| {
     }
     let mut interp_mem = data.mem.clone();
     let mut jit_mem = data.mem;
-    let mut executable = Executable::<TautologyVerifier, TestContextObject>::from_text_bytes(
+    let mut executable = Executable::<TestContextObject>::from_text_bytes(
         prog.into_bytes(),
         std::sync::Arc::new(BuiltinProgram::new_loader(config, FunctionRegistry::default())),
         SBPFVersion::V2,

diff --git a/src/assembler.rs b/src/assembler.rs
@@ -19,7 +19,6 @@ use crate::{
     },
     ebpf::{self, Insn},
     elf::{Executable, FunctionRegistry, SBPFVersion},
-    verifier::TautologyVerifier,
     vm::{BuiltinProgram, ContextObject},
 };
 use std::{collections::HashMap, sync::Arc};
@@ -218,7 +217,7 @@ fn insn(opc: u8, dst: i64, src: i64, off: i64, imm: i64) -> Result<Insn, String>
 pub fn assemble<C: ContextObject>(
     src: &str,
     loader: Arc<BuiltinProgram<C>>,
-) -> Result<Executable<TautologyVerifier, C>, String> {
+) -> Result<Executable<C>, String> {
     let sbpf_version = if loader.get_config().enable_sbpf_v2 {
         SBPFVersion::V2
     } else {
@@ -366,11 +365,6 @@ pub fn assemble<C: ContextObject>(
         .iter()
         .flat_map(|insn| insn.to_vec())
         .collect::<Vec<_>>();
-    Executable::<TautologyVerifier, C>::from_text_bytes(
-        &program,
-        loader,
-        sbpf_version,
-        function_registry,
-    )
-    .map_err(|err| format!("Executable constructor {err:?}"))
+    Executable::<C>::from_text_bytes(&program, loader, sbpf_version, function_registry)
+        .map_err(|err| format!("Executable constructor {err:?}"))
 }