Add heap_load, heap_store, and heap_addr instructions.

These are used when lowering WebAssembly sandbox code.

lib/cretonne/meta/base/formats.py

@@ -8,7 +8,8 @@ in this module.
 from __future__ import absolute_import
 from cdsl.formats import InstructionFormat
 from cdsl.operands import VALUE, VARIABLE_ARGS
-from .immediates import imm64, uimm8, ieee32, ieee64, offset32, intcc, floatcc
+from .immediates import imm64, uimm8, ieee32, ieee64, offset32, uoffset32
+from .immediates import intcc, floatcc
 from .entities import ebb, sig_ref, func_ref, jump_table, stack_slot
 
 Nullary = InstructionFormat()
@@ -55,5 +56,10 @@ IndirectCall = InstructionFormat(
 StackLoad = InstructionFormat(stack_slot, offset32)
 StackStore = InstructionFormat(VALUE, stack_slot, offset32)
 
+# Accessing a WebAssembly heap.
+# TODO: Add a reference to a `heap` declared in the preamble.
+HeapLoad = InstructionFormat(VALUE, uoffset32)
+HeapStore = InstructionFormat(VALUE, VALUE, uoffset32)
+
 # Finally extract the names of global variables in this module.
 InstructionFormat.extract_names(globals())

lib/cretonne/meta/base/instructions.py

@@ -9,7 +9,7 @@ from cdsl.operands import Operand, VARIABLE_ARGS
 from cdsl.typevar import TypeVar
 from cdsl.instructions import Instruction, InstructionGroup
 from base.types import i8, f32, f64, b1
-from base.immediates import imm64, uimm8, ieee32, ieee64, offset32
+from base.immediates import imm64, uimm8, ieee32, ieee64, offset32, uoffset32
 from base.immediates import intcc, floatcc
 from base import entities
 import base.formats  # noqa
@@ -209,6 +209,7 @@ SS = Operand('SS', entities.stack_slot)
 Offset = Operand('Offset', offset32, 'In-bounds offset into stack slot')
 x = Operand('x', Mem, doc='Value to be stored')
 a = Operand('a', Mem, doc='Value loaded')
+p = Operand('p', iAddr)
 addr = Operand('addr', iAddr)
 
 stack_load = Instruction(
@@ -247,6 +248,44 @@ stack_addr = Instruction(
         """,
         ins=(SS, Offset), outs=addr)
 
+#
+# WebAssembly bounds-checked heap accesses.
+#
+# TODO: Add a `heap` operand that selects between multiple heaps.
+# TODO: Should the immediate offset be a `u32`?
+# TODO: Distinguish between `iAddr` for a heap and for a target address? i.e.,
+#       32-bit WebAssembly on a 64-bit target has two different types.
+
+Offset = Operand('Offset', uoffset32, 'Unsigned offset to effective address')
+
+heap_load = Instruction(
+        'heap_load', r"""
+        Load a value at the address :math:`p + Offset` in the heap H.
+
+        Trap if the heap access would be out of bounds.
+        """,
+        ins=(p, Offset), outs=a)
+
+heap_store = Instruction(
+        'heap_store', r"""
+        Store a value at the address :math:`p + Offset` in the heap H.
+
+        Trap if the heap access would be out of bounds.
+        """,
+        ins=(x, p, Offset))
+
+heap_addr = Instruction(
+        'heap_addr', r"""
+        Bounds check and compute absolute address of heap memory.
+
+        Verify that the address range ``p .. p + Size - 1`` is valid in the
+        heap H, and trap if not.
+
+        Convert the heap-relative address in ``p`` to a real absolute address
+        and return it.
+        """,
+        ins=(p, Offset), outs=addr)
+
 #
 # Materializing constants.
 #