repos/blastem: cpu_dsl.py annotate

annotate cpu_dsl.py @ 2591:563d05355a12

Cut down on code bloat in 68K core a little

author	Michael Pavone <pavone@retrodev.com>
date	Sun, 09 Feb 2025 14:15:22 -0800
parents	6bca3c28e2ad
children	8ef8b2e99f4f

rev	line source
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1 #!/usr/bin/env python3
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2
2440 338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	3 assignmentOps = {
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	4 '=': 'mov',
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	5 '+=': 'add',
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	6 '-=': 'sub',
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	7 '<<=': 'lsl',
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	8 '>>=': 'lsr',
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	9 '&=': 'and',
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	10 '\|=': 'or',
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	11 '^=': 'xor'
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	12 }
2441 4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	13 binaryOps = {
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	14 '+': 'add',
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	15 '-': 'sub',
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	16 '<<': 'lsl',
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	17 '>>': 'lsr',
2562 595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	18 '*': 'mulu',
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	19 '*S': 'muls',
2441 4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	20 '&': 'and',
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	21 '\|': 'or',
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	22 '^': 'xor'
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	23 }
2443 461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	24 unaryOps = {
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	25 '~': 'not',
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	26 '!': 'lnot',
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	27 '-': 'neg'
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	28 }
2442 52cfc7b14dd2 Sugar for some basic conditionals in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2441 diff changeset	29 compareOps = {'>=U', '=', '!='}
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	30 class Block:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	31 def addOp(self, op):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	32 pass
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	33
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	34 def processLine(self, parts):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	35 if parts[0] == 'switch':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	36 o = Switch(self, parts[1])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	37 self.addOp(o)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	38 return o
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	39 elif parts[0] == 'if':
2442 52cfc7b14dd2 Sugar for some basic conditionals in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2441 diff changeset	40 if len(parts) == 4 and parts[2] in compareOps:
52cfc7b14dd2 Sugar for some basic conditionals in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2441 diff changeset	41 self.addOp(NormalOp(['cmp', parts[3], parts[1]]))
52cfc7b14dd2 Sugar for some basic conditionals in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2441 diff changeset	42 cond = parts[2]
52cfc7b14dd2 Sugar for some basic conditionals in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2441 diff changeset	43 else:
52cfc7b14dd2 Sugar for some basic conditionals in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2441 diff changeset	44 cond = parts[1]
52cfc7b14dd2 Sugar for some basic conditionals in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2441 diff changeset	45 o = If(self, cond)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	46 self.addOp(o)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	47 return o
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	48 elif parts[0] == 'end':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	49 raise Exception('end is only allowed inside a switch or if block')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	50 else:
2440 338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	51 if len(parts) > 1 and parts[1] in assignmentOps:
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	52 dst = parts[0]
2448 d1eec03dca09 Fix some issues in new 68K core and add implementations of negx and clr instructions Michael Pavone <pavone@retrodev.com> parents: 2443 diff changeset	53 dst,_,size = dst.partition(':')
2440 338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	54 op = parts[1]
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	55 parts = [assignmentOps[op]] + parts[2:]
2441 4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	56 if op == '=':
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	57 if len(parts) > 2 and parts[2] in binaryOps:
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	58 op = parts[2]
2478 ea37200967c7 Implement lea and pea in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2468 diff changeset	59 if op == '-':
ea37200967c7 Implement lea and pea in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2468 diff changeset	60 tmp = parts[1]
ea37200967c7 Implement lea and pea in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2468 diff changeset	61 parts[1] = parts[3]
ea37200967c7 Implement lea and pea in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2468 diff changeset	62 parts[3] = tmp
2441 4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	63 parts[0] = binaryOps[op]
4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	64 del parts[2]
2443 461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	65 elif len(parts) > 1 and parts[1][0] in unaryOps:
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	66 rest = parts[1][1:]
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	67 op = parts[1][0]
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	68 if rest:
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	69 parts[1] = rest
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	70 else:
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	71 del parts[1]
461fffc226e0 Sugar for unary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2442 diff changeset	72 parts[0] = unaryOps[op]
2441 4435abe5db5e Sugar for binary operators in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2440 diff changeset	73 else:
2440 338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	74 if op == '<<=' or op == '>>=':
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	75 parts.insert(1, dst)
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	76 else:
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	77 parts.append(dst)
338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	78 parts.append(dst)
2448 d1eec03dca09 Fix some issues in new 68K core and add implementations of negx and clr instructions Michael Pavone <pavone@retrodev.com> parents: 2443 diff changeset	79 if size:
d1eec03dca09 Fix some issues in new 68K core and add implementations of negx and clr instructions Michael Pavone <pavone@retrodev.com> parents: 2443 diff changeset	80 parts.append(size)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	81 self.addOp(NormalOp(parts))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	82 return self
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	83
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	84 def processOps(self, prog, fieldVals, output, otype, oplist):
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	85 for i in range(0, len(oplist)):
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	86 if i + 1 < len(oplist) and oplist[i+1].op == 'update_flags':
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	87 flagUpdates, _ = prog.flags.parseFlagUpdate(oplist[i+1].params[0])
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	88 else:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	89 flagUpdates = None
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	90 oplist[i].generate(prog, self, fieldVals, output, otype, flagUpdates)
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	91
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	92 def processDispatch(self, prog):
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	93 for op in self.implementation:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	94 op.processDispatch(prog)
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	95
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	96 def resolveLocal(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	97 return None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	98
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	99 class ChildBlock(Block):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	100 def processLine(self, parts):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	101 if parts[0] == 'end':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	102 return self.parent
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	103 return super().processLine(parts)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	104
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	105 #Represents an instruction of the emulated CPU
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	106 class Instruction(Block):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	107 def __init__(self, value, fields, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	108 self.value = value
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	109 self.fields = fields
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	110 self.name = name
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	111 self.implementation = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	112 self.locals = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	113 self.regValues = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	114 self.varyingBits = 0
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	115 self.invalidFieldValues = {}
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	116 self.invalidCombos = []
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	117 self.newLocals = []
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	118 self.noSpecialize = set()
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	119 for field in fields:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	120 self.varyingBits += fields[field][1]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	121
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	122 def addOp(self, op):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	123 if op.op == 'local':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	124 name = op.params[0]
1715 4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	125 size = int(op.params[1])
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	126 self.locals[name] = size
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	127 elif op.op == 'invalid':
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	128 if len(op.params) < 3:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	129 name = op.params[0]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	130 value = int(op.params[1])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	131 self.invalidFieldValues.setdefault(name, set()).add(value)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	132 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	133 vmap = {}
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	134 for i in range(0, len(op.params), 2):
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	135 name = op.params[i]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	136 value = int(op.params[i+1])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	137 vmap[name] = value
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	138 self.invalidCombos.append(vmap)
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	139 elif op.op == 'nospecialize':
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	140 for name in op.params:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	141 self.noSpecialize.add(name)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	142 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	143 self.implementation.append(op)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	144
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	145 def resolveLocal(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	146 if name in self.locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	147 return name
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	148 return None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	149
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	150 def addLocal(self, name, size):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	151 self.locals[name] = size
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	152 self.newLocals.append(name)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	153
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	154 def localSize(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	155 return self.locals.get(name)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	156
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	157 def __lt__(self, other):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	158 if isinstance(other, Instruction):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	159 if self.varyingBits != other.varyingBits:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	160 return self.varyingBits < other.varyingBits
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	161 return self.value < other.value
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	162 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	163 return NotImplemented
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	164
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	165 def allValues(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	166 values = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	167 for i in range(0, 1 << self.varyingBits):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	168 iword = self.value
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	169 doIt = True
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	170 combos = []
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	171 for combo in self.invalidCombos:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	172 combos.append(dict(combo))
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	173 for field in self.fields:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	174 shift,bits = self.fields[field]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	175 val = i & ((1 << bits) - 1)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	176 if field in self.invalidFieldValues and val in self.invalidFieldValues[field]:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	177 doIt = False
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	178 break
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	179 nextcombos = []
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	180 for combo in combos:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	181 if field in combo:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	182 if combo[field] == val:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	183 del combo[field]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	184 if not combo:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	185 doIt = False
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	186 break
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	187 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	188 continue
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	189 nextcombos.append(combo)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	190 combos = nextcombos
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	191 if not doIt:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	192 break
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	193 i >>= bits
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	194 iword \|= val << shift
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	195 if doIt:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	196 values.append(iword)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	197 return values
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	198
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	199 def getFieldVals(self, value):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	200 fieldVals = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	201 fieldBits = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	202 for field in self.fields:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	203 shift,bits = self.fields[field]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	204 val = (value >> shift) & ((1 << bits) - 1)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	205 fieldVals[field] = val
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	206 fieldBits[field] = bits
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	207 return (fieldVals, fieldBits)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	208
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	209 def generateName(self, value):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	210 fieldVals,fieldBits = self.getFieldVals(value)
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	211 for name in self.noSpecialize:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	212 del fieldVals[name]
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	213 names = list(fieldVals.keys())
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	214 names.sort()
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	215 funName = self.name
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	216 for name in names:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	217 funName += '_{0}_{1:0>{2}}'.format(name, bin(fieldVals[name])[2:], fieldBits[name])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	218 return funName
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	219
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	220 def generateBody(self, value, prog, otype):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	221 output = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	222 prog.meta = {}
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	223 prog.pushScope(self)
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	224 self.regValues = {}
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	225 for var in self.locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	226 output.append('\n\tuint{sz}_t {name};'.format(sz=self.locals[var], name=var))
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	227 self.newLocals = []
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	228 fieldVals,_ = self.getFieldVals(value)
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	229 for name in self.noSpecialize:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	230 del fieldVals[name]
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	231 self.locals[name] = prog.opsize
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	232 if len(prog.mainDispatch) != 1:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	233 raise Exception('nospecialize requires exactly 1 field used for main table dispatch')
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	234 shift,bits = self.fields[name]
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	235 mask = (1 << bits) - 1
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	236 opfield = list(prog.mainDispatch)[0]
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	237 if shift:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	238 output.append(f'\n\tuint{prog.opsize}_t {name} = context->{opfield} >> {shift} & {mask};')
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	239 else:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	240 output.append(f'\n\tuint{prog.opsize}_t {name} = context->{opfield} & {mask};')
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	241 self.processOps(prog, fieldVals, output, otype, self.implementation)
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	242 for name in self.noSpecialize:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	243 del self.locals[name]
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	244
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	245 if prog.dispatch == 'call':
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	246 begin = '\nvoid ' + self.generateName(value) + '(' + prog.context_type + ' *context, uint32_t target_cycle)\n{'
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	247 elif prog.dispatch == 'goto':
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	248 begin = '\n' + self.generateName(value) + ': {'
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	249 else:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	250 raise Exception('Unsupported dispatch type ' + prog.dispatch)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	251 if prog.needFlagCoalesce:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	252 begin += prog.flags.coalesceFlags(prog, otype)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	253 if prog.needFlagDisperse:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	254 output.append(prog.flags.disperseFlags(prog, otype))
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	255 for var in self.newLocals:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	256 begin += '\n\tuint{sz}_t {name};'.format(sz=self.locals[var], name=var)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	257 for size in prog.temp:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	258 begin += '\n\tuint{sz}_t gen_tmp{sz}__;'.format(sz=size)
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	259 prog.popScope()
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	260 if prog.dispatch == 'goto':
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	261 output += prog.nextInstruction(otype)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	262 return begin + ''.join(output) + '\n}'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	263
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	264 def __str__(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	265 pieces = [self.name + ' ' + hex(self.value) + ' ' + str(self.fields)]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	266 for name in self.locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	267 pieces.append('\n\tlocal {0} {1}'.format(name, self.locals[name]))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	268 for op in self.implementation:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	269 pieces.append(str(op))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	270 return ''.join(pieces)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	271
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	272 #Represents the definition of a helper function
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	273 class SubRoutine(Block):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	274 def __init__(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	275 self.name = name
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	276 self.implementation = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	277 self.args = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	278 self.arg_map = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	279 self.locals = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	280 self.regValues = {}
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	281 self.argValues = {}
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	282
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	283 def addOp(self, op):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	284 if op.op == 'arg':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	285 name = op.params[0]
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	286 size = int(op.params[1])
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	287 self.arg_map[name] = len(self.args)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	288 self.args.append((name, size))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	289 elif op.op == 'local':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	290 name = op.params[0]
1734 88fbc4e711fd Implemented the rest of the block move instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1733 diff changeset	291 size = int(op.params[1])
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	292 self.locals[name] = size
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	293 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	294 self.implementation.append(op)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	295
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	296 def resolveLocal(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	297 if name in self.locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	298 return self.name + '_' + name
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	299 return None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	300
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	301 def addLocal(self, name, size):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	302 self.locals[name] = size
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	303
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	304 def localSize(self, name):
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	305 if name in self.locals:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	306 return self.locals[name]
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	307 if name in self.arg_map:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	308 argIndex = self.arg_map[name]
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	309 return self.args[argIndex][1]
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	310 return None
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	311
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	312 def inline(self, prog, params, output, otype, parent):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	313 if len(params) != len(self.args):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	314 raise Exception('{0} expects {1} arguments, but was called with {2}'.format(self.name, len(self.args), len(params)))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	315 argValues = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	316 if parent:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	317 self.regValues = parent.regValues
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	318 prog.pushScope(self)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	319 i = 0
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	320 for name,size in self.args:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	321 argValues[name] = params[i]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	322 i += 1
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	323 for name in self.locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	324 size = self.locals[name]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	325 output.append('\n\tuint{size}_t {sub}_{local};'.format(size=size, sub=self.name, local=name))
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	326 self.argValues = argValues
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	327 self.processOps(prog, argValues, output, otype, self.implementation)
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	328 prog.popScope()
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	329
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	330 def __str__(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	331 pieces = [self.name]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	332 for name,size in self.args:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	333 pieces.append('\n\targ {0} {1}'.format(name, size))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	334 for name in self.locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	335 pieces.append('\n\tlocal {0} {1}'.format(name, self.locals[name]))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	336 for op in self.implementation:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	337 pieces.append(str(op))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	338 return ''.join(pieces)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	339
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	340 class Op:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	341 def __init__(self, evalFun = None):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	342 self.evalFun = evalFun
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	343 self.impls = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	344 self.outOp = ()
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	345 def cBinaryOperator(self, op):
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	346 def _impl(prog, params, rawParams, flagUpdates):
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	347 if op == '-':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	348 a = params[1]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	349 b = params[0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	350 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	351 a = params[0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	352 b = params[1]
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	353 needsSizeAdjust = False
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	354 if len(params) > 3:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	355 size = params[3]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	356 if size == 0:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	357 size = 8
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	358 elif size == 1:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	359 size = 16
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	360 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	361 size = 32
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	362 prog.lastSize = size
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	363 destSize = prog.paramSize(rawParams[2])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	364 if destSize > size:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	365 needsSizeAdjust = True
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	366 prog.sizeAdjust = size
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	367 needsCarry = needsOflow = needsHalf = False
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	368 if flagUpdates:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	369 for flag in flagUpdates:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	370 calc = prog.flags.flagCalc[flag]
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	371 if calc == 'carry':
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	372 needsCarry = True
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	373 elif calc == 'half-carry':
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	374 needsHalf = True
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	375 elif calc == 'overflow':
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	376 needsOflow = True
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	377 decl = ''
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	378 if needsCarry or needsOflow or needsHalf or (flagUpdates and needsSizeAdjust):
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	379 if len(params) <= 3:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	380 size = prog.paramSize(rawParams[2])
2448 d1eec03dca09 Fix some issues in new 68K core and add implementations of negx and clr instructions Michael Pavone <pavone@retrodev.com> parents: 2443 diff changeset	381 if needsCarry and op != '>>':
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	382 size *= 2
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	383 decl,name = prog.getTemp(size)
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	384 dst = prog.carryFlowDst = name
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	385 prog.lastA = a
1708 5bfed2eedc9d Fixed flag calculation for sub instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1707 diff changeset	386 prog.lastB = b
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	387 if size == 64:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	388 a = '((uint64_t){a})'.format(a=a)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	389 b = '((uint64_t){b})'.format(b=b)
1711 87d4f0b4bf1d Actually correct overflow flag calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1710 diff changeset	390 prog.lastBFlow = b if op == '-' else '(~{b})'.format(b=b)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	391 elif needsSizeAdjust:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	392 decl,name = prog.getTemp(size)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	393 dst = params[2]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	394 return '{decl}\n\t{tmp} = ({a} & {mask}) {op} ({b} & {mask});\n\t{dst} = ({dst} & ~{mask}) \| {tmp};'.format(
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	395 decl = decl, tmp = name, a = a, b = b, op = op, dst = dst, mask = ((1 << size) - 1)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	396 )
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	397 else:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	398 dst = params[2]
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	399 if needsSizeAdjust:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	400 return decl + '\n\t{dst} = ({a} & {mask}) {op} ({b} & {mask});'.format(
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	401 dst = dst, a = a, b = b, op = op, mask = (1 << prog.sizeAdjust) - 1
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	402 )
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	403 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	404 return decl + '\n\t{dst} = {a} {op} {b};'.format(
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	405 dst = dst, a = a, b = b, op = op
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	406 )
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	407 self.impls['c'] = _impl
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	408 self.outOp = (2,)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	409 return self
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	410 def cUnaryOperator(self, op):
1725 89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	411 def _impl(prog, params, rawParams, flagUpdates):
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	412 dst = params[1]
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	413 decl = ''
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	414 needsSizeAdjust = False
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	415 if len(params) > 2:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	416 size = params[2]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	417 if size == 0:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	418 size = 8
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	419 elif size == 1:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	420 size = 16
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	421 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	422 size = 32
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	423 prog.lastSize = size
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	424 destSize = prog.paramSize(rawParams[1])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	425 if destSize > size:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	426 needsSizeAdjust = True
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	427 prog.sizeAdjust = size
2463 679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	428 needsCarry = needsOflow = needsHalf = False
1725 89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	429 if op == '-':
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	430 if flagUpdates:
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	431 for flag in flagUpdates:
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	432 calc = prog.flags.flagCalc[flag]
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	433 if calc == 'carry':
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	434 needsCarry = True
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	435 elif calc == 'half-carry':
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	436 needsHalf = True
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	437 elif calc == 'overflow':
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	438 needsOflow = True
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	439 if needsCarry or needsOflow or needsHalf or (flagUpdates and needsSizeAdjust):
1725 89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	440 size = prog.paramSize(rawParams[1])
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	441 decl,name = prog.getTemp(size)
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	442 dst = prog.carryFlowDst = name
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	443 prog.lastA = 0
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	444 prog.lastB = params[0]
89ee53a149ea Miscellaneous small fixes to new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1723 diff changeset	445 prog.lastBFlow = params[0]
2463 679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	446 if needsSizeAdjust:
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	447 return decl + '\n\t{dst} = {op}({a} & {mask});'.format(
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	448 dst = dst, a = params[0], op = op, mask = (1 << prog.sizeAdjust) - 1
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	449 )
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	450 if needsSizeAdjust:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	451 return decl + '\n\t{dst} = ({dst} & ~{mask}) \| (({op}{a}) & {mask});'.format(
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	452 dst = dst, a = params[0], op = op, mask = (1 << prog.sizeAdjust) - 1
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	453 )
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	454 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	455 return decl + '\n\t{dst} = {op}{a};'.format(
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	456 dst = dst, a = params[0], op = op
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	457 )
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	458 self.impls['c'] = _impl
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	459 self.outOp = (1,)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	460 return self
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	461 def addImplementation(self, lang, outOp, impl):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	462 self.impls[lang] = impl
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	463 if not outOp is None:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	464 if type(outOp) is tuple:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	465 self.outOp = outOp
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	466 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	467 self.outOp = (outOp,)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	468 return self
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	469 def evaluate(self, params):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	470 return self.evalFun(*params)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	471 def canEval(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	472 return not self.evalFun is None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	473 def numArgs(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	474 return self.evalFun.__code__.co_argcount
1716 04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	475 def numParams(self):
04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	476 if self.outOp:
04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	477 params = max(self.outOp) + 1
04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	478 else:
04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	479 params = 0
04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	480 if self.evalFun:
04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	481 params = max(params, self.numArgs())
04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	482 return params
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	483 def generate(self, otype, prog, params, rawParams, flagUpdates):
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	484 if self.impls[otype].__code__.co_argcount == 2:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	485 return self.impls[otype](prog, params)
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	486 elif self.impls[otype].__code__.co_argcount == 3:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	487 return self.impls[otype](prog, params, rawParams)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	488 else:
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	489 return self.impls[otype](prog, params, rawParams, flagUpdates)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	490
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	491
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	492 def _xchgCImpl(prog, params, rawParams):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	493 size = prog.paramSize(rawParams[0])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	494 decl,name = prog.getTemp(size)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	495 return decl + '\n\t{tmp} = {a};\n\t{a} = {b};\n\t{b} = {tmp};'.format(a = params[0], b = params[1], tmp = name)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	496
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	497 def _dispatchCImpl(prog, params):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	498 if len(params) == 1:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	499 table = 'main'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	500 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	501 table = params[1]
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	502 if table == 'main':
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	503 prog.mainDispatch.add(params[0])
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	504 if prog.dispatch == 'call':
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	505 return '\n\timpl_{tbl}[{op}](context, target_cycle);'.format(tbl = table, op = params[0])
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	506 elif prog.dispatch == 'goto':
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	507 return '\n\tgoto *impl_{tbl}[{op}];'.format(tbl = table, op = params[0])
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	508 else:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	509 raise Exception('Unsupported dispatch type ' + prog.dispatch)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	510
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	511 def _addExplicitFlagSet(prog, output, flag, flagval):
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	512 location = prog.flags.getStorage(flag)
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	513 if type(location) is tuple:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	514 reg,bit = location
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	515 reg = prog.resolveReg(reg, None, {})
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	516 value = str(1 << bit)
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	517 if flagval:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	518 operator = '\|='
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	519 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	520 operator = '&='
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	521 value = '~' + value
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	522 output.append('\n\t{reg} {op} {val};'.format(reg=reg, op=operator, val=value))
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	523 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	524 reg = prog.resolveReg(location, None, {})
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	525 output.append('\n\t{reg} = {val};'.format(reg=reg, val=flagval))
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	526
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	527 def _updateFlagsCImpl(prog, params, rawParams):
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	528 autoUpdate, explicit = prog.flags.parseFlagUpdate(params[0])
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	529 output = []
1713 0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	530 parity = None
1747 89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	531 directFlags = {}
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	532 for flag in autoUpdate:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	533 calc = prog.flags.flagCalc[flag]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	534 calc,_,resultBit = calc.partition('-')
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	535 if prog.carryFlowDst:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	536 lastDst = prog.carryFlowDst
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	537 else:
1734 88fbc4e711fd Implemented the rest of the block move instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1733 diff changeset	538 lastDst = prog.resolveParam(prog.lastDst, prog.currentScope, {})
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	539 storage = prog.flags.getStorage(flag)
1705 9ab64ef5cba0 Initial stab at overflow flag implementation in CPU DSL. Probably broken for subtraction Michael Pavone <pavone@retrodev.com> parents: 1704 diff changeset	540 if calc == 'bit' or calc == 'sign' or calc == 'carry' or calc == 'half' or calc == 'overflow':
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	541 myRes = lastDst
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	542 after = ''
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	543 if calc == 'sign':
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	544 resultBit = prog.getLastSize() - 1
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	545 elif calc == 'carry':
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	546 if prog.lastOp.op in ('asr', 'lsr', 'rrc'):
2448 d1eec03dca09 Fix some issues in new 68K core and add implementations of negx and clr instructions Michael Pavone <pavone@retrodev.com> parents: 2443 diff changeset	547 if type(prog.lastB) is int:
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	548 if prog.lastB == 0:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	549 explicit[flag] = 0
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	550 continue
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	551 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	552 resultBit = prog.lastB - 1
2448 d1eec03dca09 Fix some issues in new 68K core and add implementations of negx and clr instructions Michael Pavone <pavone@retrodev.com> parents: 2443 diff changeset	553 else:
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	554 output.append(f'\n\tif (!{prog.lastB}) {{')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	555 _addExplicitFlagSet(prog, output, flag, 0)
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	556 output.append('\n\t} else {')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	557 after = '\n\t}'
2502 ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	558 resultBit = f'({prog.lastB} - 1)'
1723 b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	559 myRes = prog.lastA
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	560 elif prog.lastOp.op == 'rlc':
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	561 if type(prog.lastB) is int:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	562 if prog.lastB == 0:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	563 explicit[flag] = 0
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	564 continue
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	565 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	566 resultBit = prog.getLastSize() - prog.lastB
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	567 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	568 output.append(f'\n\tif (!{prog.lastB}) {{')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	569 _addExplicitFlagSet(prog, output, flag, 0)
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	570 output.append('\n\t} else {')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	571 after = '\n\t}'
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	572 resultBit = f'({prog.getLastSize()} - {prog.lastB})'
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	573 myRes = prog.lastA
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	574 elif prog.lastOp.op == 'rol':
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	575 if type(prog.lastBUnmasked) is int:
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	576 if prog.lastBUnmasked == 0:
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	577 explicit[flag] = 0
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	578 continue
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	579 else:
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	580 output.append(f'\n\tif (!{prog.lastBUnmasked}) {{')
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	581 _addExplicitFlagSet(prog, output, flag, 0)
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	582 output.append('\n\t} else {')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	583 after = '\n\t}'
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	584 resultBit = 0
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	585 elif prog.lastOp.op == 'ror':
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	586 if type(prog.lastBUnmasked) is int:
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	587 if prog.lastBUnmasked == 0:
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	588 explicit[flag] = 0
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	589 continue
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	590 else:
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	591 output.append(f'\n\tif (!{prog.lastBUnmasked}) {{')
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	592 _addExplicitFlagSet(prog, output, flag, 0)
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	593 output.append('\n\t} else {')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	594 after = '\n\t}'
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	595 resultBit = prog.getLastSize() - 1
2463 679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	596 elif prog.lastOp.op == 'neg':
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	597 if prog.carryFlowDst:
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	598 realSize = prog.getLastSize()
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	599 if realSize != prog.paramSize(prog.carryFlowDst):
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	600 lastDst = '({res} & {mask})'.format(res=lastDst, mask = (1 << realSize) - 1)
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	601 if type(storage) is tuple:
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	602 reg,storageBit = storage
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	603 reg = prog.resolveParam(reg, None, {})
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	604 output.append('\n\t{reg} = {res} ? ({reg} \| {bit}U) : ({reg} & {mask}U);'.format(
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	605 reg = reg, mask = ~(1 << storageBit), res = lastDst, bit = 1 << storageBit
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	606 ))
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	607 else:
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	608 reg = prog.resolveParam(storage, None, {})
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	609 output.append('\n\t{reg} = {res} != 0;'.format(
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	610 reg = reg, res = lastDst
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	611 ))
679c31768013 Fix carry flag calculation for neg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2452 diff changeset	612 continue
1723 b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	613 else:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	614 resultBit = prog.getLastSize()
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	615 elif calc == 'half':
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	616 resultBit = prog.getLastSize() - 4
1708 5bfed2eedc9d Fixed flag calculation for sub instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1707 diff changeset	617 myRes = '({a} ^ {b} ^ {res})'.format(a = prog.lastA, b = prog.lastB, res = lastDst)
1705 9ab64ef5cba0 Initial stab at overflow flag implementation in CPU DSL. Probably broken for subtraction Michael Pavone <pavone@retrodev.com> parents: 1704 diff changeset	618 elif calc == 'overflow':
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	619 resultBit = prog.getLastSize() - 1
1711 87d4f0b4bf1d Actually correct overflow flag calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1710 diff changeset	620 myRes = '((({a} ^ {b})) & ({a} ^ {res}))'.format(a = prog.lastA, b = prog.lastBFlow, res = lastDst)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	621 else:
1715 4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	622 #Note: offsetting this by the operation size - 8 makes sense for the Z80
4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	623 #but might not for other CPUs with this kind of fixed bit flag behavior
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	624 resultBit = int(resultBit) + prog.getLastSize() - 8
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	625 if type(storage) is tuple:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	626 reg,storageBit = storage
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	627 if storageBit == resultBit:
1747 89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	628 directFlags.setdefault((reg, myRes), []).append(resultBit)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	629 else:
1747 89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	630 reg = prog.resolveParam(reg, None, {})
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	631 if resultBit > storageBit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	632 op = '>>'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	633 shift = resultBit - storageBit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	634 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	635 op = '<<'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	636 shift = storageBit - resultBit
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	637 output.append('\n\t{reg} = ({reg} & ~{mask}U) \| ({res} {op} {shift}U & {mask}U);'.format(
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	638 reg = reg, mask = 1 << storageBit, res = myRes, op = op, shift = shift
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	639 ))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	640 else:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	641 reg = prog.resolveParam(storage, None, {})
1715 4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	642 maxBit = prog.paramSize(storage) - 1
2502 ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	643 if type(resultBit) is int:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	644 mask = f'{1 << resultBit}U'
1715 4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	645 else:
2502 ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	646 mask = f'(1 << {resultBit})'
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	647 if not type(resultBit) is int:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	648 output.append(f'\n\t{reg} = !!({myRes} & {mask});')
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	649 elif resultBit > maxBit:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	650 mask = f'{1 << maxBit}U'
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	651 output.append('\n\t{reg} = {res} >> {shift} & {mask};'.format(reg=reg, res=myRes, shift = resultBit - maxBit, mask = mask))
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	652 else:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	653 output.append('\n\t{reg} = {res} & {mask};'.format(reg=reg, res=myRes, mask = mask))
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	654 if after:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	655 output.append(after)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	656 elif calc == 'zero':
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	657 if prog.carryFlowDst:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	658 realSize = prog.getLastSize()
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	659 if realSize != prog.paramSize(prog.carryFlowDst):
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	660 lastDst = '({res} & {mask})'.format(res=lastDst, mask = (1 << realSize) - 1)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	661 if type(storage) is tuple:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	662 reg,storageBit = storage
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	663 reg = prog.resolveParam(reg, None, {})
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	664 output.append('\n\t{reg} = {res} ? ({reg} & {mask}U) : ({reg} \| {bit}U);'.format(
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	665 reg = reg, mask = ~(1 << storageBit), res = lastDst, bit = 1 << storageBit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	666 ))
1703 49a52c737bf0 Fix zero flag calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1702 diff changeset	667 else:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	668 reg = prog.resolveParam(storage, None, {})
1703 49a52c737bf0 Fix zero flag calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1702 diff changeset	669 output.append('\n\t{reg} = {res} == 0;'.format(
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	670 reg = reg, res = lastDst
1705 9ab64ef5cba0 Initial stab at overflow flag implementation in CPU DSL. Probably broken for subtraction Michael Pavone <pavone@retrodev.com> parents: 1704 diff changeset	671 ))
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	672 elif calc == 'parity':
1713 0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	673 parity = storage
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	674 paritySize = prog.getLastSize()
1713 0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	675 if prog.carryFlowDst:
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	676 parityDst = paritySrc = prog.carryFlowDst
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	677 else:
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	678 paritySrc = lastDst
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	679 decl,name = prog.getTemp(paritySize)
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	680 output.append(decl)
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	681 parityDst = name
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	682 else:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	683 raise Exception('Unknown flag calc type: ' + calc)
1747 89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	684 for reg, myRes in directFlags:
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	685 bits = directFlags[(reg, myRes)]
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	686 resolved = prog.resolveParam(reg, None, {})
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	687 if len(bits) == len(prog.flags.storageToFlags[reg]):
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	688 output.append('\n\t{reg} = {res};'.format(reg = resolved, res = myRes))
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	689 else:
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	690 mask = 0
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	691 for bit in bits:
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	692 mask \|= 1 << bit
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	693 output.append('\n\t{reg} = ({reg} & ~{mask}U) \| ({res} & {mask}U);'.format(
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	694 reg = resolved, mask = mask, res = myRes
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	695 ))
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	696 if prog.carryFlowDst:
1719 fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	697 if prog.lastOp.op != 'cmp':
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	698 if prog.sizeAdjust:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	699 output.append('\n\t{dst} = ({dst} & ~{mask}) \| ({tmpdst} & {mask});'.format(
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	700 dst = prog.resolveParam(prog.lastDst, prog.currentScope, {}), tmpdst = prog.carryFlowDst, mask = ((1 << prog.sizeAdjust) - 1)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	701 ))
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	702 prog.sizeAdjust = None
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	703 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	704 output.append('\n\t{dst} = {tmpdst};'.format(dst = prog.resolveParam(prog.lastDst, prog.currentScope, {}), tmpdst = prog.carryFlowDst))
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	705 prog.carryFlowDst = None
1713 0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	706 if parity:
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	707 if paritySize > 8:
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	708 if paritySize > 16:
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	709 output.append('\n\t{dst} = {src} ^ ({src} >> 16);'.format(dst=parityDst, src=paritySrc))
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	710 paritySrc = parityDst
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	711 output.append('\n\t{dst} = {src} ^ ({src} >> 8);'.format(dst=parityDst, src=paritySrc))
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	712 paritySrc = parityDst
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	713 output.append('\n\t{dst} = ({src} ^ ({src} >> 4)) & 0xF;'.format(dst=parityDst, src=paritySrc))
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	714 if type(parity) is tuple:
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	715 reg,bit = parity
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	716 reg = prog.resolveParam(reg, None, {})
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	717 output.append('\n\t{flag} = ({flag} & ~{mask}U) \| ((0x6996 >> {parity}) << {bit} & {mask}U);'.format(
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	718 flag=reg, mask = 1 << bit, bit = bit, parity = parityDst
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	719 ))
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	720 else:
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	721 reg = prog.resolveParam(parity, None, {})
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	722 output.append('\n\t{flag} = 0x9669 >> {parity} & 1;'.format(flag=reg, parity=parityDst))
0264d8b288e2 Implement parity flag calculation type Michael Pavone <pavone@retrodev.com> parents: 1711 diff changeset	723
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	724 #TODO: combine explicit flags targeting the same storage location
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	725 for flag in explicit:
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	726 _addExplicitFlagSet(prog, output, flag, explicit[flag])
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	727 return ''.join(output)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	728
1719 fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	729 def _cmpCImpl(prog, params, rawParams, flagUpdates):
2451 edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	730 b_size = size = prog.paramSize(rawParams[1])
1719 fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	731 needsCarry = False
fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	732 if flagUpdates:
fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	733 for flag in flagUpdates:
fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	734 calc = prog.flags.flagCalc[flag]
fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	735 if calc == 'carry':
fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	736 needsCarry = True
fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	737 break
2451 edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	738 if len(params) > 2:
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	739 size = params[2]
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	740 if size == 0:
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	741 size = 8
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	742 elif size == 1:
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	743 size = 16
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	744 else:
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	745 size = 32
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	746 prog.lastSize = size
1719 fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	747 if needsCarry:
fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	748 size *= 2
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	749 tmpvar = 'cmp_tmp{sz}__'.format(sz=size)
1745 a8f04b0ab744 Fixes to DAA, SCF and CCF to pass ZEXALL in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1744 diff changeset	750 if flagUpdates:
a8f04b0ab744 Fixes to DAA, SCF and CCF to pass ZEXALL in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1744 diff changeset	751 prog.carryFlowDst = tmpvar
a8f04b0ab744 Fixes to DAA, SCF and CCF to pass ZEXALL in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1744 diff changeset	752 prog.lastA = params[1]
a8f04b0ab744 Fixes to DAA, SCF and CCF to pass ZEXALL in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1744 diff changeset	753 prog.lastB = params[0]
a8f04b0ab744 Fixes to DAA, SCF and CCF to pass ZEXALL in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1744 diff changeset	754 prog.lastBFlow = params[0]
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	755 scope = prog.getRootScope()
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	756 if not scope.resolveLocal(tmpvar):
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	757 scope.addLocal(tmpvar, size)
1719 fb5ae8c20b85 Fix cp instruction in new Z80 core and implement its DD/FD prefixes Michael Pavone <pavone@retrodev.com> parents: 1716 diff changeset	758 prog.lastDst = rawParams[1]
2451 edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	759 a = params[0]
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	760 b = params[1]
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	761 a_size = prog.paramSize(rawParams[0])
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	762 if prog.lastSize != a_size:
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	763 a = '(({a}) & {mask})'.format(a = a, mask = (1 << prog.lastSize) - 1)
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	764 if prog.lastSize != b_size:
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	765 b = '(({b}) & {mask})'.format(b = b, mask = (1 << prog.lastSize) - 1)
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	766 if size == 64:
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	767 a = '((uint64_t){a})'.format(a = a)
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	768 b = '((uint64_t){b})'.format(b = b)
edd73a009537 Fix implementation of cmp for 32-bit operands or when operation size is smaller than the size of the operands Michael Pavone <pavone@retrodev.com> parents: 2448 diff changeset	769 return '\n\t{var} = {b} - {a};'.format(var = tmpvar, a = a, b = b)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	770
1723 b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	771 def _asrCImpl(prog, params, rawParams, flagUpdates):
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	772 needsCarry = False
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	773 if flagUpdates:
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	774 for flag in flagUpdates:
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	775 calc = prog.flags.flagCalc[flag]
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	776 if calc == 'carry':
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	777 needsCarry = True
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	778 decl = ''
2502 ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	779 needsSizeAdjust = False
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	780 destSize = prog.paramSize(rawParams[2])
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	781 if len(params) > 3:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	782 size = params[3]
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	783 if size == 0:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	784 size = 8
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	785 elif size == 1:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	786 size = 16
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	787 else:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	788 size = 32
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	789 prog.lastSize = size
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	790 if destSize > size:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	791 needsSizeAdjust = True
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	792 prog.sizeAdjust = size
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	793 else:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	794 size = destSize
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	795 mask = 1 << (size - 1)
1723 b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	796 if needsCarry:
2502 ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	797 decl,name = prog.getTemp(size)
1723 b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	798 dst = prog.carryFlowDst = name
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	799 prog.lastA = params[0]
2502 ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	800 prog.lastB = params[1]
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	801 if needsSizeAdjust:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	802 sizeMask = (1 << size) - 1
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	803 return decl + '\n\t{name} = (({a} & {sizeMask}) >> ({b} & {sizeMask})) \| ({a} & {mask} ? 0xFFFFFFFFU << ({size} - ({b} & {sizeMask})) : 0);'.format(
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	804 name = name, a = params[0], b = params[1], dst = dst, mask = mask, size=size, sizeMask=sizeMask)
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	805 elif needsSizeAdjust:
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	806 decl,name = prog.getTemp(size)
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	807 sizeMask = (1 << size) - 1
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	808 return decl + ('\n\t{name} = (({a} & {sizeMask}) >> ({b} & {sizeMask})) \| ({a} & {mask} ? 0xFFFFFFFFU << ({size} - ({b} & {sizeMask})) : 0);' +
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	809 '\n\t{dst} = ({dst} & ~{sizeMask}) \| {name};').format(
ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	810 name = name, a = params[0], b = params[1], dst = dst, mask = mask, size=size, sizeMask=sizeMask)
1723 b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	811 else:
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	812 dst = params[2]
2502 ad50530a7c27 Partially functional asr/asl implementations in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2500 diff changeset	813
1723 b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	814 return decl + '\n\t{dst} = ({a} >> {b}) \| ({a} & {mask} ? 0xFFFFFFFFU << ({size} - {b}) : 0);'.format(
b757ebc59851 Implemented shift instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1722 diff changeset	815 a = params[0], b = params[1], dst = dst, mask = mask, size=size)
1697 44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	816
44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	817 def _sext(size, src):
44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	818 if size == 16:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	819 return src \| 0xFF00 if src & 0x80 else src & 0x7F
1697 44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	820 else:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	821 return src \| 0xFFFF0000 if src & 0x8000 else src & 0x7FFF
1697 44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	822
44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	823 def _sextCImpl(prog, params, rawParms):
44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	824 if params[0] == 16:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	825 fmt = '\n\t{dst} = {src} & 0x80 ? {src} \| 0xFF00 : {src} & 0x7F;'
1697 44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	826 else:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	827 fmt = '\n\t{dst} = {src} & 0x8000 ? {src} \| 0xFFFF0000 : {src} & 0x7FFF;'
2468 0ca78837e4d2 Implement ext instruction in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2463 diff changeset	828 prog.lastSize = params[0]
1697 44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	829 return fmt.format(src=params[1], dst=params[2])
2562 595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	830
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	831 def _mulsCImpl(prog, params, rawParams, flagUpdates):
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	832 p0Size = prog.paramSize(rawParams[0])
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	833 p1Size = prog.paramSize(rawParams[1])
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	834 destSize = prog.paramSize(rawParams[2])
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	835 if len(params) > 3:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	836 size = params[3]
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	837 if size == 0:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	838 size = 8
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	839 elif size == 1:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	840 size = 16
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	841 else:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	842 size = 32
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	843 prog.lastSize = size
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	844 else:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	845 size = destSize
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	846 if p0Size >= size:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	847 p0Size = size // 2
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	848 if p1Size >= size:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	849 p1Size = size // 2
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	850 #TODO: Handle case in which destSize > size
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	851 return f'\n\t{params[2]} = (int{size}_t)(((int{p0Size}_t){params[0]}) * ((int{p1Size}_t){params[1]}));'
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	852
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	853 def _muluCImpl(prog, params, rawParams, flagUpdates):
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	854 p0Size = prog.paramSize(rawParams[0])
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	855 p1Size = prog.paramSize(rawParams[1])
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	856 destSize = prog.paramSize(rawParams[2])
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	857 if len(params) > 3:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	858 size = params[3]
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	859 if size == 0:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	860 size = 8
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	861 elif size == 1:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	862 size = 16
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	863 else:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	864 size = 32
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	865 prog.lastSize = size
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	866 else:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	867 size = destSize
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	868 if p0Size >= size:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	869 p0Size = size // 2
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	870 if p1Size >= size:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	871 p1Size = size // 2
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	872 #TODO: Handle case in which destSize > size
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	873 return f'\n\t{params[2]} = ((uint{p0Size}_t){params[0]}) * ((uint{p1Size}_t){params[1]});'
1702 73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	874
73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	875 def _getCarryCheck(prog):
1701 4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	876 carryFlag = None
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	877 for flag in prog.flags.flagOrder:
1701 4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	878 if prog.flags.flagCalc[flag] == 'carry':
4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	879 carryFlag = flag
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	880 break
1701 4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	881 if carryFlag is None:
4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	882 raise Exception('adc requires a defined carry flag')
4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	883 carryStorage = prog.flags.getStorage(carryFlag)
4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	884 if type(carryStorage) is tuple:
4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	885 reg,bit = carryStorage
4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	886 reg = prog.resolveReg(reg, None, (), False)
1702 73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	887 return '({reg} & 1 << {bit})'.format(reg=reg, bit=bit)
1701 4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	888 else:
1702 73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	889 return prog.resolveReg(carryStorage, None, (), False)
73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	890
1709 9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	891 def _adcCImpl(prog, params, rawParams, flagUpdates):
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	892 needsSizeAdjust = False
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	893 if len(params) > 3:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	894 size = params[3]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	895 if size == 0:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	896 size = 8
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	897 elif size == 1:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	898 size = 16
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	899 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	900 size = 32
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	901 prog.lastSize = size
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	902 destSize = prog.paramSize(rawParams[2])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	903 if destSize > size:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	904 needsSizeAdjust = True
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	905 prog.sizeAdjust = size
1709 9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	906 needsCarry = needsOflow = needsHalf = False
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	907 if flagUpdates:
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	908 for flag in flagUpdates:
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	909 calc = prog.flags.flagCalc[flag]
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	910 if calc == 'carry':
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	911 needsCarry = True
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	912 elif calc == 'half-carry':
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	913 needsHalf = True
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	914 elif calc == 'overflow':
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	915 needsOflow = True
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	916 decl = ''
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	917 carryCheck = _getCarryCheck(prog)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	918 vals = '1 : 0'
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	919 if needsCarry or needsOflow or needsHalf or (flagUpdates and needsSizeAdjust):
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	920 if len(params) <= 3:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	921 size = prog.paramSize(rawParams[2])
1709 9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	922 if needsCarry:
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	923 size *= 2
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	924 decl,name = prog.getTemp(size)
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	925 dst = prog.carryFlowDst = name
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	926 prog.lastA = params[0]
1744 91aa789e57bd Fixed half-carry flag calcuation for adc/sbc in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1742 diff changeset	927 prog.lastB = params[1]
1711 87d4f0b4bf1d Actually correct overflow flag calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1710 diff changeset	928 prog.lastBFlow = '(~{b})'.format(b=params[1])
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	929 if size == 64:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	930 params[0] = '((uint64_t){a})'.format(a=params[0])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	931 params[1] = '((uint64_t){b})'.format(b=params[1])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	932 vals = '((uint64_t)1) : ((uint64_t)0)'
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	933 elif needsSizeAdjust:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	934 decl,name = prog.getTemp(size)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	935 dst = params[2]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	936 return '{decl}\n\t{tmp} = ({a} & {mask}) + ({b} & {mask}) + ({check} ? 1 : 0);\n\t{dst} = ({dst} & ~{mask}) \| {tmp};'.format(
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	937 decl = decl, tmp = name, a = a, b = b, op = op, dst = dst, mask = ((1 << size) - 1), check = carryCheck
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	938 )
1709 9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	939 else:
9c058ea77b7a Implementation of carry/overflow flags for adc instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1708 diff changeset	940 dst = params[2]
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	941 return decl + '\n\t{dst} = {a} + {b} + ({check} ? {vals});'.format(dst = dst,
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	942 a = params[0], b = params[1], check = carryCheck, vals = vals
1702 73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	943 )
73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	944
1710 2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	945 def _sbcCImpl(prog, params, rawParams, flagUpdates):
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	946 needsSizeAdjust = False
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	947 if len(params) > 3:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	948 size = params[3]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	949 if size == 0:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	950 size = 8
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	951 elif size == 1:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	952 size = 16
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	953 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	954 size = 32
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	955 prog.lastSize = size
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	956 destSize = prog.paramSize(rawParams[2])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	957 if destSize > size:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	958 needsSizeAdjust = True
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	959 prog.sizeAdjust = size
1710 2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	960 needsCarry = needsOflow = needsHalf = False
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	961 if flagUpdates:
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	962 for flag in flagUpdates:
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	963 calc = prog.flags.flagCalc[flag]
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	964 if calc == 'carry':
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	965 needsCarry = True
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	966 elif calc == 'half-carry':
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	967 needsHalf = True
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	968 elif calc == 'overflow':
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	969 needsOflow = True
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	970 decl = ''
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	971 carryCheck = _getCarryCheck(prog)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	972 vals = '1 : 0'
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	973 if needsCarry or needsOflow or needsHalf or (flagUpdates and needsSizeAdjust):
1710 2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	974 size = prog.paramSize(rawParams[2])
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	975 if needsCarry:
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	976 size *= 2
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	977 decl,name = prog.getTemp(size)
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	978 dst = prog.carryFlowDst = name
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	979 prog.lastA = params[1]
1744 91aa789e57bd Fixed half-carry flag calcuation for adc/sbc in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1742 diff changeset	980 prog.lastB = params[0]
1711 87d4f0b4bf1d Actually correct overflow flag calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1710 diff changeset	981 prog.lastBFlow = params[0]
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	982 if size == 64:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	983 params[1] = '((uint64_t){a})'.format(a=params[1])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	984 params[0] = '((uint64_t){b})'.format(b=params[0])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	985 vals = '((uint64_t)1) : ((uint64_t)0)'
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	986 elif needsSizeAdjust:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	987 decl,name = prog.getTemp(size)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	988 dst = params[2]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	989 return '{decl}\n\t{tmp} = ({b} & {mask}) - ({a} & {mask}) - ({check} ? 1 : 0);\n\t{dst} = ({dst} & ~{mask}) \| {tmp};'.format(
2589 6bca3c28e2ad Low confidence fix for edge case in CPU DSL not currently hit Michael Pavone <pavone@retrodev.com> parents: 2587 diff changeset	990 decl = decl, tmp = name, a = params[0], b = params[1], dst = dst, mask = ((1 << size) - 1), check = carryCheck
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	991 )
1710 2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	992 else:
2344b3650b38 Fix sbc and implement carry/overflow flags for it in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1709 diff changeset	993 dst = params[2]
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	994 return decl + '\n\t{dst} = {b} - {a} - ({check} ? {vals});'.format(dst = dst,
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	995 a = params[0], b = params[1], check=_getCarryCheck(prog), vals = vals
1702 73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	996 )
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	997
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	998 def _rolCImpl(prog, params, rawParams, flagUpdates):
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	999 needsCarry = False
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1000 if flagUpdates:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1001 for flag in flagUpdates:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1002 calc = prog.flags.flagCalc[flag]
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1003 if calc == 'carry':
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1004 needsCarry = True
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1005 destSize = prog.paramSize(rawParams[2])
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1006 needsSizeAdjust = False
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1007 if len(params) > 3:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1008 size = params[3]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1009 if size == 0:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1010 size = 8
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1011 elif size == 1:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1012 size = 16
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1013 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1014 size = 32
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1015 prog.lastSize = size
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1016 if destSize > size:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1017 needsSizeAdjust = True
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1018 if needsCarry:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1019 prog.sizeAdjust = size
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1020 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1021 size = destSize
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1022 rotMask = size - 1
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1023 if type(params[1]) is int:
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1024 b = params[1] & rotMask
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1025 mdecl = ''
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1026 ret = ''
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1027 else:
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1028 mdecl,b = prog.getTemp(prog.paramSize(rawParams[1]))
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1029 ret = f'\n\t{b} = {params[1]} & {rotMask};'
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1030 prog.lastB = b
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1031 prog.lastBUnmasked = params[1]
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1032 if needsSizeAdjust:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1033 decl,name = prog.getTemp(size)
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1034 mdecl += decl
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1035 dst = prog.carryFlowDst = name
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1036 else:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1037 dst = params[2]
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1038 ret += '\n\t{dst} = {a} << {b} \| {a} >> ({size} - {b});'.format(dst = dst,
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1039 a = params[0], b = b, size=size
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1040 )
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1041 if needsSizeAdjust and not needsCarry:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1042 mask = (1 << size) - 1
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1043 ret += f'\n\t{params[2]} = ({params[2]} & ~{mask}) \| ({dst} & {mask});'
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1044 return mdecl + ret
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1045
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1046 def _rlcCImpl(prog, params, rawParams, flagUpdates):
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1047 needsCarry = False
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1048 if flagUpdates:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1049 for flag in flagUpdates:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1050 calc = prog.flags.flagCalc[flag]
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1051 if calc == 'carry':
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1052 needsCarry = True
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1053 decl = ''
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1054 destSize = prog.paramSize(rawParams[2])
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1055 needsSizeAdjust = False
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1056 if len(params) > 3:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1057 size = params[3]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1058 if size == 0:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1059 size = 8
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1060 elif size == 1:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1061 size = 16
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1062 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1063 size = 32
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1064 prog.lastSize = size
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1065 if destSize > size:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1066 needsSizeAdjust = True
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1067 if needsCarry:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1068 prog.sizeAdjust = size
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1069 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1070 size = destSize
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1071 carryCheck = _getCarryCheck(prog)
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1072 size = prog.paramSize(rawParams[2])
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1073 if needsCarry or needsSizeAdjust:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1074 decl,name = prog.getTemp(size)
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1075 dst = prog.carryFlowDst = name
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1076 prog.lastA = params[0]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1077 prog.lastB = params[1]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1078 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1079 dst = params[2]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1080 if size == 32 and (not type(params[1]) is int) or params[1] <= 1:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1081 # we may need to shift by 32-bits which is too much for a normal int
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1082 a = f'((uint64_t){params[0]})'
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1083 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1084 a = params[0]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1085 ret = decl + '\n\t{dst} = {a} << {b} \| {a} >> ({size} + 1 - {b}) \| ({check} ? 1 : 0) << ({b} - 1);'.format(dst = dst,
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1086 a = a, b = params[1], size=size, check=carryCheck
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1087 )
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1088 if needsSizeAdjust and not needsCarry:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1089 mask = (1 << size) - 1
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1090 ret += f'\n\t{params[2]} = ({params[2]} & ~{mask}) \| ({dst} & {mask});'
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1091 return ret
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1092
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1093 def _rorCImpl(prog, params, rawParams, flagUpdates):
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1094 needsCarry = False
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1095 if flagUpdates:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1096 for flag in flagUpdates:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1097 calc = prog.flags.flagCalc[flag]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1098 if calc == 'carry':
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1099 needsCarry = True
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1100 destSize = prog.paramSize(rawParams[2])
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1101 needsSizeAdjust = False
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1102 if len(params) > 3:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1103 size = params[3]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1104 if size == 0:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1105 size = 8
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1106 elif size == 1:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1107 size = 16
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1108 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1109 size = 32
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1110 prog.lastSize = size
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1111 if destSize > size:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1112 needsSizeAdjust = True
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1113 if needsCarry:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1114 prog.sizeAdjust = size
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1115 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1116 size = destSize
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1117 rotMask = size - 1
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1118 if type(params[1]) is int:
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1119 b = params[1] & rotMask
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1120 mdecl = ''
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1121 ret = ''
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1122 else:
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1123 mdecl,b = prog.getTemp(prog.paramSize(rawParams[1]))
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1124 ret = f'\n\t{b} = {params[1]} & {rotMask};'
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1125 prog.lastB = b
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1126 prog.lastBUnmasked = params[1]
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1127 if needsSizeAdjust:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1128 decl,name = prog.getTemp(size)
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1129 dst = prog.carryFlowDst = name
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1130 mdecl += decl
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1131 else:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1132 dst = params[2]
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1133 ret += '\n\t{dst} = {a} >> {b} \| {a} << ({size} - {b});'.format(dst = dst,
9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1134 a = params[0], b = b, size=size
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1135 )
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1136 if needsSizeAdjust and not needsCarry:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1137 mask = (1 << size) - 1
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1138 ret += f'\n\t{params[2]} = ({params[2]} & ~{mask}) \| ({dst} & {mask});'
2578 9b01541cbd60 Fix rol and ror in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2577 diff changeset	1139 return mdecl + ret
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1140
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1141 def _rrcCImpl(prog, params, rawParams, flagUpdates):
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1142 needsCarry = False
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1143 if flagUpdates:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1144 for flag in flagUpdates:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1145 calc = prog.flags.flagCalc[flag]
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1146 if calc == 'carry':
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1147 needsCarry = True
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1148 decl = ''
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1149 destSize = prog.paramSize(rawParams[2])
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1150 needsSizeAdjust = False
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1151 if len(params) > 3:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1152 size = params[3]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1153 if size == 0:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1154 size = 8
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1155 elif size == 1:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1156 size = 16
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1157 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1158 size = 32
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1159 prog.lastSize = size
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1160 if destSize > size:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1161 needsSizeAdjust = True
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1162 if needsCarry:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1163 prog.sizeAdjust = size
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1164 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1165 size = destSize
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1166 carryCheck = _getCarryCheck(prog)
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1167 size = prog.paramSize(rawParams[2])
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1168 if needsCarry or needsSizeAdjust:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1169 decl,name = prog.getTemp(size)
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1170 dst = prog.carryFlowDst = name
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1171 prog.lastA = params[0]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1172 prog.lastB = params[1]
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1173 else:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1174 dst = params[2]
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1175 if size == 32 and (not type(params[1]) is int) or params[1] <= 1:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1176 # we may need to shift by 32-bits which is too much for a normal int
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1177 a = f'((uint64_t){params[0]})'
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1178 else:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1179 a = params[0]
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1180 ret = decl + '\n\t{dst} = {a} >> {b} \| {a} << ({size} + 1 - {b}) \| ({check} ? 1 : 0) << ({size}-{b});'.format(dst = dst,
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1181 a = a, b = params[1], size=size, check=carryCheck
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1182 )
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1183 if needsSizeAdjust and not needsCarry:
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1184 mask = (1 << size) - 1
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1185 ret += f'\n\t{params[2]} = ({params[2]} & ~{mask}) \| ({dst} & {mask});'
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1186 return ret
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1187
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1188 def _updateSyncCImpl(prog, params):
1759 6e4faa10f9ee Store sync_cycle in context rather than in a local in CPU DSL. Fix the timing of a number of instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1754 diff changeset	1189 return '\n\t{sync}(context, target_cycle);'.format(sync=prog.sync_cycle)
1701 4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	1190
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1191 _opMap = {
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1192 'mov': Op(lambda val: val).cUnaryOperator(''),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1193 'not': Op(lambda val: ~val).cUnaryOperator('~'),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1194 'lnot': Op(lambda val: 0 if val else 1).cUnaryOperator('!'),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1195 'neg': Op(lambda val: -val).cUnaryOperator('-'),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1196 'add': Op(lambda a, b: a + b).cBinaryOperator('+'),
1701 4fd34fde390c Added adc instruction to CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1700 diff changeset	1197 'adc': Op().addImplementation('c', 2, _adcCImpl),
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1198 'sub': Op(lambda a, b: b - a).cBinaryOperator('-'),
1702 73ac2e59fa3f Implemented sbc instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1701 diff changeset	1199 'sbc': Op().addImplementation('c', 2, _sbcCImpl),
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1200 'lsl': Op(lambda a, b: a << b).cBinaryOperator('<<'),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1201 'lsr': Op(lambda a, b: a >> b).cBinaryOperator('>>'),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1202 'asr': Op(lambda a, b: a >> b).addImplementation('c', 2, _asrCImpl),
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1203 'rol': Op().addImplementation('c', 2, _rolCImpl),
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1204 'rlc': Op().addImplementation('c', 2, _rlcCImpl),
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1205 'ror': Op().addImplementation('c', 2, _rorCImpl),
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1206 'rrc': Op().addImplementation('c', 2, _rrcCImpl),
2562 595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	1207 'mulu': Op(lambda a, b: a * b).addImplementation('c', 2, _muluCImpl),
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	1208 'muls': Op().addImplementation('c', 2, _mulsCImpl),
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1209 'and': Op(lambda a, b: a & b).cBinaryOperator('&'),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1210 'or': Op(lambda a, b: a \| b).cBinaryOperator('\|'),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1211 'xor': Op(lambda a, b: a ^ b).cBinaryOperator('^'),
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1212 'abs': Op(lambda val: abs(val)).addImplementation(
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1213 'c', 1, lambda prog, params: '\n\t{dst} = abs({src});'.format(dst=params[1], src=params[0])
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1214 ),
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1215 'cmp': Op().addImplementation('c', None, _cmpCImpl),
1697 44d8c6e61ad4 Added new sext instruction for sign extension to CPU sdl Michael Pavone <pavone@retrodev.com> parents: 1621 diff changeset	1216 'sext': Op(_sext).addImplementation('c', 2, _sextCImpl),
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1217 'ocall': Op().addImplementation('c', None, lambda prog, params: '\n\t{pre}{fun}({args});'.format(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1218 pre = prog.prefix, fun = params[0], args = ', '.join(['context'] + [str(p) for p in params[1:]])
1759 6e4faa10f9ee Store sync_cycle in context rather than in a local in CPU DSL. Fix the timing of a number of instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1754 diff changeset	1219 )),
2587 e04c7e753bf6 Implement divs and divu in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2581 diff changeset	1220 'ccall': Op().addImplementation('c', None, lambda prog, params: '\n\t{fun}({args});'.format(
e04c7e753bf6 Implement divs and divu in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2581 diff changeset	1221 pre = prog.prefix, fun = params[0], args = ', '.join([str(p) for p in params[1:]])
e04c7e753bf6 Implement divs and divu in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2581 diff changeset	1222 )),
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1223 'pcall': Op().addImplementation('c', None, lambda prog, params: '\n\t(({typ}){fun})({args});'.format(
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1224 typ = params[1], fun = params[0], args = ', '.join([str(p) for p in params[2:]])
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1225 )),
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1226 'cycles': Op().addImplementation('c', None,
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1227 lambda prog, params: '\n\tcontext->cycles += context->opts->gen.clock_divider * {0};'.format(
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1228 params[0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1229 )
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1230 ),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1231 'addsize': Op(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1232 lambda a, b: b + (2 * a if a else 1)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1233 ).addImplementation('c', 2, lambda prog, params: '\n\t{dst} = {val} + ({sz} ? {sz} * 2 : 1);'.format(
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1234 dst = params[2], sz = params[0], val = params[1]
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1235 )),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1236 'decsize': Op(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1237 lambda a, b: b - (2 * a if a else 1)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1238 ).addImplementation('c', 2, lambda prog, params: '\n\t{dst} = {val} - ({sz} ? {sz} * 2 : 1);'.format(
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1239 dst = params[2], sz = params[0], val = params[1]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1240 )),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1241 'xchg': Op().addImplementation('c', (0,1), _xchgCImpl),
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1242 'dispatch': Op().addImplementation('c', None, _dispatchCImpl),
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1243 'update_flags': Op().addImplementation('c', None, _updateFlagsCImpl),
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1244 'update_sync': Op().addImplementation('c', None, _updateSyncCImpl)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1245 }
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1246
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1247 #represents a simple DSL instruction
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1248 class NormalOp:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1249 def __init__(self, parts):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1250 self.op = parts[0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1251 self.params = parts[1:]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1252
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1253 def generate(self, prog, parent, fieldVals, output, otype, flagUpdates):
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1254 procParams = []
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1255 allParamsConst = flagUpdates is None and not prog.conditional
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1256 opDef = _opMap.get(self.op)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1257 for param in self.params:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1258 isDst = (not opDef is None) and len(procParams) in opDef.outOp
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1259 allowConst = (self.op in prog.subroutines or not isDst) and param in parent.regValues
1765 7b6831305a6a Fix calculation for whether coalesceFlags is needed for xchg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1759 diff changeset	1260 if isDst and self.op == 'xchg':
7b6831305a6a Fix calculation for whether coalesceFlags is needed for xchg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1759 diff changeset	1261 #xchg uses its regs as both source and destination
7b6831305a6a Fix calculation for whether coalesceFlags is needed for xchg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1759 diff changeset	1262 #we need to resolve as both so that disperse/coalesce flag stuff gets done
7b6831305a6a Fix calculation for whether coalesceFlags is needed for xchg instruction in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1759 diff changeset	1263 prog.resolveParam(param, parent, fieldVals, allowConst, False)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1264 param = prog.resolveParam(param, parent, fieldVals, allowConst, isDst)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1265
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1266 if (not type(param) is int) and len(procParams) != len(self.params) - 1:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1267 allParamsConst = False
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1268 procParams.append(param)
2587 e04c7e753bf6 Implement divs and divu in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2581 diff changeset	1269 if prog.needFlagCoalesce:
e04c7e753bf6 Implement divs and divu in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2581 diff changeset	1270 output.append(prog.flags.coalesceFlags(prog, otype))
e04c7e753bf6 Implement divs and divu in new CPU core Michael Pavone <pavone@retrodev.com> parents: 2581 diff changeset	1271 prog.needFlagCoalesce = False
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1272
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1273 if self.op == 'meta':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1274 param,_,index = self.params[1].partition('.')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1275 if index:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1276 index = (parent.resolveLocal(index) or index)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1277 if index in fieldVals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1278 index = str(fieldVals[index])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1279 param = param + '.' + index
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1280 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1281 param = parent.resolveLocal(param) or param
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1282 if param in fieldVals:
1991 7d4df6b74263 Somewhat buggy implementations of shift instructions in new 68K core Michael Pavone <pavone@retrodev.com> parents: 1938 diff changeset	1283 param = fieldVals[param]
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1284 prog.meta[self.params[0]] = param
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1285 elif self.op == 'dis':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1286 #TODO: Disassembler
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1287 pass
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1288 elif not opDef is None:
1716 04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	1289 if opDef.numParams() > len(procParams):
04cafe626118 Better error reporting when an instruction is given an insufficient number of parameters Michael Pavone <pavone@retrodev.com> parents: 1715 diff changeset	1290 raise Exception('Insufficient params for ' + self.op + ' (' + ', '.join(self.params) + ')')
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1291 if opDef.canEval() and allParamsConst:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1292 #do constant folding
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1293 if opDef.numArgs() >= len(procParams):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1294 raise Exception('Insufficient args for ' + self.op + ' (' + ', '.join(self.params) + ')')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1295 dst = self.params[opDef.numArgs()]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1296 result = opDef.evaluate(procParams[:opDef.numArgs()])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1297 while dst in prog.meta:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1298 dst = prog.meta[dst]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1299 maybeLocal = parent.resolveLocal(dst)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1300 if maybeLocal:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1301 dst = maybeLocal
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1302 parent.regValues[dst] = result
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1303 if prog.isReg(dst):
2497 95d9809a3973 Fix constant propagation for sext instruction Michael Pavone <pavone@retrodev.com> parents: 2478 diff changeset	1304 shortProc = (result, procParams[-1])
95d9809a3973 Fix constant propagation for sext instruction Michael Pavone <pavone@retrodev.com> parents: 2478 diff changeset	1305 shortParams = (result, self.params[-1])
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1306 output.append(_opMap['mov'].generate(otype, prog, shortProc, shortParams, None))
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1307 else:
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1308 output.append(opDef.generate(otype, prog, procParams, self.params, flagUpdates))
1728 b0e01e64d76d Implemented RES instruction in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1725 diff changeset	1309 for dstIdx in opDef.outOp:
b0e01e64d76d Implemented RES instruction in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1725 diff changeset	1310 dst = self.params[dstIdx]
b0e01e64d76d Implemented RES instruction in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1725 diff changeset	1311 while dst in prog.meta:
b0e01e64d76d Implemented RES instruction in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1725 diff changeset	1312 dst = prog.meta[dst]
b0e01e64d76d Implemented RES instruction in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1725 diff changeset	1313 if dst in parent.regValues:
b0e01e64d76d Implemented RES instruction in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1725 diff changeset	1314 del parent.regValues[dst]
b0e01e64d76d Implemented RES instruction in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1725 diff changeset	1315
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1316 elif self.op in prog.subroutines:
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1317 procParams = []
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1318 for param in self.params:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1319 begin,sep,end = param.partition('.')
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1320 if sep:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1321 if end in fieldVals:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1322 param = begin + '.' + str(fieldVals[end])
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1323 else:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1324 if param in fieldVals:
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1325 param = fieldVals[param]
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1326 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1327 maybeLocal = parent.resolveLocal(param)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1328 if maybeLocal and maybeLocal in parent.regValues:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1329 param = parent.regValues[maybeLocal]
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	1330 procParams.append(param)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1331 prog.subroutines[self.op].inline(prog, procParams, output, otype, parent)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1332 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1333 output.append('\n\t' + self.op + '(' + ', '.join([str(p) for p in procParams]) + ');')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1334 prog.lastOp = self
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1335
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1336 def processDispatch(self, prog):
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1337 if self.op == 'dispatch' and (len(self.params) == 1 or self.params[1] == 'main'):
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1338 prog.mainDispatch.add(self.params[0])
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1339
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1340 def __str__(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1341 return '\n\t' + self.op + ' ' + ' '.join(self.params)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1342
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1343 #represents a DSL switch construct
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1344 class Switch(ChildBlock):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1345 def __init__(self, parent, param):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1346 self.op = 'switch'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1347 self.parent = parent
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1348 self.param = param
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1349 self.cases = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1350 self.regValues = None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1351 self.current_locals = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1352 self.case_locals = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1353 self.current_case = None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1354 self.default = None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1355 self.default_locals = None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1356
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1357 def addOp(self, op):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1358 if op.op == 'case':
2562 595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	1359 if op.params[0].startswith('0x'):
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	1360 val = int(op.params[0], 16)
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	1361 elif op.params[0].startswith('0b'):
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	1362 val = int(op.params[0], 2)
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	1363 else:
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	1364 val = int(op.params[0])
1619 0e8438a4c76f Clean up warnings from -1 case Michael Pavone <pavone@retrodev.com> parents: 1618 diff changeset	1365 self.cases[val] = self.current_case = []
0e8438a4c76f Clean up warnings from -1 case Michael Pavone <pavone@retrodev.com> parents: 1618 diff changeset	1366 self.case_locals[val] = self.current_locals = {}
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1367 elif op.op == 'default':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1368 self.default = self.current_case = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1369 self.default_locals = self.current_locals = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1370 elif self.current_case == None:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1371 raise ion('Orphan instruction in switch')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1372 elif op.op == 'local':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1373 name = op.params[0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1374 size = op.params[1]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1375 self.current_locals[name] = size
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1376 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1377 self.current_case.append(op)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1378
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1379 def resolveLocal(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1380 if name in self.current_locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1381 return name
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1382 return self.parent.resolveLocal(name)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1383
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1384 def addLocal(self, name, size):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1385 self.current_locals[name] = size
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1386
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1387 def localSize(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1388 if name in self.current_locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1389 return self.current_locals[name]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1390 return self.parent.localSize(name)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1391
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1392 def generate(self, prog, parent, fieldVals, output, otype, flagUpdates):
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1393 prog.pushScope(self)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1394 param = prog.resolveParam(self.param, parent, fieldVals)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1395 if type(param) is int:
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1396 self.regValues = self.parent.regValues
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1397 if param in self.cases:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1398 self.current_locals = self.case_locals[param]
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1399 output.append('\n\t{')
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1400 for local in self.case_locals[param]:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1401 output.append('\n\tuint{0}_t {1};'.format(self.case_locals[param][local], local))
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1402 self.processOps(prog, fieldVals, output, otype, self.cases[param])
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1403 output.append('\n\t}')
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1404 elif self.default:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1405 self.current_locals = self.default_locals
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1406 output.append('\n\t{')
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1407 for local in self.default_locals:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1408 output.append('\n\tuint{0}_t {1};'.format(self.default[local], local))
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1409 self.processOps(prog, fieldVals, output, otype, self.default)
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1410 output.append('\n\t}')
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1411 else:
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1412 oldCond = prog.conditional
2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1413 prog.conditional = True
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1414 output.append('\n\tswitch(' + param + ')')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1415 output.append('\n\t{')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1416 for case in self.cases:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1417 #temp = prog.temp.copy()
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1418 self.current_locals = self.case_locals[case]
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1419 self.regValues = dict(self.parent.regValues)
1619 0e8438a4c76f Clean up warnings from -1 case Michael Pavone <pavone@retrodev.com> parents: 1618 diff changeset	1420 output.append('\n\tcase {0}U: '.format(case) + '{')
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1421 for local in self.case_locals[case]:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1422 output.append('\n\tuint{0}_t {1};'.format(self.case_locals[case][local], local))
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1423 self.processOps(prog, fieldVals, output, otype, self.cases[case])
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1424 output.append('\n\tbreak;')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1425 output.append('\n\t}')
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1426 #prog.temp = temp
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1427 if self.default:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1428 #temp = prog.temp.copy()
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1429 self.current_locals = self.default_locals
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1430 self.regValues = dict(self.parent.regValues)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1431 output.append('\n\tdefault: {')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1432 for local in self.default_locals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1433 output.append('\n\tuint{0}_t {1};'.format(self.default_locals[local], local))
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1434 self.processOps(prog, fieldVals, output, otype, self.default)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1435 #prog.temp = temp
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1436 output.append('\n\t}')
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1437 prog.conditional = oldCond
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1438 prog.popScope()
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1439
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1440 def processDispatch(self, prog):
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1441 for case in self.cases:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1442 for op in self.cases[case]:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1443 op.processDispatch(prog)
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1444 if self.default:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1445 for op in self.default:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1446 op.processDispatch(prog)
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1447
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1448 def __str__(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1449 keys = self.cases.keys()
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1450 keys.sort()
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1451 lines = ['\n\tswitch']
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1452 for case in keys:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1453 lines.append('\n\tcase {0}'.format(case))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1454 lines.append(''.join([str(op) for op in self.cases[case]]))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1455 lines.append('\n\tend')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1456 return ''.join(lines)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1457
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1458
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1459 def _geuCImpl(prog, parent, fieldVals, output):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1460 if prog.lastOp.op == 'cmp':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1461 output.pop()
1616 8c78543c4783 Fix implementation cmp+condition version of if in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1615 diff changeset	1462 params = [prog.resolveParam(p, parent, fieldVals) for p in prog.lastOp.params]
8c78543c4783 Fix implementation cmp+condition version of if in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1615 diff changeset	1463 return '\n\tif ({a} >= {b}) '.format(a=params[1], b = params[0]) + '{'
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1464 else:
1733 1f0a86f5e055 Implemented LDI in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1728 diff changeset	1465 raise Exception(">=U not implemented in the general case yet")
1f0a86f5e055 Implemented LDI in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1728 diff changeset	1466
1f0a86f5e055 Implemented LDI in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1728 diff changeset	1467 def _eqCImpl(prog, parent, fieldVals, output):
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1468 if prog.lastOp.op == 'cmp':
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1469 output.pop()
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1470 params = [prog.resolveParam(p, parent, fieldVals) for p in prog.lastOp.params]
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1471 return '\n\tif ({a} == {b}) '.format(a=params[1], b = params[0]) + '{'
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1472 else:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1473 return '\n\tif (!{a}) {{'.format(a=prog.resolveParam(prog.lastDst, None, {}))
1733 1f0a86f5e055 Implemented LDI in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1728 diff changeset	1474
1f0a86f5e055 Implemented LDI in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1728 diff changeset	1475 def _neqCImpl(prog, parent, fieldVals, output):
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1476 return '\n\tif ({a}) {{'.format(a=prog.resolveParam(prog.lastDst, None, {}))
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1477
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1478 _ifCmpImpl = {
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1479 'c': {
1733 1f0a86f5e055 Implemented LDI in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1728 diff changeset	1480 '>=U': _geuCImpl,
1f0a86f5e055 Implemented LDI in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1728 diff changeset	1481 '=': _eqCImpl,
1f0a86f5e055 Implemented LDI in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1728 diff changeset	1482 '!=': _neqCImpl
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1483 }
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1484 }
2452 8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1485 _ifCmpEval = {
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1486 '>=U': lambda a, b: a >= b,
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1487 '=': lambda a, b: a == b,
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1488 '!=': lambda a, b: a != b
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1489 }
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1490 #represents a DSL conditional construct
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1491 class If(ChildBlock):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1492 def __init__(self, parent, cond):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1493 self.op = 'if'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1494 self.parent = parent
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1495 self.cond = cond
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1496 self.body = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1497 self.elseBody = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1498 self.curBody = self.body
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1499 self.locals = {}
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1500 self.elseLocals = {}
c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1501 self.curLocals = self.locals
c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1502 self.regValues = None
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1503
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1504 def addOp(self, op):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1505 if op.op in ('case', 'arg'):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1506 raise Exception(self.op + ' is not allows inside an if block')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1507 if op.op == 'local':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1508 name = op.params[0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1509 size = op.params[1]
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1510 self.curLocals[name] = size
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1511 elif op.op == 'else':
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1512 self.curLocals = self.elseLocals
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1513 self.curBody = self.elseBody
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1514 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1515 self.curBody.append(op)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1516
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1517 def localSize(self, name):
c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1518 return self.curLocals.get(name)
c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1519
c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1520 def resolveLocal(self, name):
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1521 if name in self.curLocals:
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1522 return name
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1523 return self.parent.resolveLocal(name)
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1524
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1525 def _genTrueBody(self, prog, fieldVals, output, otype):
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1526 self.curLocals = self.locals
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1527 subOut = []
2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1528 self.processOps(prog, fieldVals, subOut, otype, self.body)
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1529 for local in self.locals:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1530 output.append('\n\tuint{sz}_t {nm};'.format(sz=self.locals[local], nm=local))
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1531 output += subOut
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1532
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1533 def _genFalseBody(self, prog, fieldVals, output, otype):
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1534 self.curLocals = self.elseLocals
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1535 subOut = []
2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1536 self.processOps(prog, fieldVals, subOut, otype, self.elseBody)
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1537 for local in self.elseLocals:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1538 output.append('\n\tuint{sz}_t {nm};'.format(sz=self.elseLocals[local], nm=local))
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1539 output += subOut
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1540
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1541 def _genConstParam(self, param, prog, fieldVals, output, otype):
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1542 if param:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1543 self._genTrueBody(prog, fieldVals, output, otype)
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1544 else:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1545 self._genFalseBody(prog, fieldVals, output, otype)
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1546
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1547 def generate(self, prog, parent, fieldVals, output, otype, flagUpdates):
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1548 self.regValues = parent.regValues
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1549 if self.cond in prog.booleans:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1550 self._genConstParam(prog.checkBool(self.cond), prog, fieldVals, output, otype)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1551 else:
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1552 if self.cond in _ifCmpImpl[otype]:
2452 8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1553 if prog.lastOp.op == 'cmp':
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1554 params = [prog.resolveParam(p, parent, fieldVals) for p in prog.lastOp.params]
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1555 if type(params[0]) is int and type(params[1]) is int:
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1556 output.pop()
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1557 res = _ifCmpEval[self.cond](params[1], params[0])
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1558 self._genConstParam(res, prog, fieldVals, output, otype)
8b3daed1c076 Allow more if statements to be constant folded in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2451 diff changeset	1559 return
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1560 oldCond = prog.conditional
2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1561 prog.conditional = True
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1562 #temp = prog.temp.copy()
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1563 output.append(_ifCmpImpl[otype][self.cond](prog, parent, fieldVals, output))
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1564 self._genTrueBody(prog, fieldVals, output, otype)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1565 #prog.temp = temp
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1566 if self.elseBody:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1567 #temp = prog.temp.copy()
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1568 output.append('\n\t} else {')
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1569 self._genFalseBody(prog, fieldVals, output, otype)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1570 #prog.temp = temp
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1571 output.append('\n\t}')
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1572 prog.conditional = oldCond
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1573 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1574 cond = prog.resolveParam(self.cond, parent, fieldVals)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1575 if type(cond) is int:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1576 self._genConstParam(cond, prog, fieldVals, output, otype)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1577 else:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1578 #temp = prog.temp.copy()
1614 c9639139aedf Did some cleanup of SVP code using the newly more powerful DSL if block and fixed some issues in the DSL implementation that cropped up as a result Michael Pavone <pavone@retrodev.com> parents: 1613 diff changeset	1579 output.append('\n\tif ({cond}) '.format(cond=cond) + '{')
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1580 oldCond = prog.conditional
2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1581 prog.conditional = True
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1582 self._genTrueBody(prog, fieldVals, output, otype)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1583 #prog.temp = temp
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1584 if self.elseBody:
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1585 #temp = prog.temp.copy()
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1586 output.append('\n\t} else {')
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1587 self._genFalseBody(prog, fieldVals, output, otype)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1588 #prog.temp = temp
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1589 output.append('\n\t}')
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1590 prog.conditional = oldCond
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1591
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1592
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1593 def processDispatch(self, prog):
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1594 for op in self.body:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1595 op.processDispatch(prog)
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1596 for op in self.elseBody:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1597 op.processDispatch(prog)
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1598
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1599 def __str__(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1600 lines = ['\n\tif']
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1601 for op in self.body:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1602 lines.append(str(op))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1603 lines.append('\n\tend')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1604 return ''.join(lines)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1605
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1606 class Registers:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1607 def __init__(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1608 self.regs = {}
1621 ca158bc091f9 Implement program ROM reads Michael Pavone <pavone@retrodev.com> parents: 1620 diff changeset	1609 self.pointers = {}
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1610 self.regArrays = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1611 self.regToArray = {}
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1612 self.addReg('cycles', 32)
1759 6e4faa10f9ee Store sync_cycle in context rather than in a local in CPU DSL. Fix the timing of a number of instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1754 diff changeset	1613 self.addReg('sync_cycle', 32)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1614
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1615 def addReg(self, name, size):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1616 self.regs[name] = size
1621 ca158bc091f9 Implement program ROM reads Michael Pavone <pavone@retrodev.com> parents: 1620 diff changeset	1617
1750 01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1618 def addPointer(self, name, size, count):
01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1619 self.pointers[name] = (size, count)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1620
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1621 def addRegArray(self, name, size, regs):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1622 self.regArrays[name] = (size, regs)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1623 idx = 0
1615 28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1624 if not type(regs) is int:
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1625 for reg in regs:
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1626 self.regs[reg] = size
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1627 self.regToArray[reg] = (name, idx)
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1628 idx += 1
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1629
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1630 def isReg(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1631 return name in self.regs
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1632
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1633 def isRegArray(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1634 return name in self.regArrays
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1635
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1636 def isRegArrayMember(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1637 return name in self.regToArray
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1638
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1639 def arrayMemberParent(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1640 return self.regToArray[name][0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1641
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1642 def arrayMemberIndex(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1643 return self.regToArray[name][1]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1644
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1645 def arrayMemberName(self, array, index):
1615 28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1646 if type(index) is int and not type(self.regArrays[array][1]) is int:
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1647 return self.regArrays[array][1][index]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1648 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1649 return None
1615 28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1650
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1651 def isNamedArray(self, array):
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1652 return array in self.regArrays and type(self.regArrays[array][1]) is int
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1653
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1654 def processLine(self, parts):
1615 28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1655 if len(parts) == 3:
1750 01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1656 if parts[1].startswith('ptr'):
01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1657 self.addPointer(parts[0], parts[1][3:], int(parts[2]))
01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1658 else:
01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1659 self.addRegArray(parts[0], int(parts[1]), int(parts[2]))
1615 28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	1660 elif len(parts) > 2:
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1661 self.addRegArray(parts[0], int(parts[1]), parts[2:])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1662 else:
1621 ca158bc091f9 Implement program ROM reads Michael Pavone <pavone@retrodev.com> parents: 1620 diff changeset	1663 if parts[1].startswith('ptr'):
1750 01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1664 self.addPointer(parts[0], parts[1][3:], 1)
1621 ca158bc091f9 Implement program ROM reads Michael Pavone <pavone@retrodev.com> parents: 1620 diff changeset	1665 else:
ca158bc091f9 Implement program ROM reads Michael Pavone <pavone@retrodev.com> parents: 1620 diff changeset	1666 self.addReg(parts[0], int(parts[1]))
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1667 return self
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1668
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1669 def writeHeader(self, otype, hFile):
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1670 fieldList = []
1621 ca158bc091f9 Implement program ROM reads Michael Pavone <pavone@retrodev.com> parents: 1620 diff changeset	1671 for pointer in self.pointers:
1735 ca2336469397 Get new Z80 core running in CPM harness Michael Pavone <pavone@retrodev.com> parents: 1734 diff changeset	1672 stars = '*'
1750 01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1673 ptype, count = self.pointers[pointer]
1735 ca2336469397 Get new Z80 core running in CPM harness Michael Pavone <pavone@retrodev.com> parents: 1734 diff changeset	1674 while ptype.startswith('ptr'):
ca2336469397 Get new Z80 core running in CPM harness Michael Pavone <pavone@retrodev.com> parents: 1734 diff changeset	1675 stars += '*'
ca2336469397 Get new Z80 core running in CPM harness Michael Pavone <pavone@retrodev.com> parents: 1734 diff changeset	1676 ptype = ptype[3:]
ca2336469397 Get new Z80 core running in CPM harness Michael Pavone <pavone@retrodev.com> parents: 1734 diff changeset	1677 if ptype.isdigit():
ca2336469397 Get new Z80 core running in CPM harness Michael Pavone <pavone@retrodev.com> parents: 1734 diff changeset	1678 ptype = 'uint{sz}_t'.format(sz=ptype)
1750 01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1679 if count > 1:
01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1680 arr = '[{n}]'.format(n=count)
01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1681 else:
01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1682 arr = ''
01236179fc71 Optimization to memory access in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1749 diff changeset	1683 hFile.write('\n\t{ptype} {stars}{nm}{arr};'.format(nm=pointer, ptype=ptype, stars=stars, arr=arr))
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1684 for reg in self.regs:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1685 if not self.isRegArrayMember(reg):
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1686 fieldList.append((self.regs[reg], 1, reg))
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1687 for arr in self.regArrays:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1688 size,regs = self.regArrays[arr]
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1689 if not type(regs) is int:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1690 regs = len(regs)
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1691 fieldList.append((size, regs, arr))
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1692 fieldList.sort()
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1693 fieldList.reverse()
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1694 for size, count, name in fieldList:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1695 if count > 1:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1696 hFile.write('\n\tuint{sz}_t {nm}[{ct}];'.format(sz=size, nm=name, ct=count))
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1697 else:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1698 hFile.write('\n\tuint{sz}_t {nm};'.format(sz=size, nm=name))
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1699
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1700 class Flags:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1701 def __init__(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1702 self.flagBits = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1703 self.flagCalc = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1704 self.flagStorage = {}
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1705 self.flagOrder = []
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1706 self.flagReg = None
1747 89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	1707 self.storageToFlags = {}
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1708 self.maxBit = -1
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1709
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1710 def processLine(self, parts):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1711 if parts[0] == 'register':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1712 self.flagReg = parts[1]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1713 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1714 flag,bit,calc,storage = parts
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1715 bit,_,top = bit.partition('-')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1716 bit = int(bit)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1717 if top:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1718 top = int(bit)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1719 if top > self.maxBit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1720 self.maxBit = top
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1721 self.flagBits[flag] = (bit,top)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1722 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1723 if bit > self.maxBit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1724 self.maxBit = bit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1725 self.flagBits[flag] = bit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1726 self.flagCalc[flag] = calc
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1727 self.flagStorage[flag] = storage
1747 89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	1728 storage,_,storebit = storage.partition('.')
89ddf41a50bb Optimization of flag calculation for flags that just copy a bit from the result in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1745 diff changeset	1729 self.storageToFlags.setdefault(storage, []).append((storebit, flag))
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1730 self.flagOrder.append(flag)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1731 return self
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1732
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1733 def getStorage(self, flag):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1734 if not flag in self.flagStorage:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1735 raise Exception('Undefined flag ' + flag)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1736 loc,_,bit = self.flagStorage[flag].partition('.')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1737 if bit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1738 return (loc, int(bit))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1739 else:
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1740 return loc
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1741
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1742 def parseFlagUpdate(self, flagString):
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1743 last = ''
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1744 autoUpdate = set()
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1745 explicit = {}
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1746 for c in flagString:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1747 if c.isdigit():
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1748 if last.isalpha():
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1749 num = int(c)
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1750 if num > 1:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1751 raise Exception(c + ' is not a valid digit for update_flags')
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1752 explicit[last] = num
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1753 last = c
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1754 else:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1755 raise Exception('Digit must follow flag letter in update_flags')
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1756 else:
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1757 if last.isalpha():
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1758 autoUpdate.add(last)
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1759 last = c
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1760 if last.isalpha():
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1761 autoUpdate.add(last)
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1762 return (autoUpdate, explicit)
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1763
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1764 def disperseFlags(self, prog, otype):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1765 bitToFlag = [None] * (self.maxBit+1)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1766 src = prog.resolveReg(self.flagReg, None, {})
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1767 output = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1768 for flag in self.flagBits:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1769 bit = self.flagBits[flag]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1770 if type(bit) is tuple:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1771 bot,top = bit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1772 mask = ((1 << (top + 1 - bot)) - 1) << bot
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1773 output.append('\n\t{dst} = {src} & mask;'.format(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1774 dst=prog.resolveReg(self.flagStorage[flag], None, {}), src=src, mask=mask
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1775 ))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1776 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1777 bitToFlag[self.flagBits[flag]] = flag
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1778 multi = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1779 for bit in range(len(bitToFlag)-1,-1,-1):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1780 flag = bitToFlag[bit]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1781 if not flag is None:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1782 field,_,dstbit = self.flagStorage[flag].partition('.')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1783 dst = prog.resolveReg(field, None, {})
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1784 if dstbit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1785 dstbit = int(dstbit)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1786 multi.setdefault(dst, []).append((dstbit, bit))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1787 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1788 output.append('\n\t{dst} = {src} & {mask};'.format(dst=dst, src=src, mask=(1 << bit)))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1789 for dst in multi:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1790 didClear = False
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1791 direct = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1792 for dstbit, bit in multi[dst]:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1793 if dstbit == bit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1794 direct.append(bit)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1795 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1796 if not didClear:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1797 output.append('\n\t{dst} = 0;'.format(dst=dst))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1798 didClear = True
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1799 if dstbit > bit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1800 shift = '<<'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1801 diff = dstbit - bit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1802 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1803 shift = '>>'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1804 diff = bit - dstbit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1805 output.append('\n\t{dst} \|= {src} {shift} {diff} & {mask};'.format(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1806 src=src, dst=dst, shift=shift, diff=diff, mask=(1 << dstbit)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1807 ))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1808 if direct:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1809 if len(direct) == len(multi[dst]):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1810 output.append('\n\t{dst} = {src};'.format(dst=dst, src=src))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1811 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1812 mask = 0
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1813 for bit in direct:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1814 mask = mask \| (1 << bit)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1815 output.append('\n\t{dst} = {src} & {mask};'.format(dst=dst, src=src, mask=mask))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1816 return ''.join(output)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1817
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1818 def coalesceFlags(self, prog, otype):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1819 dst = prog.resolveReg(self.flagReg, None, {})
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1820 output = ['\n\t{dst} = 0;'.format(dst=dst)]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1821 bitToFlag = [None] * (self.maxBit+1)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1822 for flag in self.flagBits:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1823 bit = self.flagBits[flag]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1824 if type(bit) is tuple:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1825 bot,_ = bit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1826 src = prog.resolveReg(self.flagStorage[flag], None, {})
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1827 if bot:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1828 output.append('\n\t{dst} \|= {src} << {shift};'.format(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1829 dst=dst, src = src, shift = bot
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1830 ))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1831 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1832 output.append('\n\t{dst} \|= {src};'.format(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1833 dst=dst, src = src
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1834 ))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1835 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1836 bitToFlag[bit] = flag
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1837 multi = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1838 for bit in range(len(bitToFlag)-1,-1,-1):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1839 flag = bitToFlag[bit]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1840 if not flag is None:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1841 field,_,srcbit = self.flagStorage[flag].partition('.')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1842 src = prog.resolveReg(field, None, {})
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1843 if srcbit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1844 srcbit = int(srcbit)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1845 multi.setdefault(src, []).append((srcbit,bit))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1846 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1847 output.append('\n\tif ({src}) {{\n\t\t{dst} \|= 1 << {bit};\n\t}}'.format(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1848 dst=dst, src=src, bit=bit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1849 ))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1850 for src in multi:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1851 direct = 0
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1852 for srcbit, dstbit in multi[src]:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1853 if srcbit == dstbit:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1854 direct = direct \| (1 << srcbit)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1855 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1856 output.append('\n\tif ({src} & (1 << {srcbit})) {{\n\t\t{dst} \|= 1 << {dstbit};\n\t}}'.format(
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1857 src=src, dst=dst, srcbit=srcbit, dstbit=dstbit
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1858 ))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1859 if direct:
1698 90272218469c Fixed missing semicolon in coalesceFlags Michael Pavone <pavone@retrodev.com> parents: 1697 diff changeset	1860 output.append('\n\t{dst} \|= {src} & {mask};'.format(
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1861 dst=dst, src=src, mask=direct
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1862 ))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1863 return ''.join(output)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1864
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1865
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1866 class Program:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1867 def __init__(self, regs, instructions, subs, info, flags):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1868 self.regs = regs
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1869 self.instructions = instructions
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1870 self.subroutines = subs
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1871 self.meta = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1872 self.booleans = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1873 self.prefix = info.get('prefix', [''])[0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1874 self.opsize = int(info.get('opcode_size', ['8'])[0])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1875 self.extra_tables = info.get('extra_tables', [])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1876 self.context_type = self.prefix + 'context'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1877 self.body = info.get('body', [None])[0]
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1878 self.interrupt = info.get('interrupt', [None])[0]
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1879 self.sync_cycle = info.get('sync_cycle', [None])[0]
1620 a172f97d873f Add the ability for a CPU definition to reference arbitrary C includes and use it to add a placeholder definition of svp_read_16 Michael Pavone <pavone@retrodev.com> parents: 1619 diff changeset	1880 self.includes = info.get('include', [])
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1881 self.flags = flags
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1882 self.lastDst = None
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1883 self.scopes = []
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1884 self.currentScope = None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1885 self.lastOp = None
1704 89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1886 self.carryFlowDst = None
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1887 self.lastA = None
89932fd29abd First stab at carry and half-carry calculation in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1703 diff changeset	1888 self.lastB = None
1708 5bfed2eedc9d Fixed flag calculation for sub instructions in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1707 diff changeset	1889 self.lastBFlow = None
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1890 self.sizeAdjust = None
1737 2207cd2bae14 Fixed some issues involving conditional execution and temporaries/constant folding Michael Pavone <pavone@retrodev.com> parents: 1735 diff changeset	1891 self.conditional = False
1748 48a43dff4dc0 Added init functions to z80_util.c so new Z80 core is closer to a drop in replacement for the old one Michael Pavone <pavone@retrodev.com> parents: 1747 diff changeset	1892 self.declares = []
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	1893 self.lastSize = None
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	1894 self.mainDispatch = set()
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1895
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1896 def __str__(self):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1897 pieces = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1898 for reg in self.regs:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1899 pieces.append(str(self.regs[reg]))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1900 for name in self.subroutines:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1901 pieces.append('\n'+str(self.subroutines[name]))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1902 for instruction in self.instructions:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1903 pieces.append('\n'+str(instruction))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1904 return ''.join(pieces)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1905
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1906 def writeHeader(self, otype, header):
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1907 hFile = open(header, 'w')
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1908 macro = header.upper().replace('.', '_')
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1909 hFile.write('#ifndef {0}_'.format(macro))
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1910 hFile.write('\n#define {0}_'.format(macro))
2500 d44fe974fb85 Get blastem compiling with new 68K core Michael Pavone <pavone@retrodev.com> parents: 2499 diff changeset	1911 hFile.write('\n#include <stdio.h>')
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1912 hFile.write('\n#include "backend.h"')
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1913 hFile.write(f'\n\ntypedef struct {self.prefix}options {self.prefix}options;')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1914 hFile.write(f'\n\ntypedef struct {self.prefix}context {self.prefix}context;')
1748 48a43dff4dc0 Added init functions to z80_util.c so new Z80 core is closer to a drop in replacement for the old one Michael Pavone <pavone@retrodev.com> parents: 1747 diff changeset	1915 for decl in self.declares:
2499 d74d3998482c Make some progress on compiling full emulator with new 68K core Michael Pavone <pavone@retrodev.com> parents: 2497 diff changeset	1916 if decl.startswith('define '):
d74d3998482c Make some progress on compiling full emulator with new 68K core Michael Pavone <pavone@retrodev.com> parents: 2497 diff changeset	1917 decl = '#' + decl
1748 48a43dff4dc0 Added init functions to z80_util.c so new Z80 core is closer to a drop in replacement for the old one Michael Pavone <pavone@retrodev.com> parents: 1747 diff changeset	1918 hFile.write('\n' + decl)
2577 5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1919 hFile.write(f'\n\nstruct {self.prefix}options {{')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1920 hFile.write('\n\tcpu_options gen;')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1921 hFile.write('\n\tFILE* address_log;')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1922 hFile.write('\n};')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1923 hFile.write(f'\n\nstruct {self.prefix}context {{')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1924 hFile.write(f'\n\t{self.prefix}options *opts;')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1925 self.regs.writeHeader(otype, hFile)
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1926 hFile.write('\n};')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1927 hFile.write('\n')
5f725429d08f WIP changes to new CPU core for rotate instructions and to get interrupts more functional Michael Pavone <pavone@retrodev.com> parents: 2562 diff changeset	1928 hFile.write('\nvoid {pre}execute({type} *context, uint32_t target_cycle);'.format(pre = self.prefix, type = self.context_type))
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1929 hFile.write('\n#endif //{0}_'.format(macro))
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1930 hFile.write('\n')
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	1931 hFile.close()
1700 e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1932
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1933 def _buildTable(self, otype, table, body, lateBody):
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1934 pieces = []
1700 e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1935 opmap = [None] * (1 << self.opsize)
e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1936 bodymap = {}
e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1937 if table in self.instructions:
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1938 instructions = self.instructions[table]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1939 instructions.sort()
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1940 for inst in instructions:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1941 for val in inst.allValues():
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1942 if opmap[val] is None:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1943 self.meta = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1944 self.temp = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1945 self.needFlagCoalesce = False
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1946 self.needFlagDisperse = False
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	1947 self.lastOp = None
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1948 name = inst.generateName(val)
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1949 opmap[val] = name
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1950 if not name in bodymap:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1951 bodymap[name] = inst.generateBody(val, self, otype)
1700 e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1952
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1953 alreadyAppended = set()
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1954 if self.dispatch == 'call':
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	1955 lateBody.append('\nstatic impl_fun impl_{name}[{sz}] = {{'.format(name = table, sz=len(opmap)))
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1956 for inst in range(0, len(opmap)):
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1957 op = opmap[inst]
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1958 if op is None:
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	1959 lateBody.append('\n\tunimplemented,')
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1960 else:
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	1961 lateBody.append('\n\t' + op + ',')
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1962 if not op in alreadyAppended:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1963 body.append(bodymap[op])
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1964 alreadyAppended.add(op)
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	1965 lateBody.append('\n};')
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1966 elif self.dispatch == 'goto':
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1967 body.append('\n\tstatic void *impl_{name}[{sz}] = {{'.format(name = table, sz=len(opmap)))
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1968 for inst in range(0, len(opmap)):
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1969 op = opmap[inst]
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1970 if op is None:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1971 body.append('\n\t\t&&unimplemented,')
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1972 else:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1973 body.append('\n\t\t&&' + op + ',')
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1974 if not op in alreadyAppended:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	1975 lateBody.append(bodymap[op])
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1976 body.append('\n\t};')
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1977 else:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1978 raise Exception("unimplmeneted dispatch type " + self.dispatch)
1700 e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1979 body.extend(pieces)
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1980
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1981 def nextInstruction(self, otype):
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1982 output = []
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1983 if self.dispatch == 'goto':
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1984 if self.interrupt in self.subroutines:
1759 6e4faa10f9ee Store sync_cycle in context rather than in a local in CPU DSL. Fix the timing of a number of instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1754 diff changeset	1985 output.append('\n\tif (context->cycles >= context->sync_cycle) {')
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1986 output.append('\n\tif (context->cycles >= target_cycle) { return; }')
1752 d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1987 if self.interrupt in self.subroutines:
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1988 self.meta = {}
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1989 self.temp = {}
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1990 self.subroutines[self.interrupt].inline(self, [], output, otype, None)
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1991 output.append('\n\t}')
d6d4c006a7b3 Initial attempt at interrupts in new Z80 core and integrating it into main executable Michael Pavone <pavone@retrodev.com> parents: 1750 diff changeset	1992
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1993 self.meta = {}
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1994 self.temp = {}
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1995 self.subroutines[self.body].inline(self, [], output, otype, None)
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	1996 return output
1700 e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1997
e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1998 def build(self, otype):
e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	1999 body = []
e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	2000 pieces = []
e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	2001 for include in self.includes:
e4b4e21a37fa Output tables in order specified by the extra_tables field so the user can deal with dependencies between tables Michael Pavone <pavone@retrodev.com> parents: 1699 diff changeset	2002 body.append('#include "{0}"\n'.format(include))
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2003 if self.dispatch == 'call':
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2004 body.append('\ntypedef void (impl_fun)({pre}context context, uint32_t target_cycle);'.format(pre=self.prefix))
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2005 for table in self.extra_tables:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2006 body.append('\nstatic impl_fun impl_{name}[{sz}];'.format(name = table, sz=(1 << self.opsize)))
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2007 body.append('\nstatic impl_fun impl_main[{sz}];'.format(sz=(1 << self.opsize)))
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2008 elif self.dispatch == 'goto':
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2009 body.append('\nvoid {pre}execute({type} *context, uint32_t target_cycle)'.format(pre = self.prefix, type = self.context_type))
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2010 body.append('\n{')
2591 563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	2011
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	2012 for table in self.instructions:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	2013 for inst in self.instructions[table]:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	2014 inst.processDispatch(self)
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	2015 for sub in self.subroutines:
563d05355a12 Cut down on code bloat in 68K core a little Michael Pavone <pavone@retrodev.com> parents: 2589 diff changeset	2016 self.subroutines[sub].processDispatch(self)
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2017
1740 28ab56ff8cea Implement DD/FD prefixes for instructions that don't reference HL Michael Pavone <pavone@retrodev.com> parents: 1737 diff changeset	2018 for table in self.extra_tables:
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2019 self._buildTable(otype, table, body, pieces)
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2020 self._buildTable(otype, 'main', body, pieces)
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2021 if self.dispatch == 'call':
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2022 if self.body in self.subroutines:
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2023 pieces.append('\nvoid {pre}execute({type} *context, uint32_t target_cycle)'.format(pre = self.prefix, type = self.context_type))
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2024 pieces.append('\n{')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2025 pieces.append('\n\t{sync}(context, target_cycle);'.format(sync=self.sync_cycle))
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2026 pieces.append('\n\twhile (context->cycles < target_cycle)')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2027 pieces.append('\n\t{')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2028 if self.interrupt in self.subroutines:
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2029 pieces.append('\n\t\tif (context->cycles >= context->sync_cycle) {')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2030 pieces.append(f'\n\t\t\t{self.sync_cycle}(context, target_cycle);')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2031 pieces.append('\n\t\t}')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2032 self.meta = {}
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2033 self.temp = {}
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2034 intpieces = []
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2035 self.subroutines[self.interrupt].inline(self, [], intpieces, otype, None)
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2036 for size in self.temp:
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2037 pieces.append('\n\tuint{sz}_t gen_tmp{sz}__;'.format(sz=size))
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2038 pieces += intpieces
1883 9ab5184811ea Implement interrupts in call dispatch mode in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1838 diff changeset	2039 self.meta = {}
9ab5184811ea Implement interrupts in call dispatch mode in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1838 diff changeset	2040 self.temp = {}
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2041 self.subroutines[self.body].inline(self, [], pieces, otype, None)
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2042 pieces.append('\n\t}')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2043 pieces.append('\n}')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2044 body.append('\nstatic void unimplemented({pre}context *context, uint32_t target_cycle)'.format(pre = self.prefix))
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2045 body.append('\n{')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2046 if len(self.mainDispatch) == 1:
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2047 dispatch = list(self.mainDispatch)[0]
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2048 body.append(f'\n\tfatal_error("Unimplemented instruction: %X\\n", {dispatch});')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2049 else:
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2050 body.append('\n\tfatal_error("Unimplemented instruction\\n");')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2051 body.append('\n}\n')
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2052 elif self.dispatch == 'goto':
1759 6e4faa10f9ee Store sync_cycle in context rather than in a local in CPU DSL. Fix the timing of a number of instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1754 diff changeset	2053 body.append('\n\t{sync}(context, target_cycle);'.format(sync=self.sync_cycle))
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2054 body += self.nextInstruction(otype)
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2055 pieces.append('\nunimplemented:')
2581 9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2056 if len(self.mainDispatch) == 1:
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2057 dispatch = list(self.mainDispatch)[0]
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2058 body.append(f'\n\tfatal_error("Unimplemented instruction: %X\\n", {dispatch});')
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2059 else:
9e10149c9e10 Better unimplemented instruction error message in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 2580 diff changeset	2060 body.append('\n\tfatal_error("Unimplemented instruction\\n");')
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2061 pieces.append('\n}')
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2062 return ''.join(body) + ''.join(pieces)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2063
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2064 def checkBool(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2065 if not name in self.booleans:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2066 raise Exception(name + ' is not a defined boolean flag')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2067 return self.booleans[name]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2068
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2069 def getTemp(self, size):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2070 if size in self.temp:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2071 return ('', self.temp[size])
1742 6290c88949bd Fixed CPI/CPD/CPIR/CPDR in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1740 diff changeset	2072 self.temp[size] = 'gen_tmp{sz}__'.format(sz=size);
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2073 return ('', self.temp[size])
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2074
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2075 def resolveParam(self, param, parent, fieldVals, allowConstant=True, isdst=False):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2076 keepGoing = True
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2077 while keepGoing:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2078 keepGoing = False
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2079 try:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2080 if type(param) is int:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2081 pass
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2082 elif param.startswith('0x'):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2083 param = int(param, 16)
2562 595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	2084 elif param.startswith('0b'):
595719fe69f2 Implement exg, muls and mulu in new 68K core Michael Pavone <pavone@retrodev.com> parents: 2502 diff changeset	2085 param = int(param, 2)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2086 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2087 param = int(param)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2088 except ValueError:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2089
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2090 if parent:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2091 if param in parent.regValues and allowConstant:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2092 return parent.regValues[param]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2093 maybeLocal = parent.resolveLocal(param)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2094 if maybeLocal:
1715 4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2095 if isdst:
4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2096 self.lastDst = param
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2097 self.lastSize = None
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2098 return maybeLocal
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2099 if param in fieldVals:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2100 param = fieldVals[param]
1721 0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	2101 fieldVals = {}
0e5df2bc0f9f Implementation of some of the rotate instructions in new Z80 core Michael Pavone <pavone@retrodev.com> parents: 1719 diff changeset	2102 keepGoing = True
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2103 elif param in self.meta:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2104 param = self.meta[param]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2105 keepGoing = True
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2106 elif self.isReg(param):
1715 4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2107 return self.resolveReg(param, parent, fieldVals, isdst)
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2108 elif param in self.regs.pointers:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2109 return 'context->' + param
1715 4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2110 if isdst:
4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2111 self.lastDst = param
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2112 self.lastSize = None
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2113 return param
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2114
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2115 def isReg(self, name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2116 if not type(name) is str:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2117 return False
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2118 begin,sep,_ = name.partition('.')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2119 if sep:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2120 if begin in self.meta:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2121 begin = self.meta[begin]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2122 return self.regs.isRegArray(begin)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2123 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2124 return self.regs.isReg(name)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2125
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2126 def resolveReg(self, name, parent, fieldVals, isDst=False):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2127 begin,sep,end = name.partition('.')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2128 if sep:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2129 if begin in self.meta:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2130 begin = self.meta[begin]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2131 if not self.regs.isRegArrayMember(end):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2132 end = self.resolveParam(end, parent, fieldVals)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2133 if not type(end) is int and self.regs.isRegArrayMember(end):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2134 arrayName = self.regs.arrayMemberParent(end)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2135 end = self.regs.arrayMemberIndex(end)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2136 if arrayName != begin:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2137 end = 'context->{0}[{1}]'.format(arrayName, end)
1615 28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	2138 if self.regs.isNamedArray(begin):
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	2139 regName = self.regs.arrayMemberName(begin, end)
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	2140 else:
28f80d1b343e Support immediate operands for ld and alu ops in SVP. Support double indirect and immediate address modes for alu ops. Fixed DSL issues revealed by those changes Michael Pavone <pavone@retrodev.com> parents: 1614 diff changeset	2141 regName = '{0}.{1}'.format(begin, end)
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2142 ret = 'context->{0}[{1}]'.format(begin, end)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2143 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2144 regName = name
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2145 if self.regs.isRegArrayMember(name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2146 arr,idx = self.regs.regToArray[name]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2147 ret = 'context->{0}[{1}]'.format(arr, idx)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2148 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2149 ret = 'context->' + name
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2150 if regName == self.flags.flagReg:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2151 if isDst:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2152 self.needFlagDisperse = True
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2153 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2154 self.needFlagCoalesce = True
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2155 if isDst:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2156 self.lastDst = regName
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2157 return ret
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2158
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2159
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2160
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2161 def paramSize(self, name):
1715 4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2162 if name in self.meta:
4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2163 return self.paramSize(self.meta[name])
4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2164 for i in range(len(self.scopes) -1, -1, -1):
4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2165 size = self.scopes[i].localSize(name)
4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2166 if size:
4fd84c3efc72 Implement 16-bit addition in new Z80 core along with necessary CPU DSL fixes to make them work right Michael Pavone <pavone@retrodev.com> parents: 1713 diff changeset	2167 return size
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2168 begin,sep,_ = name.partition('.')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2169 if sep and self.regs.isRegArray(begin):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2170 return self.regs.regArrays[begin][0]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2171 if self.regs.isReg(name):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2172 return self.regs.regs[name]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2173 return 32
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2174
1838 0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2175 def getLastSize(self):
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2176 if self.lastSize:
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2177 return self.lastSize
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2178 return self.paramSize(self.lastDst)
0c1491818f4b WIP new 68K core using CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1765 diff changeset	2179
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2180 def pushScope(self, scope):
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2181 self.scopes.append(scope)
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2182 self.currentScope = scope
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2183
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2184 def popScope(self):
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2185 ret = self.scopes.pop()
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2186 self.currentScope = self.scopes[-1] if self.scopes else None
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2187 return ret
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2188
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2189 def getRootScope(self):
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2190 return self.scopes[0]
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2191
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2192 def parse(args):
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2193 f = args.source
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2194 instructions = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2195 subroutines = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2196 registers = None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2197 flags = None
1748 48a43dff4dc0 Added init functions to z80_util.c so new Z80 core is closer to a drop in replacement for the old one Michael Pavone <pavone@retrodev.com> parents: 1747 diff changeset	2198 declares = []
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2199 errors = []
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2200 info = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2201 line_num = 0
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2202 cur_object = None
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2203 for line in f:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2204 line_num += 1
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2205 line,_,comment = line.partition('#')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2206 if not line.strip():
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2207 continue
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2208 if line[0].isspace():
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2209 if not cur_object is None:
1754 043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2210 sep = True
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2211 parts = []
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2212 while sep:
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2213 before,sep,after = line.partition('"')
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2214 before = before.strip()
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2215 if before:
2440 338c78da3fff Added a little syntax sugar to CPU DSL and started updating new Z80 core to use it Michael Pavone <pavone@retrodev.com> parents: 1991 diff changeset	2216 parts += [el.strip() for el in before.split(' ') if el.strip()]
1754 043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2217 if sep:
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2218 #TODO: deal with escaped quotes
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2219 inside,sep,after = after.partition('"')
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2220 parts.append('"' + inside + '"')
043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2221 line = after
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2222 if type(cur_object) is dict:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2223 cur_object[parts[0]] = parts[1:]
1748 48a43dff4dc0 Added init functions to z80_util.c so new Z80 core is closer to a drop in replacement for the old one Michael Pavone <pavone@retrodev.com> parents: 1747 diff changeset	2224 elif type(cur_object) is list:
1754 043cf458704c Basic support for string operands in CPU DSL Michael Pavone <pavone@retrodev.com> parents: 1753 diff changeset	2225 cur_object.append(' '.join(parts))
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2226 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2227 cur_object = cur_object.processLine(parts)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2228
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2229 # if type(cur_object) is Registers:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2230 # if len(parts) > 2:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2231 # cur_object.addRegArray(parts[0], int(parts[1]), parts[2:])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2232 # else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2233 # cur_object.addReg(parts[0], int(parts[1]))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2234 # elif type(cur_object) is dict:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2235 # cur_object[parts[0]] = parts[1:]
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2236 # elif parts[0] == 'switch':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2237 # o = Switch(cur_object, parts[1])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2238 # cur_object.addOp(o)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2239 # cur_object = o
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2240 # elif parts[0] == 'if':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2241 # o = If(cur_object, parts[1])
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2242 # cur_object.addOp(o)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2243 # cur_object = o
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2244 # elif parts[0] == 'end':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2245 # cur_object = cur_object.parent
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2246 # else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2247 # cur_object.addOp(NormalOp(parts))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2248 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2249 errors.append("Orphan instruction on line {0}".format(line_num))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2250 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2251 parts = line.split(' ')
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2252 if len(parts) > 1:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2253 if len(parts) > 2:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2254 table,bitpattern,name = parts
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2255 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2256 bitpattern,name = parts
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2257 table = 'main'
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2258 value = 0
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2259 fields = {}
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2260 curbit = len(bitpattern) - 1
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2261 for char in bitpattern:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2262 value <<= 1
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2263 if char in ('0', '1'):
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2264 value \|= int(char)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2265 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2266 if char in fields:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2267 fields[char] = (curbit, fields[char][1] + 1)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2268 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2269 fields[char] = (curbit, 1)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2270 curbit -= 1
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2271 cur_object = Instruction(value, fields, name.strip())
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2272 instructions.setdefault(table, []).append(cur_object)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2273 elif line.strip() == 'regs':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2274 if registers is None:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2275 registers = Registers()
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2276 cur_object = registers
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2277 elif line.strip() == 'info':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2278 cur_object = info
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2279 elif line.strip() == 'flags':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2280 if flags is None:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2281 flags = Flags()
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2282 cur_object = flags
1748 48a43dff4dc0 Added init functions to z80_util.c so new Z80 core is closer to a drop in replacement for the old one Michael Pavone <pavone@retrodev.com> parents: 1747 diff changeset	2283 elif line.strip() == 'declare':
48a43dff4dc0 Added init functions to z80_util.c so new Z80 core is closer to a drop in replacement for the old one Michael Pavone <pavone@retrodev.com> parents: 1747 diff changeset	2284 cur_object = declares
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2285 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2286 cur_object = SubRoutine(line.strip())
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2287 subroutines[cur_object.name] = cur_object
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2288 if errors:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2289 print(errors)
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2290 else:
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2291 p = Program(registers, instructions, subroutines, info, flags)
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2292 p.dispatch = args.dispatch
1748 48a43dff4dc0 Added init functions to z80_util.c so new Z80 core is closer to a drop in replacement for the old one Michael Pavone <pavone@retrodev.com> parents: 1747 diff changeset	2293 p.declares = declares
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2294 p.booleans['dynarec'] = False
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2295 p.booleans['interp'] = True
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2296 if args.define:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2297 for define in args.define:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2298 name,sep,val = define.partition('=')
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2299 name = name.strip()
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2300 val = val.strip()
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2301 if sep:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2302 p.booleans[name] = bool(val)
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2303 else:
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2304 p.booleans[name] = True
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2305
1618 5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2306 if 'header' in info:
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2307 print('#include "{0}"'.format(info['header'][0]))
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2308 p.writeHeader('c', info['header'][0])
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2309 print('#include "util.h"')
5dbc453cd345 Getting SVP core closer to compiling Michael Pavone <pavone@retrodev.com> parents: 1616 diff changeset	2310 print('#include <stdlib.h>')
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2311 print(p.build('c'))
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2312
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2313 def main(argv):
1749 e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2314 from argparse import ArgumentParser, FileType
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2315 argParser = ArgumentParser(description='CPU emulator DSL compiler')
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2316 argParser.add_argument('source', type=FileType('r'))
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2317 argParser.add_argument('-D', '--define', action='append')
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2318 argParser.add_argument('-d', '--dispatch', choices=('call', 'switch', 'goto'), default='call')
e4fe5a450d05 Added option to CPU DSL to produce a threaded interpreter using computed goto Michael Pavone <pavone@retrodev.com> parents: 1748 diff changeset	2319 parse(argParser.parse_args(argv[1:]))
1613 2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2320
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2321 if __name__ == '__main__':
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2322 from sys import argv
2d9e8a7b8ba2 Initial commit of CPU DSL and a WIP SVP implementation written in that DSL Michael Pavone <pavone@retrodev.com> parents: diff changeset	2323 main(argv)

Mercurial > repos > blastem

annotate cpu_dsl.py @ 2591:563d05355a12