Advertisement
luckytyphlosion

better gbz80disasm.py

May 27th, 2016
306
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 27.91 KB | None | 0 0
  1. # -*- coding: utf-8 -*-
  2. """
  3. GBC disassembler
  4. """
  5.  
  6. import os
  7. import sys
  8. import argparse
  9. from copy import copy, deepcopy
  10. from ctypes import c_int8
  11.  
  12. import configuration
  13. from wram import read_constants
  14.  
  15. z80_table = [
  16.     ('nop', 0),                    # 00
  17.     ('ld bc, {}', 2),              # 01
  18.     ('ld [bc], a', 0),             # 02
  19.     ('inc bc', 0),                 # 03
  20.     ('inc b', 0),                  # 04
  21.     ('dec b', 0),                  # 05
  22.     ('ld b, ${:02x}', 1),          # 06
  23.     ('rlca', 0),                   # 07
  24.     ('ld [{}], sp', 2),            # 08
  25.     ('add hl, bc', 0),             # 09
  26.     ('ld a, [bc]', 0),             # 0a
  27.     ('dec bc', 0),                 # 0b
  28.     ('inc c', 0),                  # 0c
  29.     ('dec c', 0),                  # 0d
  30.     ('ld c, ${:02x}', 1),          # 0e
  31.     ('rrca', 0),                   # 0f
  32.     ('db $10', 0),                 # 10
  33.     ('ld de, {}', 2),              # 11
  34.     ('ld [de], a', 0),             # 12
  35.     ('inc de', 0),                 # 13
  36.     ('inc d', 0),                  # 14
  37.     ('dec d', 0),                  # 15
  38.     ('ld d, ${:02x}', 1),          # 16
  39.     ('rla', 0),                    # 17
  40.     ('jr {}', 1),                  # 18
  41.     ('add hl, de', 0),             # 19
  42.     ('ld a, [de]', 0),             # 1a
  43.     ('dec de', 0),                 # 1b
  44.     ('inc e', 0),                  # 1c
  45.     ('dec e', 0),                  # 1d
  46.     ('ld e, ${:02x}', 1),          # 1e
  47.     ('rra', 0),                    # 1f
  48.     ('jr nz, {}', 1),              # 20
  49.     ('ld hl, {}', 2),              # 21
  50.     ('ld [hli], a', 0),            # 22
  51.     ('inc hl', 0),                 # 23
  52.     ('inc h', 0),                  # 24
  53.     ('dec h', 0),                  # 25
  54.     ('ld h, ${:02x}', 1),          # 26
  55.     ('daa', 0),                    # 27
  56.     ('jr z, {}', 1),               # 28
  57.     ('add hl, hl', 0),             # 29
  58.     ('ld a, [hli]', 0),            # 2a
  59.     ('dec hl', 0),                 # 2b
  60.     ('inc l', 0),                  # 2c
  61.     ('dec l', 0),                  # 2d
  62.     ('ld l, ${:02x}', 1),          # 2e
  63.     ('cpl', 0),                    # 2f
  64.     ('jr nc, {}', 1),              # 30
  65.     ('ld sp, {}', 2),              # 31
  66.     ('ld [hld], a', 0),            # 32
  67.     ('inc sp', 0),                 # 33
  68.     ('inc [hl]', 0),               # 34
  69.     ('dec [hl]', 0),               # 35
  70.     ('ld [hl], ${:02x}', 1),       # 36
  71.     ('scf', 0),                    # 37
  72.     ('jr c, {}', 1),               # 38
  73.     ('add hl, sp', 0),             # 39
  74.     ('ld a, [hld]', 0),            # 3a
  75.     ('dec sp', 0),                 # 3b
  76.     ('inc a', 0),                  # 3c
  77.     ('dec a', 0),                  # 3d
  78.     ('ld a, ${:02x}', 1),          # 3e
  79.     ('ccf', 0),                    # 3f
  80.     ('ld b, b', 0),                # 40
  81.     ('ld b, c', 0),                # 41
  82.     ('ld b, d', 0),                # 42
  83.     ('ld b, e', 0),                # 43
  84.     ('ld b, h', 0),                # 44
  85.     ('ld b, l', 0),                # 45
  86.     ('ld b, [hl]', 0),             # 46
  87.     ('ld b, a', 0),                # 47
  88.     ('ld c, b', 0),                # 48
  89.     ('ld c, c', 0),                # 49
  90.     ('ld c, d', 0),                # 4a
  91.     ('ld c, e', 0),                # 4b
  92.     ('ld c, h', 0),                # 4c
  93.     ('ld c, l', 0),                # 4d
  94.     ('ld c, [hl]', 0),             # 4e
  95.     ('ld c, a', 0),                # 4f
  96.     ('ld d, b', 0),                # 50
  97.     ('ld d, c', 0),                # 51
  98.     ('ld d, d', 0),                # 52
  99.     ('ld d, e', 0),                # 53
  100.     ('ld d, h', 0),                # 54
  101.     ('ld d, l', 0),                # 55
  102.     ('ld d, [hl]', 0),             # 56
  103.     ('ld d, a', 0),                # 57
  104.     ('ld e, b', 0),                # 58
  105.     ('ld e, c', 0),                # 59
  106.     ('ld e, d', 0),                # 5a
  107.     ('ld e, e', 0),                # 5b
  108.     ('ld e, h', 0),                # 5c
  109.     ('ld e, l', 0),                # 5d
  110.     ('ld e, [hl]', 0),             # 5e
  111.     ('ld e, a', 0),                # 5f
  112.     ('ld h, b', 0),                # 60
  113.     ('ld h, c', 0),                # 61
  114.     ('ld h, d', 0),                # 62
  115.     ('ld h, e', 0),                # 63
  116.     ('ld h, h', 0),                # 64
  117.     ('ld h, l', 0),                # 65
  118.     ('ld h, [hl]', 0),             # 66
  119.     ('ld h, a', 0),                # 67
  120.     ('ld l, b', 0),                # 68
  121.     ('ld l, c', 0),                # 69
  122.     ('ld l, d', 0),                # 6a
  123.     ('ld l, e', 0),                # 6b
  124.     ('ld l, h', 0),                # 6c
  125.     ('ld l, l', 0),                # 6d
  126.     ('ld l, [hl]', 0),             # 6e
  127.     ('ld l, a', 0),                # 6f
  128.     ('ld [hl], b', 0),             # 70
  129.     ('ld [hl], c', 0),             # 71
  130.     ('ld [hl], d', 0),             # 72
  131.     ('ld [hl], e', 0),             # 73
  132.     ('ld [hl], h', 0),             # 74
  133.     ('ld [hl], l', 0),             # 75
  134.     ('halt', 0),                   # 76
  135.     ('ld [hl], a', 0),             # 77
  136.     ('ld a, b', 0),                # 78
  137.     ('ld a, c', 0),                # 79
  138.     ('ld a, d', 0),                # 7a
  139.     ('ld a, e', 0),                # 7b
  140.     ('ld a, h', 0),                # 7c
  141.     ('ld a, l', 0),                # 7d
  142.     ('ld a, [hl]', 0),             # 7e
  143.     ('ld a, a', 0),                # 7f
  144.     ('add b', 0),                  # 80
  145.     ('add c', 0),                  # 81
  146.     ('add d', 0),                  # 82
  147.     ('add e', 0),                  # 83
  148.     ('add h', 0),                  # 84
  149.     ('add l', 0),                  # 85
  150.     ('add [hl]', 0),               # 86
  151.     ('add a', 0),                  # 87
  152.     ('adc b', 0),                  # 88
  153.     ('adc c', 0),                  # 89
  154.     ('adc d', 0),                  # 8a
  155.     ('adc e', 0),                  # 8b
  156.     ('adc h', 0),                  # 8c
  157.     ('adc l', 0),                  # 8d
  158.     ('adc [hl]', 0),               # 8e
  159.     ('adc a', 0),                  # 8f
  160.     ('sub b', 0),                  # 90
  161.     ('sub c', 0),                  # 91
  162.     ('sub d', 0),                  # 92
  163.     ('sub e', 0),                  # 93
  164.     ('sub h', 0),                  # 94
  165.     ('sub l', 0),                  # 95
  166.     ('sub [hl]', 0),               # 96
  167.     ('sub a', 0),                  # 97
  168.     ('sbc b', 0),                  # 98
  169.     ('sbc c', 0),                  # 99
  170.     ('sbc d', 0),                  # 9a
  171.     ('sbc e', 0),                  # 9b
  172.     ('sbc h', 0),                  # 9c
  173.     ('sbc l', 0),                  # 9d
  174.     ('sbc [hl]', 0),               # 9e
  175.     ('sbc a', 0),                  # 9f
  176.     ('and b', 0),                  # a0
  177.     ('and c', 0),                  # a1
  178.     ('and d', 0),                  # a2
  179.     ('and e', 0),                  # a3
  180.     ('and h', 0),                  # a4
  181.     ('and l', 0),                  # a5
  182.     ('and [hl]', 0),               # a6
  183.     ('and a', 0),                  # a7
  184.     ('xor b', 0),                  # a8
  185.     ('xor c', 0),                  # a9
  186.     ('xor d', 0),                  # aa
  187.     ('xor e', 0),                  # ab
  188.     ('xor h', 0),                  # ac
  189.     ('xor l', 0),                  # ad
  190.     ('xor [hl]', 0),               # ae
  191.     ('xor a', 0),                  # af
  192.     ('or b', 0),                   # b0
  193.     ('or c', 0),                   # b1
  194.     ('or d', 0),                   # b2
  195.     ('or e', 0),                   # b3
  196.     ('or h', 0),                   # b4
  197.     ('or l', 0),                   # b5
  198.     ('or [hl]', 0),                # b6
  199.     ('or a', 0),                   # b7
  200.     ('cp b', 0),                   # b8
  201.     ('cp c', 0),                   # b9
  202.     ('cp d', 0),                   # ba
  203.     ('cp e', 0),                   # bb
  204.     ('cp h', 0),                   # bc
  205.     ('cp l', 0),                   # bd
  206.     ('cp [hl]', 0),                # be
  207.     ('cp a', 0),                   # bf
  208.     ('ret nz', 0),                 # c0
  209.     ('pop bc', 0),                 # c1
  210.     ('jp nz, {}', 2),              # c2
  211.     ('jp {}', 2),                  # c3
  212.     ('call nz, {}', 2),            # c4
  213.     ('push bc', 0),                # c5
  214.     ('add ${:02x}', 1),            # c6
  215.     ('rst $0', 0),                 # c7
  216.     ('ret z', 0),                  # c8
  217.     ('ret', 0),                    # c9
  218.     ('jp z, {}', 2),               # ca
  219.     ('bitops', 1),                 # cb
  220.     ('call z, {}', 2),             # cc
  221.     ('call {}', 2),                # cd
  222.     ('adc ${:02x}', 1),            # ce
  223.     ('rst $8', 0),                 # cf
  224.     ('ret nc', 0),                 # d0
  225.     ('pop de', 0),                 # d1
  226.     ('jp nc, ${:04x}', 2),         # d2
  227.     ('db $d3', 0),                 # d3
  228.     ('call nc, {}', 2),            # d4
  229.     ('push de', 0),                # d5
  230.     ('sub ${:02x}', 1),            # d6
  231.     ('rst $10', 0),                # d7
  232.     ('ret c', 0),                  # d8
  233.     ('reti', 0),                   # d9
  234.     ('jp c, ${:04x}', 2),          # da
  235.     ('db $db', 0),                 # db
  236.     ('call c, {}', 2),             # dc
  237.     ('db $dd', 2),                 # dd
  238.     ('sbc ${:02x}', 1),            # de
  239.     ('rst $18', 0),                # df
  240.     ('ld [{}], a', 1),             # e0
  241.     ('pop hl', 0),                 # e1
  242.     ('ld [$ff00+c], a', 0),        # e2
  243.     ('db $e3', 0),                 # e3
  244.     ('db $e4', 0),                 # e4
  245.     ('push hl', 0),                # e5
  246.     ('and ${:02x}', 1),            # e6
  247.     ('rst $20', 0),                # e7
  248.     ('add sp, ${:02x}', 1),        # e8
  249.     ('jp [hl]', 0),                # e9
  250.     ('ld [{}], a', 2),             # ea
  251.     ('db $eb', 0),                 # eb
  252.     ('db $ec', 2),                 # ec
  253.     ('db $ed', 2),                 # ed
  254.     ('xor ${:02x}', 1),            # ee
  255.     ('rst $28', 0),                # ef
  256.     ('ld a, [{}]', 1),             # f0
  257.     ('pop af', 0),                 # f1
  258.     ('db $f2', 0),                 # f2
  259.     ('di', 0),                     # f3
  260.     ('db $f4', 0),                 # f4
  261.     ('push af', 0),                # f5
  262.     ('or ${:02x}', 1),             # f6
  263.     ('rst $30', 0),                # f7
  264.     ('ld hl, sp+${:02x}', 1),      # f8
  265.     ('ld sp, [hl]', 0),            # f9
  266.     ('ld a, [{}]', 2),             # fa
  267.     ('ei', 0),                     # fb
  268.     ('db $fc', 2),                 # fc
  269.     ('db $fd', 2),                 # fd
  270.     ('cp ${:02x}', 1),             # fe
  271.     ('rst $38', 0),                # ff
  272. ]
  273.  
  274. bit_ops_table = [
  275.     "rlc b",     "rlc c",     "rlc d",     "rlc e",     "rlc h",     "rlc l",     "rlc [hl]",     "rlc a",       # $00 - $07
  276.     "rrc b",     "rrc c",     "rrc d",     "rrc e",     "rrc h",     "rrc l",     "rrc [hl]",     "rrc a",       # $08 - $0f
  277.     "rl b",      "rl c",      "rl d",      "rl e",      "rl h",      "rl l",      "rl [hl]",      "rl a",        # $10 - $17
  278.     "rr b",      "rr c",      "rr d",      "rr e",      "rr h",      "rr l",      "rr [hl]",      "rr a",        # $18 - $1f
  279.     "sla b",     "sla c",     "sla d",     "sla e",     "sla h",     "sla l",     "sla [hl]",     "sla a",       # $20 - $27
  280.     "sra b",     "sra c",     "sra d",     "sra e",     "sra h",     "sra l",     "sra [hl]",     "sra a",       # $28 - $2f
  281.     "swap b",    "swap c",    "swap d",    "swap e",    "swap h",    "swap l",    "swap [hl]",    "swap a",      # $30 - $37
  282.     "srl b",     "srl c",     "srl d",     "srl e",     "srl h",     "srl l",     "srl [hl]",     "srl a",       # $38 - $3f
  283.     "bit 0, b",  "bit 0, c",  "bit 0, d",  "bit 0, e",  "bit 0, h",  "bit 0, l",  "bit 0, [hl]",  "bit 0, a",    # $40 - $47
  284.     "bit 1, b",  "bit 1, c",  "bit 1, d",  "bit 1, e",  "bit 1, h",  "bit 1, l",  "bit 1, [hl]",  "bit 1, a",    # $48 - $4f
  285.     "bit 2, b",  "bit 2, c",  "bit 2, d",  "bit 2, e",  "bit 2, h",  "bit 2, l",  "bit 2, [hl]",  "bit 2, a",    # $50 - $57
  286.     "bit 3, b",  "bit 3, c",  "bit 3, d",  "bit 3, e",  "bit 3, h",  "bit 3, l",  "bit 3, [hl]",  "bit 3, a",    # $58 - $5f
  287.     "bit 4, b",  "bit 4, c",  "bit 4, d",  "bit 4, e",  "bit 4, h",  "bit 4, l",  "bit 4, [hl]",  "bit 4, a",    # $60 - $67
  288.     "bit 5, b",  "bit 5, c",  "bit 5, d",  "bit 5, e",  "bit 5, h",  "bit 5, l",  "bit 5, [hl]",  "bit 5, a",    # $68 - $6f
  289.     "bit 6, b",  "bit 6, c",  "bit 6, d",  "bit 6, e",  "bit 6, h",  "bit 6, l",  "bit 6, [hl]",  "bit 6, a",    # $70 - $77
  290.     "bit 7, b",  "bit 7, c",  "bit 7, d",  "bit 7, e",  "bit 7, h",  "bit 7, l",  "bit 7, [hl]",  "bit 7, a",    # $78 - $7f
  291.     "res 0, b",  "res 0, c",  "res 0, d",  "res 0, e",  "res 0, h",  "res 0, l",  "res 0, [hl]",  "res 0, a",    # $80 - $87
  292.     "res 1, b",  "res 1, c",  "res 1, d",  "res 1, e",  "res 1, h",  "res 1, l",  "res 1, [hl]",  "res 1, a",    # $88 - $8f
  293.     "res 2, b",  "res 2, c",  "res 2, d",  "res 2, e",  "res 2, h",  "res 2, l",  "res 2, [hl]",  "res 2, a",    # $90 - $97
  294.     "res 3, b",  "res 3, c",  "res 3, d",  "res 3, e",  "res 3, h",  "res 3, l",  "res 3, [hl]",  "res 3, a",    # $98 - $9f
  295.     "res 4, b",  "res 4, c",  "res 4, d",  "res 4, e",  "res 4, h",  "res 4, l",  "res 4, [hl]",  "res 4, a",    # $a0 - $a7
  296.     "res 5, b",  "res 5, c",  "res 5, d",  "res 5, e",  "res 5, h",  "res 5, l",  "res 5, [hl]",  "res 5, a",    # $a8 - $af
  297.     "res 6, b",  "res 6, c",  "res 6, d",  "res 6, e",  "res 6, h",  "res 6, l",  "res 6, [hl]",  "res 6, a",    # $b0 - $b7
  298.     "res 7, b",  "res 7, c",  "res 7, d",  "res 7, e",  "res 7, h",  "res 7, l",  "res 7, [hl]",  "res 7, a",    # $b8 - $bf
  299.     "set 0, b",  "set 0, c",  "set 0, d",  "set 0, e",  "set 0, h",  "set 0, l",  "set 0, [hl]",  "set 0, a",    # $c0 - $c7
  300.     "set 1, b",  "set 1, c",  "set 1, d",  "set 1, e",  "set 1, h",  "set 1, l",  "set 1, [hl]",  "set 1, a",    # $c8 - $cf
  301.     "set 2, b",  "set 2, c",  "set 2, d",  "set 2, e",  "set 2, h",  "set 2, l",  "set 2, [hl]",  "set 2, a",    # $d0 - $d7
  302.     "set 3, b",  "set 3, c",  "set 3, d",  "set 3, e",  "set 3, h",  "set 3, l",  "set 3, [hl]",  "set 3, a",    # $d8 - $df
  303.     "set 4, b",  "set 4, c",  "set 4, d",  "set 4, e",  "set 4, h",  "set 4, l",  "set 4, [hl]",  "set 4, a",    # $e0 - $e7
  304.     "set 5, b",  "set 5, c",  "set 5, d",  "set 5, e",  "set 5, h",  "set 5, l",  "set 5, [hl]",  "set 5, a",    # $e8 - $ef
  305.     "set 6, b",  "set 6, c",  "set 6, d",  "set 6, e",  "set 6, h",  "set 6, l",  "set 6, [hl]",  "set 6, a",    # $f0 - $f7
  306.     "set 7, b",  "set 7, c",  "set 7, d",  "set 7, e",  "set 7, h",  "set 7, l",  "set 7, [hl]",  "set 7, a"     # $f8 - $ff
  307. ]
  308.  
  309. unconditional_returns = [0xc9, 0xd9]
  310. absolute_jumps = [0xc3, 0xc2, 0xca, 0xd2, 0xda]
  311. call_commands = [0xcd, 0xc4, 0xcc, 0xd4, 0xdc]
  312. relative_jumps = [0x18, 0x20, 0x28, 0x30, 0x38]
  313. unconditional_jumps = [0xc3, 0x18]
  314.  
  315.  
  316. def asm_label(address):
  317.     """
  318.     Return a local label name for asm at <address>.
  319.     """
  320.     return '.asm_%x' % address
  321.  
  322. def data_label(address):
  323.     """
  324.     Return a local label name for data at <address>.
  325.     """
  326.     return '.data_%x' % address
  327.  
  328. def get_local_address(address):
  329.     """
  330.     Return the local address of a rom address.
  331.     """
  332.     bank = address / 0x4000
  333.     address &= 0x3fff
  334.     if bank:
  335.         return address + 0x4000
  336.     return address
  337.  
  338. def get_global_address(address, bank):
  339.     """
  340.     Return the rom address of a local address and bank.
  341.  
  342.     This accounts for a quirk in mbc3 where 0:4000-7fff resolves to 1:4000-7fff.
  343.     """
  344.     if address < 0x8000:
  345.         if address >= 0x4000 and bank > 0:
  346.             return address + (bank - 1) * 0x4000
  347.         return address
  348.     return None
  349.  
  350. def created_but_unused_labels_exist(byte_labels):
  351.     """
  352.     Check whether a label has been created but not used.
  353.  
  354.     If so, then that means it has to be called or specified later.
  355.     """
  356.     return (False in [label["definition"] for label in byte_labels.values()])
  357.  
  358. def all_byte_labels_are_defined(byte_labels):
  359.     """
  360.     Check whether all labels have already been defined.
  361.     """
  362.     return (False not in [label["definition"] for label in byte_labels.values()])
  363.  
  364. def load_rom(path='baserom.gbc'):
  365.     return bytearray(open(path, 'rb').read())
  366.  
  367. def read_symfile(path='baserom.sym'):
  368.     """
  369.     Return a list of dicts of label data from an rgbds .sym file.
  370.     """
  371.     symbols = []
  372.     for line in open(path):
  373.         line = line.strip().split(';')[0]
  374.         if line:
  375.             bank_address, label = line.split(' ')[:2]
  376.             bank, address = bank_address.split(':')
  377.             symbols += [{
  378.                 'label': label,
  379.                 'bank': int(bank, 16),
  380.                 'address': int(address, 16),
  381.             }]
  382.     return symbols
  383.  
  384. def load_symbols(path):
  385.     sym = {}
  386.     reverse_sym = {}
  387.     wram_sym = {}
  388.     sram_sym = {}
  389.    
  390.     symbols = read_symfile(path)
  391.     for symbol in symbols:
  392.         bank = symbol['bank']
  393.         address = symbol['address']
  394.         label = symbol['label']
  395.        
  396.         if 0x0000 <= address < 0x8000:
  397.             if not sym.has_key(bank):
  398.                 sym[bank] = {}
  399.            
  400.             sym[bank][address] = label
  401.             reverse_sym[label] = get_global_address(address, bank)
  402.            
  403.         elif 0xa000 <= address < 0xc000:
  404.             if not sram_sym.has_key(bank):
  405.                 sram_sym[bank] = {}
  406.                
  407.             sram_sym[bank][address] = label
  408.            
  409.         elif address < 0xe000:
  410.             if not wram_sym.has_key(bank):
  411.                 wram_sym[bank] = {}
  412.            
  413.             wram_sym[bank][address] = label
  414.         else:  
  415.             raise ValueError("Unsupported symfile label type.")
  416.        
  417.     return sym, reverse_sym, wram_sym, sram_sym
  418.  
  419. def get_symbol(sym, address, bank=0):
  420.     if sym:
  421.         if 0x0000 <= address < 0x4000:
  422.             return sym.get(0, {}).get(address)
  423.         else:
  424.             return sym.get(bank, {}).get(address)
  425.    
  426.     return None
  427.  
  428. def get_banked_ram_sym(sym, address):
  429.     #if sym:
  430.     #   if 0xc000 <= address < 0xd000:
  431.     #       return sym.get(0, {}).get(address)
  432.     #   else:
  433.     #       return sym.get(bank, {}).get(address)
  434.     if sym:
  435.         for bank in sym.keys():
  436.             temp_sym = sym.get(bank, {}).get(address)
  437.             if temp_sym:
  438.                 return temp_sym
  439.        
  440.     return None
  441.  
  442. class Disassembler(object):
  443.     """
  444.     GBC disassembler
  445.     """
  446.  
  447.     def __init__(self, config):
  448.         """
  449.         Setup the class instance.
  450.         """
  451.         self.config = config
  452.         self.spacing = '\t'
  453.         self.rom = None
  454.         self.sym = None
  455.         self.rsym = None
  456.         self.gbhw = None
  457.         self.vram = None
  458.         self.sram = None
  459.         self.hram = None
  460.         self.wram = None
  461.  
  462.     def initialize(self, rom, symfile):
  463.         """
  464.         Setup the disassembler.
  465.         """
  466.         path = os.path.join(self.config.path, rom)
  467.         self.rom = load_rom(path)
  468.        
  469.         path = os.path.join(self.config.path, symfile)
  470.         if os.path.exists(path):
  471.             self.sym, self.rsym, self.wram, self.sram = load_symbols(path)
  472.  
  473.         path = os.path.join(self.config.path, 'gbhw.asm')
  474.        
  475.         if os.path.exists(path):
  476.             self.gbhw = read_constants(path)
  477.         else:
  478.             path = os.path.join(self.config.path, "constants/hardware_constants.asm")
  479.             if os.path.exists(path):
  480.                 self.gbhw = read_constants(path)
  481.        
  482.         path = os.path.join(self.config.path, 'vram.asm')
  483.         if os.path.exists(path):
  484.             self.vram = read_constants(path)
  485.            
  486.         path = os.path.join(self.config.path, 'hram.asm')
  487.         if os.path.exists(path):
  488.             self.hram = read_constants(path)
  489.  
  490.     def find_label(self, address, bank=0):
  491.         if type(address) is not int:
  492.             address = int(address.replace('$', '0x'), 16)
  493.        
  494.         if 0x0000 <= address < 0x8000:
  495.             label = self.get_symbol(address, bank)
  496.         elif address < 0xa000 and self.vram:
  497.             label = self.vram.get(address)
  498.         elif address < 0xc000:
  499.             label = self.get_sram(address)
  500.         elif address < 0xe000:
  501.             label = self.get_wram(address)
  502.         elif ((0xff00 <= address < 0xff80) or (address == 0xffff)) and self.gbhw:
  503.             label = self.gbhw.get(address)
  504.         elif (0xff80 <= address < 0xffff) and self.hram:
  505.             label = self.hram.get(address)
  506.         else:
  507.             label = None
  508.            
  509.         return label
  510.  
  511.     def get_symbol(self, address, bank):
  512.         symbol = get_symbol(self.sym, address, bank)
  513.         if symbol == 'NULL' and address == 0 and bank == 0:
  514.             return None
  515.         return symbol
  516.  
  517.     def get_wram(self, address):
  518.         symbol = get_banked_ram_sym(self.wram, address)
  519.         if symbol == 'NULL' and address == 0:
  520.             return None
  521.         return symbol
  522.        
  523.     def get_sram(self, address):
  524.         symbol = get_banked_ram_sym(self.sram, address)
  525.         if symbol == 'NULL' and address == 0:
  526.             return None
  527.         return symbol
  528.        
  529.     def find_address_from_label(self, label):
  530.         if self.rsym:
  531.             return self.rsym.get(label)
  532.        
  533.         return None
  534.  
  535.     def output_bank_opcodes(self, start_offset, stop_offset=None, max_byte_count=None, include_last_address=True, debug=False):
  536.         """
  537.         Output bank opcodes.
  538.  
  539.         fs = current_address
  540.         b = bank_byte
  541.         in = input_data  -- rom
  542.         bank_size = byte_count
  543.         i = offset
  544.         ad = end_address
  545.         a, oa = current_byte_number
  546.  
  547.         stop_at can be used to supply a list of addresses to not disassemble
  548.         over. This is useful if you know in advance that there are a lot of
  549.         fall-throughs.
  550.         """
  551.  
  552.         bank_id = start_offset / 0x4000
  553.        
  554.         if debug:
  555.             print "bank id is: " + str(bank_id)
  556.  
  557.         rom = self.rom
  558.  
  559.         offset = start_offset
  560.         current_byte_number = 0 #start from the beginning
  561.  
  562.         # check if stop_offset isn't defined
  563.         if stop_offset is None:
  564.             # if max_byte_count isn't defined either, just end at the end of the current bank
  565.             if max_byte_count is None:
  566.                 stop_offset = (bank_id + 1) * 0x4000 - 1
  567.             else:
  568.                 stop_offset = start_offset + max_byte_count
  569.  
  570.         byte_labels = {}
  571.         data_tables = {}
  572.  
  573.         first_loop = True
  574.         output = ""
  575.         is_data = False
  576.        
  577.         while offset <= stop_offset:
  578.             current_byte = rom[offset]
  579.             maybe_byte = current_byte
  580.  
  581.             #first check if this byte already has a label
  582.             #if it does, use the label
  583.             #if not, generate a new label
  584.             if offset in (byte_labels.keys() or data_tables.keys()):
  585.                 line_label = byte_labels[offset]["name"]
  586.                 byte_labels[offset]["usage"] += 1
  587.                 data_line_label = ""
  588.                 output += "\n"
  589.                 if offset in data_tables.keys():
  590.                     data_line_label = data_tables[offset]["name"]
  591.                     data_tables[offset]["usage"] += 1
  592.                     output += "\n"
  593.  
  594.             else:
  595.                 line_label = asm_label(offset)
  596.                 byte_labels[offset] = {}
  597.                 byte_labels[offset]["name"] = line_label
  598.                 byte_labels[offset]["usage"] = 0
  599.                
  600.                 data_line_label = data_label(offset)
  601.                 data_tables[offset] = {}
  602.                 data_tables[offset]["name"] = data_line_label
  603.                 data_tables[offset]["usage"] = 0
  604.                
  605.             byte_labels[offset]["definition"] = True
  606.             if offset in data_tables:
  607.                 data_tables[offset]["definition"] = True
  608.                
  609.            
  610.             output += line_label + "\n" + data_line_label + "\n" #" ; " + hex(offset) + "\n"
  611.  
  612.             #find out if there's a two byte key like this
  613.             #temp_maybe = maybe_byte
  614.             #temp_maybe += (rom[offset+1] << 8)
  615.            
  616.             opcode_byte = rom[offset]
  617.            
  618.             if not is_data:
  619.                 opcode_str = z80_table[opcode_byte][0]
  620.                 opcode_nargs = z80_table[opcode_byte][1]
  621.                 opcode_arg_1 = rom[offset+1]
  622.                 opcode_arg_2 = rom[offset+2]
  623.                
  624.                 if opcode_nargs == 0:
  625.                     opcode_output_str = opcode_str
  626.                
  627.                 elif opcode_nargs == 1:
  628.                     if opcode_byte != 0xcb: # bit opcodes are handled separately
  629.                        
  630.                         opcode_output_str = ""
  631.                        
  632.                         if opcode_byte in relative_jumps: #jr or jr nz
  633.                             #generate a label for the byte we're jumping to
  634.                             target_address = offset + 2 + c_int8(opcode_arg_1).value
  635.                             if target_address in byte_labels.keys():
  636.                                 byte_labels[target_address]["usage"] += 1
  637.                                 opcode_output_str = byte_labels[target_address]["name"]
  638.                             else:
  639.                                 opcode_output_str = asm_label(target_address)
  640.                                 byte_labels[target_address] = {}
  641.                                 byte_labels[target_address]["name"] = opcode_output_str
  642.                                 byte_labels[target_address]["usage"] = 1
  643.                                 byte_labels[target_address]["definition"] = False
  644.                            
  645.                             opcode_output_str = opcode_str.format(opcode_output_str)
  646.                            
  647.                             if created_but_unused_labels_exist(byte_labels) and debug:
  648.                                 comment_bank = offset / 0x4000
  649.                                 if comment_bank != 0:
  650.                                     comment_bank_addr = (offset % 0x4000) + 0x4000
  651.                                 else:
  652.                                     comment_bank_addr = offset
  653.                                    
  654.                                 output += " ; %x (%x:%x)" % (offset, comment_bank, comment_bank_addr)
  655.                                 #if current_byte in relative_jumps:
  656.                                 #   output += " $" + hex(rom[offset + 1])[2:]
  657.                         elif opcode_byte == 0xe0 or opcode_byte == 0xf0:
  658.                             high_ram_address = 0xff00 + opcode_arg_1
  659.                             high_ram_label = self.find_label(high_ram_address, bank_id)
  660.                             if high_ram_label is None:
  661.                                 high_ram_label = "$%x" % high_ram_address
  662.                                
  663.                             opcode_output_str = opcode_str.format(high_ram_label)
  664.                         else:
  665.                             opcode_output_str = opcode_str.format(opcode_arg_1)
  666.  
  667.                     else:
  668.                         opcode_output_str = bit_ops_table[opcode_arg_1]
  669.                        
  670.                 elif opcode_nargs == 2:
  671.                     target_offset = opcode_arg_2 << 8 | opcode_arg_1
  672.                     target_label = self.find_label(target_offset, bank_id)
  673.                    
  674.                     if opcode_byte in call_commands + absolute_jumps:
  675.                         if target_label is None:
  676.                             target_label = "Func_%x" % get_global_address(target_offset, bank_id)
  677.  
  678.                     else:
  679.                         if target_label is None:
  680.                             if target_offset in data_tables.keys():
  681.                                 data_tables[target_offset]['usage'] += 1
  682.                                 target_label = data_tables[target_offset]["name"]
  683.                             else:
  684.                                 target_label = data_label(target_offset)
  685.                                 data_tables[target_offset] = {}
  686.                                 data_tables[target_offset]["name"] = target_label
  687.                                 data_tables[target_offset]["usage"] = 0
  688.                                 data_tables[target_offset]["definition"] = False
  689.                                
  690.                     opcode_output_str = opcode_str.format(target_label)
  691.  
  692.  
  693.                 else:
  694.                     raise ValueError("Invalid amount of args.")
  695.                
  696.                 output += self.spacing + opcode_output_str + "\n" #+ " ; " + hex(offset)
  697.                 current_byte_number += opcode_nargs + 1
  698.                 offset += opcode_nargs + 1
  699.                
  700.             else:
  701.                 output += self.spacing + "db $%:02x\n" % opcode_byte #+ " ; " + hex(offset)
  702.                 offset += 1
  703.                 current_byte_number += 1
  704.                 if offset in byte_labels.keys():
  705.                     is_data = False
  706.  
  707.             if offset in data_tables.keys() and created_but_unused_labels_exist(data_tables):
  708.                 is_data = True
  709.            
  710.             if not is_data and current_byte in unconditional_jumps + unconditional_returns:
  711.                 #stop reading at a jump, relative jump or return
  712.                 if all_byte_labels_are_defined(byte_labels):
  713.                     break
  714.                 elif offset not in byte_labels.keys() and offset in data_tables.keys():
  715.                     is_data = True
  716.                 output += "\n"
  717.  
  718.             first_loop = False
  719.  
  720.         #clean up unused labels
  721.         for label_line in byte_labels.values():
  722.             if label_line["usage"] == 0:
  723.                 output = output.replace((label_line["name"] + "\n"), "")
  724.        
  725.         output_lines = [e+"\n" for e in output.split("\n") if e != ""]
  726.        
  727.         for label_addr in data_tables.keys():
  728.             label_line = data_tables[label_addr]
  729.             if label_line["usage"] == 0:
  730.                 label_name = label_line["name"]
  731.                 for i, line in enumerate(output_lines):
  732.                     if line.startswith(label_name):
  733.                         output_lines.pop(i)
  734.                     elif label_name in line:
  735.                         output_lines[i] = output_lines[i].replace(label_name, "$%x" % label_addr)
  736.        
  737.         output = "".join(output_lines)
  738.        
  739.         #tone down excessive spacing
  740.         output = output.replace("\n\n\n","\n\n")
  741.  
  742.         #add the offset of the final location
  743.         if include_last_address:
  744.             output += "; " + hex(offset)
  745.        
  746.         return [output, offset, stop_offset, byte_labels]
  747.  
  748. def main_disasm_loop(start_addr,stop_addr):
  749.     offset = 0
  750.     true_output = ""
  751.     labels = []
  752.    
  753.     while True:
  754.         output = disasm.output_bank_opcodes(start_addr,stop_offset=stop_addr)
  755.         true_output += output[0]
  756.         true_output += "\n"
  757.         labels.append(output[3])
  758.         if stop_addr <= output[1]:
  759.             break
  760.         else:
  761.             start_addr = output[1]
  762.    
  763.     return true_output
  764.  
  765. def get_raw_addr(addr):
  766.     if addr:
  767.         if ":" in addr:
  768.             addr = addr.split(":")
  769.             addr = int(addr[0], 16)*0x4000+(int(addr[1], 16)%0x4000)
  770.         else:
  771.             label_addr = disasm.find_address_from_label(addr)
  772.             if label_addr:
  773.                 addr = label_addr
  774.             else:
  775.                 addr = int(addr, 16)
  776.    
  777.     return addr
  778.  
  779. if __name__ == "__main__":
  780.     ap = argparse.ArgumentParser()
  781.     ap.add_argument("-r", dest="rom", default="baserom.gbc")
  782.     ap.add_argument('-o', dest='filename', default='gbz80disasm_output.asm')
  783.     ap.add_argument("-s", dest="symfile")
  784.     ap.add_argument("-d", "--use-disasm-path", dest="use_disasm_path", action="store_true")
  785.     ap.add_argument("-q", "--quiet", dest="quiet", action="store_true")
  786.     ap.add_argument("-nw", "--no-write", dest="no_write", action="store_true")
  787.     ap.add_argument("-dp", "--data-parsing", dest="data_parsing", action="store_true")
  788.     ap.add_argument('offset')
  789.     ap.add_argument('end', nargs='?')
  790.    
  791.     args = ap.parse_args()
  792.     if args.symfile is None:
  793.         args.symfile = args.rom.split(".")[0] + ".sym"
  794.        
  795.     if args.use_disasm_path:
  796.         conf = configuration.Config(path=os.path.abspath(os.path.join(os.getcwd(),"../..")))
  797.     else:
  798.         conf = configuration.Config()
  799.  
  800.     disasm = Disassembler(conf)
  801.     disasm.initialize(args.rom, args.symfile)
  802.    
  803.     start_addr = get_raw_addr(args.offset)
  804.    
  805.     if args.end:
  806.         stop_addr = get_raw_addr(args.end)
  807.         output = main_disasm_loop(start_addr,stop_addr)
  808.     else:
  809.         output = disasm.output_bank_opcodes(start_addr)[0]
  810.    
  811.     if not args.quiet:
  812.         print output
  813.    
  814.     if not args.no_write:
  815.         with open(args.filename, "w") as f:
  816.             f.write(output)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement