@@ -1036,18 +1036,19 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
10361036 self . charge_call_fuel ( FUEL_COST_CALL_TOTAL ) ;
10371037
10381038 // verify that the table is of the right type, this should be validated by the parser already
1039- let table_idx: u32 = <i32 >:: stack_pop ( & mut self . store . value_stack ) as u32 ;
1040- let table = self . store . state . get_table ( self . module . resolve_table_addr ( table_addr) ) ;
1039+ let table_addr = self . module . resolve_table_addr ( table_addr) ;
1040+ let table_idx = self . pop_table_operand ( self . store . state . get_table ( table_addr) . kind . arch ( ) ) ?;
1041+ let table = self . store . state . get_table ( table_addr) ;
10411042 debug_assert ! ( table. kind. element_type == WasmType :: RefFunc , "table is not of type funcref" ) ;
10421043
10431044 let Ok ( table) = table. get ( table_idx) else {
10441045 cold_path ( ) ;
1045- return Err ( Trap :: UndefinedElement { index : table_idx as usize } ) ;
1046+ return Err ( Trap :: UndefinedElement { index : table_idx } ) ;
10461047 } ;
10471048
10481049 let Some ( func_ref) = table. addr ( ) else {
10491050 cold_path ( ) ;
1050- return Err ( Trap :: UninitializedElement { index : table_idx as usize } ) ;
1051+ return Err ( Trap :: UninitializedElement { index : table_idx } ) ;
10511052 } ;
10521053
10531054 let call_ty = self . module . func_type_by_type_index ( type_addr) ;
@@ -1347,19 +1348,23 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
13471348 }
13481349
13491350 fn exec_table_copy ( & mut self , dst_table : u32 , src_table : u32 ) -> Result < ( ) , Trap > {
1350- let size = i32:: stack_pop ( & mut self . store . value_stack ) ;
1351- let src = i32:: stack_pop ( & mut self . store . value_stack ) ;
1352- let dst = i32:: stack_pop ( & mut self . store . value_stack ) ;
13531351 let dst_table_addr = self . module . resolve_table_addr ( dst_table) ;
1354-
1355- if dst_table == src_table {
1352+ let src_table_addr = self . module . resolve_table_addr ( src_table) ;
1353+ let dst_arch = self . store . state . get_table ( dst_table_addr) . kind . arch ( ) ;
1354+ let src_arch = self . store . state . get_table ( src_table_addr) . kind . arch ( ) ;
1355+ let len_arch =
1356+ if dst_arch == MemoryArch :: I32 || src_arch == MemoryArch :: I32 { MemoryArch :: I32 } else { MemoryArch :: I64 } ;
1357+ let size = self . pop_table_operand ( len_arch) ?;
1358+ let src = self . pop_table_operand ( src_arch) ?;
1359+ let dst = self . pop_table_operand ( dst_arch) ?;
1360+
1361+ if dst_table_addr == src_table_addr {
13561362 // copy within the same table
1357- self . store . state . get_table_mut ( dst_table_addr) . copy_within ( dst as usize , src as usize , size as usize )
1363+ self . store . state . get_table_mut ( dst_table_addr) . copy_within ( dst, src, size)
13581364 } else {
13591365 // copy between two tables
1360- let src_table_addr = self . module . resolve_table_addr ( src_table) ;
13611366 let ( dst_table_ref, src_table_ref) = self . store . state . get_tables_mut ( dst_table_addr, src_table_addr) ;
1362- dst_table_ref. copy_from_slice ( dst as usize , src_table_ref. load ( src as usize , size as usize ) ?)
1367+ dst_table_ref. copy_from_slice ( dst, src_table_ref. load ( src, size) ?)
13631368 }
13641369 }
13651370
@@ -1463,87 +1468,83 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
14631468 }
14641469
14651470 fn exec_table_get ( & mut self , table_index : u32 ) -> Result < ( ) , Trap > {
1466- let idx : i32 = < i32 > :: stack_pop ( & mut self . store . value_stack ) ;
1467- let table = self . store . state . get_table ( self . module . resolve_table_addr ( table_index ) ) ;
1468- let v = table . get_wasm_val ( idx as u32 ) ?;
1471+ let table_addr = self . module . resolve_table_addr ( table_index ) ;
1472+ let idx = self . pop_table_operand ( self . store . state . get_table ( table_addr ) . kind . arch ( ) ) ? ;
1473+ let v = self . store . state . get_table ( table_addr ) . get_wasm_val ( idx) ?;
14691474 self . store . value_stack . push_dyn ( v. into ( ) )
14701475 }
14711476
14721477 fn exec_table_set ( & mut self , table_index : u32 ) -> Result < ( ) , Trap > {
14731478 let val = <ValueRef >:: stack_pop ( & mut self . store . value_stack ) ;
1474- let idx = <i32 >:: stack_pop ( & mut self . store . value_stack ) as u32 ;
1475- let table = self . store . state . get_table_mut ( self . module . resolve_table_addr ( table_index) ) ;
1479+ let table_addr = self . module . resolve_table_addr ( table_index) ;
1480+ let idx = self . pop_table_operand ( self . store . state . get_table ( table_addr) . kind . arch ( ) ) ?;
1481+ let table = self . store . state . get_table_mut ( table_addr) ;
14761482 table. set ( idx, val. addr ( ) . into ( ) )
14771483 }
14781484
14791485 fn exec_table_size ( & mut self , table_index : u32 ) -> Result < ( ) , Trap > {
14801486 let table = self . store . state . get_table ( self . module . resolve_table_addr ( table_index) ) ;
1481- self . store . value_stack . push ( table. size ( ) )
1487+ match table. kind . arch ( ) {
1488+ MemoryArch :: I32 => self . store . value_stack . push ( table. size ( ) as i32 ) ,
1489+ MemoryArch :: I64 => self . store . value_stack . push ( table. size ( ) as i64 ) ,
1490+ }
14821491 }
14831492
14841493 fn exec_table_init ( & mut self , elem_index : u32 , table_index : u32 ) -> Result < ( ) , Trap > {
1485- let size = i32:: stack_pop ( & mut self . store . value_stack ) ; // n
1486- let offset = i32:: stack_pop ( & mut self . store . value_stack ) ; // s
1487- let dst = i32:: stack_pop ( & mut self . store . value_stack ) ; // d
1494+ let size = self . pop_table_operand ( MemoryArch :: I32 ) ?; // n
1495+ let offset = self . pop_table_operand ( MemoryArch :: I32 ) ?; // s
1496+ let table_addr = self . module . resolve_table_addr ( table_index) ;
1497+ let dst = self . pop_table_operand ( self . store . state . get_table ( table_addr) . kind . arch ( ) ) ?; // d
14881498 let elem_addr = self . module . resolve_elem_addr ( elem_index) as usize ;
14891499 let elem = self . store . state . elements . get ( elem_addr) . ok_or_else ( || Trap :: Other ( "element not found" ) ) ?;
1490-
1491- let table_addr = self . module . resolve_table_addr ( table_index) as usize ;
1492- let table = self . store . state . tables . get_mut ( table_addr) . ok_or_else ( || Trap :: Other ( "table not found" ) ) ?;
1493-
1494- let elem_len = elem. items . as_ref ( ) . map_or ( 0 , alloc:: vec:: Vec :: len) ;
1495- let table_len = table. size ( ) ;
1496-
1497- if size < 0 || ( ( size + offset) as usize > elem_len) || ( ( dst + size) > table_len) {
1500+ // Element kind storage is removed separately; table.init only depends on retained items.
1501+ let _ = & elem. kind ;
1502+ let items = elem. items . as_deref ( ) . unwrap_or ( & [ ] ) ;
1503+ let Some ( end) = offset. checked_add ( size) else {
14981504 cold_path ( ) ;
1499- return Err ( Trap :: TableOutOfBounds { offset : offset as usize , len : size as usize , max : elem_len } ) ;
1500- }
1501-
1502- if size == 0 {
1503- return Ok ( ( ) ) ;
1504- }
1505-
1506- if let ElementKind :: Active { .. } = elem. kind {
1505+ return Err ( Trap :: TableOutOfBounds { offset, len : size, max : items. len ( ) } ) ;
1506+ } ;
1507+ if end > items. len ( ) {
15071508 cold_path ( ) ;
1508- return Err ( Trap :: Other ( "table.init with active element" ) ) ;
1509+ return Err ( Trap :: TableOutOfBounds { offset , len : size , max : items . len ( ) } ) ;
15091510 }
15101511
1511- let Some ( items) = elem. items . as_ref ( ) else {
1512- cold_path ( ) ;
1513- return Err ( Trap :: TableOutOfBounds { offset : 0 , len : 0 , max : 0 } ) ;
1514- } ;
1515-
1516- table. init ( i64:: from ( dst) , & items[ offset as usize ..( offset + size) as usize ] )
1512+ let table =
1513+ self . store . state . tables . get_mut ( table_addr as usize ) . ok_or_else ( || Trap :: Other ( "table not found" ) ) ?;
1514+ table. init ( dst, & items[ offset..end] )
15171515 }
15181516
15191517 fn exec_table_grow ( & mut self , table_index : u32 ) -> Result < ( ) , Trap > {
1520- let table = self . store . state . get_table_mut ( self . module . resolve_table_addr ( table_index) ) ;
1521- let sz = table . size ( ) ;
1522- let n = < i32 > :: stack_pop ( & mut self . store . value_stack ) ;
1518+ let table_addr = self . module . resolve_table_addr ( table_index) ;
1519+ let arch = self . store . state . get_table ( table_addr ) . kind . arch ( ) ;
1520+ let n = self . pop_table_operand ( arch ) ? ;
15231521 let val = <ValueRef >:: stack_pop ( & mut self . store . value_stack ) ;
1524- match table. grow ( n, val. addr ( ) . into ( ) ) {
1525- Ok ( ( ) ) => self . store . value_stack . push ( sz) ,
1526- Err ( _) => self . store . value_stack . push ( -1_i32 ) ,
1522+ let table = self . store . state . get_table_mut ( table_addr) ;
1523+ let sz = table. size ( ) ;
1524+ let result = table. grow ( n, val. addr ( ) . into ( ) ) ;
1525+ match ( arch, result) {
1526+ ( MemoryArch :: I32 , Ok ( ( ) ) ) => self . store . value_stack . push ( sz as i32 ) ,
1527+ ( MemoryArch :: I32 , Err ( _) ) => self . store . value_stack . push ( -1_i32 ) ,
1528+ ( MemoryArch :: I64 , Ok ( ( ) ) ) => self . store . value_stack . push ( sz as i64 ) ,
1529+ ( MemoryArch :: I64 , Err ( _) ) => self . store . value_stack . push ( -1_i64 ) ,
15271530 }
15281531 }
15291532
15301533 fn exec_table_fill ( & mut self , table_index : u32 ) -> Result < ( ) , Trap > {
1531- let table = self . store . state . get_table_mut ( self . module . resolve_table_addr ( table_index) ) ;
1532-
1533- let n = < i32 > :: stack_pop ( & mut self . store . value_stack ) ;
1534+ let table_addr = self . module . resolve_table_addr ( table_index) ;
1535+ let arch = self . store . state . get_table ( table_addr ) . kind . arch ( ) ;
1536+ let n = self . pop_table_operand ( arch ) ? ;
15341537 let val = <ValueRef >:: stack_pop ( & mut self . store . value_stack ) ;
1535- let i = <i32 >:: stack_pop ( & mut self . store . value_stack ) ;
1536-
1537- if i + n > table. size ( ) {
1538- cold_path ( ) ;
1539- return Err ( Trap :: TableOutOfBounds { offset : i as usize , len : n as usize , max : table. size ( ) as usize } ) ;
1540- }
1541-
1542- if n == 0 {
1543- return Ok ( ( ) ) ;
1544- }
1538+ let i = self . pop_table_operand ( arch) ?;
1539+ self . store . state . get_table_mut ( table_addr) . fill ( self . module . func_addrs ( ) , i, n, val. addr ( ) . into ( ) )
1540+ }
15451541
1546- table. fill ( self . module . func_addrs ( ) , i as usize , n as usize , val. addr ( ) . into ( ) )
1542+ fn pop_table_operand ( & mut self , arch : MemoryArch ) -> Result < usize , Trap > {
1543+ let value = match arch {
1544+ MemoryArch :: I32 => <i32 >:: stack_pop ( & mut self . store . value_stack ) as u32 as u64 ,
1545+ MemoryArch :: I64 => <i64 >:: stack_pop ( & mut self . store . value_stack ) as u64 ,
1546+ } ;
1547+ usize:: try_from ( value) . map_err ( |_| Trap :: TableOutOfBounds { offset : usize:: MAX , len : 1 , max : usize:: MAX } )
15471548 }
15481549}
15491550
0 commit comments