# HG changeset patch
# User Windel Bouwman
# Date 1400739252 -7200
# Node ID 988f3fb861e4921873cfd44b53d1bb77f2c1ceb3
# Parent  6ae782a085e0a3fa21a3f36affc6fe92cd7c0b75
c3 code generator rewrite

diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/buildfunctions.py
--- a/python/ppci/buildfunctions.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/buildfunctions.py	Thu May 22 08:14:12 2014 +0200
@@ -14,7 +14,7 @@
 from .linker import Linker
 from .layout import Layout, load_layout
 from .target.target_list import targets
-from .outstream import BinaryAndLoggingStream
+from .outstream import BinaryOutputStream
 from .objectfile import ObjectFile, load_object
 from . import DiagnosticsManager
 from .tasks import TaskError, TaskRunner
@@ -91,7 +91,7 @@
     output = ObjectFile()
     assembler = target.assembler
     logger.debug('Assembling into code section')
-    ostream = BinaryAndLoggingStream(output)
+    ostream = BinaryOutputStream(output)
     ostream.select_section('code')
     assembler.prepare()
     assembler.assemble(source, ostream)
@@ -111,7 +111,7 @@
     c3b = Builder(diag, target)
     cg = CodeGenerator(target)
 
-    output_stream = BinaryAndLoggingStream(output)
+    output_stream = BinaryOutputStream(output)
 
     for ircode in c3b.build(sources, includes):
         if not ircode:
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/c3/astnodes.py
--- a/python/ppci/c3/astnodes.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/c3/astnodes.py	Thu May 22 08:14:12 2014 +0200
@@ -44,6 +44,10 @@
     def Types(self):
         return self.innerScope.Types
 
+    @property
+    def Functions(self):
+        return self.innerScope.Functions
+
     def __repr__(self):
         return 'MODULE {}'.format(self.name)
 
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/c3/codegenerator.py
--- a/python/ppci/c3/codegenerator.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/c3/codegenerator.py	Thu May 22 08:14:12 2014 +0200
@@ -13,7 +13,7 @@
         self.loc = loc
 
 
-class CodeGenerator(irutils.Builder):
+class CodeGenerator:
     """
       Generates intermediate (IR) code from a package. The entry function is
       'genModule'. The main task of this part is to rewrite complex control
@@ -26,11 +26,12 @@
     """
     def __init__(self, diag):
         self.logger = logging.getLogger('c3cgen')
+        self.builder = irutils.Builder()
         self.diag = diag
 
     def gencode(self, pkg):
         """ Generate code for a single module """
-        self.prepare()
+        self.builder.prepare()
         assert type(pkg) is ast.Package
         self.pkg = pkg
         self.intType = pkg.scope['int']
@@ -39,24 +40,24 @@
         self.logger.debug('Generating ir-code for {}'.format(pkg.name),
                           extra={'c3_ast': pkg})
         self.varMap = {}    # Maps variables to storage locations.
-        self.m = ir.Module(pkg.name)
+        self.builder.m = ir.Module(pkg.name)
         try:
             for typ in pkg.Types:
                 self.check_type(typ)
             # Only generate function if function contains a body:
             real_functions = list(filter(
-                lambda f: f.body, pkg.innerScope.Functions))
+                lambda f: f.body, pkg.Functions))
             for v in pkg.innerScope.Variables:
-                v2 = ir.GlobalVariable(v.name)
+                v2 = ir.GlobalVariable(v.name, ir.i32)
                 self.varMap[v] = v2
                 if not v.isLocal:
-                    self.m.add_variable(v2)
+                    self.builder.m.add_variable(v2)
             for s in real_functions:
                 self.gen_function(s)
         except SemanticError as e:
             self.error(e.msg, e.loc)
         if self.pkg.ok:
-            return self.m
+            return self.builder.m
 
     def error(self, msg, loc=None):
         self.pkg.ok = False
@@ -64,133 +65,145 @@
 
     def gen_function(self, fn):
         # TODO: handle arguments
-        f = self.newFunction(fn.name)
-        f.return_value = self.newTemp()
-        self.setFunction(f)
-        l2 = self.newBlock()
-        self.emit(ir.Jump(l2))
-        self.setBlock(l2)
+        f = self.builder.new_function(fn.name)
+        f.return_value = self.builder.newTemp()
+        self.builder.setFunction(f)
+        l2 = self.builder.newBlock()
+        self.builder.emit(ir.Jump(l2))
+        self.builder.setBlock(l2)
         # generate room for locals:
 
         for sym in fn.innerScope:
             self.check_type(sym.typ)
             if sym.isParameter:
-                p = ir.Parameter(sym.name)
-                variable = ir.LocalVariable(sym.name + '_copy')
+                p = ir.Parameter(sym.name, ir.i32)
+                variable = ir.LocalVariable(sym.name + '_copy', ir.i32)
                 f.addParameter(p)
                 f.addLocal(variable)
                 # Move parameter into local copy:
-                self.emit(ir.Move(ir.Mem(variable), p))
+                self.builder.emit(ir.Move(ir.Mem(variable), p))
             elif sym.isLocal:
-                variable = ir.LocalVariable(sym.name)
+                variable = ir.LocalVariable(sym.name, ir.i32)
                 f.addLocal(variable)
             elif isinstance(sym, ast.Variable):
-                variable = ir.LocalVariable(sym.name)
+                variable = ir.LocalVariable(sym.name, ir.i32)
                 f.addLocal(variable)
             else:
                 raise NotImplementedError('{}'.format(sym))
             self.varMap[sym] = variable
 
-        self.genCode(fn.body)
-        self.emit(ir.Move(f.return_value, ir.Const(0)))
-        self.emit(ir.Jump(f.epiloog))
-        self.setFunction(None)
-
-    def genCode(self, code):
-        """ Wrapper around gen_stmt to catch errors """
-        try:
-            self.gen_stmt(code)
-        except SemanticError as e:
-            self.error(e.msg, e.loc)
+        self.gen_stmt(fn.body)
+        self.builder.emit(ir.Move(f.return_value, ir.Const(0)))
+        self.builder.emit(ir.Jump(f.epiloog))
+        self.builder.setFunction(None)
 
     def gen_stmt(self, code):
         """ Generate code for a statement """
-        assert isinstance(code, ast.Statement)
-        self.setLoc(code.loc)
-        if type(code) is ast.Compound:
-            for s in code.statements:
-                self.genCode(s)
-        elif type(code) is ast.Empty:
-            pass
-        elif type(code) is ast.Assignment:
-            lval = self.gen_expr_code(code.lval)
-            rval = self.gen_expr_code(code.rval)
-            if not self.equal_types(code.lval.typ, code.rval.typ):
-                raise SemanticError('Cannot assign {} to {}'
-                                    .format(code.rval.typ, code.lval.typ),
-                                    code.loc)
-            if not code.lval.lvalue:
-                raise SemanticError('No valid lvalue {}'.format(code.lval),
-                                    code.lval.loc)
-            self.emit(ir.Move(lval, rval))
-        elif type(code) is ast.ExpressionStatement:
-            self.emit(ir.Exp(self.gen_expr_code(code.ex)))
-        elif type(code) is ast.If:
-            bbtrue = self.newBlock()
-            bbfalse = self.newBlock()
-            te = self.newBlock()
-            self.gen_cond_code(code.condition, bbtrue, bbfalse)
-            self.setBlock(bbtrue)
-            self.genCode(code.truestatement)
-            self.emit(ir.Jump(te))
-            self.setBlock(bbfalse)
-            self.genCode(code.falsestatement)
-            self.emit(ir.Jump(te))
-            self.setBlock(te)
-        elif type(code) is ast.Return:
-            re = self.gen_expr_code(code.expr)
-            self.emit(ir.Move(self.fn.return_value, re))
-            self.emit(ir.Jump(self.fn.epiloog))
-            b = self.newBlock()
-            self.setBlock(b)
-        elif type(code) is ast.While:
-            bbdo = self.newBlock()
-            bbtest = self.newBlock()
-            te = self.newBlock()
-            self.emit(ir.Jump(bbtest))
-            self.setBlock(bbtest)
-            self.gen_cond_code(code.condition, bbdo, te)
-            self.setBlock(bbdo)
-            self.genCode(code.statement)
-            self.emit(ir.Jump(bbtest))
-            self.setBlock(te)
-        elif type(code) is ast.For:
-            bbdo = self.newBlock()
-            bbtest = self.newBlock()
-            te = self.newBlock()
-            self.genCode(code.init)
-            self.emit(ir.Jump(bbtest))
-            self.setBlock(bbtest)
-            self.gen_cond_code(code.condition, bbdo, te)
-            self.setBlock(bbdo)
-            self.genCode(code.statement)
-            self.genCode(code.final)
-            self.emit(ir.Jump(bbtest))
-            self.setBlock(te)
-        elif type(code) is ast.Switch:
-            raise NotImplementedError('Unknown stmt {}'.format(code))
-        else:
-            raise NotImplementedError('Unknown stmt {}'.format(code))
+        try:
+            assert isinstance(code, ast.Statement)
+            self.builder.setLoc(code.loc)
+            if type(code) is ast.Compound:
+                for s in code.statements:
+                    self.gen_stmt(s)
+            elif type(code) is ast.Empty:
+                pass
+            elif type(code) is ast.Assignment:
+                self.gen_assignment_stmt(code)
+            elif type(code) is ast.ExpressionStatement:
+                self.builder.emit(ir.Exp(self.gen_expr_code(code.ex)))
+            elif type(code) is ast.If:
+                self.gen_if_stmt(code)
+            elif type(code) is ast.Return:
+                re = self.gen_expr_code(code.expr)
+                self.builder.emit(ir.Move(self.builder.fn.return_value, re))
+                self.builder.emit(ir.Jump(self.builder.fn.epiloog))
+                b = self.builder.newBlock()
+                self.builder.setBlock(b)
+            elif type(code) is ast.While:
+                self.gen_while(code)
+            elif type(code) is ast.For:
+                self.gen_for_stmt(code)
+            elif type(code) is ast.Switch:
+                raise NotImplementedError('Unknown stmt {}'.format(code))
+            else:
+                raise NotImplementedError('Unknown stmt {}'.format(code))
+        except SemanticError as e:
+            self.error(e.msg, e.loc)
+
+    def gen_assignment_stmt(self, code):
+        """ Generate code for assignment statement """
+        lval = self.gen_expr_code(code.lval)
+        rval = self.gen_expr_code(code.rval)
+        if not self.equal_types(code.lval.typ, code.rval.typ):
+            raise SemanticError('Cannot assign {} to {}'
+                                .format(code.rval.typ, code.lval.typ),
+                                code.loc)
+        if not code.lval.lvalue:
+            raise SemanticError('No valid lvalue {}'.format(code.lval),
+                                code.lval.loc)
+        self.builder.emit(ir.Move(lval, rval))
+
+    def gen_if_stmt(self, code):
+        """ Generate code for if statement """
+        true_block = self.builder.newBlock()
+        bbfalse = self.builder.newBlock()
+        te = self.builder.newBlock()
+        self.gen_cond_code(code.condition, true_block, bbfalse)
+        self.builder.setBlock(true_block)
+        self.gen_stmt(code.truestatement)
+        self.builder.emit(ir.Jump(te))
+        self.builder.setBlock(bbfalse)
+        self.gen_stmt(code.falsestatement)
+        self.builder.emit(ir.Jump(te))
+        self.builder.setBlock(te)
+
+    def gen_while(self, code):
+        """ Generate code for while statement """
+        bbdo = self.builder.newBlock()
+        test_block = self.builder.newBlock()
+        final_block = self.builder.newBlock()
+        self.builder.emit(ir.Jump(test_block))
+        self.builder.setBlock(test_block)
+        self.gen_cond_code(code.condition, bbdo, final_block)
+        self.builder.setBlock(bbdo)
+        self.gen_stmt(code.statement)
+        self.builder.emit(ir.Jump(test_block))
+        self.builder.setBlock(final_block)
+
+    def gen_for_stmt(self, code):
+        """ Generate for statement code """
+        bbdo = self.builder.newBlock()
+        test_block = self.builder.newBlock()
+        final_block = self.builder.newBlock()
+        self.gen_stmt(code.init)
+        self.builder.emit(ir.Jump(test_block))
+        self.builder.setBlock(test_block)
+        self.gen_cond_code(code.condition, bbdo, final_block)
+        self.builder.setBlock(bbdo)
+        self.gen_stmt(code.statement)
+        self.gen_stmt(code.final)
+        self.builder.emit(ir.Jump(test_block))
+        self.builder.setBlock(final_block)
 
     def gen_cond_code(self, expr, bbtrue, bbfalse):
         """ Generate conditional logic.
             Implement sequential logical operators. """
         if type(expr) is ast.Binop:
             if expr.op == 'or':
-                l2 = self.newBlock()
+                l2 = self.builder.newBlock()
                 self.gen_cond_code(expr.a, bbtrue, l2)
                 if not self.equal_types(expr.a.typ, self.boolType):
                     raise SemanticError('Must be boolean', expr.a.loc)
-                self.setBlock(l2)
+                self.builder.setBlock(l2)
                 self.gen_cond_code(expr.b, bbtrue, bbfalse)
                 if not self.equal_types(expr.b.typ, self.boolType):
                     raise SemanticError('Must be boolean', expr.b.loc)
             elif expr.op == 'and':
-                l2 = self.newBlock()
+                l2 = self.builder.newBlock()
                 self.gen_cond_code(expr.a, l2, bbfalse)
                 if not self.equal_types(expr.a.typ, self.boolType):
                     self.error('Must be boolean', expr.a.loc)
-                self.setBlock(l2)
+                self.builder.setBlock(l2)
                 self.gen_cond_code(expr.b, bbtrue, bbfalse)
                 if not self.equal_types(expr.b.typ, self.boolType):
                     raise SemanticError('Must be boolean', expr.b.loc)
@@ -201,16 +214,16 @@
                     raise SemanticError('Types unequal {} != {}'
                                         .format(expr.a.typ, expr.b.typ),
                                         expr.loc)
-                self.emit(ir.CJump(ta, expr.op, tb, bbtrue, bbfalse))
+                self.builder.emit(ir.CJump(ta, expr.op, tb, bbtrue, bbfalse))
             else:
                 raise SemanticError('non-bool: {}'.format(expr.op), expr.loc)
             expr.typ = self.boolType
         elif type(expr) is ast.Literal:
             self.gen_expr_code(expr)
             if expr.val:
-                self.emit(ir.Jump(bbtrue))
+                self.builder.emit(ir.Jump(bbtrue))
             else:
-                self.emit(ir.Jump(bbfalse))
+                self.builder.emit(ir.Jump(bbfalse))
         else:
             raise NotImplementedError('Unknown cond {}'.format(expr))
 
@@ -237,7 +250,7 @@
                     raise SemanticError('Can only add integers', expr.loc)
             else:
                 raise NotImplementedError("Cannot use equality as expressions")
-            return ir.Binop(ra, expr.op, rb)
+            return ir.Binop(ra, expr.op, rb, "op", ir.i32)
         elif type(expr) is ast.Unop:
             if expr.op == '&':
                 ra = self.gen_expr_code(expr.a)
@@ -274,61 +287,11 @@
             else:
                 raise SemanticError('Cannot deref non-pointer', expr.loc)
         elif type(expr) is ast.Member:
-            base = self.gen_expr_code(expr.base)
-            expr.lvalue = expr.base.lvalue
-            basetype = self.the_type(expr.base.typ)
-            if type(basetype) is ast.StructureType:
-                if basetype.hasField(expr.field):
-                    expr.typ = basetype.fieldType(expr.field)
-                else:
-                    raise SemanticError('{} does not contain field {}'
-                                        .format(basetype, expr.field),
-                                        expr.loc)
-            else:
-                raise SemanticError('Cannot select {} of non-structure type {}'
-                                    .format(expr.field, basetype), expr.loc)
-
-            assert type(base) is ir.Mem, type(base)
-            bt = self.the_type(expr.base.typ)
-            offset = ir.Const(bt.fieldOffset(expr.field))
-            return ir.Mem(ir.Add(base.e, offset))
+            return self.gen_member_expr(expr)
         elif type(expr) is ast.Index:
-            """ Array indexing """
-            base = self.gen_expr_code(expr.base)
-            idx = self.gen_expr_code(expr.i)
-            base_typ = self.the_type(expr.base.typ)
-            if not isinstance(base_typ, ast.ArrayType):
-                raise SemanticError('Cannot index non-array type {}'
-                                    .format(base_typ),
-                                    expr.base.loc)
-            idx_type = self.the_type(expr.i.typ)
-            if not self.equal_types(idx_type, self.intType):
-                raise SemanticError('Index must be int not {}'
-                                    .format(idx_type), expr.i.loc)
-            assert type(base) is ir.Mem
-            element_type = self.the_type(base_typ.element_type)
-            element_size = self.size_of(element_type)
-            expr.typ = base_typ.element_type
-            expr.lvalue = True
-
-            return ir.Mem(ir.Add(base.e, ir.Mul(idx, ir.Const(element_size))))
+            return self.gen_index_expr(expr)
         elif type(expr) is ast.Literal:
-            expr.lvalue = False
-            typemap = {int: 'int',
-                       float: 'double',
-                       bool: 'bool',
-                       str: 'string'}
-            if type(expr.val) in typemap:
-                expr.typ = self.pkg.scope[typemap[type(expr.val)]]
-            else:
-                raise SemanticError('Unknown literal type {}'
-                                    .format(expr.val), expr.loc)
-            # Construct correct const value:
-            if type(expr.val) is str:
-                cval = self.pack_string(expr.val)
-                return ir.Addr(ir.Const(cval))
-            else:
-                return ir.Const(expr.val)
+            return self.gen_literal_expr(expr)
         elif type(expr) is ast.TypeCast:
             return self.gen_type_cast(expr)
         elif type(expr) is ast.Sizeof:
@@ -342,6 +305,69 @@
         else:
             raise NotImplementedError('Unknown expr {}'.format(expr))
 
+    def gen_member_expr(self, expr):
+        base = self.gen_expr_code(expr.base)
+        expr.lvalue = expr.base.lvalue
+        basetype = self.the_type(expr.base.typ)
+        if type(basetype) is ast.StructureType:
+            if basetype.hasField(expr.field):
+                expr.typ = basetype.fieldType(expr.field)
+            else:
+                raise SemanticError('{} does not contain field {}'
+                                    .format(basetype, expr.field),
+                                    expr.loc)
+        else:
+            raise SemanticError('Cannot select {} of non-structure type {}'
+                                .format(expr.field, basetype), expr.loc)
+
+        assert type(base) is ir.Mem, type(base)
+        bt = self.the_type(expr.base.typ)
+        offset = ir.Const(bt.fieldOffset(expr.field))
+        addr = ir.Add(base.e, offset, "mem_addr", ir.i32)
+        return ir.Mem(addr)
+
+    def gen_index_expr(self, expr):
+        """ Array indexing """
+        base = self.gen_expr_code(expr.base)
+        idx = self.gen_expr_code(expr.i)
+        base_typ = self.the_type(expr.base.typ)
+        if not isinstance(base_typ, ast.ArrayType):
+            raise SemanticError('Cannot index non-array type {}'
+                                .format(base_typ),
+                                expr.base.loc)
+        idx_type = self.the_type(expr.i.typ)
+        if not self.equal_types(idx_type, self.intType):
+            raise SemanticError('Index must be int not {}'
+                                .format(idx_type), expr.i.loc)
+        assert type(base) is ir.Mem
+        element_type = self.the_type(base_typ.element_type)
+        element_size = self.size_of(element_type)
+        expr.typ = base_typ.element_type
+        expr.lvalue = True
+
+        offset = ir.Mul(idx, ir.Const(element_size), "element_offset", ir.i32)
+        addr = ir.Add(base.e, offset, "element_address", ir.i32)
+        return ir.Mem(addr)
+
+    def gen_literal_expr(self, expr):
+        """ Generate code for literal """
+        expr.lvalue = False
+        typemap = {int: 'int',
+                   float: 'double',
+                   bool: 'bool',
+                   str: 'string'}
+        if type(expr.val) in typemap:
+            expr.typ = self.pkg.scope[typemap[type(expr.val)]]
+        else:
+            raise SemanticError('Unknown literal type {}'
+                                .format(expr.val), expr.loc)
+        # Construct correct const value:
+        if type(expr.val) is str:
+            cval = self.pack_string(expr.val)
+            return ir.Addr(ir.Const(cval))
+        else:
+            return ir.Const(expr.val)
+
     def pack_string(self, txt):
         """ Pack a string using 4 bytes length followed by text data """
         length = struct.pack('<I', len(txt))
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/c3/parser.py
--- a/python/ppci/c3/parser.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/c3/parser.py	Thu May 22 08:14:12 2014 +0200
@@ -23,7 +23,7 @@
         self.tokens = tokens
         self.token = self.tokens.__next__()
         try:
-            self.parsePackage()
+            self.parse_package()
             self.mod.ok = True  # Valid until proven wrong :)
             return self.mod
         except CompilerError as e:
@@ -68,26 +68,28 @@
         self.mod.imports.append(name)
         self.Consume(';')
 
-    def parsePackage(self):
+    def parse_package(self):
+        """ Parse a package definition """
         self.Consume('module')
         name = self.Consume('ID')
         self.Consume(';')
         self.mod = Package(name.val, name.loc)
         self.currentPart = self.mod
         while self.Peak != 'END':
-            self.parseTopLevel()
+            self.parse_top_level()
         self.Consume('END')
 
-    def parseTopLevel(self):
+    def parse_top_level(self):
+        """ Parse toplevel declaration """
         if self.Peak == 'function':
             self.parse_function_def()
         elif self.Peak == 'var':
-            self.parseVarDef()
+            self.parse_variable_def()
             # TODO handle variable initialization
         elif self.Peak == 'const':
             self.parseConstDef()
         elif self.Peak == 'type':
-            self.parseTypeDef()
+            self.parse_type_def()
         elif self.Peak == 'import':
             self.parseImport()
         else:
@@ -155,7 +157,7 @@
                 raise Exception()
         return theT
 
-    def parseTypeDef(self):
+    def parse_type_def(self):
         self.Consume('type')
         newtype = self.parse_type_spec()
         typename = self.Consume('ID')
@@ -164,7 +166,8 @@
         self.addDeclaration(df)
 
     # Variable declarations:
-    def parseVarDef(self):
+    def parse_variable_def(self):
+        """ Parse variable declaration """
         self.Consume('var')
         t = self.parse_type_spec()
         for name in self.parseIdSequence():
@@ -172,7 +175,6 @@
             v.loc = name.loc
             self.addDeclaration(v)
         self.Consume(';')
-        return Empty()
 
     def parseConstDef(self):
         self.Consume('const')
@@ -234,7 +236,7 @@
         self.Consume(')')
         return Switch(condition, loc)
 
-    def parseWhile(self):
+    def parse_while(self):
         loc = self.Consume('while').loc
         self.Consume('(')
         condition = self.Expression()
@@ -275,7 +277,7 @@
         if self.Peak == 'if':
             return self.parse_if()
         elif self.Peak == 'while':
-            return self.parseWhile()
+            return self.parse_while()
         elif self.Peak == 'for':
             return self.parse_for()
         elif self.Peak == 'switch':
@@ -285,7 +287,8 @@
         elif self.hasConsumed(';'):
             return Empty()
         elif self.Peak == 'var':
-            return self.parseVarDef()
+            self.parse_variable_def()
+            return Empty()
         elif self.Peak == 'return':
             return self.parseReturn()
         else:
@@ -391,6 +394,7 @@
             return self.UnaryExpression()
 
     def sizeof_expression(self):
+        """ Compiler internal function to determine size of a type """
         loc = self.Consume('sizeof').loc
         self.Consume('(')
         typ = self.parse_type_spec()
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/c3/scope.py
--- a/python/ppci/c3/scope.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/c3/scope.py	Thu May 22 08:14:12 2014 +0200
@@ -16,6 +16,7 @@
 
     @property
     def Syms(self):
+        """ Get all the symbols defined in this scope """
         syms = self.symbols.values()
         return sorted(syms, key=lambda v: v.name)
 
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/codegen/canon.py
--- a/python/ppci/codegen/canon.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/codegen/canon.py	Thu May 22 08:14:12 2014 +0200
@@ -60,7 +60,7 @@
         return frame.parMap[exp]
     elif isinstance(exp, ir.LocalVariable):
         offset = frame.allocVar(exp)
-        return ir.Add(frame.fp, ir.Const(offset))
+        return ir.Add(frame.fp, ir.Const(offset), "Offset", ir.i32)
     elif isinstance(exp, ir.GlobalVariable):
         #frame.load_global_address(ir.label_name(exp))
         return exp
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/ir.py
--- a/python/ppci/ir.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/ir.py	Thu May 22 08:14:12 2014 +0200
@@ -4,7 +4,7 @@
 
 
 def label_name(dut):
-    """ Function that returns the assembly code label name """
+    """ Returns the assembly code label name """
     if isinstance(dut, Block):
         f = dut.function
         return label_name(f) + '_' + dut.name
@@ -16,6 +16,14 @@
         raise NotImplementedError(str(dut))
 
 
+class Typ:
+    def __init__(self):
+        pass
+
+
+i32 = Typ()
+i8 = Typ()
+
 class Module:
     """ Container unit for variables and functions. """
     def __init__(self, name):
@@ -46,14 +54,12 @@
 
     Functions = property(get_functions)
 
-    def findFunction(self, name):
+    def find_function(self, name):
         for f in self.funcs:
             if f.name == name:
                 return f
         raise KeyError(name)
 
-    getFunction = findFunction
-
 
 class Function:
     """ Represents a function. """
@@ -195,9 +201,27 @@
 # Instructions:
 
 class Value:
-    pass
+    """ A value has a type and a name """
+    def __init__(self, name, ty):
+        assert isinstance(ty, Typ)
+        self.name = name
+        self.ty = ty
+
 
-class Expression:
+class User(Value):
+    """ Value that uses other values """
+    def __init__(self, name, ty):
+        super().__init__(name, ty)
+        # Create a collection to store the values this value uses.
+        # TODO: think of better naming..
+        self.uses = set()
+
+    def add_use(self, v):
+        assert isinstance(v, Value)
+        self.uses.add(v)
+
+
+class Expression(User):
     """ Base class for an expression """
     pass
 
@@ -228,11 +252,14 @@
     """ Generic binary operation """
     ops = ['+', '-', '*', '/', '|', '&', '<<', '>>']
 
-    def __init__(self, value1, operation, value2):
+    def __init__(self, a, operation, b, name, ty):
+        super().__init__(name, ty)
         assert operation in Binop.ops
         #assert type(value1) is type(value2)
-        self.a = value1
-        self.b = value2
+        assert isinstance(a, Value), str(a)
+        assert isinstance(b, Value), str(b)
+        self.a = a
+        self.b = b
         self.operation = operation
 
     def __repr__(self):
@@ -240,9 +267,10 @@
         return '({} {} {})'.format(a, self.operation, b)
 
 
-def Add(a, b):
+class Add(Binop):
     """ Add a and b """
-    return Binop(a, '+', b)
+    def __init__(self, a, b, name, ty):
+        super().__init__(a, '+', b, name, ty)
 
 
 def Sub(a, b):
@@ -250,9 +278,9 @@
     return Binop(a, '-', b)
 
 
-def Mul(a, b):
+def Mul(a, b, name, ty):
     """ Multiply a by b """
-    return Binop(a, '*', b)
+    return Binop(a, '*', b, name, ty)
 
 
 def Div(a, b):
@@ -260,6 +288,16 @@
     return Binop(a, '/', b)
 
 
+def Phi(User):
+    """ Imaginary phi instruction to make SSA possible. """
+    def __init__(self, name, ty):
+        super().__init__(name, ty)
+        self.inputs = []
+
+    def add_input(self, value, block):
+        self.inputs.append((value, block))
+
+
 class Eseq(Expression):
     """ Sequence of instructions where the last is an expression """
     def __init__(self, stmt, e):
@@ -280,7 +318,8 @@
 
 
 class Variable(Expression):
-    def __init__(self, name):
+    def __init__(self, name, ty):
+        super().__init__(name, ty)
         self.name = name
 
     def __repr__(self):
@@ -320,6 +359,23 @@
         return '[{}]'.format(self.e)
 
 
+class Load(Value):
+    """ Load a value from memory """
+    def __init__(self, address, name, ty):
+        super().__init__(name, ty)
+        assert isinstance(address, Value)
+        self.address = address
+
+    def __repr__(self):
+        return 'load {}'.format(self.address)
+
+
+class Store:
+    """ Store a value into memory """
+    def __init__(self, address, value):
+        self.address = address
+
+
 class Addr(Expression):
     """ Address of label """
     def __init__(self, e):
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/ir2tree.py
--- a/python/ppci/ir2tree.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/ir2tree.py	Thu May 22 08:14:12 2014 +0200
@@ -13,6 +13,7 @@
     return reg_f
 
 @register(ir.Binop)
+@register(ir.Add)
 def binop_to_tree(e):
     names = {'+':'ADDI32', '-':'SUBI32', '|':'ORI32', '<<':'SHLI32',
         '*':'MULI32', '&':'ANDI32', '>>':'SHRI32'}
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/irutils.py
--- a/python/ppci/irutils.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/irutils.py	Thu May 22 08:14:12 2014 +0200
@@ -210,7 +210,7 @@
     def setModule(self, m):
         self.m = m
 
-    def newFunction(self, name):
+    def new_function(self, name):
         f = ir.Function(name)
         self.m.add_function(f)
         return f
@@ -240,6 +240,7 @@
 
 
 class Verifier:
+    """ Checks an ir module for correctness """
     def verify(self, module):
         """ Verifies a module for some sanity """
         assert isinstance(module, ir.Module)
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/target/token.py
--- a/python/ppci/target/token.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/target/token.py	Thu May 22 08:14:12 2014 +0200
@@ -13,7 +13,6 @@
     b = []
     for i in range(bits):
         b.append(bool((1<<i) & v))
-    #b.reverse()
     return b
 
 
@@ -48,6 +47,7 @@
         elif type(key) is slice:
             assert key.step is None
             bits = key.stop - key.start
+            assert value < (2**bits)
             value_bits = val2bit(value, bits)
             for i in range(key.start, key.stop):
                 self.set_bit(i, value_bits[i - key.start])
diff -r 6ae782a085e0 -r 988f3fb861e4 python/ppci/transform.py
--- a/python/ppci/transform.py	Sat May 17 21:17:40 2014 +0200
+++ b/python/ppci/transform.py	Thu May 22 08:14:12 2014 +0200
@@ -125,6 +125,7 @@
 
 child_nodes = {}
 child_nodes[ir.Binop] = ['a', 'b']
+child_nodes[ir.Add] = ['a', 'b']
 child_nodes[ir.Const] = []
 child_nodes[ir.Temp] = []
 child_nodes[ir.Exp] = ['e']
diff -r 6ae782a085e0 -r 988f3fb861e4 test/testir.py
--- a/test/testir.py	Sat May 17 21:17:40 2014 +0200
+++ b/test/testir.py	Thu May 22 08:14:12 2014 +0200
@@ -1,5 +1,4 @@
 import unittest
-import os
 import sys
 import io
 import ppci
@@ -10,7 +9,7 @@
 
 class IrCodeTestCase(unittest.TestCase):
     def testAdd(self):
-        v = ir.Add(ir.Const(1), ir.Const(2))
+        v = ir.Add(ir.Const(1), ir.Const(2), "add", ir.i32)
 
 
 class IrBuilderTestCase(unittest.TestCase):
@@ -20,7 +19,7 @@
         self.b.setModule(self.m)
 
     def testBuilder(self):
-        f = self.b.newFunction('add')
+        f = self.b.new_function('add')
         self.b.setFunction(f)
         bb = self.b.newBlock()
         self.b.emit(ir.Jump(bb))
@@ -65,23 +64,23 @@
         self.b.setModule(self.m)
 
     def testBuilder(self):
-        f = self.b.newFunction('test')
+        f = self.b.new_function('test')
         self.b.setFunction(f)
         bb = self.b.newBlock()
         self.b.emit(ir.Jump(bb))
         self.b.setBlock(bb)
         v1 = ir.Const(5)
         v2 = ir.Const(7)
-        v3 = ir.Add(v1, v2)
+        v3 = ir.Add(v1, v2, "add", ir.i32)
         self.b.emit(ir.Jump(f.epiloog))
         self.cf.run(self.m)
 
     def testAdd0(self):
-        f = self.b.newFunction('test')
+        f = self.b.new_function('test')
         self.b.setFunction(f)
         self.b.setBlock(self.b.newBlock())
-        v1 = ir.Const(0)
-        v3 = ir.Add(v1, ir.Const(0))
+        v1 = ir.Const(12)
+        v3 = ir.Add(v1, ir.Const(0), "add", ir.i32)
 
 
 class TestWriter(unittest.TestCase):