@@ -9,7 +9,7 @@ use alloc::rc::Rc;
99use alloc:: vec:: Vec ;
1010
1111use alloc:: sync:: Arc ;
12- use interpreter:: stack:: CallFrame ;
12+ use interpreter:: stack:: { CallFrame , ValueStack } ;
1313use tinywasm_types:: * ;
1414
1515use super :: ExecState ;
@@ -31,6 +31,19 @@ pub(crate) struct Executor<'store, const BUDGETED: bool> {
3131}
3232
3333impl < ' store , const BUDGETED : bool > Executor < ' store , BUDGETED > {
34+ #[ inline( always) ]
35+ fn pop_memory_addr < const N : usize > (
36+ stack : & mut ValueStack ,
37+ mem : & MemoryInstance ,
38+ offset : u64 ,
39+ ) -> Result < usize , Trap > {
40+ if mem. is_64bit ( ) {
41+ mem. effective_addr_64 :: < N > ( <i64 >:: stack_pop ( stack) as u64 , offset)
42+ } else {
43+ mem. effective_addr_32 :: < N > ( <i32 >:: stack_pop ( stack) as u32 , offset)
44+ }
45+ }
46+
3447 pub ( crate ) fn new ( store : & ' store mut Store , cf : CallFrame , call_stack_base : u32 ) -> Self {
3548 let wasm_func = store. state . get_wasm_func ( cf. func_addr ) ;
3649 let module = store. get_module_instance_internal ( wasm_func. owner ) ;
@@ -240,18 +253,10 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
240253 } } ;
241254 }
242255
243- let Some ( next) = self . func . instructions . get ( self . cf . instr_ptr ) else {
244- unreachable ! (
245- "Instruction pointer out of bounds: {} ({} instructions)" ,
246- self . cf. instr_ptr,
247- self . func. instructions. len( )
248- )
249- } ;
250-
251256 use tinywasm_types:: Instruction :: * ;
252257 #[ rustfmt:: skip]
253- match next {
254- Unreachable => return Err ( Trap :: Unreachable ) ,
258+ match & self . func . instructions [ self . cf . instr_ptr ] {
259+ Unreachable => { cold_path ( ) ; return Err ( Trap :: Unreachable ) } ,
255260 Drop32 => { _ = Value32 :: stack_pop ( & mut self . store . value_stack ) } ,
256261 Drop64 => { _ = Value64 :: stack_pop ( & mut self . store . value_stack ) } ,
257262 Drop128 => { _ = Value128 :: stack_pop ( & mut self . store . value_stack ) } ,
@@ -755,10 +760,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
755760 I64x2ExtendHighI32x4S => stack_op ! ( unary Value128 , |a| a. i64x2_extend_high_i32x4_s( ) ) ,
756761 I64x2ExtendHighI32x4U => stack_op ! ( unary Value128 , |a| a. i64x2_extend_high_i32x4_u( ) ) ,
757762 I8x16Popcnt => stack_op ! ( unary Value128 , |v| v. i8x16_popcnt( ) ) ,
758- I8x16Shuffle ( idx) => {
759- let mask = self . func . data . v128_const ( * idx) ;
760- stack_op ! ( binary Value128 , |a, b| Value128 :: i8x16_shuffle( a, b, Value128 ( mask) ) )
761- } ,
763+ I8x16Shuffle ( idx) => stack_op ! ( binary Value128 , |a, b| Value128 :: i8x16_shuffle( a, b, Value128 ( self . func. data. v128_const( * idx) ) ) ) ,
762764 I16x8Q15MulrSatS => stack_op ! ( binary Value128 , |a, b| a. i16x8_q15mulr_sat_s( b) ) ,
763765 I32x4DotI16x8S => stack_op ! ( binary Value128 , |a, b| a. i32x4_dot_i16x8_s( b) ) ,
764766 I8x16RelaxedLaneselect => stack_op ! ( ternary Value128 , |a, b, c| Value128 :: i8x16_relaxed_laneselect( a, b, c) ) ,
@@ -822,7 +824,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
822824 I32x4RelaxedTruncF64x2UZero => stack_op ! ( unary Value128 , |v| v. i32x4_relaxed_trunc_f64x2_u_zero( ) ) ,
823825 } ;
824826
825- self . cf . incr_instr_ptr ( ) ;
827+ self . cf . instr_ptr += 1 ;
826828
827829 Ok ( None )
828830 }
@@ -985,7 +987,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
985987 } ;
986988
987989 self . store . value_stack . extend_from_wasmvalues ( & res) ?;
988- self . cf . incr_instr_ptr ( ) ;
990+ self . cf . instr_ptr += 1 ;
989991 Ok ( ( ) )
990992 }
991993
@@ -1140,10 +1142,11 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
11401142 addr_local : u8 ,
11411143 value_local : u8 ,
11421144 ) -> Result < ( ) , Trap > {
1143- let addr = u64 :: from ( u32:: local_get ( & self . store . value_stack , & self . cf , u16:: from ( addr_local) ) ) ;
1144- let value = T :: local_get ( & self . store . value_stack , & self . cf , u16:: from ( value_local) ) . to_mem_bytes ( ) ;
1145+ let base = u32:: local_get ( & self . store . value_stack , & self . cf , u16:: from ( addr_local) ) ;
1146+ let value = T :: local_get ( & self . store . value_stack , & self . cf , u16:: from ( value_local) ) ;
11451147 let mem = self . store . state . get_mem_mut ( self . module . resolve_mem_addr ( memarg. mem_addr ( ) ) ) ;
1146- mem. store ( addr, memarg. offset ( ) , value) ?;
1148+ let addr = mem. effective_addr_32 :: < N > ( base, memarg. offset ( ) ) ?;
1149+ value. store_at ( & mut * mem. inner , addr) ?;
11471150 Ok ( ( ) )
11481151 }
11491152
@@ -1161,7 +1164,8 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
11611164 let addr = i32:: stack_pop ( & mut self . store . value_stack ) ;
11621165 let fma = acc + lhs * rhs;
11631166 let mem = self . store . state . get_mem_mut ( self . module . resolve_mem_addr ( m. mem_addr ( ) ) ) ;
1164- mem. store ( addr as u32 as u64 , m. offset ( ) , fma. to_mem_bytes ( ) ) ?;
1167+ let addr = mem. effective_addr_32 :: < N > ( addr as u32 , m. offset ( ) ) ?;
1168+ fma. store_at ( & mut * mem. inner , addr) ?;
11651169 Ok ( ( ) )
11661170 }
11671171
@@ -1183,9 +1187,15 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
11831187 addr_local : u8 ,
11841188 ) -> Result < T , Trap > {
11851189 let mem = self . store . state . get_mem ( self . module . resolve_mem_addr ( memarg. mem_addr ( ) ) ) ;
1186- let addr = u64:: from ( u32:: local_get ( & self . store . value_stack , & self . cf , u16:: from ( addr_local) ) ) ;
1187- let bytes = mem. load ( addr, memarg. offset ( ) ) ?;
1188- Ok ( T :: from_mem_bytes ( bytes) )
1190+ let base = u32:: local_get ( & self . store . value_stack , & self . cf , u16:: from ( addr_local) ) ;
1191+ let addr = mem. effective_addr_32 :: < N > ( base, memarg. offset ( ) ) ?;
1192+ match T :: load_at ( & * mem. inner , addr) {
1193+ Ok ( res) => Ok ( res) ,
1194+ Err ( err) => {
1195+ cold_path ( ) ;
1196+ Err ( err)
1197+ }
1198+ }
11891199 }
11901200
11911201 fn exec_load_local_tee < T : InternalValue + MemValue < N > , const N : usize > (
@@ -1375,20 +1385,11 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
13751385 lane : u8 ,
13761386 ) -> Result < ( ) , Trap > {
13771387 let mem = self . store . state . get_mem ( self . module . resolve_mem_addr ( mem_addr) ) ;
1378- let base = match mem. is_64bit ( ) {
1379- true => <i64 >:: stack_pop ( & mut self . store . value_stack ) as u64 ,
1380- false => <i32 >:: stack_pop ( & mut self . store . value_stack ) as u32 as u64 ,
1381- } ;
1382- let val = match mem. load :: < LOAD_SIZE > ( base, offset) {
1383- Ok ( val) => val,
1384- Err ( e) => {
1385- cold_path ( ) ;
1386- return Err ( e) ;
1387- }
1388- } ;
1388+ let addr = Self :: pop_memory_addr :: < LOAD_SIZE > ( & mut self . store . value_stack , mem, offset) ?;
1389+ let val = LOAD :: load_at ( & * mem. inner , addr) ?;
13891390 let offset = lane as usize * LOAD_SIZE ;
13901391 let mut imm = <Value128 >:: stack_pop ( & mut self . store . value_stack ) . to_mem_bytes ( ) ;
1391- imm[ offset..offset + LOAD_SIZE ] . copy_from_slice ( & val) ;
1392+ imm[ offset..offset + LOAD_SIZE ] . copy_from_slice ( & val. to_mem_bytes ( ) ) ;
13921393 self . store . value_stack . push ( Value128 ( imm) ) ?;
13931394 Ok ( ( ) )
13941395 }
@@ -1401,12 +1402,9 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
14011402 cast : impl Fn ( LOAD ) -> TARGET ,
14021403 ) -> Result < ( ) , Trap > {
14031404 let mem = self . store . state . get_mem ( self . module . resolve_mem_addr ( mem_addr) ) ;
1404- let base = match mem. is_64bit ( ) {
1405- true => <i64 >:: stack_pop ( & mut self . store . value_stack ) as u64 ,
1406- false => <i32 >:: stack_pop ( & mut self . store . value_stack ) as u32 as u64 ,
1407- } ;
1405+ let addr = Self :: pop_memory_addr :: < LOAD_SIZE > ( & mut self . store . value_stack , mem, offset) ?;
14081406
1409- match LOAD :: load ( & * mem. inner , base , offset ) {
1407+ match LOAD :: load_at ( & * mem. inner , addr ) {
14101408 Ok ( val) => {
14111409 self . store . value_stack . push ( cast ( val) ) ?;
14121410 Ok ( ( ) )
@@ -1426,15 +1424,13 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
14261424 ) -> Result < ( ) , Trap > {
14271425 let bytes = <Value128 >:: stack_pop ( & mut self . store . value_stack ) . to_mem_bytes ( ) ;
14281426 let lane_offset = lane as usize * N ;
1429- let mut val = [ 0u8 ; N ] ;
1430- val. copy_from_slice ( & bytes[ lane_offset..lane_offset + N ] ) ;
1427+ let mut val_bytes = [ 0u8 ; N ] ;
1428+ val_bytes. copy_from_slice ( & bytes[ lane_offset..lane_offset + N ] ) ;
1429+ let val = U :: from_mem_bytes ( val_bytes) ;
14311430 let mem_addr = self . module . resolve_mem_addr ( mem_addr) ;
14321431 let mem = self . store . state . get_mem_mut ( mem_addr) ;
1433- let addr = match mem. is_64bit ( ) {
1434- true => <i64 >:: stack_pop ( & mut self . store . value_stack ) as u64 ,
1435- false => <i32 >:: stack_pop ( & mut self . store . value_stack ) as u32 as u64 ,
1436- } ;
1437- match mem. store ( addr, offset, val) {
1432+ let addr = Self :: pop_memory_addr :: < N > ( & mut self . store . value_stack , mem, offset) ?;
1433+ match val. store_at ( & mut * mem. inner , addr) {
14381434 Ok ( ( ) ) => Ok ( ( ) ) ,
14391435 Err ( e) => {
14401436 cold_path ( ) ;
@@ -1450,15 +1446,12 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
14501446 cast : impl Fn ( T ) -> U ,
14511447 ) -> Result < ( ) , Trap > {
14521448 let val = <T >:: stack_pop ( & mut self . store . value_stack ) ;
1453- let val = cast ( val) . to_mem_bytes ( ) ;
1449+ let val = cast ( val) ;
14541450
14551451 let mem_addr = self . module . resolve_mem_addr ( mem_addr) ;
14561452 let mem = self . store . state . get_mem_mut ( mem_addr) ;
1457- let addr = match mem. is_64bit ( ) {
1458- true => <i64 >:: stack_pop ( & mut self . store . value_stack ) as u64 ,
1459- false => <i32 >:: stack_pop ( & mut self . store . value_stack ) as u32 as u64 ,
1460- } ;
1461- match mem. store ( addr, offset, val) {
1453+ let addr = Self :: pop_memory_addr :: < N > ( & mut self . store . value_stack , mem, offset) ?;
1454+ match val. store_at ( & mut * mem. inner , addr) {
14621455 Ok ( ( ) ) => Ok ( ( ) ) ,
14631456 Err ( e) => {
14641457 cold_path ( ) ;
0 commit comments