1use wasm_runtime_layer::{
2 backend::{
3 AsContext, AsContextMut, Export, Extern, Imports, Value, WasmEngine, WasmExternRef,
4 WasmFunc, WasmGlobal, WasmInstance, WasmMemory, WasmModule, WasmStore, WasmStoreContext,
5 WasmStoreContextMut, WasmTable,
6 },
7 ExportType, ExternType, FuncType, GlobalType, ImportType, MemoryType, TableType,
8};
9
10use crate::transform::{
11 instcnt::{InstructionCounterInjecter, PerfWitInterfaces},
12 nan::NaNCanonicaliser,
13};
14
15#[derive(Clone)]
16#[repr(transparent)]
17pub struct ReproducibleEngine<E: WasmEngine>(E);
18
19impl<E: WasmEngine> WasmEngine for ReproducibleEngine<E> {
20 type ExternRef = ReproducibleExternRef<E>;
21 type Func = ReproducibleFunc<E>;
22 type Global = ReproducibleGlobal<E>;
23 type Instance = ReproducibleInstance<E>;
24 type Memory = ReproducibleMemory<E>;
25 type Module = ReproducibleModule<E>;
26 type Store<T> = ReproducibleStore<T, E>;
27 type StoreContext<'a, T: 'a> = ReproducibleStoreContext<'a, T, E>;
28 type StoreContextMut<'a, T: 'a> = ReproducibleStoreContextMut<'a, T, E>;
29 type Table = ReproducibleTable<E>;
30}
31
32impl<E: WasmEngine> ReproducibleEngine<E> {
33 pub const fn new(engine: E) -> Self {
34 Self(engine)
35 }
36
37 const fn as_ref(&self) -> &E {
38 &self.0
39 }
40
41 const fn from_ref(engine: &E) -> &Self {
42 #[expect(unsafe_code)]
44 unsafe {
45 &*std::ptr::from_ref(engine).cast()
46 }
47 }
48}
49
50#[derive(Clone)]
51#[repr(transparent)]
52pub struct ReproducibleExternRef<E: WasmEngine>(E::ExternRef);
53
54impl<E: WasmEngine> WasmExternRef<ReproducibleEngine<E>> for ReproducibleExternRef<E> {
55 fn new<T: 'static + Send + Sync>(
56 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
57 object: T,
58 ) -> Self {
59 Self(<E::ExternRef as WasmExternRef<E>>::new(
60 ctx.as_context_mut().as_inner_context_mut(),
61 object,
62 ))
63 }
64
65 fn downcast<'a, 's: 'a, T: 'static, S: 'a>(
66 &'a self,
67 store: ReproducibleStoreContext<'s, S, E>,
68 ) -> anyhow::Result<&'a T> {
69 WasmExternRef::downcast(&self.0, store.0)
70 }
71}
72
73#[derive(Clone)]
74#[repr(transparent)]
75pub struct ReproducibleFunc<E: WasmEngine>(E::Func);
76
77impl<E: WasmEngine> WasmFunc<ReproducibleEngine<E>> for ReproducibleFunc<E> {
78 fn new<T>(
79 mut ctx: impl AsContextMut<ReproducibleEngine<E>, UserState = T>,
80 ty: FuncType,
81 func: impl 'static
82 + Send
83 + Sync
84 + Fn(
85 ReproducibleStoreContextMut<T, E>,
86 &[Value<ReproducibleEngine<E>>],
87 &mut [Value<ReproducibleEngine<E>>],
88 ) -> anyhow::Result<()>,
89 ) -> Self {
90 Self(<E::Func as WasmFunc<E>>::new(
91 ctx.as_context_mut().as_inner_context_mut(),
92 ty,
93 move |ctx, args, results| {
94 func(
95 ReproducibleStoreContextMut(ctx),
96 from_values(args),
97 from_values_mut(results),
98 )
99 },
100 ))
101 }
102
103 fn ty(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> FuncType {
104 WasmFunc::ty(&self.0, ctx.as_context().as_inner_context())
105 }
106
107 fn call<T>(
108 &self,
109 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
110 args: &[Value<ReproducibleEngine<E>>],
111 results: &mut [Value<ReproducibleEngine<E>>],
112 ) -> anyhow::Result<()> {
113 WasmFunc::call::<T>(
114 &self.0,
115 ctx.as_context_mut().as_inner_context_mut(),
116 as_values(args),
117 as_values_mut(results),
118 )
119 }
120}
121
122#[derive(Clone)]
123#[repr(transparent)]
124pub struct ReproducibleGlobal<E: WasmEngine>(E::Global);
125
126impl<E: WasmEngine> WasmGlobal<ReproducibleEngine<E>> for ReproducibleGlobal<E> {
127 fn new(
128 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
129 value: Value<ReproducibleEngine<E>>,
130 mutable: bool,
131 ) -> Self {
132 Self(<E::Global as WasmGlobal<E>>::new(
133 ctx.as_context_mut().as_inner_context_mut(),
134 into_value(value),
135 mutable,
136 ))
137 }
138
139 fn ty(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> GlobalType {
140 WasmGlobal::ty(&self.0, ctx.as_context().as_inner_context())
141 }
142
143 fn set(
144 &self,
145 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
146 new_value: Value<ReproducibleEngine<E>>,
147 ) -> anyhow::Result<()> {
148 WasmGlobal::set(
149 &self.0,
150 ctx.as_context_mut().as_inner_context_mut(),
151 into_value(new_value),
152 )
153 }
154
155 fn get(
156 &self,
157 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
158 ) -> Value<ReproducibleEngine<E>> {
159 from_value(WasmGlobal::get(
160 &self.0,
161 ctx.as_context_mut().as_inner_context_mut(),
162 ))
163 }
164}
165
166#[derive(Clone)]
167#[repr(transparent)]
168pub struct ReproducibleInstance<E: WasmEngine>(E::Instance);
169
170impl<E: WasmEngine> WasmInstance<ReproducibleEngine<E>> for ReproducibleInstance<E> {
171 fn new(
172 mut store: impl AsContextMut<ReproducibleEngine<E>>,
173 module: &ReproducibleModule<E>,
174 imports: &Imports<ReproducibleEngine<E>>,
175 ) -> anyhow::Result<Self> {
176 let mut new_imports = Imports::new();
177 new_imports.extend(
178 imports
179 .into_iter()
180 .map(|((module, name), value)| ((module, name), into_extern(value))),
181 );
182
183 let PerfWitInterfaces {
184 perf: perf_interface,
185 instruction_counter,
186 } = PerfWitInterfaces::get();
187 new_imports.define(
188 &format!("{perf_interface}"),
189 instruction_counter,
190 Extern::Global(
191 store
192 .as_context_mut()
193 .get_instruction_counter_global()
194 .0
195 .clone(),
196 ),
197 );
198
199 Ok(Self(<E::Instance as WasmInstance<E>>::new(
200 store.as_context_mut().as_inner_context_mut(),
201 &module.0,
202 &new_imports,
203 )?))
204 }
205
206 fn exports(
207 &self,
208 store: impl AsContext<ReproducibleEngine<E>>,
209 ) -> Box<dyn Iterator<Item = Export<ReproducibleEngine<E>>>> {
210 Box::new(
211 WasmInstance::exports(&self.0, store.as_context().as_inner_context()).map(
212 |Export { name, value }| Export {
213 name,
214 value: from_extern(value),
215 },
216 ),
217 )
218 }
219
220 fn get_export(
221 &self,
222 store: impl AsContext<ReproducibleEngine<E>>,
223 name: &str,
224 ) -> Option<Extern<ReproducibleEngine<E>>> {
225 WasmInstance::get_export(&self.0, store.as_context().as_inner_context(), name)
226 .map(from_extern)
227 }
228}
229
230#[derive(Clone)]
231#[repr(transparent)]
232pub struct ReproducibleMemory<E: WasmEngine>(E::Memory);
233
234impl<E: WasmEngine> WasmMemory<ReproducibleEngine<E>> for ReproducibleMemory<E> {
235 fn new(
236 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
237 ty: MemoryType,
238 ) -> anyhow::Result<Self> {
239 Ok(Self(<E::Memory as WasmMemory<E>>::new(
240 ctx.as_context_mut().as_inner_context_mut(),
241 ty,
242 )?))
243 }
244
245 fn ty(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> MemoryType {
246 WasmMemory::ty(&self.0, ctx.as_context().as_inner_context())
247 }
248
249 fn grow(
250 &self,
251 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
252 additional: u32,
253 ) -> anyhow::Result<u32> {
254 WasmMemory::grow(
255 &self.0,
256 ctx.as_context_mut().as_inner_context_mut(),
257 additional,
258 )
259 }
260
261 fn current_pages(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> u32 {
262 WasmMemory::current_pages(&self.0, ctx.as_context().as_inner_context())
263 }
264
265 fn read(
266 &self,
267 ctx: impl AsContext<ReproducibleEngine<E>>,
268 offset: usize,
269 buffer: &mut [u8],
270 ) -> anyhow::Result<()> {
271 WasmMemory::read(&self.0, ctx.as_context().as_inner_context(), offset, buffer)
272 }
273
274 fn write(
275 &self,
276 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
277 offset: usize,
278 buffer: &[u8],
279 ) -> anyhow::Result<()> {
280 WasmMemory::write(
281 &self.0,
282 ctx.as_context_mut().as_inner_context_mut(),
283 offset,
284 buffer,
285 )
286 }
287}
288
289pub const DETERMINISTIC_WASM_MODULE_FEATURES: wasmparser::WasmFeaturesInflated =
290 wasmparser::WasmFeaturesInflated {
291 mutable_global: true,
295 saturating_float_to_int: true,
297 sign_extension: true,
299 reference_types: false,
301 multi_value: true,
303 bulk_memory: true,
305 simd: true,
307 relaxed_simd: false,
309 threads: false,
311 shared_everything_threads: false,
313 tail_call: false,
317 floats: false,
319 multi_memory: true,
321 exceptions: false,
323 memory64: false,
326 extended_const: false,
330 component_model: false,
333 function_references: false,
335 memory_control: false,
337 gc: false,
339 custom_page_sizes: false,
343 component_model_values: false,
346 component_model_nested_names: false,
349 legacy_exceptions: false,
351 gc_types: false,
354 stack_switching: false,
356 wide_arithmetic: true,
358 component_model_async: false,
361 };
362
363#[derive(Clone)]
364#[repr(transparent)]
365pub struct ReproducibleModule<E: WasmEngine>(E::Module);
366
367impl<E: WasmEngine> WasmModule<ReproducibleEngine<E>> for ReproducibleModule<E> {
368 fn new(engine: &ReproducibleEngine<E>, mut stream: impl std::io::Read) -> anyhow::Result<Self> {
369 let features = wasmparser::WasmFeatures::from(wasmparser::WasmFeaturesInflated {
370 floats: true,
373 ..DETERMINISTIC_WASM_MODULE_FEATURES
374 });
375
376 let mut bytes = Vec::new();
377 stream.read_to_end(&mut bytes)?;
378
379 wasmparser::Validator::new_with_features(features).validate_all(&bytes)?;
380
381 let bytes = InstructionCounterInjecter::apply_to_module(&bytes, features)?;
383
384 let bytes = NaNCanonicaliser::apply_to_module(&bytes, features)?;
386
387 Ok(Self(<E::Module as WasmModule<E>>::new(
388 engine.as_ref(),
389 bytes.as_slice(),
390 )?))
391 }
392
393 fn exports(&self) -> Box<dyn '_ + Iterator<Item = ExportType<'_>>> {
394 WasmModule::exports(&self.0)
395 }
396
397 fn get_export(&self, name: &str) -> Option<ExternType> {
398 WasmModule::get_export(&self.0, name)
399 }
400
401 fn imports(&self) -> Box<dyn '_ + Iterator<Item = ImportType<'_>>> {
402 WasmModule::imports(&self.0)
403 }
404}
405
406struct StoreData<T, E: WasmEngine> {
407 data: T,
408 instruction_counter: Option<ReproducibleGlobal<E>>,
409}
410
411#[derive(Clone)]
412#[repr(transparent)]
413pub struct ReproducibleStore<T, E: WasmEngine>(E::Store<StoreData<T, E>>);
414
415impl<T, E: WasmEngine> WasmStore<T, ReproducibleEngine<E>> for ReproducibleStore<T, E> {
416 fn new(engine: &ReproducibleEngine<E>, data: T) -> Self {
417 Self(<E::Store<StoreData<T, E>> as WasmStore<
418 StoreData<T, E>,
419 E,
420 >>::new(
421 engine.as_ref(),
422 StoreData {
423 data,
424 instruction_counter: None,
425 },
426 ))
427 }
428
429 fn engine(&self) -> &ReproducibleEngine<E> {
430 ReproducibleEngine::from_ref(WasmStore::engine(&self.0))
431 }
432
433 fn data(&self) -> &T {
434 &WasmStore::data(&self.0).data
435 }
436
437 fn data_mut(&mut self) -> &mut T {
438 &mut WasmStore::data_mut(&mut self.0).data
439 }
440
441 fn into_data(self) -> T {
442 WasmStore::into_data(self.0).data
443 }
444}
445
446impl<T, E: WasmEngine> AsContext<ReproducibleEngine<E>> for ReproducibleStore<T, E> {
447 type UserState = T;
448
449 fn as_context(&self) -> ReproducibleStoreContext<'_, Self::UserState, E> {
450 ReproducibleStoreContext(AsContext::as_context(&self.0))
451 }
452}
453
454impl<T, E: WasmEngine> AsContextMut<ReproducibleEngine<E>> for ReproducibleStore<T, E> {
455 fn as_context_mut(&mut self) -> ReproducibleStoreContextMut<'_, Self::UserState, E> {
456 ReproducibleStoreContextMut(AsContextMut::as_context_mut(&mut self.0))
457 }
458}
459
460#[repr(transparent)]
461pub struct ReproducibleStoreContext<'a, T: 'a, E: WasmEngine>(E::StoreContext<'a, StoreData<T, E>>);
462
463impl<'a, T: 'a, E: WasmEngine> WasmStoreContext<'a, T, ReproducibleEngine<E>>
464 for ReproducibleStoreContext<'a, T, E>
465{
466 fn engine(&self) -> &ReproducibleEngine<E> {
467 ReproducibleEngine::from_ref(WasmStoreContext::engine(&self.0))
468 }
469
470 fn data(&self) -> &T {
471 &WasmStoreContext::data(&self.0).data
472 }
473}
474
475impl<'a, T: 'a, E: WasmEngine> AsContext<ReproducibleEngine<E>>
476 for ReproducibleStoreContext<'a, T, E>
477{
478 type UserState = T;
479
480 fn as_context(&self) -> ReproducibleStoreContext<'_, Self::UserState, E> {
481 ReproducibleStoreContext(AsContext::as_context(&self.0))
482 }
483}
484
485impl<'a, T: 'a, E: WasmEngine> ReproducibleStoreContext<'a, T, E> {
486 fn as_inner_context(&self) -> E::StoreContext<'_, StoreData<T, E>> {
487 self.0.as_context()
488 }
489}
490
491#[repr(transparent)]
492pub struct ReproducibleStoreContextMut<'a, T: 'a, E: WasmEngine>(
493 E::StoreContextMut<'a, StoreData<T, E>>,
494);
495
496impl<'a, T: 'a, E: WasmEngine> WasmStoreContext<'a, T, ReproducibleEngine<E>>
497 for ReproducibleStoreContextMut<'a, T, E>
498{
499 fn engine(&self) -> &ReproducibleEngine<E> {
500 ReproducibleEngine::from_ref(WasmStoreContext::engine(&self.0))
501 }
502
503 fn data(&self) -> &T {
504 &WasmStoreContext::data(&self.0).data
505 }
506}
507
508impl<'a, T: 'a, E: WasmEngine> WasmStoreContextMut<'a, T, ReproducibleEngine<E>>
509 for ReproducibleStoreContextMut<'a, T, E>
510{
511 fn data_mut(&mut self) -> &mut T {
512 &mut WasmStoreContextMut::data_mut(&mut self.0).data
513 }
514}
515
516impl<'a, T: 'a, E: WasmEngine> AsContext<ReproducibleEngine<E>>
517 for ReproducibleStoreContextMut<'a, T, E>
518{
519 type UserState = T;
520
521 fn as_context(&self) -> ReproducibleStoreContext<'_, Self::UserState, E> {
522 ReproducibleStoreContext(AsContext::as_context(&self.0))
523 }
524}
525
526impl<'a, T: 'a, E: WasmEngine> AsContextMut<ReproducibleEngine<E>>
527 for ReproducibleStoreContextMut<'a, T, E>
528{
529 fn as_context_mut(&mut self) -> ReproducibleStoreContextMut<'_, Self::UserState, E> {
530 ReproducibleStoreContextMut(AsContextMut::as_context_mut(&mut self.0))
531 }
532}
533
534impl<'a, T: 'a, E: WasmEngine> ReproducibleStoreContextMut<'a, T, E> {
535 fn as_inner_context_mut(&mut self) -> E::StoreContextMut<'_, StoreData<T, E>> {
536 self.0.as_context_mut()
537 }
538
539 fn get_instruction_counter_global(&mut self) -> &ReproducibleGlobal<E> {
540 let mut this = self;
541
542 polonius_the_crab::polonius!(|this| -> &'polonius ReproducibleGlobal<E> {
544 let data: &mut StoreData<T, E> = WasmStoreContextMut::data_mut(&mut this.0);
545 if let Some(global) = &data.instruction_counter {
546 polonius_the_crab::polonius_return!(global);
547 }
548 });
549
550 let global = WasmGlobal::new(AsContextMut::as_context_mut(this), Value::I64(0), true);
551
552 let data: &mut StoreData<T, E> = WasmStoreContextMut::data_mut(&mut this.0);
553 data.instruction_counter.insert(global)
554 }
555}
556
557#[derive(Clone)]
558#[repr(transparent)]
559pub struct ReproducibleTable<E: WasmEngine>(E::Table);
560
561impl<E: WasmEngine> WasmTable<ReproducibleEngine<E>> for ReproducibleTable<E> {
562 fn new(
563 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
564 ty: TableType,
565 init: Value<ReproducibleEngine<E>>,
566 ) -> anyhow::Result<Self> {
567 Ok(Self(<E::Table as WasmTable<E>>::new(
568 ctx.as_context_mut().as_inner_context_mut(),
569 ty,
570 into_value(init),
571 )?))
572 }
573
574 fn ty(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> TableType {
575 WasmTable::ty(&self.0, ctx.as_context().as_inner_context())
576 }
577
578 fn size(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> u32 {
579 WasmTable::size(&self.0, ctx.as_context().as_inner_context())
580 }
581
582 fn grow(
583 &self,
584 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
585 delta: u32,
586 init: Value<ReproducibleEngine<E>>,
587 ) -> anyhow::Result<u32> {
588 WasmTable::grow(
589 &self.0,
590 ctx.as_context_mut().as_inner_context_mut(),
591 delta,
592 into_value(init),
593 )
594 }
595
596 fn get(
597 &self,
598 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
599 index: u32,
600 ) -> Option<Value<ReproducibleEngine<E>>> {
601 WasmTable::get(&self.0, ctx.as_context_mut().as_inner_context_mut(), index).map(from_value)
602 }
603
604 fn set(
605 &self,
606 mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
607 index: u32,
608 value: Value<ReproducibleEngine<E>>,
609 ) -> anyhow::Result<()> {
610 WasmTable::set(
611 &self.0,
612 ctx.as_context_mut().as_inner_context_mut(),
613 index,
614 into_value(value),
615 )
616 }
617}
618
619const fn as_values<E: WasmEngine>(values: &[Value<ReproducibleEngine<E>>]) -> &[Value<E>] {
620 #[expect(unsafe_code)]
622 unsafe {
623 std::slice::from_raw_parts(values.as_ptr().cast(), values.len())
624 }
625}
626
627fn as_values_mut<E: WasmEngine>(values: &mut [Value<ReproducibleEngine<E>>]) -> &mut [Value<E>] {
628 #[expect(unsafe_code)]
630 unsafe {
631 std::slice::from_raw_parts_mut(values.as_mut_ptr().cast(), values.len())
632 }
633}
634
635const fn from_values<E: WasmEngine>(values: &[Value<E>]) -> &[Value<ReproducibleEngine<E>>] {
636 #[expect(unsafe_code)]
638 unsafe {
639 std::slice::from_raw_parts(values.as_ptr().cast(), values.len())
640 }
641}
642
643fn from_values_mut<E: WasmEngine>(values: &mut [Value<E>]) -> &mut [Value<ReproducibleEngine<E>>] {
644 #[expect(unsafe_code)]
646 unsafe {
647 std::slice::from_raw_parts_mut(values.as_mut_ptr().cast(), values.len())
648 }
649}
650
651fn into_value<E: WasmEngine>(value: Value<ReproducibleEngine<E>>) -> Value<E> {
652 match value {
653 Value::I32(v) => Value::I32(v),
654 Value::I64(v) => Value::I64(v),
655 Value::F32(v) => Value::F32(v),
656 Value::F64(v) => Value::F64(v),
657 Value::FuncRef(v) => Value::FuncRef(v.map(|v| v.0)),
658 Value::ExternRef(v) => Value::ExternRef(v.map(|v| v.0)),
659 }
660}
661
662fn from_value<E: WasmEngine>(value: Value<E>) -> Value<ReproducibleEngine<E>> {
663 match value {
664 Value::I32(v) => Value::I32(v),
665 Value::I64(v) => Value::I64(v),
666 Value::F32(v) => Value::F32(v),
667 Value::F64(v) => Value::F64(v),
668 Value::FuncRef(v) => Value::FuncRef(v.map(ReproducibleFunc)),
669 Value::ExternRef(v) => Value::ExternRef(v.map(ReproducibleExternRef)),
670 }
671}
672
673fn into_extern<E: WasmEngine>(value: Extern<ReproducibleEngine<E>>) -> Extern<E> {
674 match value {
675 Extern::Global(v) => Extern::Global(v.0),
676 Extern::Table(v) => Extern::Table(v.0),
677 Extern::Memory(v) => Extern::Memory(v.0),
678 Extern::Func(v) => Extern::Func(v.0),
679 }
680}
681
682fn from_extern<E: WasmEngine>(value: Extern<E>) -> Extern<ReproducibleEngine<E>> {
683 match value {
684 Extern::Global(v) => Extern::Global(ReproducibleGlobal(v)),
685 Extern::Table(v) => Extern::Table(ReproducibleTable(v)),
686 Extern::Memory(v) => Extern::Memory(ReproducibleMemory(v)),
687 Extern::Func(v) => Extern::Func(ReproducibleFunc(v)),
688 }
689}