mirror of https://github.com/g012/l65.git
639 lines
20 KiB
Lua
639 lines
20 KiB
Lua
M = require "asm"
|
|
|
|
local op_eval_byte = function(late, early) return M.byte_normalize(M.op_eval(late, early)) end
|
|
M.op_eval_byte = op_eval_byte
|
|
|
|
local op_eval_word = function(late, early) return M.word_normalize(M.op_eval(late, early)) end
|
|
M.op_eval_word = op_eval_word
|
|
|
|
local opimp={
|
|
block=M.op(0x31,13),
|
|
calb=M.op(0x63,13),
|
|
daa=M.op(0x61,4),
|
|
ex=M.op(0x10,4),
|
|
exx=M.op(0x11,4),
|
|
halt=M.op(0x01,6),
|
|
jb=M.op(0x73,4),
|
|
nop=M.op(0x00,4),
|
|
ret=M.op(0x08,11),
|
|
reti=M.op(0x62,15),
|
|
rets=M.op(0x18,11),
|
|
sio=M.op(0x09,4),
|
|
softi=M.op(0x72,19),
|
|
stm=M.op(0x19,4),
|
|
['table']=M.op(0x21,19)
|
|
} M.opimp = opimp
|
|
for k,v in pairs(opimp) do
|
|
M[k .. 'imp' ] = function()
|
|
table.insert(M.section_current.instructions, { size=1, cycles=v.cycles, bin=v.opc })
|
|
end
|
|
end
|
|
|
|
local opa={
|
|
dcr=M.op(0x51,4),
|
|
inr=M.op(0x41,4),
|
|
} M.opa = opa
|
|
for k,v in pairs(opa) do
|
|
M[k .. 'a'] = function()
|
|
table.insert(M.section_current.instructions, { size=1, cycles=v.cycles, bin=v.opc })
|
|
end
|
|
end
|
|
|
|
local opb={
|
|
dcr=M.op(0x52,4),
|
|
inr=M.op(0x42,4),
|
|
} M.opb = opb
|
|
for k,v in pairs(opb) do
|
|
M[k .. 'b'] = function()
|
|
table.insert(M.section_current.instructions, { size=1, cycles=v.cycles, bin=v.opc })
|
|
end
|
|
end
|
|
|
|
local opc={
|
|
dcr=M.op(0x53,4),
|
|
inr=M.op(0x43,4),
|
|
} M.opc = opc
|
|
for k,v in pairs(opc) do
|
|
M[k .. 'c'] = function()
|
|
table.insert(M.section_current.instructions, { size=1, cycles=v.cycles, bin=v.opc })
|
|
end
|
|
end
|
|
|
|
local opsp={
|
|
dcx=M.op(0x03,7),
|
|
inx=M.op(0x02,7)
|
|
} M.opsp = opsp
|
|
for k,v in pairs(opsp) do
|
|
M[k .. 'sp'] = function()
|
|
table.insert(M.section_current.instructions, { size=1, cycles=v.cycles, bin=v.opc })
|
|
end
|
|
end
|
|
|
|
local opr16={
|
|
dcxbc=M.op(0x13,7),
|
|
dcxde=M.op(0x23,7),
|
|
dcxhl=M.op(0x33,7),
|
|
inxbc=M.op(0x12,7),
|
|
inxde=M.op(0x22,7),
|
|
inxhl=M.op(0x32,7),
|
|
ldaxbc=M.op(0x29,7),
|
|
ldaxdde=M.op(0x2e,7),
|
|
ldaxde=M.op(0x2a,7),
|
|
ldaxhl=M.op(0x2b,7),
|
|
ldaxide=M.op(0x2c,7),
|
|
ldaxdhl=M.op(0x2f,7),
|
|
ldaxihl=M.op(0x2d,7),
|
|
staxbc=M.op(0x39,7),
|
|
staxde=M.op(0x3a,7),
|
|
staxdde=M.op(0x3e,7),
|
|
staxdhl=M.op(0x3f,7),
|
|
staxhl=M.op(0x3b,7),
|
|
staxide=M.op(0x3c,7),
|
|
staxihl=M.op(0x3d,7),
|
|
} M.opr16 = opr16
|
|
for k,v in pairs(opr16) do
|
|
M[k] = function()
|
|
table.insert(M.section_current.instructions, { size=1, cycles=v.cycles, bin=v.opc })
|
|
end
|
|
end
|
|
|
|
local opregxx ={
|
|
mvib=M.op(0x6a,7),
|
|
mvic=M.op(0x6b,7),
|
|
mvid=M.op(0x6c,7),
|
|
mvie=M.op(0x6d,7),
|
|
mvih=M.op(0x6e,7),
|
|
mvil=M.op(0x6f,7),
|
|
mviv=M.op(0x68,7),
|
|
mvixbc=M.op(0x49,10),
|
|
mvixde=M.op(0x4a,10),
|
|
mvixhl=M.op(0x4b,10),
|
|
} M.opregxx = opregxx
|
|
for k,v in pairs(opregxx) do
|
|
M[k] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 2 end
|
|
local bin = function() local l7801dbg=l7801dbg return { v.opc, M.op_eval_byte(late,early) } end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
local opaxx ={
|
|
aci=M.op(0x56,7),
|
|
adi=M.op(0x46,7),
|
|
adinc=M.op(0x26,7),
|
|
ani=M.op(0x07,7),
|
|
eqi=M.op(0x77,7),
|
|
gti=M.op(0x27,7),
|
|
lti=M.op(0x37,7),
|
|
mvi=M.op(0x69,7),
|
|
nei=M.op(0x67,7),
|
|
offi=M.op(0x57,7),
|
|
oni=M.op(0x47,7),
|
|
ori=M.op(0x17,7),
|
|
sbi=M.op(0x76,7),
|
|
sui=M.op(0x66,7),
|
|
suinb=M.op(0x36,7),
|
|
xri=M.op(0x16,7)
|
|
} M.opaxx = opaxx
|
|
for k,v in pairs(opaxx) do
|
|
M[k .. 'a'] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 2 end
|
|
local bin = function() local l7801dbg=l7801dbg return { v.opc, M.op_eval_byte(late,early) } end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
local opr8r8 ={
|
|
movab=M.op(0x0a,4), movac=M.op(0x0b,4),
|
|
movad=M.op(0x0c,4), movae=M.op(0x0d,4),
|
|
movah=M.op(0x0e,4), moval=M.op(0x0f,4),
|
|
movba=M.op(0x1a,4), movca=M.op(0x1b,4),
|
|
movda=M.op(0x1c,4), movea=M.op(0x1d,4),
|
|
movha=M.op(0x1e,4), movla=M.op(0x1f,4),
|
|
} M.opr8r8 = opr8r8
|
|
for k,v in pairs(opr8r8) do
|
|
M[k] = function()
|
|
table.insert(M.section_current.instructions, { size=1, cycles=v.cycles, bin=v.opc })
|
|
end
|
|
end
|
|
|
|
local opw = {
|
|
call=M.op(0x44,16),
|
|
jmp=M.op(0x54,10),
|
|
} M.opw = opw
|
|
for k,v in pairs(opw) do
|
|
M[k .. 'imm'] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 3 end
|
|
local bin = function() local l7801dbg=l7801dbg
|
|
local x = M.op_eval_word(late,early)
|
|
return { v.opc, x&0xff, x>>8 }
|
|
end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
local opr16w = {
|
|
lxisp=M.op(0x04,10),
|
|
lxibc=M.op(0x14,10),
|
|
lxide=M.op(0x24,10),
|
|
lxihl=M.op(0x34,10)
|
|
} M.opr16w = opr16w
|
|
for k,v in pairs(opr16w) do
|
|
M[k] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 3 end
|
|
local bin = function() local l7801dbg=l7801dbg
|
|
local x = M.op_eval_word(late,early)
|
|
return { v.opc, x&0xff, x>>8 }
|
|
end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
|
|
M['calt' .. 'imm'] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local op = { cycles=19 }
|
|
op.size = function() late,early = M.size_op(late,early) return 1 end
|
|
op.bin = function()
|
|
local l7801dbg=l7801dbg
|
|
local x = M.op_eval_byte(late,early)
|
|
if (x%2 == 1) then error("offset should be even : " .. x) end
|
|
if x < 0x80 or x > 0xfe then error("offset out of range : " .. x) end
|
|
x = (x>>1) + 0x40
|
|
return x
|
|
end
|
|
table.insert(M.section_current.instructions, op)
|
|
end
|
|
|
|
M['calf' .. 'imm'] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local op = { cycles=16 }
|
|
op.size = function() late,early = M.size_op(late,early) return 2 end
|
|
op.bin = function() local l7801dbg=l7801dbg
|
|
local x = 0 + M.op_eval_word(late,early)
|
|
if x < 0x0800 or x > 0xffff then error("subroutine address out of range [0x0800-0xffff]: " .. x) end
|
|
x = x - 0x0800;
|
|
return { 0x78 | ((x>>8) & 0x07), x&0xff }
|
|
end
|
|
table.insert(M.section_current.instructions, op)
|
|
end
|
|
|
|
M.jr = function(label)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local parent,offset = M.label_current
|
|
local section,rorg = M.section_current,M.location_current.rorg
|
|
local op = { cycles=13 }
|
|
op.size = function()
|
|
offset = section.size
|
|
label = M.size_dc(label)
|
|
return 1
|
|
end
|
|
op.bin = function()
|
|
local l7801dbg=l7801dbg
|
|
local x,l = label,label
|
|
if type(x) == 'function' then x=x() end
|
|
if type(x) == 'string' then
|
|
if x:sub(1,1) == '_' then x=parent..x l=x end
|
|
x = symbols[x]
|
|
end
|
|
if type(x) ~= 'number' then error("unresolved branch target: " .. tostring(x)) end
|
|
x = x-1 - offset - rorg(section.org)
|
|
if x < -32 or x > 32 then error("branch target out of range for " .. l .. ": " .. x)
|
|
elseif x >= 0 then
|
|
x = 0xc0 + x
|
|
return x
|
|
else
|
|
return x & 0xff
|
|
end
|
|
end
|
|
table.insert(M.section_current.instructions, op)
|
|
end
|
|
|
|
M.jre = function(label)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local parent,offset = M.label_current
|
|
local section,rorg = M.section_current,M.location_current.rorg
|
|
local op = { cycles=17 }
|
|
op.size = function()
|
|
offset = section.size
|
|
label = M.size_dc(label)
|
|
return 2
|
|
end
|
|
op.bin = function()
|
|
local l7801dbg=l7801dbg
|
|
local x,l = label,label
|
|
if type(x) == 'function' then x=x() end
|
|
if type(x) == 'string' then
|
|
if x:sub(1,1) == '_' then x=parent..x l=x end
|
|
x = symbols[x]
|
|
end
|
|
if type(x) ~= 'number' then error("unresolved branch target: " .. tostring(x)) end
|
|
x = x-2 - offset - rorg(section.org)
|
|
if x < -128 or x > 127 then error("branch target out of range for " .. l .. ": " .. x) end
|
|
local opcode = x >= 0 and 0x4e or 0x4f
|
|
return { opcode, x&0xff }
|
|
end
|
|
table.insert(M.section_current.instructions, op)
|
|
end
|
|
|
|
local opwa = {
|
|
inrw=M.op(0x20,13),
|
|
ldaw=M.op(0x28,10),
|
|
dcrw=M.op(0x30,13),
|
|
staw=M.op(0x38,10),
|
|
bit0=M.op(0x58,10),
|
|
bit1=M.op(0x59,10),
|
|
bit2=M.op(0x5a,10),
|
|
bit3=M.op(0x5b,10),
|
|
bit4=M.op(0x5c,10),
|
|
bit5=M.op(0x5d,10),
|
|
bit6=M.op(0x5e,10),
|
|
bit7=M.op(0x5f,10)
|
|
} M.opwa = opwa
|
|
for k,v in pairs(opwa) do
|
|
M[k .. 'wa'] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 2 end
|
|
local bin = function() local l7801dbg=l7801dbg return { v.opc, M.op_eval_byte(late,early) } end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
local opwaxx = {
|
|
mviw=M.op(0x71,3,13),
|
|
eqiw=M.op(0x75,3,13),
|
|
} M.opwaxx = opwaxx
|
|
for k,v in pairs(opwaxx) do
|
|
M[k .. 'waxx'] = function(late_offset, late_data, early_offset, early_data)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function()
|
|
late_offset,early_offset = M.size_op(late_offset,early_offset)
|
|
late_data,early_data = M.size_op(late_data,early_data)
|
|
return 3
|
|
end
|
|
local bin = function()
|
|
local l7801dbg=l7801dbg
|
|
return { v.opc, M.op_eval_byte(late_offset,early_offset), M.op_eval_byte(late_data,early_data) }
|
|
end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
local op48imp = {
|
|
ei=M.op(0x20,8),
|
|
di=M.op(0x24,8),
|
|
clc=M.op(0x2a,8),
|
|
pen=M.op(0x2c,11),
|
|
per=M.op(0x3c,11),
|
|
pex=M.op(0x2d,11),
|
|
rld=M.op(0x38,17),
|
|
rrd=M.op(0x39,17),
|
|
skc=M.op(0x0a,8),
|
|
skz=M.op(0x0c,8),
|
|
sknc=M.op(0x1a,8),
|
|
sknz=M.op(0x1c,8),
|
|
stc=M.op(0x2b,8),
|
|
} M.op48imp = op48imp
|
|
for k,v in pairs(op48imp) do
|
|
M[k .. 'imp'] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, bin={ 0x48, v.opc } })
|
|
end
|
|
end
|
|
|
|
local op48r8={
|
|
rlla=M.op(0x30,8),
|
|
rlra=M.op(0x31,8),
|
|
rllc=M.op(0x32,8),
|
|
rlrc=M.op(0x33,8),
|
|
slla=M.op(0x34,8),
|
|
slra=M.op(0x35,8),
|
|
sllc=M.op(0x36,8),
|
|
slrc=M.op(0x37,8),
|
|
} M.op48r8 = op48r8
|
|
for k,v in pairs(op48r8) do
|
|
M[k] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, bin={ 0x48, v.opc } })
|
|
end
|
|
end
|
|
|
|
local op48r16={
|
|
pushbc=M.op(0x1e,17),
|
|
pushde=M.op(0x2e,17),
|
|
pushhl=M.op(0x3e,17),
|
|
pushva=M.op(0x0e,17),
|
|
popbc=M.op(0x1f,15),
|
|
popde=M.op(0x2f,15),
|
|
pophl=M.op(0x3f,15),
|
|
popva=M.op(0x0f,15),
|
|
} M.op48r16 = op48r16
|
|
for k,v in pairs(op48r16) do
|
|
M[k] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, bin={ 0x48, v.opc } })
|
|
end
|
|
end
|
|
|
|
local op48int={
|
|
skitf0=M.op(0x00,8),
|
|
skitft=M.op(0x01,8),
|
|
skitf1=M.op(0x02,8),
|
|
skitf2=M.op(0x03,8),
|
|
skitfs=M.op(0x04,8),
|
|
sknitf0=M.op(0x10,8),
|
|
sknitft=M.op(0x11,8),
|
|
sknitf1=M.op(0x12,8),
|
|
sknitf2=M.op(0x13,8),
|
|
sknitfs=M.op(0x14,8),
|
|
} M.op48int = op48int
|
|
for k,v in pairs(op48int) do
|
|
M[k] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, bin={ 0x48, v.opc } })
|
|
end
|
|
end
|
|
|
|
-- IN/OUT
|
|
local opinout={
|
|
['in']=M.op(0x4c,10),
|
|
out=M.op(0x4d,10),
|
|
} M.opinout = op4inout
|
|
for k,v in pairs(opinout) do
|
|
M[k .. 'imm'] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local op = { cycles=v.cycles }
|
|
op.size = function() late,early = M.size_op(late,early) return 2 end
|
|
op.bin = function() local l7801dbg=l7801dbg
|
|
local x = 0x00 + M.op_eval_byte(late,early)
|
|
return { v.opc, 0x00, x }
|
|
end
|
|
table.insert(M.section_current.instructions, op)
|
|
end
|
|
end
|
|
|
|
|
|
local op4car8={
|
|
movapa=M.op(0xc0,10),
|
|
movapb=M.op(0xc1,10),
|
|
movapc=M.op(0xc2,10),
|
|
movamk=M.op(0xc3,10),
|
|
movamb=M.op(0xc4,10),
|
|
movamc=M.op(0xc5,10),
|
|
movatm0=M.op(0xc6,10),
|
|
movatm1=M.op(0xc7,10),
|
|
movas=M.op(0xc8,10),
|
|
} M.op4car8 = op4car8
|
|
for k,v in pairs(op4car8) do
|
|
M[k] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, bin={ 0x4c, v.opc } })
|
|
end
|
|
end
|
|
|
|
local op4dr8a={
|
|
movpaa=M.op(0xc0,10),
|
|
movpba=M.op(0xc1,10),
|
|
movpca=M.op(0xc2,10),
|
|
movmka=M.op(0xc3,10),
|
|
movmba=M.op(0xc4,10),
|
|
movmca=M.op(0xc5,10),
|
|
movtm0a=M.op(0xc6,10),
|
|
movtm1a=M.op(0xc7,10),
|
|
movsa=M.op(0xc8,10),
|
|
} M.op4dr8a = op4dr8a
|
|
for k,v in pairs(op4dr8a) do
|
|
M[k] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, bin={ 0x4d, v.opc } })
|
|
end
|
|
end
|
|
|
|
local op60names = {'ana','xra','ora','addnc','gta','subnb','lta','add','','adc','','sub','nea','sbb','eqa'}
|
|
local register_names = {'v','a','b','c','d','e','h','l'}
|
|
local k = 0x08
|
|
for i,o in ipairs(op60names) do
|
|
if o == '' then
|
|
k = k + #register_names
|
|
else
|
|
for j,r in ipairs(register_names) do
|
|
local l = k
|
|
M[o .. r .. 'a'] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=8, bin={ 0x60, l } })
|
|
end
|
|
k = k + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
k = 0x88
|
|
op60names[9] = 'ona'
|
|
op60names[11] = 'offa'
|
|
for i,o in ipairs(op60names) do
|
|
if o == '' then
|
|
k = k + #register_names
|
|
else
|
|
for j,r in ipairs(register_names) do
|
|
local l = k
|
|
local name = o .. 'a' .. r
|
|
if not M[name] then
|
|
M[name] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=8, bin={ 0x60, l } })
|
|
end
|
|
end
|
|
k = k + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
k = 0x08
|
|
local op64names = { 'ani','xri','ori','adinc','gti','suinb','lti','adi','oni','aci','offi','sui','nei','sbi','eqi' }
|
|
for i,o in ipairs(op64names) do
|
|
for j,r in ipairs(register_names) do
|
|
local name = o .. r
|
|
if not M[name] then
|
|
local l = k
|
|
M[name] = function(late,early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local op = { cycles=11 }
|
|
op.size = function() late,early = M.size_op(late,early) return 3 end
|
|
op.bin = function() local l7801dbg=l7801dbg
|
|
local x = 0x00 + l;
|
|
local y = 0x00 + M.op_eval_byte(late,early)
|
|
return { 0x64, x, y }
|
|
end
|
|
table.insert(M.section_current.instructions, op)
|
|
end
|
|
end
|
|
k = k + 1
|
|
end
|
|
end
|
|
|
|
k = 0x88
|
|
local ex_register_names = {'pa','pb','pc','mk'}
|
|
for i,o in ipairs(op64names) do
|
|
for j,r in ipairs(ex_register_names) do
|
|
local name = o .. r
|
|
if not M[name] then
|
|
local l = k
|
|
M[name] = function(late,early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local op = { cycles=11 }
|
|
op.size = function() late,early = M.size_op(late,early) return 3 end
|
|
op.bin = function() local l7801dbg=l7801dbg
|
|
local x = 0x00 + l;
|
|
local y = 0x00 + M.op_eval_byte(late,early)
|
|
return { 0x64, x, y }
|
|
end
|
|
table.insert(M.section_current.instructions, op)
|
|
end
|
|
end
|
|
k = k + 1
|
|
end
|
|
k = k + 4
|
|
end
|
|
|
|
local op74wa = {
|
|
anaw=M.op(0x88,14),
|
|
xraw=M.op(0x90,14),
|
|
oraw=M.op(0x98,14),
|
|
addncw=M.op(0xa0,14),
|
|
gtaw=M.op(0xa8,14),
|
|
subnbw=M.op(0xb0,14),
|
|
ltaw=M.op(0xb8,14),
|
|
addw=M.op(0xc0,14),
|
|
onaw=M.op(0xc8,14),
|
|
adcw=M.op(0xd0,14),
|
|
offaw=M.op(0xd8,14),
|
|
subw=M.op(0xe0,14),
|
|
neaw=M.op(0xe8,14),
|
|
sbbw=M.op(0xf0,14),
|
|
eqaw=M.op(0xf8,14),
|
|
} M.op74wa = op74wa
|
|
for k,v in pairs(op74wa) do
|
|
M[k .. 'wa'] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 3 end
|
|
local bin = function() local l7801dbg=l7801dbg return { 0x74, v.opc, M.op_eval_byte(late,early) } end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
local op70ind = {
|
|
sspd=M.op(0x0e,20),
|
|
lspd=M.op(0x0f,20),
|
|
sbcd=M.op(0x1e,20),
|
|
lbcd=M.op(0x1f,20),
|
|
sded=M.op(0x2e,20),
|
|
lded=M.op(0x2f,20),
|
|
shld=M.op(0x3e,20),
|
|
lhld=M.op(0x3f,20),
|
|
} M.op70ind = op70ind
|
|
for k,v in pairs(op70ind) do
|
|
M[k] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 4 end
|
|
local bin = function() local l7801dbg=l7801dbg
|
|
local x = M.op_eval_word(late,early)
|
|
return { 0x70, v.opc, x&0xff, x>>8 }
|
|
end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
local op70indr8 = {
|
|
movindv=M.op(0x78,17),
|
|
movinda=M.op(0x79,17),
|
|
movindb=M.op(0x7a,17),
|
|
movindc=M.op(0x7b,17),
|
|
movindd=M.op(0x7c,17),
|
|
movinde=M.op(0x7d,17),
|
|
movindh=M.op(0x7e,17),
|
|
movindl=M.op(0x7f,17),
|
|
} M.op70indr8 = op70indr8
|
|
for k,v in pairs(op70indr8) do
|
|
M[k] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 4 end
|
|
local bin = function() local l7801dbg=l7801dbg
|
|
local x = M.op_eval_word(late,early)
|
|
return { 0x70, v.opc, x&0xff, x>>8 }
|
|
end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
local op70r8ind = {
|
|
movvind=M.op(0x68,17),
|
|
movaind=M.op(0x69,17),
|
|
movbind=M.op(0x6a,17),
|
|
movcind=M.op(0x6b,17),
|
|
movdind=M.op(0x6c,17),
|
|
moveind=M.op(0x6d,17),
|
|
movhind=M.op(0x6e,17),
|
|
movlind=M.op(0x6f,17),
|
|
} M.op70r8ind = op70r8ind
|
|
for k,v in pairs(op70r8ind) do
|
|
M[k] = function(late, early)
|
|
local l7801dbg = { info=debug.getinfo(2, 'Sl'), trace=debug.traceback(nil, 1) }
|
|
local size = function() late,early = M.size_op(late,early) return 4 end
|
|
local bin = function() local l7801dbg=l7801dbg
|
|
local x = M.op_eval_word(late,early)
|
|
return { 0x70, v.opc, x&0xff, x>>8 }
|
|
end
|
|
table.insert(M.section_current.instructions, { size=size, cycles=v.cycles, bin=bin })
|
|
end
|
|
end
|
|
|
|
k = 0x89
|
|
local op70names = {'anax','xrax','orax','addncx','gtax','subnbx','ltax','addx','onax','adcx','offax','subx','neax','sbbx','eqax'}
|
|
local op70suffixes = {'bc','de','hl','ide','ihl','dde','dhl'}
|
|
for i,o in ipairs(op70names) do
|
|
for j,s in ipairs(op70suffixes) do
|
|
local l = 0x00 + k + (j-1) + (8 * (i-1))
|
|
M[o .. s] = function()
|
|
table.insert(M.section_current.instructions, { size=2, cycles=11, bin={ 0x70, l } })
|
|
end
|
|
end
|
|
end
|
|
|
|
return M
|