lisp_x64.dasl

local ffi = require('ffi') --required
local dasm = require('dasm') --required

local log = require('log')

--must be the first instruction
|.arch x64
--make an action list called `actions`
|.actionlist actions
|.globalnames globalnames

local gen = {}

local registers = {
    scratch = {
        0, -- rax
        1, -- rcx
        2, -- rdx
        6, -- rsi
        7, -- rdi
        8, -- r8
        9, -- r9
        10, -- r10
        11, -- r11
    },
    returns = {
        0, -- rax
        2, -- rdx
    },
    args = {
        7, --- rdi
        6, --- rsi
        2, --- rdx
        1, --- rcx
        8, --- r8
        9, --- r9
    },
    saved = {
        3, -- rbx
        5, -- rbp
        12, -- r12
        13, -- r13
        14, -- r14
        15, -- r15
    },
}


-- scratch
-- RAX, RCX, RDX, RSI, RDI, R8, R9, R10, R11,
-- ST0-7, K0-7,XMM0-15, YMM0-15, ZMM0-15

-- return
-- RAX, RDX, -- float ST(0), XMM0, YMM0, ZMM0

-- arguments
-- RDI, RSI, RDX, RCX, R8, R9,
-- float
-- XMM0-XMM7, YMM0-YMM7, ZMM0-ZMM7

-- saved
-- RBX, RBP, R12, R13, R14, R15

function gen.new_context()
    local context = {}
    context.parking = {}
    context.reg_stack = {}
    context.reg_index = 1
    context.free_reg = 0 -- rax
    context.free_reg2 = 10 -- r10

    context.label = 0

    context.docontinue = {}
    context.dobreak = {}
    context.dostack = {}

    context.alignstack = {}

    context.registers = registers

    context.cells = {}
    return context
end

function gen.new_context_with_registers(count)
    count = count or 0
    local context = {}
    context.parking = {}
    context.reg_stack = {
        --12, -- r12
        --13, -- r13
        --14, -- r14
        --15, -- r15
    }
    if count > 0 then
        table.insert(context.reg_stack, 12) -- r12
    end
    if count > 1 then
        table.insert(context.reg_stack, 13) -- r13
    end
    if count > 2 then
        table.insert(context.reg_stack, 14) -- r14
    end
    if count > 3 then
        table.insert(context.reg_stack, 15) -- r15
    end
    context.reg_index = 1
    context.free_reg = 0 -- rax
    context.free_reg2 = 10 -- rdx

    context.label = 0

    context.docontinue = {}
    context.dobreak = {}
    context.dostack = {}
    context.alignstack = {}

    context.registers = registers

    context.cells = {}
    return context
end

function gen.align_stack_to16(Dst, context)
    local filled = context.reg_index - 1
    if filled > #context.reg_stack then
        filled = filled - #context.reg_stack
    end


    if (filled + 1) % 2 ~= 0 then
        table.insert(context.alignstack, true)
        local mask = tonumber64('0xFFFFFFFFFFFFFFF0')
            |and rsp, mask
    else
        table.insert(context.alignstack, false)
    end
end

function gen.align_stack_back_to16(Dst, context)
    if context.alignstack[#context.alignstack] then
            |add rsp, 0x8
    end

    table.remove(context.alignstack)
end

function gen.pop_result_to(Dst, context, reg)
    -- operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        context.reg_index = context.reg_index - 1
            |pop Rq(reg)
    else
        -- operand in register
        local src = context.reg_stack[context.reg_index - 1]
        context.reg_index = context.reg_index - 1
            |mov Rq(reg), Rq(src)
    end
end

function gen.mov_result_to_mem(Dst, context, mem)
    -- operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local dst = context.free_reg2
        local src = context.free_reg
            |mov Rq(src), [rsp]
            |mov64 Rq(dst), mem
            |mov [Rq(dst)], Rq(src)
    else
        -- operand in register
        local src = context.reg_stack[context.reg_index - 1]
        local dst = context.free_ref
            |mov64 Rq(dst), mem
            |mov [Rq(dst)], Rq(src)
    end
end

function gen.push_result_from(Dst, context, reg)
    -- operand in stack
    if context.reg_stack[context.reg_index] == nil then
        context.reg_index = context.reg_index + 1
            |push Rq(reg)
    else
        -- operand in register
        local dst = context.reg_stack[context.reg_index]
        context.reg_index = context.reg_index + 1
            |mov Rq(dst), Rq(reg)
    end
end

function gen.push_result_from_mem(Dst, context, mem)
    -- operand in stack
    if context.reg_stack[context.reg_index] == nil then
        local reg = context.free_reg
        local src = context.free_reg2
        context.reg_index = context.reg_index + 1

            |mov64 Rq(src), mem
            |mov Rq(reg), [Rq(src)]
            |push Rq(reg)
    else
        -- operand in register
        local dst = context.reg_stack[context.reg_index]
        local src = context.free_reg

        context.reg_index = context.reg_index + 1

            |mov64 Rq(src), mem
            |mov Rq(dst), [Rq(src)]
    end
end

function gen.discard_result(Dst, context)
    -- operand in stack
    if context.reg_stack[context.reg_index-1] == nil then
        context.reg_index = context.reg_index - 1
        |add rsp,8
    else
        -- operand in register
        context.reg_index = context.reg_index - 1
    end
end

function gen.unwind_results(Dst, context)
    assert(#context.dostack ~= 0)

    local reg_remain = 0
    local i = context.dostack[#context.dostack]
    while true do
        if context.reg_stack[i] == nil or i >= context.reg_index then
            break
        end
        i = i + 1
        reg_remain = reg_remain + 1
    end

    local level = context.reg_index - 1
    level = level - reg_remain

    level = level * 8
    -- save current stack level

        |lea rsp,[rsp+level]
end

function gen.label(Dst, context, label)
    |=>label:
end

function gen.jmp(Dst, context, label)
        |jmp =>label
end

function gen.pop_test_jz(Dst, context, label)
    if context.reg_index == 1 then
        error('Too few operands for pop test jz')
    end
    -- operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        context.reg_index = context.reg_index - 1

        local reg = context.free_reg
            |pop Rq(reg)
            |test Rq(reg), Rq(reg)
            |je =>label
    else
        -- operand in register
        local reg = context.reg_stack[context.reg_index-1]

        context.reg_index = context.reg_index - 1

            |test Rq(reg), Rq(reg)
            |je =>label
    end
end

function gen.test_jz(Dst, context, label)
    if context.reg_index == 1 then
        error('Too few operands for test jz')
    end
    -- operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
            |mov Rq(context.free_reg), [rsp]
            |test Rq(context.free_reg), Rq(context.free_reg)
            |je =>label
    else
        -- operand in register
        local reg = context.reg_stack[context.reg_index-1]
            |test Rq(reg), Rq(reg)
            |je =>label
    end
end

function gen.test_jnz(Dst, context, label)
    if context.reg_index == 1 then
        error('Too few operands for testjnz')
    end
    -- operand in stack
    if context.reg_stack[context.reg_index-1] == nil then
            |mov Rq(context.free_reg), [rsp]
            |test Rq(context.free_reg), Rq(context.free_reg)
            |jne =>label
    else
        -- operand in register
        local reg = context.reg_stack[context.reg_index-1]
            |test Rq(reg), Rq(reg)
            |jne =>label
    end
end

gen['logical_not'] = function(Dst, context)
    if context.reg_index == 1 then
        error('Too few operands for logical not')
    end
    -- operand in stack
    if context.reg_stack[context.reg_index-1] == nil then
            |pop Rq(context.free_reg2)
            |xor Rq(context.free_reg), Rq(context.free_reg)
            |test Rq(context.free_reg2), Rq(context.free_reg2)
            |sete Rb(context.free_reg)
            |push Rq(context.free_reg)
    else
        -- operand in register
        local reg = context.reg_stack[context.reg_index-1]
            |xor Rq(context.free_reg), Rq(context.free_reg)
            |test Rq(reg), Rq(reg)
            |sete Rb(context.free_reg)
            |mov Rq(reg), Rq(context.free_reg)
    end
end

gen['sete'] = function(Dst, context, reg)
        |sete Rb(reg)
end

gen['setne'] = function(Dst, context, reg)
        |setne Rb(reg)
end

gen['setl'] = function(Dst, context, reg)
        |setl Rb(reg)
end

gen['setle'] = function(Dst, context, reg)
        |setle Rb(reg)
end

gen['setg'] = function(Dst, context, reg)
        |setg Rb(reg)
end

gen['setge'] = function(Dst, context, reg)
        |setge Rb(reg)
end

for op, generator in pairs({['=']=gen['sete'],
        ['<']=gen['setl'],
        ['<=']=gen['setle'],
        ['>']=gen['setg'],
        ['>=']=gen['setge'],
        ['/=']=gen['setne']}) do

    gen[op] = function(Dst, context)
        if context.reg_index == 1 or context.reg_index == 2 then
            error('Too few operands for ' .. op)
        end

        -- two operands in stack
        if context.reg_stack[context.reg_index - 2] == nil then

            local res = context.free_reg
            local dst = context.free_reg2

            context.reg_index = context.reg_index - 1

                |pop Rq(dst)
                |xor Rq(res), Rq(res)
                |cmp [rsp], Rq(dst)

            generator(Dst, context, res)

                |mov [rsp], Rq(res)
            return
        end

        -- one operand in stack
        if context.reg_stack[context.reg_index - 1] == nil then
            -- operand in register

            local res = context.free_reg
            local reg = context.reg_stack[context.reg_index-2]

            context.reg_index = context.reg_index - 1

                |xor Rq(res), Rq(res)
                |cmp Rq(reg), [rsp]

            generator(Dst, context, res)

                |mov Rq(reg), Rq(res)
                |add rsp, 8

            return
        end

        -- two operands in registers

        local res = context.free_reg
        local dst = context.reg_stack[context.reg_index - 2]
        local src = context.reg_stack[context.reg_index - 1]
        context.reg_index = context.reg_index - 1

            |xor Rq(res), Rq(res)
            |cmp Rq(dst), Rq(src)

        generator(Dst, context, res)

            |mov Rq(dst), Rq(res)
    end
end

gen['not'] = function(Dst, context)
    if context.reg_index == 1 then
        error('Too few operands for not')
    end
    -- operand in stack
    if context.reg_stack[context.reg_index-1] == nil then
            |not qword[rsp]
    else
        -- operand in register
        local q = context.reg_stack[context.reg_index-1]
            |not Rq(q)
    end
end

gen['and'] = function(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Too few operands for and')
    end

    -- all operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        local reg = context.free_reg
        context.reg_index = context.reg_index - 1
            |pop Rq(reg)
            |and qword [rsp], Rq(reg)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local reg = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |and Rq(reg), [rsp]
            |add rsp, 8
        return
    end

    -- all operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]
    context.reg_index = context.reg_index - 1

        |and Rq(dst), Rq(src)
end

gen['or'] = function(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Too few operands for and')
    end

    -- all operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        local reg = context.free_reg
        context.reg_index = context.reg_index - 1
            |pop Rq(reg)
            |or qword [rsp], Rq(reg)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local reg = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |or Rq(reg), [rsp]
            |add rsp, 8
        return
    end

    -- all operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]
    context.reg_index = context.reg_index - 1

        |or Rq(dst), Rq(src)
end

gen['xor'] = function(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Too few operands for xor')
    end

    -- all operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        local reg = context.free_reg
        context.reg_index = context.reg_index - 1
            |pop Rq(reg)
            |xor qword [rsp], Rq(reg)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local reg = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |xor Rq(reg), [rsp]
            |add rsp, 8
        return
    end

    -- all operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]
    context.reg_index = context.reg_index - 1

        |xor Rq(dst), Rq(src)
end

gen['shl'] = function(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Too few operands for shl')
    end

    -- all operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        local free_reg = context.free_reg
        context.reg_index = context.reg_index - 1
            |mov Rq(free_reg), rcx
            |pop rcx
            |shl qword [rsp], cl
            |mov rcx, Rq(free_reg)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local reg = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |mov Rq(free_reg), rcx
            |pop rcx
            |shl Rq(reg), cl
            |mov rcx, Rq(free_reg)
        return
    end

    local reg = context.reg_stack[context.reg_index - 2]
    -- all operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]
    context.reg_index = context.reg_index - 1

        |mov Rq(free_reg), rcx
        |mov rcx, Rq(src)
        |shl Rq(dst), cl
        |mov rcx, Rq(free_reg)
end

gen['shr'] = function(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Too few operands for shl')
    end

    -- all operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        local free_reg = context.free_reg
        context.reg_index = context.reg_index - 1
            |mov Rq(free_reg), rcx
            |pop rcx
            |shr qword [rsp], cl
            |mov rcx, Rq(free_reg)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local reg = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |mov Rq(free_reg), rcx
            |pop rcx
            |shr Rq(reg), cl
            |mov rcx, Rq(free_reg)
        return
    end

    local reg = context.reg_stack[context.reg_index - 2]
    -- all operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]
    context.reg_index = context.reg_index - 1

        |mov Rq(free_reg), rcx
        |mov rcx, Rq(src)
        |shr Rq(dst), cl
        |mov rcx, Rq(free_reg)
end

function gen.push(Dst, imm, context)
    -- registers is over
    if context.reg_stack[context.reg_index] == nil then
        context.reg_index = context.reg_index + 1
            |mov64 Rq(context.free_reg), imm
            |push Rq(context.free_reg)
    else
        local q = context.reg_stack[context.reg_index]
        context.reg_index = context.reg_index + 1
            |mov64 Rq(q), imm
    end
end

function gen.mov64(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Nothing to mov. Stack is empty')
    end

    -- two operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then

        free_reg = context.free_reg
        free_reg2 = context.free_reg2
        context.reg_index = context.reg_index - 1

            |pop Rq(free_reg2) -- index
            |pop Rq(free_reg) -- base
            |mov Rq(free_reg), [Rq(free_reg)+Rq(free_reg2)]
            |push Rq(free_reg)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local index = context.reg_stack[context.reg_index - 2]
        local free_reg = context.free_reg
        context.reg_index = context.reg_index - 1

            |pop Rq(free_reg) -- base
            |mov Rq(index), [Rq(free_reg)+Rq(index)]
        return
    end

    -- operands in registers
    local dst = context.reg_stack[context.reg_index - 2] -- base
    local src = context.reg_stack[context.reg_index - 1] -- index

    context.reg_index = context.reg_index - 1

        |mov Rq(dst), [Rq(dst)+Rq(src)]
end

function gen.mov64_to_mem(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Nothing to mov to mem. Stack is empty')
    end

    -- two operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then

        free_reg = context.free_reg
        free_reg2 = context.free_reg2
        context.reg_index = context.reg_index - 1

            |pop Rq(free_reg2) -- value
            |pop Rq(free_reg) -- base
            |mov [Rq(free_reg)], Rq(free_reg2)
            |push Rq(free_reg2)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local base = context.reg_stack[context.reg_index - 2]
        local free_reg = context.free_reg
        context.reg_index = context.reg_index - 1

            |pop Rq(free_reg) -- value
            |mov [Rq(base)], Rq(free_reg)
            |mov Rq(base), Rq(free_reg)
        return
    end

    -- operands in registers
    local dst = context.reg_stack[context.reg_index - 2] -- base
    local src = context.reg_stack[context.reg_index - 1] -- value

    context.reg_index = context.reg_index - 1

        |mov [Rq(dst)], Rq(src)
end

function gen.clear_rq0(Dst, context)
        |xor Rq(0), Rq(0)
end

function gen.add(Dst, context, arity)
    if context.reg_index == 1 then
        error('Nothing to add. Stack is empty')
    end

    if arity == 1 then
        -- nothing to do
        return
    end

    -- two operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        context.reg_index = context.reg_index - 1
            |pop Rq(context.free_reg)
            |add qword [rsp], Rq(context.free_reg)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local dst = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |add Rq(dst), [rsp]
            |add rsp, 8
        return
    end

    -- operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]

    context.reg_index = context.reg_index - 1

        |add Rq(dst), Rq(src)
end

-- subtract stack head from stack head+1
-- pop head and result placed on head
-- one value is just negotiated
function gen.sub(Dst, context, arity)
    if context.reg_index == 1 then
        error('Nothing to sub. Stack is empty')
    end

    if context.reg_index == 2 and arity ~= 1 then
        error('Too few args in stack for 2-arity sub.')
    end

    -- one operand only
    if arity == 1 then
        if context.reg_stack[context.reg_index - 1] == nil then
                |neg qword [rsp]
        else
            reg = context.reg_stack[context.reg_index - 1]
                |neg Rq(reg)
        end
        return
    end

    -- two operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        context.reg_index = context.reg_index - 1
            |pop Rq(context.free_reg)
            |sub qword [rsp], Rq(context.free_reg)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local dst = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |sub Rq(dst), [rsp]
            |add rsp, 8
        return
    end

    -- operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]

    context.reg_index = context.reg_index - 1

        |sub Rq(dst), Rq(src)
end

function gen.imul(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Too few multiply operands')
    end

    -- two operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        context.reg_index = context.reg_index - 1
            |pop Rq(context.free_reg)
            |imul Rq(context.free_reg), qword [rsp]
            |mov qword [rsp], Rq(context.free_ref)
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local dst = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |imul Rq(dst), [rsp]
            |add rsp, 8
        return
    end

    -- operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]

    context.reg_index = context.reg_index - 1

        |imul Rq(dst), Rq(src)
end

-- divide head+1 by head+
-- pop head and result placed on head
function gen.idiv(Dst, context)
    if context.reg_index == 1 or context.reg_index == 2 then
        error('Nothing to integer div. Stack is empty')
    end

    -- two operands in stack
    if context.reg_stack[context.reg_index - 2] == nil then
        context.reg_index = context.reg_index - 1
            |push Rq(2)
            |push Rq(0)

            |xor Rq(2), Rq(2)
            |mov Rq(0), qword [rsp+24]
            |idiv qword [rsp+16]
            |mov qword [rsp+24], Rq(0)

            |pop Rq(0)
            |pop Rq(2)

            |add rsp, 8
        return
    end

    -- one operand in stack
    if context.reg_stack[context.reg_index - 1] == nil then
        local dst = context.reg_stack[context.reg_index - 2]
        context.reg_index = context.reg_index - 1
            |push Rq(2)
            |push Rq(0)

            |xor Rq(2), Rq(2)
            |mov Rq(0), Rq(dst)
            |idiv qword [rsp+16]
            |mov Rq(dst), Rq(0)

            |pop Rq(0)
            |pop Rq(2)
            |add rsp, 8
        return
    end

    -- operands in registers
    local dst = context.reg_stack[context.reg_index - 2]
    local src = context.reg_stack[context.reg_index - 1]

    context.reg_index = context.reg_index - 1

        |push Rq(2)
        |push Rq(0)

        |xor Rq(2), Rq(2)
        |mov Rq(0), Rq(dst)
        |idiv Rq(src)
        |mov Rq(dst), Rq(0)

        |pop Rq(0)
        |pop Rq(2)
end

function gen.call(Dst, ffisymbol)
    if ffi.C[ffisymbol] == nil then
        error('ffi symbol ' .. ffisymbol .. ' not found')
    end
    local ffiaddr = ffi.C[ffisymbol]

        |mov64 rax, ffiaddr
        |call rax
end


function gen.nop(Dst, context)
        |nop
end

function gen.int3(Dst, context)
        |int3
end

function gen.prolog(Dst, context)
        |push rbp
        |mov rbp,rsp

        |push r15
        |push r14
        |push r13
        |push r12
        |push rbx
end

function gen.epilog(Dst, context)
        |pop rbx
        |pop r12
        |pop r13
        |pop r14
        |pop r15

        |mov rsp,rbp
        |pop rbp

        |ret
end

_G.diff = 1
function gen.test(Dst)
        |add rax, _G.diff
end

return {gen = gen, actions = actions, globalnames = globalnames}