Preprocessor for ULP/RTC macros

esp32_ulp/assemble.py

@@ -12,9 +12,10 @@
 
 
 class SymbolTable:
-    def __init__(self, symbols, bases):
+    def __init__(self, symbols, bases, globals):
         self._symbols = symbols
         self._bases = bases
+        self._globals = globals
         self._pass = None
 
     def set_pass(self, _pass):
@@ -32,7 +33,7 @@ def get_from(self):
     def set_sym(self, symbol, stype, section, value):
         entry = (stype, section, value)
         if symbol in self._symbols and entry != self._symbols[symbol]:
-            raise Exception('redefining symbol %s with different value %r -> %r.' % (label, self._symbols[symbol], entry))
+            raise Exception('redefining symbol %s with different value %r -> %r.' % (symbol, self._symbols[symbol], entry))
         self._symbols[symbol] = entry
 
     def has_sym(self, symbol):
@@ -53,7 +54,9 @@ def dump(self):
             print(symbol, entry)
 
     def export(self):
-        addrs_syms = [(self.resolve_absolute(entry), symbol) for symbol, entry in self._symbols.items()]
+        addrs_syms = [(self.resolve_absolute(entry), symbol)
+                      for symbol, entry in self._symbols.items()
+                      if symbol in self._globals]
         return sorted(addrs_syms)
 
     def to_abs_addr(self, section, offset):
@@ -93,11 +96,15 @@ def resolve_relative(self, symbol):
         from_addr = self.to_abs_addr(self._from_section, self._from_offset)
         return sym_addr - from_addr
 
+    def set_global(self, symbol):
+        self._globals[symbol] = True
+        pass
+
 
 class Assembler:
 
-    def __init__(self, symbols=None, bases=None):
-        self.symbols = SymbolTable(symbols or {}, bases or {})
+    def __init__(self, symbols=None, bases=None, globls=None):
+        self.symbols = SymbolTable(symbols or {}, bases or {}, globls or {})
         opcodes.symbols = self.symbols  # XXX dirty hack
 
     def init(self, a_pass):
@@ -118,7 +125,7 @@ def parse_line(self, line):
         """
         if not line:
             return
-        has_label = line[0] not in '\t '
+        has_label = line[0] not in '\t .'
         if has_label:
             label_line = line.split(None, 1)
             if len(label_line) == 2:
@@ -150,8 +157,10 @@ def append_section(self, value, expected_section=None):
         if expected_section is not None and s is not expected_section:
             raise TypeError('only allowed in %s section' % expected_section)
         if s is BSS:
-            # just increase BSS size by value
-            self.offsets[s] += value
+            if int.from_bytes(value, 'little') != 0:
+                raise ValueError('attempt to store non-zero value in section .bss')
+            # just increase BSS size by length of value
+            self.offsets[s] += len(value)
         else:
             self.sections[s].append(value)
             self.offsets[s] += len(value)
@@ -234,6 +243,9 @@ def d_set(self, symbol, expr):
         value = int(expr)  # TODO: support more than just integers
         self.symbols.set_sym(symbol, ABS, None, value)
 
+    def d_global(self, symbol):
+        self.symbols.set_global(symbol)
+
     def append_data(self, wordlen, args):
         data = [int(arg).to_bytes(wordlen, 'little') for arg in args]
         self.append_section(b''.join(data))

esp32_ulp/opcodes.py

@@ -112,7 +112,7 @@ def make_ins(layout):
     unused : 8      # Unused
     low : 5         # Low bit
     high : 5        # High bit
-    opcode : 4      # Opcode (OPCODE_WR_REG)
+    opcode : 4      # Opcode (OPCODE_RD_REG)
 """)
 
 

tests/assemble.py

@@ -3,25 +3,54 @@
 from esp32_ulp.nocomment import remove_comments
 
 src = """\
+        .set const, 123
+.set const_left, 976
 
 start:  wait 42
         ld r0, r1, 0
         st  r0,  r1,0
         halt
 end:
+.data
+"""
+
+src_bss = """\
+  .bss
+
+label:
+  .long 0
+"""
+
+
+src_global = """\
+
+  .global counter
+counter:
+  .long 0
+
+internal:
+  .long 0
+
+  .text
+  .global entry
+entry:
+  wait 42
+  halt
 """
 
 
 def test_parse_line():
     a = Assembler()
-    lines = src.splitlines()
-    # note: line number = index + 1
-    assert a.parse_line(lines[0]) == None
-    assert a.parse_line(lines[1]) == ('start', 'wait', ('42', ))
-    assert a.parse_line(lines[2]) == (None, 'ld', ('r0', 'r1', '0', ))
-    assert a.parse_line(lines[3]) == (None, 'st', ('r0', 'r1', '0', ))
-    assert a.parse_line(lines[4]) == (None, 'halt', ())
-    assert a.parse_line(lines[5]) == ('end', None, ())
+    lines = iter(src.splitlines())
+    assert a.parse_line(next(lines)) == (None, '.set', ('const', '123', ))
+    assert a.parse_line(next(lines)) == (None, '.set', ('const_left', '976', ))
+    assert a.parse_line(next(lines)) == None
+    assert a.parse_line(next(lines)) == ('start', 'wait', ('42', ))
+    assert a.parse_line(next(lines)) == (None, 'ld', ('r0', 'r1', '0', ))
+    assert a.parse_line(next(lines)) == (None, 'st', ('r0', 'r1', '0', ))
+    assert a.parse_line(next(lines)) == (None, 'halt', ())
+    assert a.parse_line(next(lines)) == ('end', None, ())
+    assert a.parse_line(next(lines)) == (None, '.data', ())  # test left-aligned directive is not treated as label
 
 
 def test_parse():
@@ -34,22 +63,69 @@ def test_parse():
 def test_assemble():
     a = Assembler()
     a.assemble(src)
+    assert a.symbols.has_sym('const')
+    assert a.symbols.has_sym('const_left')
     assert a.symbols.has_sym('start')
     assert a.symbols.has_sym('end')
+    assert a.symbols.get_sym('const') == (ABS, None, 123)
+    assert a.symbols.get_sym('const_left') == (ABS, None, 976)
     assert a.symbols.get_sym('start') == (REL, TEXT, 0)
     assert a.symbols.get_sym('end') == (REL, TEXT, 4)
     assert len(b''.join(a.sections[TEXT])) == 16  # 4 instructions * 4B
     assert len(a.sections[DATA]) == 0
     assert a.offsets[BSS] == 0
 
 
+def test_assemble_bss():
+    a = Assembler()
+    try:
+        a.assemble(src_bss)
+    except TypeError:
+        raised = True
+    else:
+        raised = False
+    assert not raised
+    assert a.offsets[BSS] == 4  # 1 word * 4B
+
+
+def test_assemble_bss_with_value():
+    lines = """\
+.bss
+    .long 3  #non-zero value not allowed in bss section
+"""
+
+    a = Assembler()
+    try:
+        a.assemble(lines)
+    except ValueError as e:
+        if str(e) != "attempt to store non-zero value in section .bss":
+            raise  # re-raise failures we didn't expect
+        raised = True
+    else:
+        raised = False
+
+    assert raised
+
+
+def test_assemble_global():
+    a = Assembler()
+    a.assemble(src_global)
+    assert a.symbols.has_sym('counter')
+    assert a.symbols.has_sym('internal')
+    assert a.symbols.has_sym('entry')
+
+    exported_symbols = a.symbols.export()
+    assert exported_symbols == [(0, 'counter'), (2, 'entry')]  # internal not exported
+
+
 def test_symbols():
-    st = SymbolTable({}, {})
+    st = SymbolTable({}, {}, {})
     for entry in [
         ('rel_t4', REL, TEXT, 4),
         ('abs_t4', ABS, TEXT, 4),
         ('rel_d4', REL, DATA, 4),
         ('abs_d4', ABS, DATA, 4),
+        ('const', ABS, None, 123),
     ]:
         st.set_sym(*entry)
     # PASS 1 ========================================================
@@ -62,11 +138,13 @@ def test_symbols():
     assert st.resolve_absolute('abs_d4') == 4
     assert st.resolve_absolute('rel_t4') == 4
     assert st.resolve_absolute('rel_d4') == 4
+    assert st.resolve_absolute('const') == 123
     st.set_from(TEXT, 8)
     assert st.resolve_relative('abs_t4') == -4
     assert st.resolve_relative('abs_d4') == -4
     assert st.resolve_relative('rel_t4') == -4
     assert st.resolve_relative('rel_d4') == -4
+    assert st.resolve_absolute('const') == 123
     # PASS 2 ========================================================
     st.set_bases({TEXT: 100, DATA: 200})
     st.set_pass(2)
@@ -84,14 +162,19 @@ def test_symbols():
     assert st.resolve_absolute('abs_d4') == 4
     assert st.resolve_absolute('rel_t4') == 100 + 4
     assert st.resolve_absolute('rel_d4') == 200 + 4
+    assert st.resolve_absolute('const') == 123
     st.set_from(TEXT, 8)
     assert st.resolve_relative('abs_t4') == 4 - 108
     assert st.resolve_relative('abs_d4') == 4 - 108
     assert st.resolve_relative('rel_t4') == 104 - 108
     assert st.resolve_relative('rel_d4') == 204 - 108
+    assert st.resolve_absolute('const') == 123
 
 
 test_parse_line()
 test_parse()
 test_assemble()
+test_assemble_bss()
+test_assemble_bss_with_value()
+test_assemble_global()
 test_symbols()

tests/compat/symbols.S

@@ -1,10 +1,12 @@
             .text
 
             .set constant42, 42
+.set notindented, 1
 
 start:      move r0, data0
             move r1, data1
             move r2, constant42
+            move r3, notindented
 
             # count from 0 .. 42 in stage register
             stage_rst