Use a separate stack for data, finish implementation of function calls

"csp" - C stack pointer

Author: simon816

compiler/asm_extensions.py

@@ -40,8 +40,6 @@ def add_page(self):
         self.add_subsequence('mem_dump', s)
 
     def extended_setup(self, up, down):
-        # temp
-        up.append(SetConst(Var('stack_pointer'), 0).resolve(self.scope))
         for i in range(self.page_size):
             slot = Var('memory_slot', i)
             up.append(SetConst(slot, 0).resolve(self.scope))
@@ -65,11 +63,13 @@ def handle_mov_ind(self, src, s_off, dest, d_off):
         assert type(d_off) == int
         self.add_command(OpAssign(Var('memory_address'), src))
         if s_off != 0:
-            self.add_command(AddConst(Var('memory_address'), s_off))
+            AddFn = AddConst if s_off > 0 else RemConst
+            self.add_command(AddFn(Var('memory_address'), abs(s_off)))
         self.add_command(Function('mem_get'))
         self.add_command(OpAssign(Var('memory_address'), dest))
         if d_off != 0:
-            self.add_command(AddConst(Var('memory_address'), d_off))
+            AddFn = AddConst if d_off > 0 else RemConst
+            self.add_command(AddFn(Var('memory_address'), abs(d_off)))
         self.add_command(Function('mem_set'))
 
     def handle_mov_ind_d(self, src, dest, d_off):
@@ -80,7 +80,8 @@ def handle_mov_ind_d(self, src, dest, d_off):
         self.add_command(self.assign_op(Var('memory_buffer'), src))
         self.add_command(OpAssign(Var('memory_address'), dest))
         if offset != 0:
-            self.add_command(AddConst(Var('memory_address'), offset))
+            AddFn = AddConst if offset > 0 else RemConst
+            self.add_command(AddFn(Var('memory_address'), abs(offset)))
         self.add_command(Function('mem_set'))
 
     def handle_mov_ind_s(self, src, s_off, dest):
@@ -90,6 +91,7 @@ def handle_mov_ind_s(self, src, s_off, dest):
         assert type(offset) == int
         self.add_command(self.assign_op(Var('memory_address'), src))
         if offset != 0:
-            self.add_command(AddConst(Var('memory_address'), offset))
+            AddFn = AddConst if offset > 0 else RemConst
+            self.add_command(AddFn(Var('memory_address'), abs(offset)))
         self.add_command(Function('mem_get'))
         self.add_command(OpAssign(dest, Var('memory_buffer')))

compiler/compiler.py

@@ -56,6 +56,18 @@ def get_output(self):
             setup += '\n\n'
         return setup + self.output
 
+
+class Preprocessor:
+
+    def transform(self, input):
+        output = ''
+        for line in input.splitlines():
+            strip = line.strip()
+            if strip.startswith('#'):
+                continue
+            output += line + '\n'
+        return output
+
 class Compiler:
     def __init__(self):
         self.types = {}
@@ -247,6 +259,13 @@ def __init__(self, writer):
             self.writer.write_constant(reg.name, self.global_offset)
             self.global_offset += 1 # size always 1
 
+        self.writer.write_constant('csp', self.global_offset)
+        self.writer.write_instruction('MOV', '#0', str(self.global_offset))
+        self.global_offset += 1
+        self.writer.write_constant('cbp', self.global_offset)
+        self.writer.write_instruction('MOV', '#0', str(self.global_offset))
+        self.global_offset += 1
+
         self.current_function = None
 
     def visit_program(self, program):
@@ -360,6 +379,9 @@ def visit_func_decl(self, stmt):
         self.current_function = func
         self.functions[name] = func
         self.visit_statements(stmt.body)
+        if not stmt.body or not isinstance(stmt.body[-1], ReturnStmt) \
+           and name != 'main': # main function doesn't return
+            self.write('RET')
         self.current_function = None
         self.writer.end_subroutine()
 
@@ -433,7 +455,7 @@ def visit_var_decl(self, stmt):
     def clear_locals(self):
         self.locals = {}
         self.local_labels = {}
-        local_offset = 0
+        self.local_offset = 0
 
     def add_global(self, type, name):
         assert name not in self.globals
@@ -449,9 +471,10 @@ def add_local(self, type, name):
         self.local_offset += type.size
         return var
 
-    def new_temporary_var(self, copy_from=None):
-        type = copy_from.type if copy_from else Types.types['int']
-        if len(self.free_gpr) > 0:
+    def new_temporary_var(self, copy_from=None, type=None):
+        type = type if type else copy_from.type if copy_from else Types.types['int']
+        assert type.size > 0
+        if len(self.free_gpr) > 0 and type.size == 1:
             return self.free_gpr.pop()
         tmp = self.add_local(type, 'tmp_%d'% len(self.locals))
         self.temporary_names.add(tmp.name)
@@ -576,9 +599,15 @@ def move(self, src, dest):
 
         if type(src) == int:
             s_ref, s_off = '#%d' % src, None
+            size = 1
         elif type(src) == str:
             s_ref, s_off = src, None
+            size = 1
         else:
+            if isinstance(src, Register):
+                size = 1
+            else:
+                size = src.type.size
             src_addr = self.load_address(src)
             steps = unwrap(src_addr, lambda: self.__next_volatile().name)
             s_ref, s_off = act_out(steps)
@@ -590,11 +619,21 @@ def move(self, src, dest):
             steps = unwrap(dest_addr, lambda: self.__next_volatile().name)
             d_ref, d_off = act_out(steps)
 
-        move(s_ref, s_off, d_ref, d_off)
+        def shift(ref, off, shift):
+            if shift == 0:
+                return (ref, off)
+            if off is None:
+                assert type(ref) == int, type(ref)
+                return (ref + shift, off)
+            else:
+                return (ref, off + shift)
+
+        for sh in range(size):
+            move(*(shift(s_ref, s_off, sh) + shift(d_ref, d_off, sh)))
 
     def load_address(self, ref):
         if isinstance(ref, Variable):
-            return Relative(rel_to='sp', offset=ref.index)
+            return Relative(rel_to='csp', offset=ref.index)
         if isinstance(ref, Dereference):
             addr = self.load_address(ref.ref)
             return Indirect(addr)
@@ -604,6 +643,8 @@ def load_address(self, ref):
             return Direct(ref.name)
         if isinstance(ref, Global):
             return Direct(ref.loc)
+        if isinstance(ref, (Relative, Direct, Offset, Indirect)):
+            return ref
         assert False, type(ref)
 
     def dereference(self, ref):
@@ -759,7 +800,6 @@ def visit_switch_stmt(self, stmt):
                 label = self.local_label('switch_case')
                 self.writer.write_local_sub(label)
                 choice = self.visit_expression(case.choice)
-                print(choice)
                 assert type(choice) == int, "not a constant"
                 cases[choice] = label
             else: # This is the default case
@@ -795,13 +835,18 @@ def visit_break_stmt(self, stmt):
         self.break_jump = (label, True)
 
     def visit_return_stmt(self, stmt):
+        ret_type = self.current_function.ret_type
         if stmt.expr:
-            assert self.current_function.ret_type != 'void'
+            assert ret_type != Types.types['void']
             ret = self.visit_expression(stmt.expr)
-            reg = self.gpr[-1].name # Return value always in last register
-            self.write('MOV', ret, reg)
+            if ret_type.size == 1:
+                reg = self.gpr[-1].name # Return value always in last register
+                self.write('MOV', ret, reg)
+            else:
+                # Move value to position allocated before calling this function
+                self.write('MOV', ret, Relative(rel_to='csp', offset=-ret_type.size))
         else:
-            assert self.current_function.ret_type == 'void'
+            assert ret_type == Types.types['void']
         self.write('RET')
 
     def visit_goto_stmt(self, stmt):
@@ -1001,20 +1046,39 @@ def visit_func_call_expr(self, expr):
         assert name in self.functions
         func = self.functions[name]
         assert len(expr.args) == len(func.param_types)
+        large_ret = func.ret_type.size > 1 # Can't fit in single register
+        ret_dest = None
+        if large_ret:
+            ret_dest = self.new_temporary_var(type=func.ret_type)
+
+        # shift base pointer to new stack region
+        self.write('MOV', 'csp', 'cbp')
+        self.write('ADD', self.local_offset, 'cbp')
+        i = 0
         for arg in expr.args:
             var = self.visit_expression(arg)
-            self.write('MOV', var, 'sr')
-            self.write('PUSH')
-        if func.ret_type != Types.types['void']:
-            ret_reg = self.gpr[-1]
+            self.write('MOV', var, Relative(rel_to='cbp', offset=i))
+            if type(var) == int:
+                i += 1
+            else:
+                i += var.type.size
+        register_saved = False
+        if ret_dest is None and func.ret_type != Types.types['void']:
+            ret_dest = self.gpr[-1]
             if len(self.free_gpr) == 0:
-                # TODO restore tmp
-                tmp = self.new_temporary_var()
-                self.write('MOV', ret_reg, tmp)
-        else:
-            ret_reg = None
+                register_saved = True
+                self.write('MOV', ret_reg, 'sr')
+                self.write('PUSH')
+        self.write('MOV', 'csp', 'sr')
+        self.write('PUSH')
+        self.write('MOV', 'cbp', 'csp')
         self.write('CALL', name)
-        return ret_reg
+        self.write('POP')
+        self.write('MOV', 'sr', 'csp')
+        if register_saved:
+            self.write('POP')
+            #TODO delay this self.write('MOV', 'sr', ret_reg)
+        return ret_dest
 
     def func_printf(self, expr):
         args = []
@@ -1026,6 +1090,9 @@ def func_printf(self, expr):
 
     def string_format(self, template, args):
         ret = []
+        if template == '':
+            assert not args
+            return ['""']
         section = template
         ind = section.find('%')
         while ind != -1 and args:

compiler/lexer.py

@@ -76,6 +76,9 @@ def tokenize_decimal(self):
     def tokenize_string(self):
         assert self.char == '"'
         self.read_char()
+        # TODO the lexer needs to be refactored
+        if self.char == '"': # empty string
+            return Token('', Token.Type.STRING)
         string = ''
         while True:
             string += self.read_while(lambda: self.char not in '\n\\"')

compiler/parser_.py

@@ -224,7 +224,7 @@ def parse_block_item(self):
         # TODO using exceptions is bad
         pos, next = self.lexer.ptr, self.lexer.next
         try:
-            assert next != Keyword.SYNC # quick hack
+            assert next not in [Keyword.SYNC, Keyword.RETURN] # quick hack
             return self.parse_declaration(allow_functions=False)
         except AssertionError as e:
             self.lexer.ptr, self.lexer.next = pos, next

compiler_main.py

@@ -5,7 +5,7 @@
 from placer import Rel
 
 from compiler.asm_extensions import CompilerSession, ExtendedAssembler
-from compiler.compiler import Compiler
+from compiler.compiler import Compiler, Preprocessor
 from compiler.lexer import Lexer
 from compiler.parser_ import Parser
 
@@ -30,7 +30,9 @@
 
     compiler = Compiler()
     with args.file as f:
-        parser = Parser(Lexer(f.read()))
+        pre = Preprocessor()
+        code = pre.transform(f.read())
+        parser = Parser(Lexer(code))
         assembly = compiler.compile_program(parser.parse_program())
 
     if args.dump_asm:

session.py

@@ -91,7 +91,7 @@ def add_stack(self, one_function=False):
             return
 
         dump = Subsequence()
-        stack_dump = ["Stack: ["]
+        stack_dump = ["Stack{", Var('stack_pointer') ,"}: ["]
 
         push_stack = Subsequence()
         push_stack.add_command(AddConst(Var('stack_pointer'), 1))