updates

Author: jsiek

interp_Cfun.py

@@ -38,8 +38,8 @@ def interp_stmts(self, ss, env):
     if len(ss) == 0:
       raise Exception('interp_stmts function ended without return')
     match ss[0]:
-      case Return(value):
-        return self.interp_exp(value, env)
+      case TailCall(func, args):
+        return self.interp_exp(Call(func, args), env)
       case _:
         return super().interp_stmts(ss, env)
 
@@ -50,8 +50,7 @@ def interp(self, p):
         for d in defs:
             match d:
               case FunctionDef(name, params, blocks, dl, returns, comment):
-                env[name] = Function(name, [p.arg for p in params.args],
-                                     blocks, env)
+                env[name] = Function(name, [x for (x,t) in params], blocks, env)
         self.blocks = {}
         self.apply_fun(env['main'], [], None)
       case _:

interp_Lfun.py

@@ -53,8 +53,11 @@ def interp(self, p):
         for d in defs:
             match d:
               case FunctionDef(name, params, bod, dl, returns, comment):
-                env[name] = Function(name, [p.arg for p in params.args],
-                                     bod, env)
+                if isinstance(params, ast.arguments):
+                    ps = [p.arg for p in params.args]
+                else:
+                    ps = [x for (x,t) in params]
+                env[name] = Function(name, ps, bod, env)
         self.apply_fun(env['main'], [], None)
       case _:
         raise Exception('interp: unexpected ' + repr(p))

type_check_Cfun.py

@@ -68,14 +68,14 @@ def type_check_def(self, d, env):
       case _:
         raise Exception('type_check_def: unexpected ' + repr(d))
 
-  def type_check_stmts(self, ss, env):
-    if len(ss) == 0:
-      return
-    match ss[0]:
+  def type_check_stmt(self, s, env):
+    match s:
       case Return(value):
-        return self.type_check_exp(value, env)
+        self.type_check_exp(value, env)
+      case TailCall(func, args):
+        self.type_check_exp(Call(func, args), env)
       case _:
-        return super().type_check_stmts(ss, env)
+        super().type_check_stmt(s, env)
 
   def type_check(self, p):
     match p:

type_check_Cif.py

@@ -70,6 +70,10 @@ def type_check_exp(self, e, env):
       case _:
         raise Exception('error in type_check_exp, unexpected ' + repr(e))
 
+  def type_check_stmts(self, ss, env):
+      for s in ss:
+          self.type_check_stmt(s, env)
+      
   def type_check_stmt(self, s, env):
     match s:      
       case Assign([lhs], value):
@@ -96,10 +100,6 @@ def type_check_stmt(self, s, env):
       case _:
         raise Exception('error in type_check_stmt, unexpected' + repr(s))
 
-  def type_check_stmts(self, ss, env):
-    for s in ss:
-        self.type_check_stmt(s, env)
-
   def type_check(self, p):
     match p:
       case CProgram(body):

type_check_Lfun.py

@@ -1,3 +1,4 @@
+import ast
 from ast import *
 from type_check_Lvar import check_type_equal
 from type_check_Ltup import TypeCheckLtup
@@ -25,6 +26,8 @@ def parse_type_annot(self, annot):
                               self.parse_type_annot(rt))
         case Subscript(Name('tuple'), Tuple(ts)):
           return TupleType([self.parse_type_annot(t) for t in ts])
+        case t if t == int or t == bool:
+          return annot
         case _:
             raise Exception('parse_type_annot: unexpected ' + repr(annot))
 
@@ -54,10 +57,18 @@ def type_check_stmts(self, ss, env):
     match ss[0]:
       case FunctionDef(name, params, body, dl, returns, comment):
         new_env = {x: t for (x,t) in env.items()}
-        for p in params.args:
-            new_env[p.arg] = self.parse_type_annot(p.annotation)
+        if isinstance(params, ast.arguments):
+            new_params = [(p.arg, self.parse_type_annot(p.annotation)) for p in params.args]
+            ss[0].args = new_params
+            new_returns = self.parse_type_annot(returns)
+            ss[0].returns = new_returns
+        else:
+            new_params = params
+            new_returns = returns
+        for (x,t) in new_params:
+            new_env[x] = t
         rt = self.type_check_stmts(body, new_env)
-        check_type_equal(self.parse_type_annot(returns), rt, ss[0])
+        check_type_equal(new_returns, rt, ss[0])
         return self.type_check_stmts(ss[1:], env)
       case Return(value):
         return self.type_check_exp(value, env)
@@ -71,10 +82,12 @@ def type_check(self, p):
         for s in body:
             match s:
               case FunctionDef(name, params, bod, dl, returns, comment):
-                params_t = [self. parse_type_annot(p.annotation) \
-                            for p in params.args]
-                env[name] = FunctionType(params_t,
-                                         self.parse_type_annot(returns))
+                if isinstance(params, ast.arguments):
+                    params_t = [self.parse_type_annot(p.annotation) \
+                                for p in params.args]
+                else:
+                    params_t = [t for (x,t) in params]
+                env[name] = FunctionType(params_t, self.parse_type_annot(returns))
         self.type_check_stmts(body, env)
       case _:
         raise Exception('type_check: unexpected ' + repr(p))

utils.py

@@ -10,7 +10,7 @@
 
 indent_amount = 0
 
-sed = 'sed'
+sed = 'gsed'
 
 def indent_stmt():
     return " " * indent_amount
@@ -436,6 +436,17 @@ def __str__(self):
         return self.name + '(%rip)'
     def __repr__(self):
         return 'FunRef(' + self.name + ')'
+
+class TailCall:
+    __match_args__ = ("func","args")
+    def __init__(self, func, args):
+        self.func = func
+        self.args = args
+    def __str__(self):
+        return str(self.func) + '(' + ','.join([str(e) for e in self.args]) + ')'
+    def __repr__(self):
+        return 'TailCall(' + repr(self.func) + ',' + repr(self.args) + ')'
+    
 
 ################################################################################
 # Miscellaneous Auxiliary Functions

x86_ast.py

@@ -11,21 +11,31 @@ def __str__(self):
             for (l,ss) in self.body.items():
                 if l == label_name('main'):
                     result += '\t.globl ' + label_name('main') + '\n'
+                result += '\t.align 16\n'
                 result += l + ':\n'
                 indent()
-                result += '\n'.join([str(s) for s in ss]) + '\n\n'
+                result += ''.join([str(s) for s in ss]) + '\n'
                 dedent()
         else:
             result += '\t.globl ' + label_name('main') + '\n' + \
                       label_name('main') + ':\n'
             indent()
-            result += '\n'.join([str(s) for s in self.body])
+            result += ''.join([str(s) for s in self.body])
             dedent()
         result += '\n'
         return result
     def __repr__(self):
         return 'X86Program(' + repr(self.body) + ')'
-                
+
+class X86ProgramDefs:
+    __match_args__ = ("defs",)
+    def __init__(self, defs):
+        self.defs = defs
+    def __str__(self):
+        return '\n'.join([str(d) for d in self.defs])
+    def __repr__(self):
+        return 'X86ProgramDefs(' + repr(self.defs) + ')'
+    
 class instr: ...
 class arg: ...
 class location(arg): ...
@@ -43,7 +53,7 @@ def source(self):
     def target(self):
         return self.args[-1]
     def __str__(self):
-        return indent_stmt() + self.instr + ' ' + ', '.join(str(a) for a in self.args)
+        return indent_stmt() + self.instr + ' ' + ', '.join(str(a) for a in self.args) + '\n'
     def __repr__(self):
         return 'Instr(' + repr(self.instr) + ', ' + repr(self.args) + ')'
 
@@ -53,9 +63,19 @@ def __init__(self, func, num_args):
         self.func = func
         self.num_args = num_args
     def __str__(self):
-        return indent_stmt() + 'callq' + ' ' + self.func
+        return indent_stmt() + 'callq' + ' ' + self.func + '\n'
     def __repr__(self):
         return 'Callq(' + repr(self.func) + ', ' + repr(self.num_args) + ')'
+
+class IndirectCallq(instr):
+    __match_args__ = ("func", "num_args")
+    def __init__(self, func, num_args):
+        self.func = func
+        self.num_args = num_args
+    def __str__(self):
+        return indent_stmt() + 'callq' + ' *' + str(self.func) + '\n'
+    def __repr__(self):
+        return 'IndirectCallq(' + repr(self.func) + ', ' + repr(self.num_args) + ')'
 
 class JumpIf(instr):
     cc: str
@@ -66,7 +86,7 @@ def __init__(self, cc, label):
         self.cc = cc
         self.label = label
     def __str__(self):
-        return indent_stmt() + 'j' + self.cc + ' ' + self.label
+        return indent_stmt() + 'j' + self.cc + ' ' + self.label + '\n'
     def __repr__(self):
         return 'JumpIf(' + repr(self.cc) + ', ' + repr(self.label) + ')'
 
@@ -77,10 +97,29 @@ class Jump(instr):
     def __init__(self, label):
         self.label = label
     def __str__(self):
-        return indent_stmt() + 'jmp ' + self.label
+        return indent_stmt() + 'jmp ' + self.label + '\n'
     def __repr__(self):
         return 'Jump(' + repr(self.label) + ')'
 
+class IndirectJump(instr):
+    __match_args__ = ("target",)
+    def __init__(self, target):
+        self.target = target
+    def __str__(self):
+        return indent_stmt() + 'jmp *' + str(self.target) + '\n'
+    def __repr__(self):
+        return 'IndirectJump(' + repr(self.target) + ')'
+    
+class TailJump(instr):
+    __match_args__ = ("func","arity")
+    def __init__(self, func, arity):
+        self.func = func
+        self.arity = arity
+    def __str__(self):
+        return indent_stmt() + 'tailjmp ' + str(self.func) + '\n'
+    def __repr__(self):
+        return 'TailJump(' + repr(self.func) + ',' + repr(self.arity) + ')'
+    
 class Variable(location):
     __match_args__ = ("id",)
     def __init__(self, id):