11use alloc:: boxed:: Box ;
2- use alloc:: vec:: Vec ;
3- use core:: cell:: RefCell ;
42use core:: hint:: cold_path;
53
64use tinywasm_types:: MemoryType ;
@@ -9,167 +7,119 @@ use crate::{Error, MemoryBackend, Result};
97
108use super :: LinearMemory ;
119
12- /// A linear memory wrapper that materializes its inner backend on first access .
10+ /// A linear memory wrapper that allocates its backend on the first mutation .
1311///
14- /// If the wrapped backend fails to create the inner memory during first access,
15- /// this wrapper will panic .
12+ /// Before materialization, the memory is represented by its logical length and
13+ /// reads return the zeroes required by WebAssembly semantics .
1614pub struct LazyLinearMemory {
1715 ty : MemoryType ,
1816 initial_len : usize ,
1917 backend : MemoryBackend ,
20- inner : RefCell < Option < Box < dyn LinearMemory > > > ,
18+ inner : Option < Box < dyn LinearMemory > > ,
2119}
2220
2321impl LazyLinearMemory {
24- /// Creates a lazy memory for `ty` using `backend` for the eventual materialized storage.
22+ /// Creates a lazy memory for `ty` using `backend` for eventual storage.
2523 pub fn try_new ( ty : MemoryType , backend : MemoryBackend ) -> Result < Self > {
2624 let initial_len = usize:: try_from ( ty. initial_size ( ) )
2725 . map_err ( |_| Error :: UnsupportedFeature ( "memory size exceeds the host address space" ) ) ?;
2826 Ok ( Self :: new_with_initial_len ( ty, initial_len, backend) )
2927 }
3028
3129 pub ( crate ) fn new_with_initial_len ( ty : MemoryType , initial_len : usize , backend : MemoryBackend ) -> Self {
32- Self { ty, initial_len, backend, inner : RefCell :: new ( None ) }
30+ Self { ty, initial_len, backend, inner : None }
3331 }
3432
35- fn with_inner < R > ( & self , f : impl FnOnce ( & dyn LinearMemory ) -> R ) -> R {
36- self . ensure_materialized ( ) ;
37- let inner = self . inner . borrow ( ) ;
38- f ( inner. as_deref ( ) . expect ( "lazy memory should be materialized" ) )
39- }
40-
41- fn try_with_inner < R > ( & self , f : impl FnOnce ( & dyn LinearMemory ) -> R ) -> core:: result:: Result < R , crate :: Trap > {
42- self . try_ensure_materialized ( ) ?;
43- let inner = self . inner . borrow ( ) ;
44- Ok ( f ( inner. as_deref ( ) . expect ( "lazy memory should be materialized" ) ) )
45- }
46-
47- fn with_inner_mut < R > ( & self , f : impl FnOnce ( & mut dyn LinearMemory ) -> R ) -> R {
48- self . ensure_materialized ( ) ;
49- let mut inner = self . inner . borrow_mut ( ) ;
50- f ( inner. as_deref_mut ( ) . expect ( "lazy memory should be materialized" ) )
51- }
52-
53- fn try_with_inner_mut < R > (
54- & self ,
55- f : impl FnOnce ( & mut dyn LinearMemory ) -> R ,
56- ) -> core:: result:: Result < R , crate :: Trap > {
57- self . try_ensure_materialized ( ) ?;
58- let mut inner = self . inner . borrow_mut ( ) ;
59- Ok ( f ( inner. as_deref_mut ( ) . expect ( "lazy memory should be materialized" ) ) )
60- }
61-
62- fn ensure_materialized ( & self ) {
63- if self . inner . borrow ( ) . is_some ( ) {
64- return ;
33+ fn materialize ( & mut self ) -> & mut dyn LinearMemory {
34+ if self . inner . is_none ( ) {
35+ self . inner =
36+ Some ( self . backend . create ( self . ty , self . initial_len ) . expect ( "lazy memory materialization failed" ) . 0 ) ;
6537 }
66-
67- let storage = self . backend . create ( self . ty , self . initial_len ) . expect ( "lazy memory materialization failed" ) ;
68- * self . inner . borrow_mut ( ) = Some ( storage. 0 ) ;
69- }
70-
71- fn try_ensure_materialized ( & self ) -> core:: result:: Result < ( ) , crate :: Trap > {
72- if self . inner . borrow ( ) . is_some ( ) {
73- return Ok ( ( ) ) ;
38+ self . inner . as_deref_mut ( ) . expect ( "lazy memory should be materialized" )
39+ }
40+
41+ fn try_materialize ( & mut self ) -> core:: result:: Result < & mut dyn LinearMemory , crate :: Trap > {
42+ if self . inner . is_none ( ) {
43+ let storage = match self . backend . create ( self . ty , self . initial_len ) {
44+ Ok ( storage) => storage,
45+ Err ( Error :: Trap ( trap) ) => {
46+ cold_path ( ) ;
47+ return Err ( trap) ;
48+ }
49+ Err ( err) => panic ! ( "lazy memory materialization failed: {err}" ) ,
50+ } ;
51+ self . inner = Some ( storage. 0 ) ;
7452 }
75-
76- let storage = match self . backend . create ( self . ty , self . initial_len ) {
77- Ok ( storage) => storage,
78- Err ( Error :: Trap ( trap) ) => {
79- cold_path ( ) ;
80- return Err ( trap) ;
81- }
82- Err ( err) => panic ! ( "lazy memory materialization failed: {err}" ) ,
83- } ;
84- * self . inner . borrow_mut ( ) = Some ( storage. 0 ) ;
85- Ok ( ( ) )
53+ Ok ( self . inner . as_deref_mut ( ) . expect ( "lazy memory should be materialized" ) )
8654 }
8755}
8856
8957impl LinearMemory for LazyLinearMemory {
9058 fn len ( & self ) -> usize {
91- self . with_inner ( | inner| inner . len ( ) )
59+ self . inner . as_deref ( ) . map_or ( self . initial_len , LinearMemory :: len )
9260 }
9361
9462 fn grow_to ( & mut self , new_len : usize ) -> Result < ( ) , crate :: Trap > {
95- self . try_with_inner_mut ( |inner| inner . grow_to ( new_len) ) ?
63+ self . try_materialize ( ) ? . grow_to ( new_len)
9664 }
9765
9866 fn read ( & self , addr : usize , dst : & mut [ u8 ] ) -> usize {
99- self . with_inner ( |inner| inner. read ( addr, dst) )
67+ if let Some ( inner) = self . inner . as_deref ( ) {
68+ return inner. read ( addr, dst) ;
69+ }
70+ if addr >= self . initial_len {
71+ return 0 ;
72+ }
73+ let read_len = dst. len ( ) . min ( self . initial_len - addr) ;
74+ dst[ ..read_len] . fill ( 0 ) ;
75+ read_len
10076 }
10177
10278 fn write ( & mut self , addr : usize , src : & [ u8 ] ) -> usize {
103- self . with_inner_mut ( |inner| inner. write ( addr, src) )
79+ if src. is_empty ( ) || addr >= self . len ( ) {
80+ return 0 ;
81+ }
82+ self . materialize ( ) . write ( addr, src)
10483 }
10584
10685 fn write_all ( & mut self , addr : usize , src : & [ u8 ] ) -> Option < ( ) > {
107- self . with_inner_mut ( |inner| inner. write_all ( addr, src) )
86+ let end = addr. checked_add ( src. len ( ) ) ?;
87+ if end > self . len ( ) {
88+ return None ;
89+ }
90+ if src. is_empty ( ) {
91+ return Some ( ( ) ) ;
92+ }
93+ self . materialize ( ) . write_all ( addr, src)
10894 }
10995
11096 fn fill ( & mut self , addr : usize , len : usize , val : u8 ) -> Option < ( ) > {
111- self . with_inner_mut ( |inner| inner. fill ( addr, len, val) )
97+ let end = addr. checked_add ( len) ?;
98+ if end > self . len ( ) {
99+ return None ;
100+ }
101+ if len == 0 || val == 0 && self . inner . is_none ( ) {
102+ return Some ( ( ) ) ;
103+ }
104+ self . materialize ( ) . fill ( addr, len, val)
112105 }
113106
114107 fn copy_within ( & mut self , dst : usize , src : usize , len : usize ) -> Option < ( ) > {
115- self . with_inner_mut ( |inner| inner. copy_within ( dst, src, len) )
116- }
117-
118- fn read_exact ( & self , addr : usize , dst : & mut [ u8 ] ) -> Option < ( ) > {
119- self . with_inner ( |inner| inner. read_exact ( addr, dst) )
120- }
121-
122- fn read_vec ( & self , addr : usize , len : usize ) -> Option < Vec < u8 > > {
123- self . with_inner ( |inner| inner. read_vec ( addr, len) )
124- }
125-
126- fn read_8 ( & self , base : u64 , offset : u64 ) -> core:: result:: Result < u8 , crate :: Trap > {
127- self . try_with_inner ( |inner| inner. read_8 ( base, offset) ) ?
128- }
129-
130- fn read_16 ( & self , base : u64 , offset : u64 ) -> core:: result:: Result < [ u8 ; 2 ] , crate :: Trap > {
131- self . try_with_inner ( |inner| inner. read_16 ( base, offset) ) ?
132- }
133-
134- fn read_32 ( & self , base : u64 , offset : u64 ) -> core:: result:: Result < [ u8 ; 4 ] , crate :: Trap > {
135- self . try_with_inner ( |inner| inner. read_32 ( base, offset) ) ?
136- }
137-
138- fn read_64 ( & self , base : u64 , offset : u64 ) -> core:: result:: Result < [ u8 ; 8 ] , crate :: Trap > {
139- self . try_with_inner ( |inner| inner. read_64 ( base, offset) ) ?
140- }
141-
142- fn read_128 ( & self , base : u64 , offset : u64 ) -> core:: result:: Result < [ u8 ; 16 ] , crate :: Trap > {
143- self . try_with_inner ( |inner| inner. read_128 ( base, offset) ) ?
144- }
145-
146- fn write_8 ( & mut self , base : u64 , offset : u64 , byte : u8 ) -> core:: result:: Result < ( ) , crate :: Trap > {
147- self . try_with_inner_mut ( |inner| inner. write_8 ( base, offset, byte) ) ?
148- }
149-
150- fn write_16 ( & mut self , base : u64 , offset : u64 , bytes : [ u8 ; 2 ] ) -> core:: result:: Result < ( ) , crate :: Trap > {
151- self . try_with_inner_mut ( |inner| inner. write_16 ( base, offset, bytes) ) ?
152- }
153-
154- fn write_32 ( & mut self , base : u64 , offset : u64 , bytes : [ u8 ; 4 ] ) -> core:: result:: Result < ( ) , crate :: Trap > {
155- self . try_with_inner_mut ( |inner| inner. write_32 ( base, offset, bytes) ) ?
156- }
157-
158- fn write_64 ( & mut self , base : u64 , offset : u64 , bytes : [ u8 ; 8 ] ) -> core:: result:: Result < ( ) , crate :: Trap > {
159- self . try_with_inner_mut ( |inner| inner. write_64 ( base, offset, bytes) ) ?
160- }
161-
162- fn write_128 ( & mut self , base : u64 , offset : u64 , bytes : [ u8 ; 16 ] ) -> core:: result:: Result < ( ) , crate :: Trap > {
163- self . try_with_inner_mut ( |inner| inner. write_128 ( base, offset, bytes) ) ?
108+ let src_end = src. checked_add ( len) ?;
109+ let dst_end = dst. checked_add ( len) ?;
110+ if src_end > self . len ( ) || dst_end > self . len ( ) {
111+ return None ;
112+ }
113+ if self . inner . is_none ( ) || len == 0 || dst == src {
114+ return Some ( ( ) ) ;
115+ }
116+ self . materialize ( ) . copy_within ( dst, src, len)
164117 }
165118}
166119
167120#[ cfg( feature = "debug" ) ]
168121impl core:: fmt:: Debug for LazyLinearMemory {
169122 fn fmt ( & self , f : & mut core:: fmt:: Formatter < ' _ > ) -> core:: fmt:: Result {
170- f. debug_struct ( "LazyLinearMemory" )
171- . field ( "ty" , & self . ty )
172- . field ( "materialized" , & self . inner . borrow ( ) . is_some ( ) )
173- . finish ( )
123+ f. debug_struct ( "LazyLinearMemory" ) . field ( "ty" , & self . ty ) . field ( "materialized" , & self . inner . is_some ( ) ) . finish ( )
174124 }
175125}
0 commit comments