提交: 3200946f5bd923585df0f1804c507c39e7e9d4e5 - em_gb_asm (git)

Emily's Z80 assembler for the Gameboy.

Commit MetaInfo

• 修訂: 3200946f5bd923585df0f1804c507c39e7e9d4e5 (tree)
• 時間: 2021-03-02 17:22:04
• 作者: AlaskanEmily <emily@alas...>
• Commiter: AlaskanEmily

Log Message

Add ROM bank support with !bank <num>. Defaults to bank 0.

Change Summary

• modified: em_gb_asm.py

差異

--- a/em_gb_asm.py
+++ b/em_gb_asm.py
@@ -52,6 +52,7 @@ class Block:
         self.name = name
         self.current_label = None
         self.base = None
+        self.bank = None
         self.has_error = False
         self.data = bytearray()
         self.symbols = {}
@@ -618,10 +619,26 @@ def assemble(block, mnemonic, operands=()):
     # print(str(mnemonic) + " " + str(operands))
     mnemonic = mnemonic.lower()
     
+    if mnemonic.startswith("!bank"):
+        if block.bank != None:
+            block.error("!bank specified more than once")
+            return
+        
+        if len(operands) != 1:
+            block.error("!bank must have one integer argument")
+            return
+        
+        try:
+            bank = int(operands[0], 0)
+        except:
+            block.error("Invalid bank value " + operands[0])
+            return
+        block.bank = bank
+    
     # TODO: We should really split blocks with origin, not jam it in here.
     if mnemonic.startswith("!orig"):
         if block.base != None:
-            block.error("Origin specified more than once")
+            block.error(mnemonic + " specified more than once")
         
         if len(operands) != 1:
             block.error(mnemonic + " must have one integer argument")
@@ -732,7 +749,7 @@ def assemble(block, mnemonic, operands=()):
                     raise
                 finally:
                     included_names.remove(o)
-        return+    
+        return
     
     if mnemonic == "!incbin":
         for o in operands:
@@ -831,12 +848,33 @@ for p in sys.argv[1:]:
 if len(blocks) == 0:
     sys.exit(0)
 
+max_bank = 0
+for b in blocks:
+    if b.bank == None:
+        b.bank = 0
+    else:
+        if b.bank > max_bank:
+            max_bank = b.bank
+        if b.base == None:
+            b.error("!bank specified, but no !orig")
+        else:
+            if b.bank == 0 and b.base >= 0x4000:
+                b.error("Invalid base for bank 0")
+            elif b.bank == 0 and b.base + len(b.data) >= 0x4000:
+                b.error("Block is too large to fit into bank 0")
+            if b.bank != 0 and (b.base < 0x4000 or b.base >= 0x8000):
+                b.error("Invalid base for bank " + str(b.bank))
+            elif b.bank == 0 and b.base + len(b.data) >= 0x8000:
+                b.error("Block is too large to fit into bank " + str(b.bank))
+
+bank_spans=[[]] * (max_bank + 1)
+
 # First, place all already originated blocks.
-spans=[]
 for b in blocks:
     if b.base == None:
         continue
     b_len = len(b.data)
+    spans = bank_spans[b.bank]
     for s in spans:
         if s[0] <= b.base + b_len and s[0] + s[1] >= b.base:
             b.error("Conflicting origin")
@@ -845,11 +883,12 @@ for b in blocks:
     if not b.has_error:
         spans.append((b.base, b_len))
 
-if len(spans) == 0:
-    blocks[0].base = 0
-    spans = [(0, len(blocks[0].data))]
-else:
-    spans.sort(key=lambda a:a[0])
+for spans in bank_spans:
+    if len(spans) == 0:
+        blocks[0].base = 0
+        spans.append((0, len(blocks[0].data)))
+    else:
+        spans.sort(key=lambda a:a[0])
 
 blocks.sort(key=lambda b:len(b.data))
 # Place all remaining blocks where there is room.
@@ -860,6 +899,7 @@ for b in blocks:
         continue
     b_len = len(b.data)
     i = 0
+    spans = bank_spans[b.bank]
     while i + 1 < len(spans):
         if spans[i+1][0] - (spans[i][0] + spans[i][1]) > b_len:
             break
@@ -869,21 +909,31 @@ for b in blocks:
     spans.append(obj)
     spans.sort(key=lambda s:s[0])
 
-blocks.sort(key=lambda b:b.base)
+blocks.sort(key=lambda b: b.base + (b.bank << 16))
 out = open("a.gb", "wb")
 debug = open("a.sym", "w")
 debug.write("; Emily's Assembler symbol info\n")
 at = 0
 zero = bytearray([0])
 zero16 = bytearray([0] * 16)
+
+# Resolve all relocs.
 for b in blocks:
     if b.has_error:
         continue
     b.resolveRelocs(blocks)
-    while at + 16 <= b.base:
+
+# Adjust base addresses for banks.
+for b in blocks:
+    if b.has_error:
+        continue
+    base = b.base + (0x4000 * b.bank)
+    
+    # This is just to make writing a little faster
+    while at + 16 <= base:
         out.write(zero16)
         at += 16
-    while at < b.base:
+    while at < base:
         out.write(zero)
         at += 1
     
@@ -891,6 +941,7 @@ for b in blocks:
     out.write(b.data)
     at += len(b.data)
     # Write the debug symbol info
+    bank_name = hex(b.bank)[2:].upper().rjust(2, '0')
     for sym in b.symbols:
         if sym[0] == '.':
             continue
@@ -899,10 +950,12 @@ for b in blocks:
         else:
             name = sym
         addr = hex(b.symbols[sym] + b.base)[2:].upper().rjust(4, '0')
-        debug.write("00:" + addr + " " + name.replace('.', '_') + "\n")
+        debug.write(bank_name + ":" + addr + " " + name.replace('.', '_') + "\n")
+    
     for a in b.ascii:
         addr = hex(a[0] + b.base)[2:].upper().rjust(4, '0')
-        debug.write("00:" + addr + " .asc:" + hex(a[1])[2:].upper().rjust(4, '0') + "\n")
+        asc = hex(a[1])[2:].upper().rjust(4, '0')
+        debug.write(bank_name + ":" + addr + " .asc:" + asc + "\n")
 
 while at < 0x7FF0:
     out.write(zero16)