157 lines
4.0 KiB
Python
157 lines
4.0 KiB
Python
import sys
|
|
import parse_bits
|
|
from collections import OrderedDict
|
|
from os import path
|
|
|
|
register_names = [
|
|
"US_CMN_INST",
|
|
"US_ALU_RGB_ADDR",
|
|
"US_ALU_ALPHA_ADDR",
|
|
"US_ALU_RGB_INST",
|
|
"US_ALU_ALPHA_INST",
|
|
"US_ALU_RGBA_INST",
|
|
"US_TEX_INST",
|
|
"US_TEX_ADDR",
|
|
"US_TEX_ADDR_DXDY",
|
|
"US_FC_INST",
|
|
"US_FC_ADDR",
|
|
]
|
|
|
|
alu_output = [
|
|
"US_CMN_INST",
|
|
"US_ALU_RGB_ADDR",
|
|
"US_ALU_ALPHA_ADDR",
|
|
"US_ALU_RGB_INST",
|
|
"US_ALU_ALPHA_INST",
|
|
"US_ALU_RGBA_INST",
|
|
]
|
|
|
|
tex = [
|
|
"US_CMN_INST",
|
|
"US_TEX_INST",
|
|
"US_TEX_ADDR",
|
|
"US_TEX_ADDR_DXDY",
|
|
0,
|
|
0,
|
|
]
|
|
|
|
fc = [
|
|
"US_CMN_INST",
|
|
0,
|
|
"US_FC_INST",
|
|
"US_FC_ADDR",
|
|
0,
|
|
0,
|
|
]
|
|
|
|
def parse_registers():
|
|
base = path.dirname(__file__)
|
|
|
|
for register in register_names:
|
|
filename = path.join(base, "bits", register.lower() + ".txt")
|
|
l = list(parse_bits.parse_file_fields(filename))
|
|
yield register, OrderedDict(
|
|
(d.field_name, d) for d in parse_bits.aggregate(l)
|
|
)
|
|
|
|
registers = dict(parse_registers())
|
|
US_CMN_INST = registers["US_CMN_INST"]
|
|
|
|
def get_field(n, descriptor):
|
|
if type(descriptor.bits) is int:
|
|
return (n >> descriptor.bits) & 1
|
|
else:
|
|
high, low = descriptor.bits
|
|
assert high > low
|
|
mask_length = (high - low) + 1
|
|
mask = (1 << mask_length) - 1
|
|
return (n >> low) & mask
|
|
|
|
def get_possible_value(value, descriptor):
|
|
if not descriptor.possible_values:
|
|
return value
|
|
|
|
name, description = descriptor.possible_values[value]
|
|
if name is not None:
|
|
return name
|
|
else:
|
|
if len(description) < 20:
|
|
return description
|
|
else:
|
|
return value
|
|
|
|
def get_field_pv_name(value, descriptor):
|
|
return get_possible_value(get_field(value, descriptor), descriptor)
|
|
|
|
def disassemble(code, ix):
|
|
us_cmn_inst = code[ix + 0]
|
|
print(f"{ix:04x}")
|
|
|
|
def inner2(i, register_name):
|
|
if register_name == 0:
|
|
max_length = 1
|
|
else:
|
|
max_length = max(map(len, registers[register_name])) + 1
|
|
|
|
value = code[ix + i]
|
|
yield f"{register_name}"
|
|
yield f" [{value:08x}]"
|
|
if register_name == 0:
|
|
assert value == 0
|
|
return
|
|
register = registers[register_name]
|
|
for d in register.values():
|
|
field_pv_name = get_field_pv_name(value, d)
|
|
yield ' '.join([d.field_name.ljust(max_length), f"{field_pv_name}"])
|
|
|
|
def inner_columns(register_name_list):
|
|
columns = []
|
|
for i, register_name in enumerate(register_name_list):
|
|
columns.append(list(inner2(i, register_name)))
|
|
column_widths = [35, 26, 24, 24, 27, 22]
|
|
column_height = max(len(column) for column in columns)
|
|
assert len(columns) == 6
|
|
|
|
def get_row(column, rix, cix):
|
|
if rix < len(column):
|
|
value = column[rix]
|
|
else:
|
|
value = ''
|
|
return value.ljust(column_widths[cix]) + '| '
|
|
|
|
for rix in range(column_height):
|
|
row = ''.join([
|
|
get_row(column, rix, cix)
|
|
for cix, column in enumerate(columns)
|
|
])
|
|
print(" ", row)
|
|
|
|
def inner_rows(register_name_list):
|
|
for i, register_name in enumerate(register_name_list):
|
|
print('\n'.join(inner2(i, register_name)))
|
|
|
|
#inner = inner_rows
|
|
inner = inner_columns
|
|
|
|
inst_type = get_field_pv_name(us_cmn_inst, US_CMN_INST["TYPE"])
|
|
if inst_type in {"US_INST_TYPE_OUT", "US_INST_TYPE_ALU"}:
|
|
inner(alu_output)
|
|
elif inst_type == "US_INST_TYPE_FC":
|
|
inner(fc)
|
|
elif inst_type == "US_INST_TYPE_TEX":
|
|
inner(tex)
|
|
else:
|
|
assert False, inst_type
|
|
|
|
def parse_hex(s):
|
|
assert s.startswith('0x')
|
|
return int(s.removeprefix('0x'), 16)
|
|
|
|
if __name__ == "__main__":
|
|
filename = sys.argv[1]
|
|
with open(filename) as f:
|
|
buf = f.read()
|
|
code = [parse_hex(c.strip()) for c in buf.split(',') if c.strip()]
|
|
for i in range(len(code) // 6):
|
|
disassemble(code, i * 6)
|