API tools faq
paste
Advertisement
luckytyphlosion

better gbz80disasm.py

luckytyphlosion
May 27th, 2016
307
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 27.91 KB | None | 0 0
raw download clone embed print report
  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
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!