932 lines
31 KiB
Python
932 lines
31 KiB
Python
"""
|
|
This module contains the code to convert parsed Ourlang into WebAssembly code
|
|
"""
|
|
import struct
|
|
from typing import Dict, List, Optional
|
|
|
|
from . import codestyle, ourlang, wasm
|
|
from .runtime import calculate_alloc_size, calculate_member_offset
|
|
from .stdlib import alloc as stdlib_alloc
|
|
from .stdlib import types as stdlib_types
|
|
from .type3 import typeclasses as type3classes
|
|
from .type3 import types as type3types
|
|
from .wasmgenerator import Generator as WasmGenerator
|
|
|
|
LOAD_STORE_TYPE_MAP = {
|
|
'i8': 'i32', # Have to use an u32, since there is no native i8 type
|
|
'u8': 'i32', # Have to use an u32, since there is no native u8 type
|
|
|
|
'i32': 'i32',
|
|
'i64': 'i64',
|
|
'u32': 'i32',
|
|
'u64': 'i64',
|
|
'f32': 'f32',
|
|
'f64': 'f64',
|
|
|
|
'bytes': 'i32', # Bytes are passed around as pointers
|
|
}
|
|
|
|
# For now this is nice & clean, but this will get messy quick
|
|
# Especially once we get functions with polymorphying applied types
|
|
INSTANCES = {
|
|
type3classes.Eq.operators['==']: {
|
|
'a=u8': stdlib_types.u8_eq_equals,
|
|
'a=u32': stdlib_types.u32_eq_equals,
|
|
'a=u64': stdlib_types.u64_eq_equals,
|
|
'a=i8': stdlib_types.i8_eq_equals,
|
|
'a=i32': stdlib_types.i32_eq_equals,
|
|
'a=i64': stdlib_types.i64_eq_equals,
|
|
'a=f32': stdlib_types.f32_eq_equals,
|
|
'a=f64': stdlib_types.f64_eq_equals,
|
|
},
|
|
type3classes.Floating.methods['sqrt']: {
|
|
'a=f32': stdlib_types.f32_floating_sqrt,
|
|
'a=f64': stdlib_types.f64_floating_sqrt,
|
|
},
|
|
type3classes.Fractional.operators['/']: {
|
|
'a=f32': stdlib_types.f32_fractional_div,
|
|
'a=f64': stdlib_types.f64_fractional_div,
|
|
},
|
|
type3classes.Integral.methods['div']: {
|
|
'a=u32': stdlib_types.u32_integral_div,
|
|
'a=u64': stdlib_types.u64_integral_div,
|
|
'a=i32': stdlib_types.i32_integral_div,
|
|
'a=i64': stdlib_types.i64_integral_div,
|
|
},
|
|
type3classes.Num.operators['+']: {
|
|
'a=u32': stdlib_types.u32_num_add,
|
|
'a=u64': stdlib_types.u64_num_add,
|
|
'a=i32': stdlib_types.i32_num_add,
|
|
'a=i64': stdlib_types.i64_num_add,
|
|
'a=f32': stdlib_types.f32_num_add,
|
|
'a=f64': stdlib_types.f64_num_add,
|
|
},
|
|
type3classes.Num.operators['-']: {
|
|
'a=u32': stdlib_types.u32_num_sub,
|
|
'a=u64': stdlib_types.u64_num_sub,
|
|
'a=i32': stdlib_types.i32_num_sub,
|
|
'a=i64': stdlib_types.i64_num_sub,
|
|
'a=f32': stdlib_types.f32_num_sub,
|
|
'a=f64': stdlib_types.f64_num_sub,
|
|
},
|
|
type3classes.Num.operators['*']: {
|
|
'a=u32': stdlib_types.u32_num_mul,
|
|
'a=u64': stdlib_types.u64_num_mul,
|
|
'a=i32': stdlib_types.i32_num_mul,
|
|
'a=i64': stdlib_types.i64_num_mul,
|
|
'a=f32': stdlib_types.f32_num_mul,
|
|
'a=f64': stdlib_types.f64_num_mul,
|
|
},
|
|
}
|
|
|
|
def phasm_compile(inp: ourlang.Module) -> wasm.Module:
|
|
"""
|
|
Public method for compiling a parsed Phasm module into
|
|
a WebAssembly module
|
|
"""
|
|
return module(inp)
|
|
|
|
def type3(inp: type3types.Type3OrPlaceholder) -> wasm.WasmType:
|
|
"""
|
|
Compile: type
|
|
|
|
Types are used for example in WebAssembly function parameters
|
|
and return types.
|
|
"""
|
|
assert isinstance(inp, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
|
|
if inp == type3types.none:
|
|
return wasm.WasmTypeNone()
|
|
|
|
if inp == type3types.bool_:
|
|
# WebAssembly stores booleans as i32
|
|
# See e.g. f32.eq, which is [f32 f32] -> [i32]
|
|
return wasm.WasmTypeInt32()
|
|
|
|
if inp == type3types.u8:
|
|
# WebAssembly has only support for 32 and 64 bits
|
|
# So we need to store more memory per byte
|
|
return wasm.WasmTypeInt32()
|
|
|
|
if inp == type3types.u32:
|
|
return wasm.WasmTypeInt32()
|
|
|
|
if inp == type3types.u64:
|
|
return wasm.WasmTypeInt64()
|
|
|
|
if inp == type3types.i8:
|
|
# WebAssembly has only support for 32 and 64 bits
|
|
# So we need to store more memory per byte
|
|
return wasm.WasmTypeInt32()
|
|
|
|
if inp == type3types.i32:
|
|
return wasm.WasmTypeInt32()
|
|
|
|
if inp == type3types.i64:
|
|
return wasm.WasmTypeInt64()
|
|
|
|
if inp == type3types.f32:
|
|
return wasm.WasmTypeFloat32()
|
|
|
|
if inp == type3types.f64:
|
|
return wasm.WasmTypeFloat64()
|
|
|
|
if inp == type3types.bytes:
|
|
# bytes are passed as pointer
|
|
# And pointers are i32
|
|
return wasm.WasmTypeInt32()
|
|
|
|
if isinstance(inp, type3types.StructType3):
|
|
# Structs are passed as pointer, which are i32
|
|
return wasm.WasmTypeInt32()
|
|
|
|
if isinstance(inp, type3types.AppliedType3):
|
|
if inp.base == type3types.static_array:
|
|
# Static Arrays are passed as pointer, which are i32
|
|
return wasm.WasmTypeInt32()
|
|
|
|
if inp.base == type3types.tuple:
|
|
# Tuples are passed as pointer, which are i32
|
|
return wasm.WasmTypeInt32()
|
|
|
|
raise NotImplementedError(type3, inp)
|
|
|
|
U8_OPERATOR_MAP = {
|
|
# Under the hood, this is an i32
|
|
# Implementing Right Shift XOR, OR, AND is fine since the 3 remaining
|
|
# bytes stay zero after this operation
|
|
'>>': 'shr_u',
|
|
'^': 'xor',
|
|
'|': 'or',
|
|
'&': 'and',
|
|
}
|
|
|
|
U32_OPERATOR_MAP = {
|
|
'<': 'lt_u',
|
|
'>': 'gt_u',
|
|
'<=': 'le_u',
|
|
'>=': 'ge_u',
|
|
'<<': 'shl',
|
|
'>>': 'shr_u',
|
|
'^': 'xor',
|
|
'|': 'or',
|
|
'&': 'and',
|
|
}
|
|
|
|
U64_OPERATOR_MAP = {
|
|
'<': 'lt_u',
|
|
'>': 'gt_u',
|
|
'<=': 'le_u',
|
|
'>=': 'ge_u',
|
|
'<<': 'shl',
|
|
'>>': 'shr_u',
|
|
'^': 'xor',
|
|
'|': 'or',
|
|
'&': 'and',
|
|
}
|
|
|
|
I32_OPERATOR_MAP = {
|
|
'<': 'lt_s',
|
|
'>': 'gt_s',
|
|
'<=': 'le_s',
|
|
'>=': 'ge_s',
|
|
}
|
|
|
|
I64_OPERATOR_MAP = {
|
|
'<': 'lt_s',
|
|
'>': 'gt_s',
|
|
'<=': 'le_s',
|
|
'>=': 'ge_s',
|
|
}
|
|
|
|
def tuple_instantiation(wgn: WasmGenerator, inp: ourlang.TupleInstantiation) -> None:
|
|
"""
|
|
Compile: Instantiation (allocation) of a tuple
|
|
"""
|
|
assert isinstance(inp.type3, type3types.AppliedType3)
|
|
assert inp.type3.base is type3types.tuple
|
|
assert len(inp.elements) == len(inp.type3.args)
|
|
|
|
comment_elements = ''
|
|
for element in inp.elements:
|
|
assert isinstance(element.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
comment_elements += f'{element.type3.name}, '
|
|
|
|
tmp_var = wgn.temp_var_i32('tuple_adr')
|
|
wgn.add_statement('nop', comment=f'{tmp_var.name} := ({comment_elements})')
|
|
|
|
# Allocated the required amounts of bytes in memory
|
|
wgn.i32.const(calculate_alloc_size(inp.type3, is_member=False))
|
|
wgn.call(stdlib_alloc.__alloc__)
|
|
wgn.local.set(tmp_var)
|
|
|
|
# Store each element individually
|
|
offset = 0
|
|
for element, exp_type3 in zip(inp.elements, inp.type3.args):
|
|
if isinstance(exp_type3, type3types.PlaceholderForType):
|
|
assert exp_type3.resolve_as is not None
|
|
exp_type3 = exp_type3.resolve_as
|
|
|
|
assert element.type3 == exp_type3
|
|
|
|
if isinstance(exp_type3, type3types.StructType3) or isinstance(exp_type3, type3types.AppliedType3):
|
|
mtyp = 'i32'
|
|
else:
|
|
assert isinstance(exp_type3, type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs')
|
|
mtyp = LOAD_STORE_TYPE_MAP[exp_type3.name]
|
|
|
|
wgn.add_statement('nop', comment='PRE')
|
|
wgn.local.get(tmp_var)
|
|
expression(wgn, element)
|
|
wgn.add_statement(f'{mtyp}.store', 'offset=' + str(offset))
|
|
wgn.add_statement('nop', comment='POST')
|
|
|
|
offset += calculate_alloc_size(exp_type3, is_member=True)
|
|
|
|
# Return the allocated address
|
|
wgn.local.get(tmp_var)
|
|
|
|
def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
|
|
"""
|
|
Compile: Any expression
|
|
"""
|
|
if isinstance(inp, ourlang.ConstantPrimitive):
|
|
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
|
|
if inp.type3 in (type3types.i8, type3types.u8, ):
|
|
# No native u8 type - treat as i32, with caution
|
|
assert isinstance(inp.value, int)
|
|
wgn.i32.const(inp.value)
|
|
return
|
|
|
|
if inp.type3 in (type3types.i32, type3types.u32, ):
|
|
assert isinstance(inp.value, int)
|
|
wgn.i32.const(inp.value)
|
|
return
|
|
|
|
if inp.type3 in (type3types.i64, type3types.u64, ):
|
|
assert isinstance(inp.value, int)
|
|
wgn.i64.const(inp.value)
|
|
return
|
|
|
|
if inp.type3 == type3types.f32:
|
|
assert isinstance(inp.value, float)
|
|
wgn.f32.const(inp.value)
|
|
return
|
|
|
|
if inp.type3 == type3types.f64:
|
|
assert isinstance(inp.value, float)
|
|
wgn.f64.const(inp.value)
|
|
return
|
|
|
|
raise NotImplementedError(f'Constants with type {inp.type3:s}')
|
|
|
|
if isinstance(inp, ourlang.ConstantBytes):
|
|
assert inp.data_block.address is not None, 'Value not allocated'
|
|
wgn.i32.const(inp.data_block.address)
|
|
return
|
|
|
|
if isinstance(inp, ourlang.VariableReference):
|
|
if isinstance(inp.variable, ourlang.FunctionParam):
|
|
wgn.add_statement('local.get', '${}'.format(inp.variable.name))
|
|
return
|
|
|
|
if isinstance(inp.variable, ourlang.ModuleConstantDef):
|
|
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
|
|
if isinstance(inp.type3, type3types.PrimitiveType3):
|
|
expression(wgn, inp.variable.constant)
|
|
return
|
|
|
|
if inp.type3 is type3types.bytes:
|
|
assert isinstance(inp.variable.constant, ourlang.ConstantBytes)
|
|
|
|
address = inp.variable.constant.data_block.address
|
|
assert address is not None, 'Value not allocated'
|
|
wgn.i32.const(address)
|
|
return
|
|
|
|
if isinstance(inp.type3, type3types.StructType3):
|
|
assert isinstance(inp.variable.constant, ourlang.ConstantStruct)
|
|
|
|
address = inp.variable.constant.data_block.address
|
|
assert address is not None, 'Value not allocated'
|
|
wgn.i32.const(address)
|
|
return
|
|
|
|
if isinstance(inp.type3, type3types.AppliedType3):
|
|
if inp.type3.base == type3types.static_array:
|
|
assert isinstance(inp.variable.constant, ourlang.ConstantTuple)
|
|
|
|
address = inp.variable.constant.data_block.address
|
|
assert address is not None, 'Value not allocated'
|
|
wgn.i32.const(address)
|
|
return
|
|
|
|
if inp.type3.base == type3types.tuple:
|
|
assert isinstance(inp.variable.constant, ourlang.ConstantTuple)
|
|
|
|
address = inp.variable.constant.data_block.address
|
|
assert address is not None, 'Value not allocated'
|
|
wgn.i32.const(address)
|
|
return
|
|
|
|
raise NotImplementedError(expression, inp.variable, inp.type3.base)
|
|
|
|
raise NotImplementedError(expression, inp)
|
|
|
|
raise NotImplementedError(expression, inp.variable)
|
|
|
|
if isinstance(inp, ourlang.BinaryOp):
|
|
expression(wgn, inp.left)
|
|
expression(wgn, inp.right)
|
|
|
|
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
|
|
if isinstance(inp.operator, type3classes.Type3ClassMethod):
|
|
type_var_map: Dict[type3classes.TypeVariable, type3types.Type3] = {}
|
|
|
|
for type_var, arg_expr in zip(inp.operator.signature, [inp.left, inp.right, inp]):
|
|
if not isinstance(type_var, type3classes.TypeVariable):
|
|
# Fixed type, not part of the lookup requirements
|
|
continue
|
|
|
|
assert isinstance(arg_expr.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
type_var_map[type_var] = arg_expr.type3
|
|
|
|
instance_key = ','.join(
|
|
f'{k.letter}={v.name}'
|
|
for k, v in type_var_map.items()
|
|
)
|
|
|
|
instance = INSTANCES.get(inp.operator, {}).get(instance_key, None)
|
|
if instance is not None:
|
|
instance(wgn)
|
|
return
|
|
|
|
raise NotImplementedError(inp.operator, instance_key)
|
|
|
|
# FIXME: Re-implement build-in operators
|
|
# Maybe operator_annotation is the way to go
|
|
# Maybe the older stuff below that is the way to go
|
|
|
|
operator_annotation = f'({inp.operator}) :: {inp.left.type3:s} -> {inp.right.type3:s} -> {inp.type3:s}'
|
|
if operator_annotation == '(>) :: i32 -> i32 -> bool':
|
|
wgn.add_statement('i32.gt_s')
|
|
return
|
|
|
|
if operator_annotation == '(<) :: u64 -> u64 -> bool':
|
|
wgn.add_statement('i64.lt_u')
|
|
return
|
|
|
|
if inp.type3 == type3types.u8:
|
|
if operator := U8_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i32.{operator}')
|
|
return
|
|
if inp.type3 == type3types.u32:
|
|
if operator := U32_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i32.{operator}')
|
|
return
|
|
if inp.type3 == type3types.u64:
|
|
if operator := U64_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i64.{operator}')
|
|
return
|
|
if inp.type3 == type3types.i32:
|
|
if operator := I32_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i32.{operator}')
|
|
return
|
|
if inp.type3 == type3types.i64:
|
|
if operator := I64_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i64.{operator}')
|
|
return
|
|
|
|
raise NotImplementedError(expression, inp.operator, inp.left.type3, inp.right.type3, inp.type3)
|
|
|
|
if isinstance(inp, ourlang.UnaryOp):
|
|
expression(wgn, inp.right)
|
|
|
|
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
|
|
if inp.type3 == type3types.f32:
|
|
if inp.operator in ourlang.WEBASSEMBLY_BUILTIN_FLOAT_OPS:
|
|
wgn.add_statement(f'f32.{inp.operator}')
|
|
return
|
|
if inp.type3 == type3types.f64:
|
|
if inp.operator in ourlang.WEBASSEMBLY_BUILTIN_FLOAT_OPS:
|
|
wgn.add_statement(f'f64.{inp.operator}')
|
|
return
|
|
|
|
if inp.type3 == type3types.u32:
|
|
if inp.operator == 'len':
|
|
if inp.right.type3 == type3types.bytes:
|
|
wgn.i32.load()
|
|
return
|
|
|
|
if inp.operator == 'cast':
|
|
if inp.type3 == type3types.u32 and inp.right.type3 == type3types.u8:
|
|
# Nothing to do, you can use an u8 value as a u32 no problem
|
|
return
|
|
|
|
raise NotImplementedError(expression, inp.type3, inp.operator)
|
|
|
|
if isinstance(inp, ourlang.FunctionCall):
|
|
for arg in inp.arguments:
|
|
expression(wgn, arg)
|
|
|
|
if isinstance(inp.function, type3classes.Type3ClassMethod):
|
|
# FIXME: Duplicate code with BinaryOp
|
|
type_var_map = {}
|
|
|
|
for type_var, arg_expr in zip(inp.function.signature, inp.arguments + [inp]):
|
|
if not isinstance(type_var, type3classes.TypeVariable):
|
|
# Fixed type, not part of the lookup requirements
|
|
continue
|
|
|
|
assert isinstance(arg_expr.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
type_var_map[type_var] = arg_expr.type3
|
|
|
|
instance_key = ','.join(
|
|
f'{k.letter}={v.name}'
|
|
for k, v in type_var_map.items()
|
|
)
|
|
|
|
instance = INSTANCES.get(inp.function, {}).get(instance_key, None)
|
|
if instance is not None:
|
|
instance(wgn)
|
|
return
|
|
|
|
raise NotImplementedError(inp.function, instance_key)
|
|
|
|
wgn.add_statement('call', '${}'.format(inp.function.name))
|
|
return
|
|
|
|
if isinstance(inp, ourlang.TupleInstantiation):
|
|
tuple_instantiation(wgn, inp)
|
|
return
|
|
|
|
if isinstance(inp, ourlang.Subscript):
|
|
assert isinstance(inp.varref.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
|
|
if inp.varref.type3 is type3types.bytes:
|
|
expression(wgn, inp.varref)
|
|
expression(wgn, inp.index)
|
|
wgn.call(stdlib_types.__subscript_bytes__)
|
|
return
|
|
|
|
if isinstance(inp.varref.type3, type3types.AppliedType3):
|
|
if inp.varref.type3.base == type3types.static_array:
|
|
assert 2 == len(inp.varref.type3.args)
|
|
el_type = inp.varref.type3.args[0]
|
|
assert isinstance(el_type, type3types.Type3)
|
|
el_len = inp.varref.type3.args[1]
|
|
assert isinstance(el_len, type3types.IntType3)
|
|
|
|
# OPTIMIZE: If index is a constant, we can use offset instead of multiply
|
|
# and we don't need to do the out of bounds check
|
|
|
|
expression(wgn, inp.varref)
|
|
|
|
tmp_var = wgn.temp_var_i32('index')
|
|
expression(wgn, inp.index)
|
|
wgn.local.tee(tmp_var)
|
|
|
|
# Out of bounds check based on el_len.value
|
|
wgn.i32.const(el_len.value)
|
|
wgn.i32.ge_u()
|
|
with wgn.if_():
|
|
wgn.unreachable(comment='Out of bounds')
|
|
|
|
wgn.local.get(tmp_var)
|
|
wgn.i32.const(calculate_alloc_size(el_type))
|
|
wgn.i32.mul()
|
|
wgn.i32.add()
|
|
|
|
assert isinstance(el_type, type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs')
|
|
mtyp = LOAD_STORE_TYPE_MAP[el_type.name]
|
|
|
|
wgn.add_statement(f'{mtyp}.load')
|
|
return
|
|
|
|
if inp.varref.type3.base == type3types.tuple:
|
|
assert isinstance(inp.index, ourlang.ConstantPrimitive)
|
|
assert isinstance(inp.index.value, int)
|
|
|
|
offset = 0
|
|
for el_type in inp.varref.type3.args[0:inp.index.value]:
|
|
assert isinstance(el_type, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
offset += calculate_alloc_size(el_type)
|
|
|
|
# This doubles as the out of bounds check
|
|
el_type = inp.varref.type3.args[inp.index.value]
|
|
assert isinstance(el_type, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
|
|
expression(wgn, inp.varref)
|
|
|
|
if isinstance(el_type, type3types.StructType3):
|
|
mtyp = 'i32'
|
|
elif isinstance(el_type, type3types.AppliedType3) and el_type.base is type3types.tuple:
|
|
mtyp = 'i32'
|
|
else:
|
|
assert isinstance(el_type, type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs')
|
|
mtyp = LOAD_STORE_TYPE_MAP[el_type.name]
|
|
|
|
wgn.add_statement(f'{mtyp}.load', f'offset={offset}')
|
|
return
|
|
|
|
raise NotImplementedError(expression, inp, inp.varref.type3)
|
|
|
|
if isinstance(inp, ourlang.AccessStructMember):
|
|
assert isinstance(inp.struct_type3.members[inp.member], type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs')
|
|
mtyp = LOAD_STORE_TYPE_MAP[inp.struct_type3.members[inp.member].name]
|
|
|
|
expression(wgn, inp.varref)
|
|
wgn.add_statement(f'{mtyp}.load', 'offset=' + str(calculate_member_offset(
|
|
inp.struct_type3, inp.member
|
|
)))
|
|
return
|
|
|
|
if isinstance(inp, ourlang.Fold):
|
|
expression_fold(wgn, inp)
|
|
return
|
|
|
|
raise NotImplementedError(expression, inp)
|
|
|
|
def expression_fold(wgn: WasmGenerator, inp: ourlang.Fold) -> None:
|
|
"""
|
|
Compile: Fold expression
|
|
"""
|
|
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR
|
|
|
|
if inp.iter.type3 is not type3types.bytes:
|
|
raise NotImplementedError(expression_fold, inp, inp.iter.type3)
|
|
|
|
wgn.add_statement('nop', comment='acu :: u8')
|
|
acu_var = wgn.temp_var_u8(f'fold_{codestyle.type3(inp.type3)}_acu')
|
|
wgn.add_statement('nop', comment='adr :: bytes*')
|
|
adr_var = wgn.temp_var_i32('fold_i32_adr')
|
|
wgn.add_statement('nop', comment='len :: i32')
|
|
len_var = wgn.temp_var_i32('fold_i32_len')
|
|
|
|
wgn.add_statement('nop', comment='acu = base')
|
|
expression(wgn, inp.base)
|
|
wgn.local.set(acu_var)
|
|
|
|
wgn.add_statement('nop', comment='adr = adr(iter)')
|
|
expression(wgn, inp.iter)
|
|
wgn.local.set(adr_var)
|
|
|
|
wgn.add_statement('nop', comment='len = len(iter)')
|
|
wgn.local.get(adr_var)
|
|
wgn.i32.load()
|
|
wgn.local.set(len_var)
|
|
|
|
wgn.add_statement('nop', comment='i = 0')
|
|
idx_var = wgn.temp_var_i32(f'fold_{codestyle.type3(inp.type3)}_idx')
|
|
wgn.i32.const(0)
|
|
wgn.local.set(idx_var)
|
|
|
|
wgn.add_statement('nop', comment='if i < len')
|
|
wgn.local.get(idx_var)
|
|
wgn.local.get(len_var)
|
|
wgn.i32.lt_u()
|
|
with wgn.if_():
|
|
# From here on, adr_var is the address of byte we're referencing
|
|
# This is akin to calling stdlib_types.__subscript_bytes__
|
|
# But since we already know we are inside of bounds,
|
|
# can just bypass it and load the memory directly.
|
|
wgn.local.get(adr_var)
|
|
wgn.i32.const(3) # Bytes header -1, since we do a +1 every loop
|
|
wgn.i32.add()
|
|
wgn.local.set(adr_var)
|
|
|
|
wgn.add_statement('nop', comment='while True')
|
|
with wgn.loop():
|
|
wgn.add_statement('nop', comment='acu = func(acu, iter[i])')
|
|
wgn.local.get(acu_var)
|
|
|
|
# Get the next byte, write back the address
|
|
wgn.local.get(adr_var)
|
|
wgn.i32.const(1)
|
|
wgn.i32.add()
|
|
wgn.local.tee(adr_var)
|
|
wgn.i32.load8_u()
|
|
|
|
wgn.add_statement('call', f'${inp.func.name}')
|
|
wgn.local.set(acu_var)
|
|
|
|
wgn.add_statement('nop', comment='i = i + 1')
|
|
wgn.local.get(idx_var)
|
|
wgn.i32.const(1)
|
|
wgn.i32.add()
|
|
wgn.local.set(idx_var)
|
|
|
|
wgn.add_statement('nop', comment='if i >= len: break')
|
|
wgn.local.get(idx_var)
|
|
wgn.local.get(len_var)
|
|
wgn.i32.lt_u()
|
|
wgn.br_if(0)
|
|
|
|
# return acu
|
|
wgn.local.get(acu_var)
|
|
|
|
def statement_return(wgn: WasmGenerator, inp: ourlang.StatementReturn) -> None:
|
|
"""
|
|
Compile: Return statement
|
|
"""
|
|
expression(wgn, inp.value)
|
|
wgn.return_()
|
|
|
|
def statement_if(wgn: WasmGenerator, inp: ourlang.StatementIf) -> None:
|
|
"""
|
|
Compile: If statement
|
|
"""
|
|
expression(wgn, inp.test)
|
|
with wgn.if_():
|
|
for stat in inp.statements:
|
|
statement(wgn, stat)
|
|
|
|
if inp.else_statements:
|
|
raise NotImplementedError
|
|
# yield wasm.Statement('else')
|
|
# for stat in inp.else_statements:
|
|
# statement(wgn, stat)
|
|
|
|
def statement(wgn: WasmGenerator, inp: ourlang.Statement) -> None:
|
|
"""
|
|
Compile: any statement
|
|
"""
|
|
if isinstance(inp, ourlang.StatementReturn):
|
|
statement_return(wgn, inp)
|
|
return
|
|
|
|
if isinstance(inp, ourlang.StatementIf):
|
|
statement_if(wgn, inp)
|
|
return
|
|
|
|
if isinstance(inp, ourlang.StatementPass):
|
|
return
|
|
|
|
raise NotImplementedError(statement, inp)
|
|
|
|
def function_argument(inp: ourlang.FunctionParam) -> wasm.Param:
|
|
"""
|
|
Compile: function argument
|
|
"""
|
|
return (inp.name, type3(inp.type3), )
|
|
|
|
def import_(inp: ourlang.Function) -> wasm.Import:
|
|
"""
|
|
Compile: imported function
|
|
"""
|
|
assert inp.imported
|
|
|
|
return wasm.Import(
|
|
inp.imported,
|
|
inp.name,
|
|
inp.name,
|
|
[
|
|
function_argument(x)
|
|
for x in inp.posonlyargs
|
|
],
|
|
type3(inp.returns_type3)
|
|
)
|
|
|
|
def function(inp: ourlang.Function) -> wasm.Function:
|
|
"""
|
|
Compile: function
|
|
"""
|
|
assert not inp.imported
|
|
|
|
wgn = WasmGenerator()
|
|
|
|
if isinstance(inp, ourlang.StructConstructor):
|
|
_generate_struct_constructor(wgn, inp)
|
|
else:
|
|
for stat in inp.statements:
|
|
statement(wgn, stat)
|
|
|
|
return wasm.Function(
|
|
inp.name,
|
|
inp.name if inp.exported else None,
|
|
[
|
|
function_argument(x)
|
|
for x in inp.posonlyargs
|
|
],
|
|
[
|
|
(k, v.wasm_type(), )
|
|
for k, v in wgn.locals.items()
|
|
],
|
|
type3(inp.returns_type3),
|
|
wgn.statements
|
|
)
|
|
|
|
def module_data_u8(inp: int) -> bytes:
|
|
"""
|
|
Compile: module data, u8 value
|
|
|
|
# FIXME: All u8 values are stored as u32
|
|
"""
|
|
return struct.pack('<I', inp) # Should be 'B'
|
|
|
|
def module_data_u32(inp: int) -> bytes:
|
|
"""
|
|
Compile: module data, u32 value
|
|
"""
|
|
return struct.pack('<I', inp)
|
|
|
|
def module_data_u64(inp: int) -> bytes:
|
|
"""
|
|
Compile: module data, u64 value
|
|
"""
|
|
return struct.pack('<Q', inp)
|
|
|
|
def module_data_i8(inp: int) -> bytes:
|
|
"""
|
|
Compile: module data, i8 value
|
|
|
|
# FIXME: All i8 values are stored as i32
|
|
"""
|
|
return struct.pack('<i', inp) # Should be a 'b'
|
|
|
|
def module_data_i32(inp: int) -> bytes:
|
|
"""
|
|
Compile: module data, i32 value
|
|
"""
|
|
return struct.pack('<i', inp)
|
|
|
|
def module_data_i64(inp: int) -> bytes:
|
|
"""
|
|
Compile: module data, i64 value
|
|
"""
|
|
return struct.pack('<q', inp)
|
|
|
|
def module_data_f32(inp: float) -> bytes:
|
|
"""
|
|
Compile: module data, f32 value
|
|
"""
|
|
return struct.pack('<f', inp)
|
|
|
|
def module_data_f64(inp: float) -> bytes:
|
|
"""
|
|
Compile: module data, f64 value
|
|
"""
|
|
return struct.pack('<d', inp)
|
|
|
|
def module_data(inp: ourlang.ModuleData) -> bytes:
|
|
"""
|
|
Compile: module data
|
|
"""
|
|
unalloc_ptr = stdlib_alloc.UNALLOC_PTR
|
|
|
|
allocated_data = b''
|
|
|
|
for block in inp.blocks:
|
|
block.address = unalloc_ptr + 4 # 4 bytes for allocator header
|
|
|
|
data_list: List[bytes] = []
|
|
|
|
for constant in block.data:
|
|
assert isinstance(constant.type3, type3types.Type3), (id(constant), type3types.TYPE3_ASSERTION_ERROR)
|
|
|
|
if isinstance(constant, ourlang.ConstantMemoryStored) and block is not constant.data_block:
|
|
# It's stored in a different block
|
|
# We only need to store its address
|
|
# This happens for example when a tuple refers
|
|
# to a bytes constant
|
|
assert constant.data_block.address is not None, 'Referred memory not yet stored'
|
|
data_list.append(module_data_u32(constant.data_block.address))
|
|
continue
|
|
|
|
if constant.type3 == type3types.u8:
|
|
assert isinstance(constant, ourlang.ConstantPrimitive)
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_u8(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.u32:
|
|
assert isinstance(constant, ourlang.ConstantPrimitive)
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_u32(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.u64:
|
|
assert isinstance(constant, ourlang.ConstantPrimitive)
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_u64(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.i8:
|
|
assert isinstance(constant, ourlang.ConstantPrimitive)
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_i8(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.i32:
|
|
assert isinstance(constant, ourlang.ConstantPrimitive)
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_i32(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.i64:
|
|
assert isinstance(constant, ourlang.ConstantPrimitive)
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_i64(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.f32:
|
|
assert isinstance(constant, ourlang.ConstantPrimitive)
|
|
assert isinstance(constant.value, float)
|
|
data_list.append(module_data_f32(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.f64:
|
|
assert isinstance(constant, ourlang.ConstantPrimitive)
|
|
assert isinstance(constant.value, float)
|
|
data_list.append(module_data_f64(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.bytes:
|
|
assert isinstance(constant, ourlang.ConstantBytes)
|
|
assert isinstance(constant.value, bytes)
|
|
data_list.append(module_data_u32(len(constant.value)))
|
|
data_list.append(constant.value)
|
|
continue
|
|
|
|
raise NotImplementedError(constant, constant.type3)
|
|
|
|
block_data = b''.join(data_list)
|
|
|
|
allocated_data += module_data_u32(len(block_data)) + block_data
|
|
|
|
unalloc_ptr += 4 + len(block_data)
|
|
|
|
return (
|
|
# Store that we've initialized the memory
|
|
module_data_u32(stdlib_alloc.IDENTIFIER)
|
|
# Store the first reserved i32
|
|
+ module_data_u32(0)
|
|
# Store the pointer towards the first free block
|
|
# In this case, 0 since we haven't freed any blocks yet
|
|
+ module_data_u32(0)
|
|
# Store the pointer towards the first unallocated block
|
|
# In this case the end of the stdlib.alloc header at the start
|
|
+ module_data_u32(unalloc_ptr)
|
|
# Store the actual data
|
|
+ allocated_data
|
|
)
|
|
|
|
def module(inp: ourlang.Module) -> wasm.Module:
|
|
"""
|
|
Compile: module
|
|
"""
|
|
result = wasm.Module()
|
|
|
|
result.memory.data = module_data(inp.data)
|
|
|
|
result.imports = [
|
|
import_(x)
|
|
for x in inp.functions.values()
|
|
if x.imported
|
|
]
|
|
|
|
result.functions = [
|
|
stdlib_alloc.__find_free_block__,
|
|
stdlib_alloc.__alloc__,
|
|
stdlib_types.__alloc_bytes__,
|
|
stdlib_types.__subscript_bytes__,
|
|
] + [
|
|
function(x)
|
|
for x in inp.functions.values()
|
|
if not x.imported
|
|
]
|
|
|
|
return result
|
|
|
|
def _generate_struct_constructor(wgn: WasmGenerator, inp: ourlang.StructConstructor) -> None:
|
|
tmp_var = wgn.temp_var_i32('struct_adr')
|
|
|
|
# Allocated the required amounts of bytes in memory
|
|
wgn.i32.const(calculate_alloc_size(inp.struct_type3))
|
|
wgn.call(stdlib_alloc.__alloc__)
|
|
wgn.local.set(tmp_var)
|
|
|
|
# Store each member individually
|
|
for memname, mtyp3 in inp.struct_type3.members.items():
|
|
mtyp: Optional[str]
|
|
if isinstance(mtyp3, type3types.StructType3) or isinstance(mtyp3, type3types.AppliedType3):
|
|
mtyp = 'i32'
|
|
else:
|
|
mtyp = LOAD_STORE_TYPE_MAP.get(mtyp3.name)
|
|
|
|
if mtyp is None:
|
|
raise NotImplementedError(expression, inp, mtyp3)
|
|
|
|
wgn.local.get(tmp_var)
|
|
wgn.add_statement('local.get', f'${memname}')
|
|
wgn.add_statement(f'{mtyp}.store', 'offset=' + str(calculate_member_offset(
|
|
inp.struct_type3, memname
|
|
)))
|
|
|
|
# Return the allocated address
|
|
wgn.local.get(tmp_var)
|