Add wasm table copy.

windelbouwman · windelbouwman · commit faff486b30be · 2025-08-13T15:38:14.000+02:00
diff --git a/ppci/wasm/execution/_base_instance.py b/ppci/wasm/execution/_base_instance.py
@@ -8,8 +8,6 @@
 class ModuleInstance(abc.ABC):
     """Web assembly module instance"""
 
-    """ Instantiated module """
-
     def __init__(self):
         self.exports = Exports()
         self._tables = []
@@ -23,6 +21,9 @@ def invoke(self, name, *args):
 
     def table_grow(self, table_idx: int, val: int, size: int) -> int:
         logger.debug(f"table_grow({table_idx=}, {size=}, {val=})")
+        if size < 0:
+            # When i32 is large, it's signed value is negative.
+            return -1
         table = self._tables[table_idx]
         return table.grow(val, size)
 
@@ -31,17 +32,45 @@ def table_size(self, table_idx: int) -> int:
         table = self._tables[table_idx]
         return table.size()
 
-    def table_init(self, table_idx: int) -> None:
-        logger.debug(f"table_init({table_idx=})")
-        # _table = self._tables[table_idx]
-        raise NotImplementedError()
-        return 0
-
-    def table_copy(self, table_idx: int) -> None:
-        logger.debug(f"table_copy({table_idx=})")
-        # _table = self._tables[table_idx]
-        raise NotImplementedError()
-        return 0
+    def table_init(
+        self, table_idx: int, elem_idx: int, d: int, s: int, n: int
+    ) -> None:
+        logger.debug(
+            f"table_init({table_idx=}, {elem_idx=}, {d=}, {s=}, {n=})"
+        )
+        table = self._tables[table_idx]
+        elem = self._elems[elem_idx]
+        if s + n > elem.size():
+            raise ValueError("s + n > elem.size")
+        if d + n > table.size():
+            raise ValueError("d + n > table.size")
+        for index in range(n):
+            obj = elem.get_item(s + index)
+            table.set_item(d + index, obj)
+
+    def table_copy(
+        self, x_table_idx: int, y_table_idx: int, d: int, s: int, n: int
+    ) -> None:
+        logger.debug(
+            f"table_copy({x_table_idx=}, {y_table_idx=}, {d=}, {s=}, {n=})"
+        )
+        x_table = self._tables[x_table_idx]
+        y_table = self._tables[y_table_idx]
+        if d + n > x_table.size():
+            raise ValueError("d + n > x_table.size")
+        if s + n > y_table.size():
+            raise ValueError("s + n > y_table.size")
+
+        # Regions may overlap, so check dest and source:
+        if d <= s:
+            for index in range(n):
+                obj = y_table.get_item(s + index)
+                x_table.set_item(d + index, obj)
+        else:
+            for index2 in range(n):
+                index = n - 1 - index2
+                obj = y_table.get_item(s + index)
+                x_table.set_item(d + index, obj)
 
     def table_fill(self, table_idx: int, i: int, val: int, n: int) -> None:
         logger.debug(f"table_fill({table_idx=}, {i=}, {val=}, {n=})")
@@ -50,6 +79,9 @@ def table_fill(self, table_idx: int, i: int, val: int, n: int) -> None:
             index = i + x
             table.set_item(index, val)
 
+    def elem_drop(self, elem_idx: int) -> None:
+        pass
+
     def memory_grow(self, memory_idx: int, amount: int) -> int:
         """Grow memory and return the old size"""
         memory = self._memories[memory_idx]
@@ -99,7 +131,7 @@ def set_table_ptr(self, index, table):
         raise NotImplementedError()
 
     @abc.abstractmethod
-    def create_elem(self):
+    def create_elem(self, index: int, size: int):
         raise NotImplementedError()
 
     def eval_expression(self, expr):
@@ -145,7 +177,9 @@ def load_tables(self, wasm_module):
                 self.set_table_ptr(index, table)
             elif isinstance(definition, components.Elem):
                 elems.append(definition)
-                self.create_elem()
+                index = len(self._elems)
+                size = len(definition.refs)
+                self._elems.append(self.create_elem(index, size))
 
         for index, elem in enumerate(elems):
             if elem.mode:
@@ -191,8 +225,11 @@ def populate_exports(self, module):
 class ElemInstance(abc.ABC):
     """Runtime element instance"""
 
-    def __init__(self):
-        pass
+    def __init__(self, size: int):
+        self._size = size
+
+    def size(self) -> int:
+        return self._size
 
     @abc.abstractmethod
     def get_item(self, index: int):
diff --git a/ppci/wasm/execution/_native_instance.py b/ppci/wasm/execution/_native_instance.py
@@ -113,13 +113,10 @@ def set_table_ptr(self, index, table):
         table_addr = table._meta_page.addr
         self._code_module._data_page.write_fmt(table_ptr, "Q", table_addr)
 
-    def create_elem(self):
-        index = len(self._elems)
+    def create_elem(self, index: int, size: int) -> "NativeElemInstance":
         name = self._wasm_info.elem_names[index]
         offset = self._code_module.get_symbol_offset(name)
-        self._elems.append(
-            NativeElemInstance(offset, self._code_module._data_page)
-        )
+        return NativeElemInstance(offset, self._code_module._data_page, size)
 
     def set_mem_base_ptr(self, base_addr):
         """Set memory base address"""
@@ -256,8 +253,8 @@ def get_item(self, index: int):
 
 
 class NativeElemInstance(ElemInstance):
-    def __init__(self, offset, page):
-        super().__init__()
+    def __init__(self, offset, page, size):
+        super().__init__(size)
         self._offset = offset
         self._page = page
 
diff --git a/ppci/wasm/execution/_python_instance.py b/ppci/wasm/execution/_python_instance.py
@@ -76,6 +76,7 @@ def __init__(self, py_module, imports):
         imports["wasm_rt_table_init"] = self.table_init
         imports["wasm_rt_table_copy"] = self.table_copy
         imports["wasm_rt_table_fill"] = self.table_fill
+        imports["wasm_rt_elem_drop"] = self.elem_drop
 
         imports["wasm_rt_memory_grow"] = self.memory_grow
         imports["wasm_rt_memory_size"] = self.memory_size
@@ -157,11 +158,10 @@ def set_table_ptr(self, index, table):
         addr = getattr(self._py_module, name)
         self.store_ptr(addr, table._get_ptr())
 
-    def create_elem(self) -> "PythonElemInstance":
-        index = len(self._elems)
+    def create_elem(self, index: int, size: int) -> "PythonElemInstance":
         name = self._wasm_info.elem_names[index]
         addr = getattr(self._py_module, name)
-        self._elems.append(PythonElemInstance(addr, self))
+        return PythonElemInstance(addr, self, size)
 
     def get_func_by_index(self, index: int):
         exported_name = self._wasm_info.function_names[index]
@@ -304,6 +304,8 @@ def grow(self, val, count: int) -> int:
         ptr_size = 4
         old_size = self._instance.load_i32(self._addr + ptr_size)
         new_size = old_size + count
+        if new_size > 0xFFFF_FFFF:
+            return -1
         if self._max_size is not None and new_size > self._max_size:
             return -1
         old_addr = self._instance.load_ptr(self._addr)
@@ -327,12 +329,12 @@ def set_item(self, index: int, value):
     def get_item(self, index: int):
         base_ptr = self._get_ptr()
         data_ptr = self._instance.load_ptr(base_ptr) + 4 * index
-        self._instance.load_ptr(data_ptr)
+        return self._instance.load_ptr(data_ptr)
 
 
 class PythonElemInstance(ElemInstance):
-    def __init__(self, addr: int, instance):
-        super().__init__()
+    def __init__(self, addr: int, instance, size):
+        super().__init__(size)
         self._addr = addr
         self._instance = instance
 
diff --git a/ppci/wasm/opcodes.py b/ppci/wasm/opcodes.py
@@ -74,7 +74,7 @@ class Space(enum.Enum):
     (
         "table.init",
         (0xFC, 12),
-        (ArgType.ELEMIDX, ArgType.TABLEIDX),
+        (ArgType.TABLEIDX, ArgType.ELEMIDX),
         ("i32", "i32", "i32"),
         (),
     ),
diff --git a/ppci/wasm/text/parser.py b/ppci/wasm/text/parser.py
@@ -32,7 +32,7 @@ def load_tuple(module, t):
     if not isinstance(t, tuple):
         raise TypeError(f"t must be tuple, not {type(t)}")
 
-    loader = WatTupleLoader(module)
+    loader = WatParser(module)
 
     if any(isinstance(e, components.Definition) for e in t):
         if not all(isinstance(e, components.Definition) for e in t):
@@ -105,18 +105,27 @@ def load_s_expr(module, s):
 
 
 def load_from_s_tokens(module, tokens):
-    loader = WatTupleLoader(module)
+    loader = WatParser(module)
     loader.parse_module(tokens)
 
 
-class WatTupleLoader(RecursiveDescentParser):
+class WatParser(RecursiveDescentParser):
     """WebAssembly text format parser."""
 
     def __init__(self, module):
         super().__init__()
         self.module = module
         self.definitions = defaultdict(list)
         self._type_hash = {}  # (params, results) -> ref
+        self.counters = {
+            "type": 0,
+            "func": 0,
+            "table": 0,
+            "memory": 0,
+            "global": 0,
+            "elem": 0,
+            "data": 0,
+        }
 
         self.resolve_backlog = []
         self.func_backlog = []
@@ -174,12 +183,23 @@ def resolve_references(self):
             "elem": {},
             "data": {},
         }
+        counters = {
+            "type": 0,
+            "func": 0,
+            "table": 0,
+            "memory": 0,
+            "global": 0,
+            "elem": 0,
+            "data": 0,
+        }
 
         # TODO: maybe this is not needed at this point?
         # Fill imports and other objects:
         for d in self.definitions["import"]:
             id_map = id_maps[d.kind]
-            id_map[d.id] = len(id_map)
+            assert d.id not in id_map
+            id_map[d.id] = counters[d.kind]
+            counters[d.kind] += 1
 
         for space in [
             "type",
@@ -192,7 +212,9 @@ def resolve_references(self):
         ]:
             id_map = id_maps[space]
             for d in self.definitions[space]:
-                id_map[d.id] = len(id_map)
+                assert d.id not in id_map
+                id_map[d.id] = counters[space]
+                counters[space] += 1
 
         # resolve any unresolved items:
         for item in self.resolve_backlog:
@@ -231,7 +253,8 @@ def add_definition(self, definition):
         logger.debug(f"Parsed {definition} {nr}")
 
     def gen_id(self, kind):
-        id = len(self.definitions[kind])
+        id = self.counters[kind]
+        self.counters[kind] += 1
         return f"${id}"
 
     # Section types:
@@ -790,6 +813,13 @@ def _gather_opcode_arguments(self, opcode):
             type_ref = self._parse_type_use()
             args = (type_ref, table_ref)
             # TODO: compare unbound func signature with type?
+        elif opcode == "table.init":
+            if is_ref(self.look_ahead(1).val):
+                table_ref = self._parse_ref("table")
+            else:
+                table_ref = self._make_ref("table", 0)
+            elem_ref = self._parse_ref("elem")
+            args = (table_ref, elem_ref)
         else:
             operands = OPERANDS[opcode]
             args = self._parse_operands(operands)
diff --git a/ppci/wasm/wasm2ppci.py b/ppci/wasm/wasm2ppci.py
@@ -666,7 +666,7 @@ def generate_function(self, ppci_function, signature, wasm_function):
             local_id, local_typ = local
             local_id = i if local_id is None else local_id
             ir_typ = self.get_ir_type(local_typ)
-            size = ir_typ.size
+            size = self.get_type_size(local_typ)
             alignment = size
             alloc = self.emit(ir.Alloc("alloc{}".format(i), size, alignment))
             addr = self.emit(ir.AddressOf(alloc, "local{}".format(i)))
@@ -1623,6 +1623,11 @@ def _runtime_call(self, opcode, args=()):
                 assert a.space == "table"
                 arg = self.emit(ir.Const(a.index, "idx", ir.i32))
                 arg_types0.append(ir.i32)
+            elif ai == ArgType.ELEMIDX:
+                assert isinstance(a, components.Ref)
+                assert a.space == "elem"
+                arg = self.emit(ir.Const(a.index, "idx", ir.i32))
+                arg_types0.append(ir.i32)
             else:
                 raise NotImplementedError(str(ai))
             args0.append(arg)
diff --git a/test/wasm/test_suite_full.py b/test/wasm/test_suite_full.py
@@ -355,7 +355,7 @@ def invoke(self, target: SExpression):
         elif any(nan_or_inf(a) for a in args):
             self.logger.warning(f"Not invoking method {func_name}({args})")
         else:
-            self.logger.debug(f"Invoking {func_name} at line {target.loc}")
+            self.logger.debug(f"Invoking '{func_name}' at line {target.loc}")
             return instance.exports[func_name](*args)
 
     def register_instance(self, s_expr):

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ class Space(enum.Enum):`
`74`	`74`	`(`
`75`	`75`	`"table.init",`
`76`	`76`	`(0xFC, 12),`
`77`		`- (ArgType.ELEMIDX, ArgType.TABLEIDX),`
	`77`	`+ (ArgType.TABLEIDX, ArgType.ELEMIDX),`
`78`	`78`	`("i32", "i32", "i32"),`
`79`	`79`	`(),`
`80`	`80`	`),`