implement sections, .text, .data, .bss, fixes #4

Author: ThomasWaldmann

demo.s

@@ -1,5 +1,7 @@
 # comment-only line
 
+            .text
+
 start:      ld r0, r1, 0    # a comment!
             st r0, r1, 0
             add r0, r1, r2
@@ -48,3 +50,7 @@ start:      ld r0, r1, 0    # a comment!
             halt
 end:
 
+            .data
+
+            .bss
+

esp32_ulp/__main__.py

@@ -8,15 +8,8 @@ def main(fn):
         lines = f.readlines()
 
     assembler = Assembler()
-    symbols, code = assembler.assemble(lines)
-
-    print('Symbols:')
-    for name, value in sorted(symbols.items()):
-        print(name, ':', value)
-
-    print('Code:')
-    for ins in code:
-        print(hex(ins))
+    assembler.assemble(lines)
+    assembler.dump()
 
 
 main(sys.argv[1])

esp32_ulp/assemble.py

@@ -4,11 +4,15 @@
 
 from . import opcodes
 
+TEXT, DATA, BSS = 'text', 'data', 'bss'
+
 class Assembler:
+
     def __init__(self):
         self.symbols = {}
-        self.code = []
-        self.addr = 0
+        self.sections = dict(text=[], data=[], bss=0)
+        self.offsets = dict(text=0, data=0, bss=0)
+        self.section = TEXT
 
     def parse_line(self, line):
         """
@@ -48,18 +52,59 @@ def parse(self, lines):
         return [p for p in parsed if p is not None]
 
 
+    def append_section(self, value, expected_section=None):
+        s = self.section
+        if expected_section is not None and s is not expected_section:
+            raise TypeError('only allowed in %s section' % expected_section)
+        if s is TEXT or s is DATA:
+            self.sections[s].append(value)
+            self.offsets[s] += 1
+        elif s is BSS:
+            self.sections[s] += value  # just increase BSS size by value
+
+    def dump(self):
+        print("Symbols:")
+        for label, section_offset in sorted(self.symbols.items()):
+            print(label, section_offset)
+        print("%s section:" % TEXT)
+        for t in self.sections[TEXT]:
+            print(hex(t))
+        print("%s section:" % DATA)
+        for d in self.sections[DATA]:
+            print(d)
+        print("%s section:" % BSS)
+        print("size: %d" % self.sections[BSS])
+
+    def d_text(self):
+        self.section = TEXT
+
+    def d_data(self):
+        self.section = DATA
+
+    def d_bss(self):
+        self.section = BSS
+
     def assemble(self, lines):
         for label, opcode, args in self.parse(lines):
             if label is not None:
                 if label in self.symbols:
                     raise Exception('label %s is already defined.' % label)
-                self.symbols[label] = self.addr
+                self.symbols[label] = (self.section, self.offsets[self.section])
             if opcode is not None:
-                func = getattr(opcodes, 'i_' + opcode, None)
-                if func is None:
-                    raise Exception('Unknown opcode: %s' % opcode)
-                instruction = func(*args)
-                self.code.append(instruction)
-                self.addr += 1
-        return self.symbols, self.code
+                if opcode[0] == '.':
+                    # assembler directive
+                    func = getattr(self, 'd_' + opcode[1:])
+                    if func is not None:
+                        result = func(*args)
+                        if result is not None:
+                            self.append_section(result)
+                        continue
+                else:
+                    # machine instruction
+                    func = getattr(opcodes, 'i_' + opcode, None)
+                    if func is not None:
+                        instruction = func(*args)
+                        self.append_section(instruction, TEXT)
+                        continue
+                raise Exception('Unknown opcode or directive: %s' % opcode)
 

tests/assemble.py

@@ -1,4 +1,4 @@
-from esp32_ulp.assemble import Assembler
+from esp32_ulp.assemble import Assembler, TEXT, DATA, BSS
 
 src = """\
 # line 1
@@ -38,11 +38,13 @@ def test_parse():
 def test_assemble():
     a = Assembler()
     lines = src.splitlines()
-    symbols, code = a.assemble(lines)
-    assert {'start', 'end'} <= set(symbols)
-    assert symbols['start'] == 0
-    assert symbols['end'] == 4
-    assert len(code) == 4
+    a.assemble(lines)
+    assert {'start', 'end'} <= set(a.symbols)
+    assert a.symbols['start'] == (TEXT, 0)
+    assert a.symbols['end'] == (TEXT, 4)
+    assert len(a.sections[TEXT]) == 4
+    assert len(a.sections[DATA]) == 0
+    assert a.sections[BSS] == 0
 
 
 test_parse_line()