Merge pull request #219 from boriel/feature/array_addr

Feature/array addr

Author: boriel

api/errmsg.py

@@ -185,5 +185,12 @@ def syntax_error_undeclared_type(lineno, id_):
 # ----------------------------------------
 #  Cannot assign a value to 'var'. It's not a variable
 # ----------------------------------------
-def syntax_error_cannot_assing_not_a_var(lineno, id_):
+def syntax_error_cannot_assign_not_a_var(lineno, id_):
     syntax_error(lineno, "Cannot assign a value to '%s'. It's not a variable" % id_)
+
+
+# ----------------------------------------
+#  Cannot assign a value to 'var'. It's not a variable
+# ----------------------------------------
+def syntax_error_address_must_be_constant(lineno):
+    syntax_error(lineno, 'Address must be a numeric constant expression')

api/global_.py

@@ -132,6 +132,11 @@
 # ----------------------------------------------------------------------
 MANGLE_CHR = '_'
 
+# ----------------------------------------------------------------------
+# Prefix used in labels to mark the beginning of array data
+# ----------------------------------------------------------------------
+ARRAY_DATA_PREFIX = '__DATA__'
+
 # ----------------------------------------------------------------------
 # Default optimization level
 # ----------------------------------------------------------------------

api/optimize.py

@@ -41,7 +41,7 @@ def TYPE(type_):
         return gl.SYMBOL_TABLE.basic_types[type_]
 
     def visit(self, node):
-        if self.O_LEVEL < 0:  # Optimize only if O1 or above
+        if self.O_LEVEL < 1:  # Optimize only if O1 or above
             return node
 
         stack = [ToVisit(node)]

api/symboltable.py

@@ -567,7 +567,6 @@ def declare_variable(self, id_, lineno, type_, default_value=None):
                              "declared as '%s'" %
                              (id_, entry.type_, type_))
                 return None
-                # type_ = entry.type_  # TODO: Unused??
 
         entry.scope = SCOPE.global_ if self.current_scope == self.global_scope else SCOPE.local
         entry.callable = False
@@ -701,9 +700,11 @@ def declare_param(self, id_, lineno, type_=None):
             warning_implicit_type(lineno, id_, type_)
         return entry
 
-    def declare_array(self, id_, lineno, type_, bounds, default_value=None):
+    def declare_array(self, id_, lineno, type_, bounds, default_value=None, addr=None):
         """ Declares an array in the symbol table (VARARRAY). Error if already
         exists.
+        The optional parameter addr specifies if the array elements must be placed at an specific
+        (constant) memory address.
         """
         assert isinstance(type_, symbols.TYPEREF)
         assert isinstance(bounds, symbols.BOUNDLIST)
@@ -754,6 +755,7 @@ def declare_array(self, id_, lineno, type_, bounds, default_value=None):
         entry.callable = True
         entry.class_ = CLASS.array
         entry.lbound_used = entry.ubound_used = False  # Flag to true when LBOUND/UBOUND used somewhere in the code
+        entry.addr = addr
 
         __DEBUG__('Entry %s declared with class %s at scope %i' % (id_, CLASS.to_string(entry.class_),
                                                                    self.current_scope))

arch/zx48k/backend/__init__.py

@@ -579,6 +579,44 @@ def _lvard(ins):
     return output
 
 
+def _larrd(ins):
+    """ Defines a local array.
+      - 1st param is offset of the local variable.
+      - 2nd param is a list of bytes in hexadecimal corresponding to the index table
+      - 3rd param is the size of elements in byte
+      - 4rd param a list (might be empty) of byte to initialize the array with
+    """
+    output = []
+
+    label = tmp_label()
+    offset = int(ins.quad[1])
+    elements_size = ins.quad[3]
+    AT_END.extend(_vard(Quad('vard', label, ins.quad[2])))
+    must_initialize = ins.quad[4] != '[]'
+
+    if must_initialize:
+        label2 = tmp_label()
+        AT_END.extend(_vard(Quad('vard', label2, ins.quad[4])))
+        output.extend([
+            'ld hl, %s' % label2,
+            'push hl'
+        ])
+
+    output.extend([
+        'ld hl, %i' % -offset,
+        'ld de, %s' % label,
+        'ld bc, %s' % elements_size,
+    ])
+
+    if must_initialize:
+        output.append('call __ALLOC_INITIALIZED_LOCAL_ARRAY')
+    else:
+        output.append('call __ALLOC_LOCAL_ARRAY')
+
+    REQUIRES.add('arrayalloc.asm')
+    return output
+
+
 def _out(ins):
     """ Translates OUT to asm.
     """
@@ -2099,7 +2137,7 @@ def __str__(self):
     'vard': [2, _vard],  # Like the above but with a list of items (chars, bytes or words, hex)
     'lvarx': [3, _lvarx],  # Initializes a local variable. lvard X, (list of bytes): Initializes variable at offset X
     'lvard': [2, _lvard],  # Initializes a local variable. lvard X, (list of bytes): Initializes variable at offset X
-
+    'larrd': [4, _larrd],  # Initializes a local array
     'memcopy': [3, _memcopy],  # Copies a block of param 3 bytes of memory from param 2 addr to param 1 addr.
 
     'bandu8': [3, _band8],  # x = A & B

arch/zx48k/backend/__parray.py

@@ -16,14 +16,14 @@
 
 
 def _paddr(offset):
-    ''' Generic array address parameter loading.
-    Emmits output code for setting IX at the right location.
+    """ Generic element array-address stack-ptr loading.
+    Emits output code for setting IX at the right location.
     bytes = Number of bytes to load:
         1 => 8 bit value
         2 => 16 bit value / string
         4 => 32 bit value / f16 value
         5 => 40 bit value
-    '''
+    """
     output = []
 
     indirect = offset[0] == '*'
@@ -40,12 +40,9 @@ def _paddr(offset):
     output.append('add hl, de')
 
     if indirect:
-        output.append('ld c, (hl)')
-        output.append('inc hl')
-        output.append('ld h, (hl)')
-        output.append('ld l, c')
-
-    output.append('call __ARRAY')
+        output.append('call __ARRAY_PTR')
+    else:
+        output.append('call __ARRAY')
     REQUIRES.add('array.asm')
     return output
 

arch/zx48k/backend/__str.py

@@ -65,7 +65,7 @@ def _str_oper(op1, op2=None, reversed=False, no_exaf=False):
 
     if val[0] == '_':  # Direct
         output.append('ld hl, (%s)' % val)
-    elif val[0] == '#':  # Inmmediate
+    elif val[0] == '#':  # Immediate
         output.append('ld hl, %s' % val[1:])
     elif val[0] == '$':  # Direct in the stack
         output.append('pop hl')
@@ -74,7 +74,6 @@ def _str_oper(op1, op2=None, reversed=False, no_exaf=False):
         tmp1 = True
 
     if indirect:
-        output.append('ld hl, %s' % val[1:])
         output.append('ld c, (hl)')
         output.append('inc hl')
         output.append('ld h, (hl)')

arch/zx48k/translator.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import functools
 from collections import OrderedDict
 from collections import namedtuple
 
@@ -281,15 +280,18 @@ def traverse_const(node):
             syntax_error_cant_convert_to_type(node.lineno, str(node.operand), node.type_)
             return
 
-        if node.token in ('VAR', 'VARARRAY', 'LABEL', 'FUNCTION'):
+        if node.token == 'VARARRAY':
+            return node.data_label
+
+        if node.token in ('VAR', 'LABEL', 'FUNCTION'):
             # TODO: Check what happens with local vars and params
             return node.t
 
         if node.token == 'CONST':
             return Translator.traverse_const(node.expr)
 
         if node.token == 'ARRAYACCESS':
-            return '({} + {})'.format(node.entry.mangled, node.offset)
+            return '({} + {})'.format(node.entry.data_label, node.offset)
 
         raise InvalidCONSTexpr(node)
 
@@ -404,7 +406,7 @@ def visit_CONST(self, node):
         yield node.t
 
     def visit_VARARRAY(self, node):
-        self.visit_VAR(node)
+        pass
 
     def visit_PARAMDECL(self, node):
         assert node.scope == SCOPE.parameter
@@ -516,36 +518,40 @@ def visit_ARRAYLOAD(self, node):
         else:
             offset = node.offset
             if scope == SCOPE.global_:
-                self.emit('load' + self.TSUFFIX(node.type_), node.entry.t, '%s + %i' % (node.entry.mangled, offset))
+                self.emit('load' + self.TSUFFIX(node.type_), node.entry.t, '%s + %i' % (node.entry.t, offset))
             elif scope == SCOPE.parameter:
                 self.emit('pload' + self.TSUFFIX(node.type_), node.t, node.entry.offset - offset)
             elif scope == SCOPE.local:
-                self.emit('pload' + self.TSUFFIX(node.type_), node.t, -(node.entry.offset - offset))
+                t1 = optemps.new_t()
+                t2 = optemps.new_t()
+                t3 = optemps.new_t()
+                self.emit('pload' + self.TSUFFIX(gl.PTR_TYPE), t1,
+                          -(node.entry.offset - self.TYPE(gl.PTR_TYPE).size))
+                self.emit('add' + self.TSUFFIX(gl.PTR_TYPE), t2, t1, node.offset)
+                self.emit('load' + self.TSUFFIX(node.type_), t3, '*$%s' % t2)
 
     def visit_ARRAYCOPY(self, node):
         tr = node.children[0]
         scope = tr.scope
-        offset = self.TYPE(gl.SIZE_TYPE).size + self.TYPE(gl.BOUND_TYPE).size * len(tr.bounds)
         if scope == SCOPE.global_:
-            t1 = "#%s + %i" % (tr.mangled, offset)
+            t1 = "#%s" % tr.data_label
         elif scope == SCOPE.parameter:
-            self.emit('paddr', '%i' % (tr.offset - offset), tr.t)
-            t1 = tr.t
+            t1 = optemps.new_t()
+            self.emit('pload%s' % self.TSUFFIX(gl.PTR_TYPE), t1, '%i' % (tr.offset - self.TYPE(gl.PTR_TYPE).size))
         elif scope == SCOPE.local:
-            self.emit('paddr', '%i' % -(tr.offset - offset), tr.t)
-            t1 = tr.t
+            t1 = optemps.new_t()
+            self.emit('pload%s' % self.TSUFFIX(gl.PTR_TYPE), t1, '%i' % -(tr.offset - self.TYPE(gl.PTR_TYPE).size))
 
         tr = node.children[1]
         scope = tr.scope
-        offset = self.TYPE(gl.SIZE_TYPE).size + self.TYPE(gl.BOUND_TYPE).size * len(tr.bounds)
         if scope == SCOPE.global_:
-            t2 = "#%s + %i" % (tr.mangled, offset)
+            t2 = "#%s" % tr.data_label
         elif scope == SCOPE.parameter:
-            self.emit('paddr', '%i' % (tr.offset - offset), tr.t)
-            t2 = tr.t
+            t2 = optemps.new_t()
+            self.emit('pload%s' % self.TSUFFIX(gl.PTR_TYPE), t2, '%i' % (tr.offset - self.TYPE(gl.PTR_TYPE).size))
         elif scope == SCOPE.local:
-            self.emit('paddr', '%i' % -(tr.offset - offset), tr.t)
-            t2 = tr.t
+            t2 = optemps.new_t()
+            self.emit('pload%s' % self.TSUFFIX(gl.PTR_TYPE), t2, '%i' % -(tr.offset - self.TYPE(gl.PTR_TYPE).size))
 
         t = optemps.new_t()
         if tr.type_ != Type.string:
@@ -575,7 +581,7 @@ def visit_LETARRAY(self, node):
             elif scope == SCOPE.local:
                 self.emit('pastore' + suf, -arr.entry.offset, node.children[1].t)
         else:
-            name = arr.entry.mangled
+            name = arr.entry.data_label
             if scope == SCOPE.global_:
                 self.emit('store' + suf, '%s + %i' % (name, arr.offset), node.children[1].t)
             elif scope == SCOPE.parameter:
@@ -1352,28 +1358,44 @@ def visit_VARDECL(self, node):
 
     def visit_ARRAYDECL(self, node):
         entry = node.entry
+        assert entry.default_value is None or entry.addr is None, "Cannot use address and default_value at once"
+
         if not entry.accessed:
             api.errmsg.warning_not_used(entry.lineno, entry.name)
             if self.O_LEVEL > 1:
                 return
 
+        data_label = entry.data_label
+        idx_table_label = backend.tmp_label()
         l = ['%04X' % (len(node.bounds) - 1)]  # Number of dimensions - 1
 
         for bound in node.bounds[1:]:
             l.append('%04X' % (bound.upper - bound.lower + 1))
 
         l.append('%02X' % node.type_.size)
+        arr_data = []
 
-        if entry.default_value is not None:
-            l.extend(Translator.array_default_value(node.type_, entry.default_value))
+        if entry.addr:
+            self.emit('deflabel', data_label, "%s" % entry.addr)
         else:
-            l.extend(['00'] * node.size)
+            if entry.default_value is not None:
+                arr_data = Translator.array_default_value(node.type_, entry.default_value)
+            else:
+                arr_data = ['00'] * node.size
 
         for alias in entry.aliased_by:
             offset = 1 + 2 * entry.count + alias.offset  # TODO: Generalize for multi-arch
             self.emit('deflabel', alias.mangled, '%s + %i' % (entry.mangled, offset))
 
-        self.emit('vard', node.mangled, l)
+        self.emit('varx', node.mangled, self.TSUFFIX(gl.PTR_TYPE), [idx_table_label])
+
+        if entry.addr:
+            self.emit('varx', entry.data_ptr_label, self.TSUFFIX(gl.PTR_TYPE), [self.traverse_const(entry.addr)])
+        else:
+            self.emit('varx', entry.data_ptr_label, self.TSUFFIX(gl.PTR_TYPE), [data_label])
+            self.emit('vard', data_label, arr_data)
+
+        self.emit('vard', idx_table_label, l)
 
         if entry.lbound_used:
             l = ['%04X' % len(node.bounds)] + \
@@ -1597,17 +1619,18 @@ def visit_FUNCTION(self, node):
                 # if self.O_LEVEL > 1:
                 #    return
 
-            if local_var.class_ == CLASS.array:
+            if local_var.class_ == CLASS.array and local_var.scope != SCOPE.global_:
                 l = [len(local_var.bounds) - 1] + [x.count for x in local_var.bounds[1:]]  # TODO Check this
                 q = []
                 for x in l:
                     q.append('%02X' % (x & 0xFF))
                     q.append('%02X' % (x >> 8))
 
                 q.append('%02X' % local_var.type_.size)
+                r = []
                 if local_var.default_value is not None:
-                    q.extend(self.array_default_value(local_var.type_, local_var.default_value))
-                self.emit('lvard', local_var.offset, q)  # Initializes array bounds
+                    r.extend(self.array_default_value(local_var.type_, local_var.default_value))
+                self.emit('larrd', local_var.offset, q, local_var.size, r)  # Initializes array bounds
             elif local_var.class_ == CLASS.const:
                 continue
             else:  # Local vars always defaults to 0, so if 0 we do nothing
@@ -1628,8 +1651,8 @@ def visit_FUNCTION(self, node):
         # Now free any local string from memory.
         preserve_hl = False
         for local_var in node.local_symbol_table.values():
+            scope = local_var.scope
             if local_var.type_ == self.TYPE(TYPE.string):  # Only if it's string we free it
-                scope = local_var.scope
                 if local_var.class_ != CLASS.array:  # Ok just free it
                     if scope == SCOPE.local or (scope == SCOPE.parameter and not local_var.byref):
                         if not preserve_hl:
@@ -1648,13 +1671,35 @@ def visit_FUNCTION(self, node):
                             preserve_hl = True
                             self.emit('exchg')
 
-                        offset = -local_var.offset if scope == SCOPE.local else local_var.offset
-                        elems = functools.reduce(lambda x, y: x * y, [x.count for x in local_var.bounds])
-                        self.emit('param' + self.TSUFFIX(gl.BOUND_TYPE), elems)
-                        self.emit('paddr', offset, local_var.t)
-                        self.emit('fparamu16', local_var.t)
-                        self.emit('call', '__ARRAY_FREE', 0)
-                        self.REQUIRES.add('arrayfree.asm')
+                        self.emit('param' + self.TSUFFIX(gl.BOUND_TYPE), local_var.count)
+                        t2 = optemps.new_t()
+                        if scope == SCOPE.parameter:
+                            self.emit('pload%s' % self.TSUFFIX(gl.PTR_TYPE), t2,
+                                      '%i' % (local_var.offset - self.TYPE(gl.PTR_TYPE).size))
+                        elif scope == SCOPE.local:
+                            self.emit('pload%s' % self.TSUFFIX(gl.PTR_TYPE), t2,
+                                      '%i' % -(local_var.offset - self.TYPE(gl.PTR_TYPE).size))
+                        self.emit('fparam' + self.TSUFFIX(gl.PTR_TYPE), t2)
+                        self.emit('call', '__ARRAYSTR_FREE_MEM', 0)  # frees all the strings and the array itself
+                        self.REQUIRES.add('arraystrfree.asm')
+
+            if local_var.class_ == CLASS.array and local_var.type_ != self.TYPE(TYPE.string) and \
+                    (scope == SCOPE.local or (scope == SCOPE.parameter and not local_var.byref)):
+                if not preserve_hl:
+                    preserve_hl = True
+                    self.emit('exchg')
+
+                t2 = optemps.new_t()
+                if scope == SCOPE.parameter:
+                    self.emit('pload%s' % self.TSUFFIX(gl.PTR_TYPE), t2, '%i'
+                              % (local_var.offset - self.TYPE(gl.PTR_TYPE).size))
+                elif scope == SCOPE.local:
+                    self.emit('pload%s' % self.TSUFFIX(gl.PTR_TYPE), t2, '%i'
+                              % -(local_var.offset - self.TYPE(gl.PTR_TYPE).size))
+
+                self.emit('fparam' + self.TSUFFIX(gl.PTR_TYPE), t2)
+                self.emit('call', '__MEM_FREE', 0)
+                self.REQUIRES.add('free.asm')
 
         if preserve_hl:
             self.emit('exchg')