1040 lines
30 KiB
Python
1040 lines
30 KiB
Python
import argparse
|
|
import collections
|
|
import contextlib
|
|
import importlib
|
|
import io
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
|
|
import lark
|
|
|
|
asmod = importlib.import_module("as")
|
|
|
|
GRAMMAR_FILE = '/home/paulmathieu/vhdl/tools/cc.ebnf'
|
|
CPP = ('cpp', '-P')
|
|
|
|
|
|
class Scope:
|
|
def __init__(self):
|
|
self.symbols = {}
|
|
self.parent = None
|
|
|
|
|
|
class Variable:
|
|
def __init__(self, type, name, volatile=False, addr_reg=None):
|
|
self.type = type
|
|
self.name = name
|
|
self.volatile = volatile
|
|
self.addr_reg = addr_reg
|
|
|
|
def __repr__(self):
|
|
return f'<Var: {self.type} {self.name}>'
|
|
|
|
@classmethod
|
|
def from_def(cls, tree):
|
|
volatile = False
|
|
type = tree.children[0]
|
|
if isinstance(type, lark.Tree):
|
|
for c in type.children:
|
|
if c == "volatile":
|
|
volatile = True
|
|
name = tree.children[1]
|
|
return cls(type, name, volatile=volatile)
|
|
|
|
@classmethod
|
|
def from_dereference(cls, reg):
|
|
return cls('deref', 'deref', addr_reg=reg)
|
|
|
|
|
|
# - all registers pointing to unwritten stuff can be dropped as soon as we're
|
|
# done with them:
|
|
# - already fed them into the operations
|
|
# - end of statement
|
|
# - maybe should have a separate storeage for special registers?
|
|
# need ways to:
|
|
# - assign a list of registers into r0, ... rn for function call
|
|
# - ... and run all callbacks
|
|
# - get the register for an identifier
|
|
# - dereference an expression:
|
|
# - essentially turn a temp into an lvalue-address
|
|
# - if read, need a second reg for its value
|
|
# - mark a variable to have its address in a register
|
|
# - delay reading the identifier if it's lhs
|
|
# - store the value to memory when registers are claimed
|
|
# - if it was modified through:
|
|
# - assignment
|
|
# - pre-post *crement
|
|
# - retrieve the memory type:
|
|
# - stack
|
|
# - absolute
|
|
# - register
|
|
# - or just store the value when the variable is assigned
|
|
# - get a temporary register
|
|
# - return it
|
|
# - I guess dereferencing is an upgrade
|
|
|
|
def type(self, tree):
|
|
print(tree)
|
|
|
|
|
|
class RegBank:
|
|
def __init__(self, logger=None):
|
|
self.reset()
|
|
self.log = logger or print
|
|
|
|
def reset(self):
|
|
self.available = [f'r{i}' for i in range(12)]
|
|
self.vars = {}
|
|
self.varregs = {}
|
|
self.cleanup = collections.defaultdict(list)
|
|
|
|
def take(self, reg=None):
|
|
if reg is not None:
|
|
if reg not in self.available:
|
|
self.evict(self.var(reg))
|
|
self.available.remove(reg)
|
|
return reg
|
|
if not self.available:
|
|
assert self.vars, "nothing to clean, no more regs :/"
|
|
# storing one random var
|
|
var = list(self.vars.keys())[0]
|
|
self.evict(var)
|
|
return self.available.pop(0)
|
|
|
|
def give(self, reg):
|
|
if reg in self.varregs:
|
|
# Need to call evict() with the var to free it.
|
|
return
|
|
self.available.insert(0, reg)
|
|
|
|
def loaded(self, var, reg, cleanup=None):
|
|
"""Tells the regbank some variable was loaded into the given register."""
|
|
self.vars[var] = reg
|
|
self.varregs[reg] = var
|
|
self.take(reg)
|
|
if cleanup is not None:
|
|
self.log(f'recording cleanup for {reg}({var.name})')
|
|
self.cleanup[reg].append(cleanup)
|
|
|
|
def stored(self, var):
|
|
"""Tells the regbank the given var was stored to memory, register can be freed."""
|
|
assert var in self.vars
|
|
reg = self.vars.pop(var)
|
|
del self.varregs[reg]
|
|
self.give(reg)
|
|
|
|
def load(self, var):
|
|
"""Returns the reg associated with the var, or a new reg if none was,
|
|
and True if the var was created, False otherwise."""
|
|
self.log(f'vars: {self.vars}, varregs: {self.varregs}')
|
|
if var not in self.vars:
|
|
reg = self.take()
|
|
self.vars[var] = reg
|
|
self.varregs[reg] = var
|
|
return reg, True
|
|
return self.vars[var], False
|
|
|
|
def assign(self, var, reg, cleanup=None):
|
|
"""Assign a previously-used register to a variable."""
|
|
if var in self.vars:
|
|
self.stored(var)
|
|
if reg in self.varregs:
|
|
for cb in self.cleanup.pop(reg, []):
|
|
cb(reg)
|
|
self.stored(self.varregs[reg])
|
|
self.vars[var] = reg
|
|
self.varregs[reg] = var
|
|
if cleanup is not None:
|
|
self.cleanup[reg].append(cleanup)
|
|
|
|
def var(self, reg):
|
|
return self.varregs.get(reg, None)
|
|
|
|
def evict(self, var):
|
|
"""Runs var callbacks & frees the register."""
|
|
if var not in self.vars:
|
|
return
|
|
reg = self.vars[var]
|
|
for cb in self.cleanup.pop(var, []):
|
|
cb(reg)
|
|
self.stored(var)
|
|
|
|
def flush_all(self):
|
|
for reg in list(self.cleanup):
|
|
self.log(f'flushing {reg}({self.varregs[reg].name})')
|
|
for cb in self.cleanup.pop(reg):
|
|
cb(reg)
|
|
self.reset()
|
|
|
|
def swapped(self, reg0, reg1):
|
|
var0 = self.varregs.get(reg0, None)
|
|
var1 = self.varregs.get(reg1, None)
|
|
|
|
if var0 is not None:
|
|
self.stored(var0)
|
|
elif reg0 not in self.available:
|
|
self.give(reg0)
|
|
|
|
if var1 is not None:
|
|
self.stored(var1)
|
|
elif reg1 not in self.available:
|
|
self.give(reg1)
|
|
|
|
if var0 is not None:
|
|
self.loaded(var0, reg1)
|
|
if var1 is not None:
|
|
self.loaded(var1, reg0)
|
|
|
|
@contextlib.contextmanager
|
|
def borrow(self, howmany):
|
|
regs = [self.take() for i in range(howmany)]
|
|
yield regs
|
|
for reg in regs:
|
|
self.give(reg)
|
|
|
|
|
|
class FunctionSpec:
|
|
def __init__(self, fun_prot):
|
|
self.return_type = fun_prot.children[0]
|
|
self.name = fun_prot.children[1]
|
|
self.param_types = [x.children[0] for x in fun_prot.children[2:]]
|
|
|
|
def __repr__(self):
|
|
params = ', '.join(self.param_types)
|
|
return f'<Function: {self.return_type} {self.name}({params})>'
|
|
|
|
|
|
class Function:
|
|
def __init__(self, fun_prot):
|
|
self.locals = {}
|
|
self.spec = FunctionSpec(fun_prot)
|
|
self.params = [Variable(*x.children) for x in fun_prot.children[2:]]
|
|
self.ret = None
|
|
self.nextstack = 0
|
|
self.statements = []
|
|
self.regs = RegBank(logger=self.log)
|
|
self.deferred_ops = []
|
|
self.fun_calls = 0
|
|
self.ops = []
|
|
|
|
def log(self, line):
|
|
self.ops.append(lambda: [f'// {line}'])
|
|
|
|
@property
|
|
def stack_usage(self):
|
|
return self.nextstack + 2
|
|
|
|
def get_stack(self, size=2):
|
|
stk = self.nextstack
|
|
self.nextstack += size
|
|
return stk
|
|
|
|
def param_dict(self):
|
|
return {p.name: p for p in self.params}
|
|
|
|
def __repr__(self):
|
|
return repr(self.spec)
|
|
|
|
def synth(self):
|
|
if self.fun_calls > 0:
|
|
preamble = [f'store lr, [sp, -2]',
|
|
f'set r4, {self.stack_usage}',
|
|
f'sub sp, sp, r4']
|
|
else:
|
|
preamble = []
|
|
|
|
ops = preamble
|
|
for op in self.ops:
|
|
ops += op()
|
|
indented = [f' {x}' if x[-1] == ':' else f' {x}' for x in ops]
|
|
return [f'.global {self.spec.name}',
|
|
f'{self.spec.name}:'] + indented
|
|
|
|
|
|
class CcTransform(lark.visitors.Transformer):
|
|
def _binary_op(litt):
|
|
@lark.v_args(tree=True)
|
|
def _f(self, tree):
|
|
left, right = tree.children
|
|
if left.data == 'litteral' and right.data == 'litteral':
|
|
tree.data = 'litteral'
|
|
tree.children = [litt(left.children[0], right.children[0])]
|
|
return tree
|
|
return _f
|
|
|
|
def array_item(self, children):
|
|
# transform blarg[foo] into *(blarg + foo) because reasons
|
|
addop = lark.Tree('add', children)
|
|
return lark.Tree('dereference', [addop])
|
|
|
|
# operations on litterals can be done by the compiler
|
|
add = _binary_op(lambda a, b: a+b)
|
|
sub = _binary_op(lambda a, b: a-b)
|
|
mul = _binary_op(lambda a, b: a*b)
|
|
shl = _binary_op(lambda a, b: a<<b)
|
|
|
|
CHARACTER = lambda _, x: ord(x[1])
|
|
IDENTIFIER = str
|
|
SIGNED_NUMBER = int
|
|
HEX_LITTERAL = lambda _, x: int(x[2:], 16)
|
|
|
|
|
|
class AsmOp:
|
|
scratch_need = 0
|
|
|
|
def synth(self, scratches):
|
|
return [f'nop']
|
|
|
|
@property
|
|
def out(self):
|
|
return None
|
|
|
|
|
|
class Reg:
|
|
scratch_need = 0
|
|
|
|
def __init__(self, reg):
|
|
self.out = reg
|
|
|
|
def synth(self, scratches):
|
|
return []
|
|
|
|
|
|
class BinOp(AsmOp):
|
|
scratch_need = 0
|
|
|
|
def __init__(self, fun, ops):
|
|
self.fun = fun
|
|
self.dest, self.left, self.right = ops
|
|
|
|
@property
|
|
def out(self):
|
|
return self.dest
|
|
|
|
|
|
def make_cpu_bin_op(cpu_op):
|
|
class _C(BinOp):
|
|
def synth(self, _):
|
|
return [f'{cpu_op} {self.dest}, {self.left}, {self.right}']
|
|
return _C
|
|
|
|
|
|
AddOp = make_cpu_bin_op('add')
|
|
SubOp = make_cpu_bin_op('sub')
|
|
MulOp = make_cpu_bin_op('mul')
|
|
# no div
|
|
# no mod either
|
|
AndOp = make_cpu_bin_op('and')
|
|
orOp = make_cpu_bin_op('or')
|
|
XorOp = make_cpu_bin_op('xor')
|
|
|
|
class ShlOp(BinOp):
|
|
scratch_need = 3
|
|
def synth(self, scratches):
|
|
sc0, sc1, sc2 = scratches
|
|
return [f'or {sc0}, {self.right}, {self.right}',
|
|
f'or {self.dest}, {self.left}, {self.left}',
|
|
f'set {sc1}, 1',
|
|
f'set {sc2}, 0',
|
|
f'cmp {sc0}, {sc2}',
|
|
f'beq [pc, 6]',
|
|
f'add {self.dest}, {self.dest}, {self.dest}',
|
|
f'sub {sc0}, {sc0}, {sc1}',
|
|
f'bneq [pc, -6]']
|
|
|
|
|
|
class LtOp(BinOp):
|
|
scratch_need = 1
|
|
def synth(self, scratches):
|
|
sc0 = scratches[0]
|
|
return [f'set {self.dest}, 0',
|
|
f'sub {sc0}, {self.left}, {self.right}',
|
|
f'bneq [pc, 2]',
|
|
f'set {self.dest}, 1']
|
|
|
|
class GtOp(LtOp):
|
|
def __init__(self, fun, ops):
|
|
dest, left, right = ops
|
|
super(GtOp, self).__init__(fun, [dest, right, left])
|
|
|
|
|
|
class UnOp(AsmOp):
|
|
scratch_need = 0
|
|
|
|
def __init__(self, fun, ops):
|
|
self.fun = fun
|
|
self.dest, self.operand = ops
|
|
|
|
@property
|
|
def out(self):
|
|
return self.dest
|
|
|
|
|
|
class Incr(UnOp):
|
|
scratch_need = 1
|
|
def synth(self, scratches):
|
|
sc0 = scratches[0]
|
|
return [f'set {sc0}, 1',
|
|
f'add {self.dest}, {self.operand}, {sc0}',
|
|
f'or {self.operand}, {self.dest}, {self.dest}']
|
|
|
|
|
|
class NotOp(UnOp):
|
|
def synth(self, scratches):
|
|
return [f'not {self.dest}, {self.operand}']
|
|
|
|
class BoolNot(UnOp):
|
|
def synth(self, scratches):
|
|
return [f'set {self.dest}, 0',
|
|
f'cmp {self.dest}, {self.operand}',
|
|
f'bneq [pc, 2]',
|
|
f'set {self.dest}, 1']
|
|
|
|
class NeqOp(BinOp):
|
|
def synth(self, scratches):
|
|
return [f'sub {self.dest}, {self.left}, {self.right}']
|
|
|
|
|
|
class FnCall(AsmOp):
|
|
scratch_need = 1
|
|
|
|
def __init__(self, fun, ops):
|
|
self.fun = fun
|
|
self.dest_fn, self.params = ops
|
|
|
|
@property
|
|
def out(self):
|
|
return 'r0'
|
|
|
|
def synth(self, scratches):
|
|
out = []
|
|
sc0 = scratches[0]
|
|
fn = self.dest_fn
|
|
|
|
return out + [f'set {sc0}, 2',
|
|
f'add lr, pc, {sc0}',
|
|
f'or pc, {fn}, {fn}']
|
|
|
|
|
|
class ReturnReg(AsmOp):
|
|
scratch_need = 1
|
|
|
|
def __init__(self, fun, ops):
|
|
self.fun = fun
|
|
(self.ret_reg,) = ops
|
|
|
|
def synth(self, scratches):
|
|
if self.fun.fun_calls == 0:
|
|
return [f'or r0, {self.ret_reg}, {self.ret_reg}',
|
|
f'or pc, lr, lr']
|
|
sc0 = scratches[0]
|
|
stack_usage = self.fun.stack_usage
|
|
ret = self.ret_reg
|
|
assert stack_usage < 255
|
|
return [f'set {sc0}, {stack_usage}',
|
|
f'add sp, sp, {sc0}',
|
|
f'or r0, {ret}, {ret}',
|
|
f'load pc, [sp, -2] // return']
|
|
|
|
|
|
class Load(AsmOp):
|
|
scratch_need = 0
|
|
|
|
def __init__(self, fun, ops):
|
|
self.fun = fun
|
|
self.dest, self.var = ops
|
|
|
|
@property
|
|
def out(self):
|
|
return self.dest
|
|
|
|
def synth(self, scratches):
|
|
reg = self.dest
|
|
if self.var.name in self.fun.locals:
|
|
src = self.var.stackaddr
|
|
return [f'load {reg}, [sp, {src}]']
|
|
elif self.var.addr_reg is not None:
|
|
return [f'load {reg}, [{self.var.addr_reg}]']
|
|
else:
|
|
return [f'set {reg}, {self.var.name}',
|
|
f'nop // in case we load a far global',
|
|
f'load {reg}, [{reg}]']
|
|
|
|
class Store(AsmOp):
|
|
scratch_need = 1
|
|
|
|
def __init__(self, fun, ops):
|
|
self.fun = fun
|
|
self.src, self.var = ops
|
|
|
|
@property
|
|
def out(self):
|
|
return None
|
|
|
|
def synth(self, scratches):
|
|
(sc,) = scratches
|
|
reg = self.src
|
|
if self.var.name in self.fun.locals:
|
|
dst = self.var.stackaddr
|
|
self.fun.log(f'storing {self.var}({reg}) to [sp, {dst}]')
|
|
return [f'store {reg}, [sp, {dst}]']
|
|
elif self.var.addr_reg is not None:
|
|
return [f'store {reg}, [{self.var.addr_reg}]']
|
|
return [f'set {sc}, {self.var.name}',
|
|
f'nop // you know, in case blah',
|
|
f'store {reg}, [{sc}]']
|
|
|
|
|
|
class Assign(AsmOp):
|
|
scratch_need = 0
|
|
|
|
def __init__(self, fun, ops):
|
|
self.fun = fun
|
|
self.src, self.var = ops
|
|
|
|
@property
|
|
def out(self):
|
|
return self.var
|
|
|
|
def synth(self, scratches):
|
|
return [f'or {self.var}, {self.src}, {self.src}']
|
|
|
|
|
|
class SetAddr(AsmOp):
|
|
scratch_need = 0
|
|
|
|
def __init__(self, fun, ops):
|
|
self.dest, self.ident = ops
|
|
|
|
@property
|
|
def out(self):
|
|
return self.dest
|
|
|
|
def synth(self, scratches):
|
|
reg = self.dest
|
|
return [f'set {reg}, {self.ident}',
|
|
f'nop // placeholder for a long address']
|
|
|
|
|
|
class Set16Imm(AsmOp):
|
|
scratch_need = 0
|
|
|
|
def __init__(self, fun, ops):
|
|
self.dest, self.imm16 = ops
|
|
|
|
@property
|
|
def out(self):
|
|
return self.dest
|
|
|
|
def synth(self, scratches):
|
|
reg = self.dest
|
|
hi = (self.imm16 >> 8) & 0xff
|
|
lo = (self.imm16 >> 0) & 0xff
|
|
if hi != 0:
|
|
return [f'set {reg}, {lo}',
|
|
f'seth {reg}, {hi}']
|
|
else:
|
|
return [f'set {reg}, {lo}']
|
|
|
|
class Swap(AsmOp):
|
|
scratch_need = 1
|
|
|
|
def __init__(self, a0, a1):
|
|
self.a0 = a0
|
|
self.a1 = a1
|
|
|
|
def synth(self, scratches):
|
|
(sc0,) = scratches
|
|
return [f'or {sc0}, {self.a0}, {self.a0}',
|
|
f'or {self.a0}, {self.a1}, {self.a1}',
|
|
f'or {self.a1}, {sc0}, {sc0}']
|
|
|
|
|
|
class IfOp(AsmOp):
|
|
scratch_need = 1
|
|
|
|
def __init__(self, fun, op):
|
|
self.fun = fun
|
|
self.cond, mark, self.has_else = op
|
|
|
|
self.then_mark = f'_then_{mark}'
|
|
self.else_mark = f'_else_{mark}'
|
|
self.endif_mark = f'_endif_{mark}'
|
|
|
|
def synth(self, scratches):
|
|
sc0 = scratches[0]
|
|
if self.has_else:
|
|
return [f'set {sc0}, 0',
|
|
f'cmp {sc0}, {self.cond}', # flag if cond == 0
|
|
f'beq {self.else_mark}']
|
|
else:
|
|
return [f'set {sc0}, 0',
|
|
f'cmp {sc0}, {self.cond}',
|
|
f'beq {self.endif_mark}']
|
|
|
|
def synth_else(self):
|
|
return [f'cmp r0, r0', # trick because beq is better than "or pc, ."
|
|
f'beq {self.endif_mark}',
|
|
f'{self.else_mark}:']
|
|
|
|
def synth_endif(self):
|
|
return [f'{self.endif_mark}:']
|
|
|
|
|
|
class WhileOp(AsmOp):
|
|
scratch_need = 1
|
|
|
|
@staticmethod
|
|
def synth_loop(mark):
|
|
loop_mark = f'_loop_{mark}'
|
|
return [f'{loop_mark}:']
|
|
|
|
def __init__(self, cond, mark):
|
|
self.cond = cond
|
|
self.loop_mark = f'_loop_{mark}'
|
|
self.endwhile_mark = f'_endwhile_{mark}'
|
|
|
|
def synth(self, scratches):
|
|
sc0 = scratches[0]
|
|
return [f'set {sc0}, 0',
|
|
f'cmp {sc0}, {self.cond}',
|
|
f'beq {self.endwhile_mark}']
|
|
|
|
def synth_endwhile(self):
|
|
return [f'cmp r0, r0',
|
|
f'beq {self.loop_mark}',
|
|
f'{self.endwhile_mark}:']
|
|
|
|
|
|
class Delayed(AsmOp):
|
|
def __init__(self, out_cb):
|
|
self.out_cb = out_cb
|
|
|
|
@property
|
|
def out(self):
|
|
return self.out_cb()
|
|
|
|
def synth(self):
|
|
return []
|
|
|
|
|
|
class CcInterp(lark.visitors.Interpreter):
|
|
def __init__(self):
|
|
self.global_scope = Scope()
|
|
self.cur_scope = self.global_scope
|
|
self.cur_fun = None
|
|
self.funs = []
|
|
self.next_reg = 0
|
|
self.next_marker = 0
|
|
|
|
def _lookup_symbol(self, s):
|
|
scope = self.cur_scope
|
|
while scope is not None:
|
|
if s in scope.symbols:
|
|
return scope.symbols[s]
|
|
scope = scope.parent
|
|
return None
|
|
|
|
def _get_reg(self):
|
|
return self.cur_fun.regs.take()
|
|
|
|
def _get_marker(self):
|
|
mark = self.next_marker
|
|
self.next_marker += 1
|
|
return mark
|
|
|
|
def _synth(self, op):
|
|
with self.cur_fun.regs.borrow(op.scratch_need) as scratches:
|
|
self._log(f'{op.__class__.__name__}')
|
|
self.cur_fun.ops.append(lambda: op.synth(scratches))
|
|
|
|
def _load(self, ident):
|
|
s = self._lookup_symbol(ident)
|
|
assert s is not None, f'unknown identifier {ident}'
|
|
if isinstance(s, FunctionSpec) or s in self.global_scope.symbols:
|
|
reg = self._get_reg()
|
|
return SetAddr(self.cur_fun, [reg, ident])
|
|
else:
|
|
if s.volatile:
|
|
self._log(f'loading volatile {s}')
|
|
return Load(self.cur_fun, [reg, s])
|
|
reg, created = self.cur_fun.regs.load(s)
|
|
if created:
|
|
return Load(self.cur_fun, [reg, s])
|
|
else:
|
|
self._log(f'{s} was already in {reg}')
|
|
return Reg(reg)
|
|
|
|
def identifier(self, tree):
|
|
# TODO: not actually load the value until it's used in an expression
|
|
# could have the op.out() function have a side effect that does that
|
|
# if it's an assignment, we need to make a Variable with the proper
|
|
# address and assign the register to it.
|
|
# If it's volatile, we need to flush it.
|
|
def delayed_load():
|
|
self._log(f'delay-loading {tree.children[0]}')
|
|
op = self._load(tree.children[0])
|
|
self._synth(op)
|
|
return op.out
|
|
|
|
tree.op = Delayed(delayed_load)
|
|
tree.var = self._lookup_symbol(tree.children[0])
|
|
|
|
def litteral(self, tree):
|
|
imm = tree.children[0]
|
|
reg = self._get_reg()
|
|
assert self.cur_fun is not None
|
|
tree.op = Set16Imm(self.cur_fun, [reg, imm])
|
|
self._synth(tree.op)
|
|
|
|
def _assign(self, left, right):
|
|
# need to make sure there's a variable and either:
|
|
# - to store it, or
|
|
# - to mark a register for it
|
|
if left.volatile:
|
|
self._synth(Store(self.cur_fun, [right, left]))
|
|
self.cur_fun.stored(left)
|
|
return
|
|
self._log(f'assigning {left} = {right}')
|
|
# cleanup = lambda reg: self._synth(Store(self.cur_fun, [reg, left]))
|
|
self.cur_fun.regs.assign(left, right)
|
|
self._synth(Store(self.cur_fun, [right, left]))
|
|
|
|
def assignment(self, tree):
|
|
self.visit_children(tree)
|
|
val = tree.children[1].op.out
|
|
|
|
# left hand side is an lvalue, retrieve it
|
|
var = tree.children[0].var
|
|
self._assign(var, val)
|
|
|
|
def global_var(self, tree):
|
|
self.visit_children(tree)
|
|
var = Variable.from_def(tree)
|
|
self.global_scope.symbols[var.name] = var
|
|
val = 0
|
|
if len(tree.children) > 2:
|
|
val = tree.children[2].children[0].value
|
|
|
|
def fun_decl(self, tree):
|
|
fun = FunctionSpec(tree.children[0])
|
|
self.cur_scope.symbols[fun.name] = fun
|
|
|
|
def _prep_fun_call(self, fn_reg, params):
|
|
"""Move all params to r0-rn."""
|
|
def swap(old, new):
|
|
if old == new:
|
|
return
|
|
oldpos = params.index(old)
|
|
try:
|
|
newpos = params.index(new)
|
|
except ValueError:
|
|
params[oldpos] = new
|
|
else:
|
|
params[newpos], params[oldpos] = params[oldpos], params[newpos]
|
|
self._synth(Swap(old, new))
|
|
|
|
if fn_reg in [f'r{i}' for i in range(len(params))]:
|
|
new_fn = f'r{len(params)}'
|
|
self._synth(Swap(fn_reg, new_fn))
|
|
fn_reg = new_fn
|
|
for i, param in enumerate(params):
|
|
new = f'r{i}'
|
|
swap(param, new)
|
|
return fn_reg
|
|
|
|
def fun_call(self, tree):
|
|
self.cur_fun.fun_calls += 1
|
|
self.visit_children(tree)
|
|
fn_reg = tree.children[0].op.out
|
|
param_regs = [c.op.out for c in tree.children[1:]]
|
|
self.cur_fun.regs.flush_all()
|
|
for i in range(len(param_regs)):
|
|
self.cur_fun.regs.take(f'r{i}')
|
|
fn_reg = self._prep_fun_call(fn_reg, param_regs)
|
|
self.cur_fun.regs.take(fn_reg)
|
|
tree.op = FnCall(self.cur_fun, [fn_reg, param_regs])
|
|
self._synth(tree.op)
|
|
self.cur_fun.regs.reset()
|
|
self.cur_fun.regs.take('r0')
|
|
|
|
def statement(self, tree):
|
|
self.visit_children(tree)
|
|
if self.cur_fun.deferred_ops:
|
|
self._log(f'deferred logic: {len(self.cur_fun.deferred_ops)}')
|
|
for op in self.cur_fun.deferred_ops:
|
|
self._synth(op)
|
|
self.cur_fun.deferred_ops = []
|
|
|
|
iter_expression = statement
|
|
|
|
def if_stat(self, tree):
|
|
self.visit(tree.children[0])
|
|
mark = self._get_marker()
|
|
has_else = len(tree.children) > 2
|
|
op = IfOp(self.cur_fun, [tree.children[0].op.out, mark, has_else])
|
|
self._synth(op)
|
|
self.visit(tree.children[1])
|
|
if has_else:
|
|
self.cur_fun.ops.append(op.synth_else)
|
|
self.visit(tree.children[2])
|
|
self.cur_fun.ops.append(op.synth_endif)
|
|
|
|
def while_stat(self, tree):
|
|
mark = self._get_marker()
|
|
self.cur_fun.ops.append(lambda: WhileOp.synth_loop(mark))
|
|
begin_vars = dict(self.cur_fun.regs.vars)
|
|
self.visit(tree.children[0])
|
|
op = WhileOp(tree.children[0].op.out, mark)
|
|
self._synth(op)
|
|
self.visit(tree.children[1])
|
|
for v, r in begin_vars.items():
|
|
rvars = self.cur_fun.regs.vars
|
|
if v not in rvars or rvars[v] != r:
|
|
self._log(f'loading missing var {v}')
|
|
self._synth(Load(self.cur_fun, [r, v]))
|
|
self.cur_fun.ops.append(op.synth_endwhile)
|
|
|
|
def for_stat(self, tree):
|
|
mark = self._get_marker()
|
|
self.visit(tree.children[0]) # initialization
|
|
self.cur_fun.ops.append(lambda: WhileOp.synth_loop(mark))
|
|
begin_vars = dict(self.cur_fun.regs.vars)
|
|
self.visit(tree.children[1])
|
|
op = WhileOp(tree.children[1].op.out, mark)
|
|
self._synth(op)
|
|
self.visit(tree.children[3])
|
|
self.visit(tree.children[2]) # 3rd statement
|
|
for v, r in begin_vars.items():
|
|
rvars = self.cur_fun.regs.vars
|
|
if v not in rvars or rvars[v] != r:
|
|
self._log(f'loading missing var {v}')
|
|
self._synth(Load(self.cur_fun, [r, v]))
|
|
self.cur_fun.ops.append(op.synth_endwhile)
|
|
|
|
def _unary_op(op):
|
|
def _f(self, tree):
|
|
self.visit_children(tree)
|
|
operand = tree.children[0].op.out
|
|
reg = self.cur_fun.regs.take()
|
|
tree.op = op(self.cur_fun, [reg, operand])
|
|
self._synth(tree.op)
|
|
self.cur_fun.regs.give(operand)
|
|
return _f
|
|
|
|
def dereference(self, tree):
|
|
self.visit_children(tree)
|
|
reg = tree.children[0].op.out
|
|
var = Variable.from_dereference(reg)
|
|
self._log(f'making var {var} from derefing reg {reg}')
|
|
tree.var = var
|
|
def delayed_load():
|
|
self._log(f'delay-loading {tree.children[0]}')
|
|
op = Load(self.cur_fun, [reg, var])
|
|
self._synth(op)
|
|
return op.out
|
|
tree.op = Delayed(delayed_load)
|
|
|
|
def post_increment(self, tree):
|
|
self.visit_children(tree)
|
|
tree.op = Reg(tree.children[0].op.out)
|
|
var = tree.children[0].var
|
|
reg = tree.op.out
|
|
self.cur_fun.deferred_ops.append(Incr(self.cur_fun, [reg, reg]))
|
|
self.cur_fun.deferred_ops.append(Store(self.cur_fun, [reg, var]))
|
|
|
|
pre_increment = _unary_op(Incr)
|
|
bool_not = _unary_op(BoolNot)
|
|
|
|
def _binary_op(op):
|
|
def _f(self, tree):
|
|
self.visit_children(tree)
|
|
left, right = (x.op.out for x in tree.children)
|
|
dest = self.cur_fun.regs.take()
|
|
tree.op = op(self.cur_fun, [dest, left, right])
|
|
self._synth(tree.op)
|
|
self.cur_fun.regs.give(left)
|
|
self.cur_fun.regs.give(right)
|
|
return _f
|
|
|
|
def _combo(uop, bop):
|
|
def _f(self, tree):
|
|
bop.__get__(self)(tree)
|
|
uop.__get__(self)(tree)
|
|
return _f
|
|
|
|
shl = _binary_op(ShlOp)
|
|
add = _binary_op(AddOp)
|
|
sub = _binary_op(SubOp)
|
|
mul = _binary_op(MulOp)
|
|
_and = _binary_op(AndOp)
|
|
# ...
|
|
gt = _binary_op(GtOp)
|
|
lt = _binary_op(LtOp)
|
|
neq = _binary_op(NeqOp)
|
|
eq = _combo(bool_not, neq)
|
|
|
|
def _forward_op(self, tree):
|
|
self.visit_children(tree)
|
|
tree.op = tree.children[0].op
|
|
|
|
def cast(self, tree):
|
|
self.visit_children(tree)
|
|
tree.op = tree.children[1].op
|
|
|
|
def _log(self, line):
|
|
self.cur_fun.log(line)
|
|
|
|
def local_var(self, tree):
|
|
self.visit_children(tree)
|
|
assert self.cur_fun is not None
|
|
assert self.cur_scope is not None
|
|
var = Variable.from_def(tree)
|
|
var.stackaddr = self.cur_fun.get_stack() # will have to invert
|
|
self.cur_scope.symbols[var.name] = var
|
|
self.cur_fun.locals[var.name] = var
|
|
if len(tree.children) > 2:
|
|
initval = tree.children[2].children[0].op.out
|
|
cleanup = lambda reg: self._synth(Store(self.cur_fun, [reg, var]))
|
|
self.cur_fun.regs.assign(var, initval, cleanup)
|
|
self._log(f'assigning {var} = {initval}')
|
|
|
|
def fun_def(self, tree):
|
|
prot, body = tree.children
|
|
fun = Function(prot)
|
|
assert self.cur_fun is None
|
|
self.cur_fun = fun
|
|
|
|
self.cur_scope.symbols[fun.spec.name] = fun.spec
|
|
|
|
params = fun.param_dict()
|
|
|
|
def getcleanup(var):
|
|
return lambda reg: self._synth(Store(self.cur_fun, [reg, var]))
|
|
|
|
for i, param in enumerate(fun.params):
|
|
fun.locals[param.name] = param
|
|
param.stackaddr = fun.get_stack()
|
|
self._log(f'param [sp, {param.stackaddr}]: {param.name} in r{i}')
|
|
cleanup = getcleanup(param)
|
|
fun.regs.loaded(param, f'r{i}', cleanup)
|
|
|
|
fun_scope = Scope()
|
|
fun_scope.parent = self.cur_scope
|
|
fun_scope.symbols.update(params)
|
|
|
|
body.scope = fun_scope
|
|
self.visit_children(tree)
|
|
|
|
if fun.ret is None:
|
|
if fun.spec.name == 'main':
|
|
self._synth(Set16Imm(fun, ['r0', 0]))
|
|
self._synth(ReturnReg(fun, ['r0']))
|
|
elif fun.spec.return_type == 'void':
|
|
self._synth(ReturnReg(fun, ['r0']))
|
|
else:
|
|
assert fun.ret is not None
|
|
self.cur_fun = None
|
|
self.funs.append(fun)
|
|
|
|
def body(self, tree):
|
|
bscope = getattr(tree, 'scope', Scope())
|
|
bscope.parent = self.cur_scope
|
|
self.cur_scope = bscope
|
|
self.visit_children(tree)
|
|
self.cur_scope = bscope.parent
|
|
|
|
def return_stat(self, tree):
|
|
assert self.cur_fun is not None
|
|
self.cur_fun.ret = True
|
|
self.visit_children(tree)
|
|
expr_reg = tree.children[0].op.out
|
|
tree.op = ReturnReg(self.cur_fun, [expr_reg])
|
|
self._synth(tree.op)
|
|
|
|
preamble = [f'_start:',
|
|
f'xor r0, r0, r0',
|
|
f'xor r1, r1, r1',
|
|
f'set sp, 0',
|
|
f'seth sp, {0x11}', # 256 bytes of stack ought to be enough
|
|
f'set r2, main',
|
|
f'set r3, 2',
|
|
f'add lr, pc, r3',
|
|
f'or pc, r2, r2',
|
|
f'or pc, pc, pc // loop forever',
|
|
]
|
|
|
|
def filter_dupes(ops):
|
|
dupe_re = re.compile(r'or (r\d+), \1, \1')
|
|
for op in ops:
|
|
if dupe_re.search(op):
|
|
continue
|
|
yield op
|
|
|
|
def parse_tree(tree, debug=False):
|
|
tr = CcTransform()
|
|
tree = tr.transform(tree)
|
|
|
|
if debug:
|
|
print(tree.pretty())
|
|
|
|
inte = CcInterp()
|
|
inte.visit(tree)
|
|
|
|
out = []
|
|
|
|
for fun in inte.funs:
|
|
out += fun.synth()
|
|
out.append('')
|
|
return '\n'.join(filter_dupes(out))
|
|
|
|
|
|
def larkparse(f, debug=False):
|
|
with open(GRAMMAR_FILE) as g:
|
|
asparser = lark.Lark(g.read())
|
|
data = f.read()
|
|
if isinstance(data, bytes):
|
|
data = data.decode()
|
|
tree = asparser.parse(data)
|
|
return parse_tree(tree, debug=debug)
|
|
|
|
|
|
def parse_args():
|
|
parser = argparse.ArgumentParser(description='Compile.')
|
|
parser.add_argument('--debug', action='store_true',
|
|
help='print the AST')
|
|
parser.add_argument('--assembly', '-S', action='store_true',
|
|
help='output assembly')
|
|
parser.add_argument('--compile', '-c', action='store_true',
|
|
help='compile a single file')
|
|
parser.add_argument('input', type=argparse.FileType('r'),
|
|
default=sys.stdin, help='input file (default: stdin)')
|
|
parser.add_argument('--output', '-o', type=argparse.FileType('wb'),
|
|
default=sys.stdout.buffer, help='output file')
|
|
return parser.parse_args()
|
|
|
|
|
|
def preprocess(fin):
|
|
p = subprocess.Popen(CPP, stdin=fin, stdout=subprocess.PIPE)
|
|
return p.stdout
|
|
|
|
|
|
def assemble(text, fout):
|
|
fin = io.StringIO(text)
|
|
asmod.write_obj(fout, *asmod.larkparse(fin))
|
|
|
|
|
|
def main():
|
|
args = parse_args()
|
|
|
|
assy = larkparse(preprocess(args.input), debug=args.debug)
|
|
if args.assembly:
|
|
args.output.write(assy.encode() + b'\n')
|
|
else:
|
|
assemble(assy, args.output)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|