841 lines
27 KiB
Python
841 lines
27 KiB
Python
"""
|
|
This module contains the code to convert parsed Ourlang into WebAssembly code
|
|
"""
|
|
from typing import List, Union
|
|
|
|
import struct
|
|
|
|
from . import codestyle
|
|
from . import ourlang
|
|
from .type3 import types as type3types
|
|
from . import wasm
|
|
|
|
from .stdlib import alloc as stdlib_alloc
|
|
from .stdlib import types as stdlib_types
|
|
from .wasmgenerator import Generator as WasmGenerator
|
|
|
|
LOAD_STORE_TYPE_MAP = {
|
|
'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',
|
|
}
|
|
|
|
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.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.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)
|
|
|
|
# Operators that work for i32, i64, f32, f64
|
|
OPERATOR_MAP = {
|
|
'+': 'add',
|
|
'-': 'sub',
|
|
'*': 'mul',
|
|
'==': 'eq',
|
|
}
|
|
|
|
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',
|
|
'/': 'div_u' # Division by zero is a trap and the program will panic
|
|
}
|
|
|
|
U64_OPERATOR_MAP = {
|
|
'<': 'lt_u',
|
|
'>': 'gt_u',
|
|
'<=': 'le_u',
|
|
'>=': 'ge_u',
|
|
'<<': 'shl',
|
|
'>>': 'shr_u',
|
|
'^': 'xor',
|
|
'|': 'or',
|
|
'&': 'and',
|
|
'/': 'div_u' # Division by zero is a trap and the program will panic
|
|
}
|
|
|
|
I32_OPERATOR_MAP = {
|
|
'<': 'lt_s',
|
|
'>': 'gt_s',
|
|
'<=': 'le_s',
|
|
'>=': 'ge_s',
|
|
'/': 'div_s' # Division by zero is a trap and the program will panic
|
|
}
|
|
|
|
I64_OPERATOR_MAP = {
|
|
'<': 'lt_s',
|
|
'>': 'gt_s',
|
|
'<=': 'le_s',
|
|
'>=': 'ge_s',
|
|
'/': 'div_s' # Division by zero is a trap and the program will panic
|
|
}
|
|
|
|
F32_OPERATOR_MAP = {
|
|
'/': 'div' # Division by zero is a trap and the program will panic
|
|
}
|
|
|
|
F64_OPERATOR_MAP = {
|
|
'/': 'div' # Division by zero is a trap and the program will panic
|
|
}
|
|
|
|
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))
|
|
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
|
|
|
|
assert isinstance(exp_type3, type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs')
|
|
mtyp = LOAD_STORE_TYPE_MAP[exp_type3.name]
|
|
|
|
wgn.local.get(tmp_var)
|
|
expression(wgn, element)
|
|
wgn.add_statement(f'{mtyp}.store', 'offset=' + str(offset))
|
|
|
|
offset += _calculate_alloc_size(exp_type3)
|
|
|
|
# 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 == 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}')
|
|
|
|
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.StructType3):
|
|
assert inp.variable.data_block is not None, 'Structs must be memory stored'
|
|
assert inp.variable.data_block.address is not None, 'Value not allocated'
|
|
wgn.i32.const(inp.variable.data_block.address)
|
|
return
|
|
|
|
if isinstance(inp.type3, type3types.AppliedType3):
|
|
if inp.type3.base == type3types.static_array:
|
|
assert inp.variable.data_block is not None, 'Static arrays must be memory stored'
|
|
assert inp.variable.data_block.address is not None, 'Value not allocated'
|
|
wgn.i32.const(inp.variable.data_block.address)
|
|
return
|
|
|
|
if inp.type3.base == type3types.tuple:
|
|
assert inp.variable.data_block is not None, 'Tuples must be memory stored'
|
|
assert inp.variable.data_block.address is not None, 'Value not allocated'
|
|
wgn.i32.const(inp.variable.data_block.address)
|
|
return
|
|
|
|
raise NotImplementedError(expression, inp.variable, inp.type3.base)
|
|
|
|
assert inp.variable.data_block is None, 'Primitives are not memory stored'
|
|
|
|
expression(wgn, inp.variable.constant)
|
|
return
|
|
|
|
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
|
|
# 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 operator_annotation == '(==) :: u64 -> u64 -> bool':
|
|
wgn.add_statement('i64.eq')
|
|
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 := OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i32.{operator}')
|
|
return
|
|
if operator := U32_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i32.{operator}')
|
|
return
|
|
if inp.type3 == type3types.u64:
|
|
if operator := OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i64.{operator}')
|
|
return
|
|
if operator := U64_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i64.{operator}')
|
|
return
|
|
if inp.type3 == type3types.i32:
|
|
if operator := OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i32.{operator}')
|
|
return
|
|
if operator := I32_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i32.{operator}')
|
|
return
|
|
if inp.type3 == type3types.i64:
|
|
if operator := OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i64.{operator}')
|
|
return
|
|
if operator := I64_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'i64.{operator}')
|
|
return
|
|
if inp.type3 == type3types.f32:
|
|
if operator := OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'f32.{operator}')
|
|
return
|
|
if operator := F32_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'f32.{operator}')
|
|
return
|
|
if inp.type3 == type3types.f64:
|
|
if operator := OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'f64.{operator}')
|
|
return
|
|
if operator := F64_OPERATOR_MAP.get(inp.operator, None):
|
|
wgn.add_statement(f'f64.{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)
|
|
|
|
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)
|
|
|
|
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(
|
|
'imports',
|
|
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_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 constant.type3 == type3types.u8:
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_u8(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.u32:
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_u32(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.u64:
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_u64(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.i32:
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_i32(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.i64:
|
|
assert isinstance(constant.value, int)
|
|
data_list.append(module_data_i64(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.f32:
|
|
assert isinstance(constant.value, float)
|
|
data_list.append(module_data_f32(constant.value))
|
|
continue
|
|
|
|
if constant.type3 == type3types.f64:
|
|
assert isinstance(constant.value, float)
|
|
data_list.append(module_data_f64(constant.value))
|
|
continue
|
|
|
|
raise NotImplementedError(constant, constant.type3, constant.value)
|
|
|
|
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 = LOAD_STORE_TYPE_MAP.get(mtyp3.name)
|
|
if mtyp is None:
|
|
# In the future might extend this by having structs or tuples
|
|
# as members of struct or tuples
|
|
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)
|
|
|
|
def _calculate_alloc_size(typ: Union[type3types.StructType3, type3types.Type3]) -> int:
|
|
if typ == type3types.u8:
|
|
return 4 # FIXME: We allocate 4 bytes for every u8 since you load them into an i32
|
|
|
|
if typ in (type3types.u32, type3types.i32, type3types.f32, ):
|
|
return 4
|
|
|
|
if typ in (type3types.u64, type3types.i64, type3types.f64, ):
|
|
return 8
|
|
|
|
if isinstance(typ, type3types.StructType3):
|
|
return sum(
|
|
_calculate_alloc_size(x)
|
|
for x in typ.members.values()
|
|
)
|
|
|
|
if isinstance(typ, type3types.AppliedType3):
|
|
if typ.base is type3types.tuple:
|
|
size = 0
|
|
for arg in typ.args:
|
|
assert not isinstance(arg, type3types.IntType3)
|
|
|
|
if isinstance(arg, type3types.PlaceholderForType):
|
|
assert not arg.resolve_as is None
|
|
arg = arg.resolve_as
|
|
|
|
size += _calculate_alloc_size(arg)
|
|
|
|
return size
|
|
|
|
raise NotImplementedError(_calculate_alloc_size, typ)
|
|
|
|
def _calculate_member_offset(struct_type3: type3types.StructType3, member: str) -> int:
|
|
result = 0
|
|
|
|
for mem, memtyp in struct_type3.members.items():
|
|
if member == mem:
|
|
return result
|
|
|
|
result += _calculate_alloc_size(memtyp)
|
|
|
|
raise Exception(f'{member} not in {struct_type3}')
|