Skip to content

Commit 957b62b

Browse files
fix: 64 bit table addressing
Signed-off-by: Henry <mail@henrygressmann.de>
1 parent f99b3a9 commit 957b62b

13 files changed

Lines changed: 228 additions & 150 deletions

File tree

‎crates/cli/src/output.rs‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -57,8 +57,12 @@ pub fn format_memory_type(ty: &MemoryType) -> String {
5757
}
5858

5959
pub fn format_table_type(ty: &TableType) -> String {
60+
let arch = match ty.arch() {
61+
MemoryArch::I32 => "i32",
62+
MemoryArch::I64 => "i64",
63+
};
6064
let max = ty.size_max.map(|v| v.to_string()).unwrap_or_else(|| "unbounded".to_string());
61-
format!("table[{}] initial={} max={max}", format_wasm_type(ty.element_type), ty.size_initial)
65+
format!("table[{arch} {}] initial={} max={max}", format_wasm_type(ty.element_type), ty.size_initial)
6266
}
6367

6468
pub fn format_global_type(ty: &GlobalType) -> String {

‎crates/cli/src/wast_runner.rs‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -159,6 +159,11 @@ impl WastRunner {
159159
TableType::new(WasmType::RefFunc, 10, Some(20)),
160160
WasmValue::default_for(WasmType::RefFunc),
161161
)?;
162+
let table64 = Table::new(
163+
store,
164+
TableType::new64(WasmType::RefFunc, 10, Some(20)),
165+
WasmValue::default_for(WasmType::RefFunc),
166+
)?;
162167
let memory = Memory::new(store, MemoryType::default().with_page_count_initial(1).with_page_count_max(Some(2)))?;
163168
let global_i32 =
164169
Global::new(store, tinywasm::types::GlobalType::new(WasmType::I32, false), WasmValue::I32(666))?;
@@ -172,6 +177,7 @@ impl WastRunner {
172177
imports
173178
.define("spectest", "memory", memory)
174179
.define("spectest", "table", table)
180+
.define("spectest", "table64", table64)
175181
.define("spectest", "global_i32", global_i32)
176182
.define("spectest", "global_i64", global_i64)
177183
.define("spectest", "global_f32", global_f32)

‎crates/parser/src/conversion.rs‎

Lines changed: 5 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -60,8 +60,11 @@ pub(crate) fn convert_module_import(import: wasmparser::Import<'_>) -> Result<Im
6060
wasmparser::TypeRef::Func(ty) => ImportKind::Function(ty),
6161
wasmparser::TypeRef::Table(ty) => {
6262
let element_type = convert_reftype(ty.element_type)?;
63-
let (size_initial, size_max) = convert_table_limits(ty)?;
64-
ImportKind::Table(TableType { element_type, size_initial, size_max })
63+
ImportKind::Table(if ty.table64 {
64+
TableType::new64(element_type, ty.initial, ty.maximum)
65+
} else {
66+
TableType::new(element_type, ty.initial, ty.maximum)
67+
})
6568
}
6669
wasmparser::TypeRef::Memory(ty) => ImportKind::Memory(convert_module_memory(ty)),
6770
wasmparser::TypeRef::Global(ty) => {
@@ -87,25 +90,6 @@ pub(crate) fn convert_module_memory(memory: wasmparser::MemoryType) -> MemoryTyp
8790
)
8891
}
8992

90-
pub(crate) fn convert_module_table(table: wasmparser::Table<'_>) -> Result<TableType> {
91-
let (size_initial, size_max) = convert_table_limits(table.ty)?;
92-
Ok(TableType { element_type: convert_reftype(table.ty.element_type)?, size_initial, size_max })
93-
}
94-
95-
fn convert_table_limits(table: wasmparser::TableType) -> Result<(u32, Option<u32>)> {
96-
let size_initial = table.initial.try_into().map_err(|_| {
97-
crate::ParseError::UnsupportedOperator(format!("Table size initial is too large: {}", table.initial))
98-
})?;
99-
let size_max = table
100-
.maximum
101-
.map(|max| {
102-
u32::try_from(max)
103-
.map_err(|_| crate::ParseError::UnsupportedOperator(format!("Table size max is too large: {max}")))
104-
})
105-
.transpose()?;
106-
Ok((size_initial, size_max))
107-
}
108-
10993
pub(crate) fn convert_module_globals(
11094
globals: wasmparser::SectionLimited<'_, wasmparser::Global<'_>>,
11195
) -> Result<Box<[Global]>> {

‎crates/parser/src/module.rs‎

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -128,8 +128,18 @@ impl<'a> ModuleReader<'a> {
128128
if let Some(validator) = validator.as_mut() {
129129
validator.table_section(&reader)?;
130130
}
131-
self.table_types =
132-
reader.into_iter().map(|table| convert_module_table(table?)).collect::<Result<_>>()?;
131+
self.table_types = reader
132+
.into_iter()
133+
.map(|table| {
134+
let table = table?;
135+
let element_type = convert_reftype(table.ty.element_type)?;
136+
Ok(if table.ty.table64 {
137+
TableType::new64(element_type, table.ty.initial, table.ty.maximum)
138+
} else {
139+
TableType::new(element_type, table.ty.initial, table.ty.maximum)
140+
})
141+
})
142+
.collect::<Result<_>>()?;
133143
}
134144
Payload::MemorySection(reader) => {
135145
check_section("memory", !self.memory_types.is_empty())?;

‎crates/parser/src/visit.rs‎

Lines changed: 6 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -168,14 +168,14 @@ impl ModuleMetadata {
168168
ImportKind::Function(ty) => functions.push(*ty),
169169
ImportKind::Global(ty) => global_sizes.push(OperandSize::from(&ty.ty)),
170170
ImportKind::Memory(ty) => memory_sizes.push(OperandSize::from(ty.arch())),
171-
ImportKind::Table(_) => table_sizes.push(OperandSize::S32),
171+
ImportKind::Table(ty) => table_sizes.push(OperandSize::from(ty.arch())),
172172
}
173173
}
174174

175175
functions.extend_from_slice(code_type_addrs);
176176
global_sizes.extend(globals.iter().map(|global| OperandSize::from(&global.ty.ty)));
177177
memory_sizes.extend(memories.iter().map(|ty| OperandSize::from(ty.arch())));
178-
table_sizes.extend(tables.iter().map(|_| OperandSize::S32));
178+
table_sizes.extend(tables.iter().map(|ty| OperandSize::from(ty.arch())));
179179

180180
let signatures = types
181181
.iter()
@@ -653,13 +653,10 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder<'_> {
653653
}
654654

655655
fn visit_table_copy(&mut self, dst_table: u32, src_table: u32) -> Self::Output {
656-
self.metadata.table_size(dst_table)?;
657-
self.metadata.table_size(src_table)?;
658-
self.emit(
659-
&[OperandSize::S32, OperandSize::S32, OperandSize::S32],
660-
&[],
661-
Instruction::TableCopy { dst_table, src_table },
662-
)
656+
let dst = self.metadata.table_size(dst_table)?;
657+
let src = self.metadata.table_size(src_table)?;
658+
let len = if dst == OperandSize::S32 || src == OperandSize::S32 { OperandSize::S32 } else { OperandSize::S64 };
659+
self.emit(&[dst, src, len], &[], Instruction::TableCopy { dst_table, src_table })
663660
}
664661

665662
fn visit_memory_copy(&mut self, dst_mem: u32, src_mem: u32) -> Self::Output {

‎crates/tinywasm/src/imports.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -158,6 +158,7 @@ impl Imports {
158158
}
159159

160160
fn compare_table_types(import: &Import, expected: &TableType, actual: &TableType) -> Result<()> {
161+
Self::compare_types(import, &actual.arch(), &expected.arch())?;
161162
Self::compare_types(import, &actual.element_type, &expected.element_type)?;
162163
if actual.size_initial > expected.size_initial {
163164
cold_path();
@@ -248,8 +249,8 @@ impl Imports {
248249
}
249250
(ExternVal::Table(table_addr), ImportKind::Table(ty)) => {
250251
let table = store.state.get_table(table_addr);
251-
let mut kind = table.kind.clone();
252-
kind.size_initial = table.size() as u32;
252+
let mut kind = table.kind;
253+
kind.size_initial = table.size() as u64;
253254
Self::compare_table_types(import, &kind, ty)?;
254255
imports.tables.push(table_addr);
255256
}

‎crates/tinywasm/src/instance.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -172,7 +172,7 @@ impl ModuleInstance {
172172
let idx = store.next_module_instance_idx();
173173
let mut addrs = imports.unwrap_or_default().link(store, module)?;
174174
addrs.funcs.extend(store.init_funcs(&module.funcs, idx));
175-
addrs.tables.extend(store.init_tables(&module.table_types));
175+
addrs.tables.extend(store.init_tables(&module.table_types)?);
176176
match module.local_memory_allocation {
177177
LocalMemoryAllocation::Skip => {}
178178
LocalMemoryAllocation::Lazy => {

‎crates/tinywasm/src/interpreter/executor.rs‎

Lines changed: 65 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -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

‎crates/tinywasm/src/reference.rs‎

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -346,7 +346,7 @@ impl Table {
346346
_ => return Err(Error::other("invalid table init value")),
347347
};
348348
let addr = store.state.tables.len() as TableAddr;
349-
store.state.tables.push(TableInstance::new_with_init(ty, init));
349+
store.state.tables.push(TableInstance::new_with_init(ty, init)?);
350350
Ok(Self(StoreItem::new(store.id(), addr)))
351351
}
352352

@@ -364,17 +364,17 @@ impl Table {
364364

365365
/// Get the type of the table.
366366
pub fn ty(&self, store: &Store) -> Result<TableType> {
367-
Ok(self.instance(store)?.kind.clone())
367+
Ok(self.instance(store)?.kind)
368368
}
369369

370370
/// Get the current number of elements in the table.
371371
pub fn size(&self, store: &Store) -> Result<usize> {
372-
Ok(self.instance(store)?.size() as usize)
372+
Ok(self.instance(store)?.size())
373373
}
374374

375375
/// Get a table element as a wasm reference value.
376376
pub fn get(&self, store: &Store, index: TableAddr) -> Result<WasmValue> {
377-
Ok(self.instance(store)?.get_wasm_val(index)?)
377+
Ok(self.instance(store)?.get_wasm_val(index as usize)?)
378378
}
379379

380380
/// Load a range of table elements and iterate over wasm reference values.
@@ -394,7 +394,7 @@ impl Table {
394394
pub fn set(&self, store: &mut Store, index: TableAddr, value: WasmValue) -> Result<(), Trap> {
395395
let table = self.instance_mut(store)?;
396396
let value = table_value_to_element(table.kind.element_type, value)?;
397-
table.set(index, value)
397+
table.set(index as usize, value)
398398
}
399399

400400
/// Copy elements within the same table.
@@ -406,8 +406,9 @@ impl Table {
406406
pub fn grow(&self, store: &mut Store, delta: i32, init: WasmValue) -> Result<usize> {
407407
self.0.validate_store(store)?;
408408
let table = store.state.get_table_mut(self.0.addr);
409-
let old_size = table.size() as usize;
409+
let old_size = table.size();
410410
let init = table_value_to_element(table.kind.element_type, init)?;
411+
let delta = usize::try_from(delta).map_err(|_| Trap::TableOutOfBounds { offset: 0, len: 1, max: old_size })?;
411412
table.grow(delta, init)?;
412413
Ok(old_size)
413414
}

0 commit comments

Comments
 (0)