2 ## This file is part of the libsigrokdecode project.
4 ## Copyright (C) 2014 Daniel Elstner <daniel.kitta@gmail.com>
6 ## This program is free software; you can redistribute it and/or modify
7 ## it under the terms of the GNU General Public License as published by
8 ## the Free Software Foundation; either version 3 of the License, or
9 ## (at your option) any later version.
11 ## This program is distributed in the hope that it will be useful,
12 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 ## GNU General Public License for more details.
16 ## You should have received a copy of the GNU General Public License
17 ## along with this program; if not, see <http://www.gnu.org/licenses/>.
20 import sigrokdecode as srd
21 from functools import reduce
22 from .tables import instr_table_by_prefix
26 ADDR, MEMRD, MEMWR, IORD, IOWR, INSTR, ROP, WOP, WARN = range(9)
28 ADDRBUS, DATABUS, INSTRUCTIONS, OPERANDS, WARNINGS = range(5)
31 M1, RD, WR, MREQ, IORQ = range(8, 13)
34 NONE, MEMRD, MEMWR, IORD, IOWR, FETCH, INTACK = range(7)
37 IDLE = 'IDLE' # no current instruction
38 PRE1 = 'PRE1' # first prefix
39 PRE2 = 'PRE2' # second prefix
40 PREDIS = 'PREDIS' # pre-opcode displacement
41 OPCODE = 'OPCODE' # opcode byte
42 POSTDIS = 'POSTDIS' # post-opcode displacement
43 IMM1 = 'IMM1' # first byte of immediate
44 IMM2 = 'IMM2' # second byte of immediate
45 ROP1 = 'ROP1' # first byte of read operand
46 ROP2 = 'ROP2' # second byte of read operand
47 WOP1 = 'WOP1' # first byte of write operand
48 WOP2 = 'WOP2' # second byte of write operand
49 RESTART = 'RESTART' # restart instruction decoding
51 # Provide custom format type 'H' for hexadecimal output
52 # with leading decimal digit (assembler syntax).
53 class AsmFormatter(string.Formatter):
54 def format_field(self, value, format_spec):
55 if format_spec.endswith('H'):
56 result = format(value, format_spec[:-1] + 'X')
57 return result if result[0] in string.digits else '0' + result
59 return format(value, format_spec)
61 formatter = AsmFormatter()
63 ann_data_cycle_map = {
64 Cycle.MEMRD: Ann.MEMRD,
65 Cycle.MEMWR: Ann.MEMWR,
68 Cycle.FETCH: Ann.MEMRD,
69 Cycle.INTACK: Ann.IORD,
74 return None # unassigned bus probes
76 return reduce(lambda a, b: (a << 1) | b, reversed(bus))
78 def signed_byte(byte):
79 return byte if byte < 128 else byte - 256
81 class Decoder(srd.Decoder):
85 longname = 'Zilog Z80 CPU'
86 desc = 'Zilog Z80 microprocessor disassembly.'
91 {'id': 'd%d' % i, 'name': 'D%d' % i, 'desc': 'Data bus line %d' % i}
94 {'id': 'm1', 'name': '/M1', 'desc': 'Machine cycle 1'},
95 {'id': 'rd', 'name': '/RD', 'desc': 'Memory or I/O read'},
96 {'id': 'wr', 'name': '/WR', 'desc': 'Memory or I/O write'},
99 {'id': 'mreq', 'name': '/MREQ', 'desc': 'Memory request'},
100 {'id': 'iorq', 'name': '/IORQ', 'desc': 'I/O request'},
102 {'id': 'a%d' % i, 'name': 'A%d' % i, 'desc': 'Address bus line %d' % i}
107 ['addr', 'Memory or I/O address'],
108 ['memrd', 'Byte read from memory'],
109 ['memwr', 'Byte written to memory'],
110 ['iord', 'Byte read from I/O port'],
111 ['iowr', 'Byte written to I/O port'],
112 ['instr', 'Z80 CPU instruction'],
113 ['rop', 'Value of input operand'],
114 ['wop', 'Value of output operand'],
115 ['warning', 'Warning message'],
118 ('addrbus', 'Address bus', (Ann.ADDR,)),
119 ('databus', 'Data bus', (Ann.MEMRD, Ann.MEMWR, Ann.IORD, Ann.IOWR)),
120 ('instructions', 'Instructions', (Ann.INSTR,)),
121 ('operands', 'Operands', (Ann.ROP, Ann.WOP)),
122 ('warnings', 'Warnings', (Ann.WARN,))
125 def __init__(self, **kwargs):
126 self.prev_cycle = Cycle.NONE
127 self.op_state = OpState.IDLE
130 self.out_ann = self.register(srd.OUTPUT_ANN)
132 self.samplenum = None
133 self.addr_start = None
134 self.data_start = None
135 self.dasm_start = None
136 self.pend_addr = None
137 self.pend_data = None
140 self.prev_cycle = Cycle.NONE
141 self.op_state = OpState.IDLE
143 def decode(self, ss, es, data):
144 for (self.samplenum, pins) in data:
146 if pins[Pin.MREQ] != 1: # default to asserted
147 if pins[Pin.RD] == 0:
148 cycle = Cycle.FETCH if pins[Pin.M1] == 0 else Cycle.MEMRD
149 elif pins[Pin.WR] == 0:
151 elif pins[Pin.IORQ] == 0: # default to not asserted
152 if pins[Pin.M1] == 0:
154 elif pins[Pin.RD] == 0:
156 elif pins[Pin.WR] == 0:
159 if cycle != Cycle.NONE:
160 self.bus_data = reduce_bus(pins[Pin.D0:Pin.D7+1])
161 if cycle != self.prev_cycle:
162 if self.prev_cycle == Cycle.NONE:
163 self.on_cycle_begin(reduce_bus(pins[Pin.A0:Pin.A15+1]))
164 elif cycle == Cycle.NONE:
167 self.on_cycle_trans()
168 self.prev_cycle = cycle
170 def on_cycle_begin(self, bus_addr):
171 if self.pend_addr is not None:
172 self.put_text(self.addr_start, Ann.ADDR,
173 '{:04X}'.format(self.pend_addr))
174 self.addr_start = self.samplenum
175 self.pend_addr = bus_addr
177 def on_cycle_end(self):
178 self.op_state = getattr(self, 'on_state_' + self.op_state)()
179 if self.ann_dasm is not None:
181 if self.op_state == OpState.RESTART:
182 self.op_state = self.on_state_IDLE()
184 if self.ann_data is not None:
185 self.put_text(self.data_start, self.ann_data,
186 '{:02X}'.format(self.pend_data))
187 self.data_start = self.samplenum
188 self.pend_data = self.bus_data
189 self.ann_data = ann_data_cycle_map[self.prev_cycle]
191 def on_cycle_trans(self):
192 self.put_text(self.samplenum - 1, Ann.WARN,
193 'Illegal transition between control states')
194 self.pend_addr = None
198 def put_disasm(self):
199 text = formatter.format(self.mnemonic, r=self.arg_reg,
200 d=self.arg_dis, i=self.arg_imm,
201 ro=self.arg_read, wo=self.arg_write)
202 self.put_text(self.dasm_start, self.ann_dasm, text)
204 self.dasm_start = self.samplenum
206 def put_text(self, ss, ann_idx, ann_text):
207 self.put(ss, self.samplenum, self.out_ann, [ann_idx, [ann_text]])
209 def on_state_IDLE(self):
210 if self.prev_cycle != Cycle.FETCH:
216 self.want_wr_be = False
217 self.op_repeat = False
224 self.instr_pend = False
225 self.read_pend = False
226 self.write_pend = False
227 self.dasm_start = self.samplenum
229 if self.bus_data in (0xCB, 0xED, 0xDD, 0xFD):
232 return OpState.OPCODE
234 def on_state_PRE1(self):
235 if self.prev_cycle != Cycle.FETCH:
236 self.mnemonic = 'Prefix not followed by fetch'
237 self.ann_dasm = Ann.WARN
238 return OpState.RESTART
239 self.op_prefix = self.pend_data
240 if self.op_prefix in (0xDD, 0xFD):
241 if self.bus_data == 0xCB:
243 if self.bus_data in (0xDD, 0xED, 0xFD):
245 return OpState.OPCODE
247 def on_state_PRE2(self):
248 if self.prev_cycle != Cycle.MEMRD:
249 self.mnemonic = 'Missing displacement'
250 self.ann_dasm = Ann.WARN
251 return OpState.RESTART
252 self.op_prefix = (self.op_prefix << 8) | self.pend_data
253 return OpState.PREDIS
255 def on_state_PREDIS(self):
256 if self.prev_cycle != Cycle.MEMRD:
257 self.mnemonic = 'Missing opcode'
258 self.ann_dasm = Ann.WARN
259 return OpState.RESTART
260 self.arg_dis = signed_byte(self.pend_data)
261 return OpState.OPCODE
263 def on_state_OPCODE(self):
264 (table, self.arg_reg) = instr_table_by_prefix[self.op_prefix]
266 instruction = table.get(self.pend_data, None)
267 if instruction is None:
268 self.mnemonic = 'Invalid instruction'
269 self.ann_dasm = Ann.WARN
270 return OpState.RESTART
271 (self.want_dis, self.want_imm, self.want_read, want_write,
272 self.op_repeat, self.mnemonic) = instruction
273 self.want_write = abs(want_write)
274 self.want_wr_be = (want_write < 0)
275 if self.want_dis > 0:
276 return OpState.POSTDIS
277 if self.want_imm > 0:
279 self.ann_dasm = Ann.INSTR
280 if self.want_read > 0 and self.prev_cycle in (Cycle.MEMRD, Cycle.IORD):
282 if self.want_write > 0 and self.prev_cycle in (Cycle.MEMWR, Cycle.IOWR):
284 return OpState.RESTART
286 def on_state_POSTDIS(self):
287 self.arg_dis = signed_byte(self.pend_data)
288 if self.want_imm > 0:
290 self.ann_dasm = Ann.INSTR
291 if self.want_read > 0:
293 if self.want_write > 0:
295 return OpState.RESTART
297 def on_state_IMM1(self):
298 self.arg_imm = self.pend_data
299 if self.want_imm > 1:
301 self.ann_dasm = Ann.INSTR
302 if self.want_read > 0:
304 if self.want_write > 0:
306 return OpState.RESTART
308 def on_state_IMM2(self):
309 self.arg_imm |= self.pend_data << 8
310 self.ann_dasm = Ann.INSTR
311 if self.want_read > 0:
313 if self.want_write > 0:
315 return OpState.RESTART
317 def on_state_ROP1(self):
318 self.arg_read = self.pend_data
319 if self.want_write > 0:
321 if self.want_read > 1:
323 if self.op_repeat and self.prev_cycle in (Cycle.MEMRD, Cycle.IORD):
325 self.mnemonic = '{ro:02X}'
326 self.ann_dasm = Ann.ROP
327 return OpState.RESTART
329 def on_state_ROP2(self):
330 self.arg_read |= self.pend_data << 8
331 self.mnemonic = '{ro:04X}'
332 self.ann_dasm = Ann.ROP
333 if self.want_write > 0:
335 return OpState.RESTART
337 def on_state_WOP1(self):
338 self.arg_write = self.pend_data
339 if self.want_read > 1:
341 if self.want_write > 1:
343 if self.want_read > 0 and self.op_repeat and \
344 self.prev_cycle in (Cycle.MEMRD, Cycle.IORD):
346 self.mnemonic = '{wo:02X}'
347 self.ann_dasm = Ann.WOP
348 return OpState.RESTART
350 def on_state_WOP2(self):
352 self.arg_write = (self.arg_write << 8) | self.pend_data
354 self.arg_write |= self.pend_data << 8
355 self.mnemonic = '{wo:04X}'
356 self.ann_dasm = Ann.WOP
357 return OpState.RESTART