mirror of https://git.sr.ht/~rabbits/uxn
281 lines
8.5 KiB
Plaintext
281 lines
8.5 KiB
Plaintext
--
|
|
-- Uxn core unroller script
|
|
--
|
|
-- This script updates src/uxn-fast.c when Uxn's opcode set changes, so that
|
|
-- updates in the human-readable src/uxn.c core can be easily converted into
|
|
-- high-performance code.
|
|
--
|
|
-- To run, you need Lua or LuaJIT, and just run etc/mkuxn-fast.lua from the top
|
|
-- directory of Uxn's git repository:
|
|
--
|
|
-- lua etc/mkuxn-fast.lua
|
|
--
|
|
-- This file is written in MoonScript, which is a language that compiles to
|
|
-- Lua, the same way as e.g. CoffeeScript compiles to JavaScript. Since
|
|
-- installing MoonScript has more dependencies than Lua, the compiled
|
|
-- etc/mkuxn-fast.lua is kept in Uxn's repository and will be kept updated as
|
|
-- this file changes.
|
|
--
|
|
|
|
generate_labels = false -- add labels to each opcode to inspect disassembled code
|
|
|
|
replacements =
|
|
op_and16: '{ Uint8 a = pop8(u->src), b = pop8(u->src), c = pop8(u->src), d = pop8(u->src); push8(u->src, d & b); push8(u->src, c & a); }'
|
|
op_ora16: '{ Uint8 a = pop8(u->src), b = pop8(u->src), c = pop8(u->src), d = pop8(u->src); push8(u->src, d | b); push8(u->src, c | a); }'
|
|
op_eor16: '{ Uint8 a = pop8(u->src), b = pop8(u->src), c = pop8(u->src), d = pop8(u->src); push8(u->src, d ^ b); push8(u->src, c ^ a); }'
|
|
op_lit16: '{ push8(u->src, peek8(u->ram.dat, u->ram.ptr++)); push8(u->src, peek8(u->ram.dat, u->ram.ptr++)); }'
|
|
op_swp16: '{ Uint8 a = pop8(u->src), b = pop8(u->src), c = pop8(u->src), d = pop8(u->src); push8(u->src, b); push8(u->src, a); push8(u->src, d); push8(u->src, c); }'
|
|
op_ovr16: '{ Uint8 a = pop8(u->src), b = pop8(u->src), c = pop8(u->src), d = pop8(u->src); push8(u->src, d); push8(u->src, c); push8(u->src, b); push8(u->src, a); push8(u->src, d); push8(u->src, c); }'
|
|
op_dup16: '{ Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b); push8(u->src, a); push8(u->src, b); push8(u->src, a); }'
|
|
op_rot16: '{ Uint8 a = pop8(u->src), b = pop8(u->src), c = pop8(u->src), d = pop8(u->src), e = pop8(u->src), f = pop8(u->src); push8(u->src, d); push8(u->src, c); push8(u->src, b); push8(u->src, a); push8(u->src, f); push8(u->src, e); }'
|
|
op_sth16: '{ Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->dst, b); push8(u->dst, a); }'
|
|
|
|
local top, bottom, pushtop
|
|
|
|
offset = (n, s = '') ->
|
|
if n < 0
|
|
' -%s %d'\format s, -n
|
|
elseif n > 0
|
|
' +%s %d'\format s, n
|
|
elseif s != ''
|
|
' +%s 0'\format s
|
|
else
|
|
''
|
|
|
|
pop_push = (k, n, s) ->
|
|
switch k
|
|
when 'pop'
|
|
s = s\match '^%((%S+)%)$'
|
|
assert s == 'src'
|
|
switch n
|
|
when '8'
|
|
top[s] -= 1
|
|
if bottom[s] > top[s]
|
|
bottom[s] = top[s]
|
|
'%s.dat[%s.ptr%s]'\format s, s, offset(top[s])
|
|
when '16'
|
|
top[s] -= 2
|
|
if bottom[s] > top[s]
|
|
bottom[s] = top[s]
|
|
'(%s.dat[%s.ptr%s] | (%s.dat[%s.ptr%s] << 8))'\format s, s, offset(top[s] + 1), s, s, offset(top[s])
|
|
when 'push'
|
|
s, v = s\match '^%((%S+), (.*)%)$'
|
|
assert s == 'src' or s == 'dst', s
|
|
switch n
|
|
when '8'
|
|
pushtop[s] += 1
|
|
'%s.dat[%s.ptr%s] = %s'\format s, s, offset(pushtop[s] - 1), v
|
|
when '16'
|
|
if v\match'%+%+' or v\match'%-%-'
|
|
error 'push16 has side effects: ' .. v
|
|
peek, args = v\match '^([md]e[mv]peek)16(%b())$'
|
|
if peek
|
|
args = args\sub 2, -2
|
|
return pop_push('push', '8', '(%s, %s8(%s))'\format s, peek, args) .. ';\n' .. pop_push('push', '8', '(%s, %s8(%s + 1))'\format s, peek, args)
|
|
pushtop[s] += 2
|
|
if v\match ' '
|
|
v = '(' .. v .. ')'
|
|
'%s.dat[%s.ptr%s] = %s >> 8;\n%s.dat[%s.ptr%s] = %s & 0xff'\format s, s, offset(pushtop[s] - 2), v, s, s, offset(pushtop[s] - 1), v
|
|
else
|
|
nil
|
|
|
|
indented_block = (s) ->
|
|
s = s\gsub('^%{ *', '{\n')\gsub('\n', '\n\t')\gsub('\t%} *$', '}\n')
|
|
s = s\gsub('\n[^\n]+%.error = [^\n]+', '%0\n#ifndef NO_STACK_CHECKS\n\tgoto error;\n#endif')
|
|
s
|
|
|
|
process = (body) ->
|
|
out_body = body\gsub('^%{ *', '')\gsub(' *%}$', '')\gsub('; ', ';\n')\gsub('%b{} *', indented_block)\gsub '(%a+)(%d+)(%b())', pop_push
|
|
in_ifdef = false
|
|
for k in *{'src', 'dst'}
|
|
if bottom[k] != 0
|
|
if not in_ifdef
|
|
out_body ..= '\n#ifndef NO_STACK_CHECKS'
|
|
in_ifdef = true
|
|
out_body ..= '\nif(__builtin_expect(%s.ptr < %d, 0)) {\n\t%s.error = 1;\n\tgoto error;\n}'\format k, -bottom[k], k
|
|
if pushtop[k] != 0
|
|
if pushtop[k] > 0
|
|
if not in_ifdef
|
|
out_body ..= '\n#ifndef NO_STACK_CHECKS'
|
|
in_ifdef = true
|
|
out_body ..= '\nif(__builtin_expect(%s.ptr > %d, 0)) {\n\t%s.error = 2;\n\tgoto error;\n}'\format k, 255 - pushtop[k], k
|
|
if in_ifdef
|
|
out_body ..= '\n#endif'
|
|
in_ifdef = false
|
|
out_body ..= '\n%s.ptr %s= %d;'\format k, pushtop[k] < 0 and '-' or '+', math.abs pushtop[k]
|
|
if in_ifdef
|
|
out_body ..= '\n#endif'
|
|
in_ifdef = false
|
|
t = {}
|
|
out_body\gsub '[^%w_]([a-f]) = (src%.dat%[[^]]+%])[,;]', (v, k) -> t[k] = v
|
|
out_body = out_body\gsub '(src%.dat%[[^]]+%]) = ([a-f]);\n', (k, v) ->
|
|
if t[k] and t[k] == v
|
|
return ''
|
|
return nil
|
|
out_body
|
|
|
|
ops = {}
|
|
|
|
for l in assert io.lines 'src/uxn.c'
|
|
name, body = l\match 'void (op_%S*)%(Uxn %*u%) (%b{})'
|
|
if not name
|
|
continue
|
|
if replacements[name]
|
|
body = replacements[name]
|
|
body = body\gsub 'u%-%>src%-%>', 'src.'
|
|
body = body\gsub 'u%-%>dst%-%>', 'dst.'
|
|
body = body\gsub 'u%-%>src', 'src'
|
|
body = body\gsub 'u%-%>dst', 'dst'
|
|
top = { src: 0, dst: 0 }
|
|
bottom = { src: 0, dst: 0 }
|
|
pushtop = top
|
|
ops[name] = process body
|
|
top = { src: 0, dst: 0 }
|
|
bottom = { src: 0, dst: 0 }
|
|
pushtop = { src: 0, dst: 0 }
|
|
ops['keep_' .. name] = process body
|
|
|
|
dump = (s, src, dst) ->
|
|
ret = '\t\t\t{\n'
|
|
for l in s\gmatch '[^\n]+'
|
|
if not l\match '^%#'
|
|
ret ..= '\t\t\t\t'
|
|
ret ..= '%s\n'\format l
|
|
ret ..= '\t\t\t}\n\t\t\tbreak;\n'
|
|
(ret\gsub('src', src)\gsub('dst', dst))
|
|
|
|
i = 0
|
|
allops = {}
|
|
wanted = false
|
|
for l in assert io.lines 'src/uxn.c'
|
|
if l == 'static void (*ops[])(Uxn *u) = {'
|
|
wanted = true
|
|
elseif l == '};'
|
|
wanted = false
|
|
elseif wanted
|
|
l = l\gsub '%/%b**%/', ''
|
|
for op in l\gmatch '[%w_]+'
|
|
if not ops[op]
|
|
error 'missing ' .. op
|
|
allops[i + 0x00 + 1] = { n: { i + 0x00 }, body: dump ops[op], 'u->wst', 'u->rst' }
|
|
allops[i + 0x20 + 1] = { n: { i + 0x20 }, body: dump ops[op], 'u->rst', 'u->wst' }
|
|
allops[i + 0x80 + 1] = { n: { i + 0x80 }, body: dump ops['keep_' .. op], 'u->wst', 'u->rst' }
|
|
allops[i + 0xa0 + 1] = { n: { i + 0xa0 }, body: dump ops['keep_' .. op], 'u->rst', 'u->wst' }
|
|
i += 1
|
|
if i == 0x20
|
|
i += 0x20
|
|
|
|
i = 0
|
|
wanted = false
|
|
for l in assert io.lines 'src/uxnasm.c'
|
|
if l == 'static char ops[][4] = {'
|
|
wanted = true
|
|
elseif l == '};'
|
|
wanted = false
|
|
elseif wanted
|
|
for op in l\gmatch '"(...)"'
|
|
i += 1
|
|
allops[i + 0x00].name = op
|
|
allops[i + 0x20].name = op .. 'r'
|
|
allops[i + 0x40].name = op .. '2'
|
|
allops[i + 0x60].name = op .. '2r'
|
|
allops[i + 0x80].name = op .. 'k'
|
|
allops[i + 0xa0].name = op .. 'kr'
|
|
allops[i + 0xc0].name = op .. '2k'
|
|
allops[i + 0xe0].name = op .. '2kr'
|
|
|
|
for i = 1, 256
|
|
if not allops[i]
|
|
continue
|
|
for j = i + 1, 256
|
|
if allops[i].body == allops[j].body
|
|
table.insert allops[i].n, (table.remove allops[j].n)
|
|
allops[j].body = nil
|
|
|
|
with assert io.open 'src/uxn-fast.c', 'w'
|
|
f = assert io.open 'src/uxn.c'
|
|
while true
|
|
l = f\read '*l'
|
|
\write '%s\n'\format l
|
|
if l == '*/'
|
|
break
|
|
\write '\n'
|
|
\write [[
|
|
/*
|
|
^
|
|
/!\ THIS FILE IS AUTOMATICALLY GENERATED
|
|
---
|
|
|
|
Its contents can get overwritten with the processed contents of src/uxn.c.
|
|
See etc/mkuxn-fast.moon for instructions.
|
|
|
|
*/
|
|
]]
|
|
wanted = true
|
|
while true
|
|
l = f\read '*l'
|
|
if l\match' push' or l\match'[ *]pop' or l\match'devr16'
|
|
continue
|
|
if l == '/* Stack */'
|
|
wanted = false
|
|
if wanted
|
|
\write '%s\n'\format l
|
|
if l == '}'
|
|
\write '\n'
|
|
break
|
|
\write [[
|
|
/* clang-format on */
|
|
|
|
#pragma mark - Core
|
|
|
|
int
|
|
uxn_eval(Uxn *u, Uint16 vec)
|
|
{
|
|
Uint8 instr;
|
|
if(!vec || u->dev[0].dat[0xf])
|
|
return 0;
|
|
u->ram.ptr = vec;
|
|
if(u->wst.ptr > 0xf8) u->wst.ptr = 0xf8;
|
|
while((instr = u->ram.dat[u->ram.ptr++])) {
|
|
switch(instr) {
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wunused-value"
|
|
#pragma GCC diagnostic ignored "-Wunused-variable"
|
|
]]
|
|
for i = 1, 256
|
|
if not allops[i].body
|
|
continue
|
|
for n in *allops[i].n
|
|
\write '\t\tcase 0x%02x: /* %s */\n'\format n, allops[n + 1].name
|
|
if generate_labels
|
|
\write '\t\t\t__asm__("evaluxn_%02x_%s:");\n'\format allops[i].n[1], allops[i].name
|
|
\write allops[i].body
|
|
\write [[
|
|
#pragma GCC diagnostic pop
|
|
}
|
|
}
|
|
return 1;
|
|
#ifndef NO_STACK_CHECKS
|
|
error:
|
|
if(u->wst.error)
|
|
return uxn_halt(u, u->wst.error, "Working-stack", instr);
|
|
else
|
|
return uxn_halt(u, u->rst.error, "Return-stack", instr);
|
|
#endif
|
|
}
|
|
|
|
int
|
|
]]
|
|
wanted = false
|
|
while true
|
|
l = f\read '*l'
|
|
if not l
|
|
break
|
|
if l\match '^uxn_boot'
|
|
wanted = true
|
|
if wanted
|
|
\write '%s\n'\format l
|
|
f\close!
|
|
\close!
|
|
|