Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.45.0

0.45.0 / src / back / native / x86_64 / helpers.lucb

#==============================================================================================
#
#   x86_64/helpers - Helpers
#
#   DESCRIPTION:
#       Functions of registers, classes, and operands that need no generator.
#
#==============================================================================================
# mark: Helpers ================================================================================
import strings

## The registers a fallible result of up to four words comes back in (private_words).
let private_result_registers: str[4] = ["%rax", "%rdx", "%rcx", "%r8"]
let private_result_narrow: str[4] = ["%eax", "%edx", "%ecx", "%r8d"]
let windows_arguments: str[4] = ["%rcx", "%rdx", "%r8", "%r9"]

## Windows' nonvolatile registers the allocator does not hand out, and the lines that stand
## for their saves and restores until the function's text shows which it names.
let windows_nonvolatile: str[12] = ["%rdi", "%rsi", "%xmm6", "%xmm7", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15"]
let windows_save_marker: str = "# lb: windows saves"
let windows_restore_marker: str = "# lb: windows restores"

## The bytes of a save area holding the registers `plan` marks: rdi and rsi first, eight
## bytes each, then the xmm registers, sixteen each.
func save_area(plan: u16) -> u64:
    let ints = (u64)(plan & 1) + (u64)((plan >> 1) & 1)
    var floats: u64 = 0
    for i in 2..<12:
        floats += (u64)((plan >> (u16)i) & 1)
    return round_up16(ints * 8) + floats * 16

## Where, below the frame's top, register `i` of `plan` is saved.
func save_offset(plan: u16, i: i64) -> u64:
    var before: u64 = 0
    if i < 2:
        if i == 1:
            before = (u64)(plan & 1)
        return (before + 1) * 8
    for k in 2..<i:
        before += (u64)((plan >> (u16)k) & 1)
    let ints = (u64)(plan & 1) + (u64)((plan >> 1) & 1)
    return round_up16(ints * 8) + (before + 1) * 16

func round_up16(n: u64) -> u64:
    return (n + 15) & ~(u64)15

## Whether an assembly line names Windows nonvolatile register `i`, in any width.
func names_register(line: str, i: usize) -> bool:
    if i == 0:
        return has_text(line, "%rdi") or has_text(line, "%edi") or has_text(line, "%di")
    if i == 1:
        return has_text(line, "%rsi") or has_text(line, "%esi") or has_text(line, "%si")
    let name = windows_nonvolatile[i]
    var position: usize = 0
    while position + name.length <= line.length:
        if has_text_at(line, name, position):
            # %xmm1 is not %xmm10: the name ends where the digits do
            let next = position + name.length
            if next >= line.length or line.bytes[next] < '0' or line.bytes[next] > '9':
                return true
        position += 1
    return false

func has_text(line: str, part: str) -> bool:
    var position: usize = 0
    while position + part.length <= line.length:
        if has_text_at(line, part, position):
            return true
        position += 1
    return false

func has_text_at(line: str, part: str, at: usize) -> bool:
    for k in 0..<part.length:
        if line.bytes[at + k] != part.bytes[k]:
            return false
    return true

## The registers the allocator hands out, by code, under each convention, in their four
## widths (an xmm register has one name). Codes 1–5 are the callee-saved rbx and r12–r15 on
## both. System V: 6–11 the caller-saved r8, r9, rsi, rdi, rdx and rcx, for integers that
## cross no call, which a call's parallel move fills last; 12–25 the caller-saved
## xmm8–xmm12, xmm7 down to xmm0 (the argument registers last), and xmm13, for floats and
## vectors. Windows x64: 6–15 the nonvolatile xmm6–xmm15, which the save area holds whole
## (`settle_windows_saves`); 16–21 r8, r9, rdx, rcx, rsi and rdi, which the allocator treats
## as a call's to clobber although rsi and rdi are nonvolatile (the save area holds them too
## when the text names them); 22–25 the volatile xmm3 down to xmm0. rdx and rcx are a
## temporary's except across an instruction that names them itself (`fixed_clobbers`): a
## division, a shift by a variable count. rax, r10 and r11 are the generator's integer
## scratch registers (`reg`), no temporary's. The float scratch registers are no
## temporary's either: xmm14 and xmm15 on System V, xmm4 and xmm5 on Windows; the third,
## xmm13 or xmm15, is kept out of the pools only in a function that needs it
## (`third_scratch`).
let sysv_q: str[26] = ["", "%rbx", "%r12", "%r13", "%r14", "%r15", "%r8", "%r9", "%rsi", "%rdi", "%rdx", "%rcx", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm7", "%xmm6", "%xmm5", "%xmm4", "%xmm3", "%xmm2", "%xmm1", "%xmm0", "%xmm13"]
let sysv_l: str[26] = ["", "%ebx", "%r12d", "%r13d", "%r14d", "%r15d", "%r8d", "%r9d", "%esi", "%edi", "%edx", "%ecx", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm7", "%xmm6", "%xmm5", "%xmm4", "%xmm3", "%xmm2", "%xmm1", "%xmm0", "%xmm13"]
let sysv_w: str[26] = ["", "%bx", "%r12w", "%r13w", "%r14w", "%r15w", "%r8w", "%r9w", "%si", "%di", "%dx", "%cx", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm7", "%xmm6", "%xmm5", "%xmm4", "%xmm3", "%xmm2", "%xmm1", "%xmm0", "%xmm13"]
let sysv_b: str[26] = ["", "%bl", "%r12b", "%r13b", "%r14b", "%r15b", "%r8b", "%r9b", "%sil", "%dil", "%dl", "%cl", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm7", "%xmm6", "%xmm5", "%xmm4", "%xmm3", "%xmm2", "%xmm1", "%xmm0", "%xmm13"]
let windows_q: str[26] = ["", "%rbx", "%r12", "%r13", "%r14", "%r15", "%xmm6", "%xmm7", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15", "%r8", "%r9", "%rdx", "%rcx", "%rsi", "%rdi", "%xmm3", "%xmm2", "%xmm1", "%xmm0"]
let windows_l: str[26] = ["", "%ebx", "%r12d", "%r13d", "%r14d", "%r15d", "%xmm6", "%xmm7", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15", "%r8d", "%r9d", "%edx", "%ecx", "%esi", "%edi", "%xmm3", "%xmm2", "%xmm1", "%xmm0"]
let windows_w: str[26] = ["", "%bx", "%r12w", "%r13w", "%r14w", "%r15w", "%xmm6", "%xmm7", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15", "%r8w", "%r9w", "%dx", "%cx", "%si", "%di", "%xmm3", "%xmm2", "%xmm1", "%xmm0"]
let windows_b: str[26] = ["", "%bl", "%r12b", "%r13b", "%r14b", "%r15b", "%xmm6", "%xmm7", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15", "%r8b", "%r9b", "%dl", "%cl", "%sil", "%dil", "%xmm3", "%xmm2", "%xmm1", "%xmm0"]

## The register set of each convention (`frame.Registers`), as the tables above number it.
## Floats live only in the frame's own registers on x86-64: no slot is promoted to an xmm
## register, and Windows saves its nonvolatile ones itself. Where floats want more registers
## than there are, a float constant is formed at each use (`constant`) instead of keeping one.
func registers_of(windows: bool) -> frame.Registers:
    if windows:
        return frame.Registers(ints = 5, floats = 10, keep_ints = 2, keep_floats = 0, scratch_ints = 6, scratch_floats = 4, frame_floats = false, formed_constants = true)
    return frame.Registers(ints = 5, floats = 0, keep_ints = 2, keep_floats = 0, scratch_ints = 6, scratch_floats = 14, frame_floats = false, formed_constants = true)

## The code of the third float scratch register, xmm13 on System V and xmm15 on Windows,
## which the pools give up in a function that needs it (`third_scratch`).
func third_scratch_code(windows: bool) -> u8:
    return 15 if windows else 25

## The code of rcx (`rcx`) or rdx under a convention, by the tables above.
func fixed_code(windows: bool, rcx: bool) -> u8:
    if windows:
        return 19 if rcx else 18
    return 11 if rcx else 10

## Whether `r` is a constant an instruction carries as a sign-extended 32-bit immediate.
func fits_immediate(r: ir.Ref) -> bool:
    return r.kind == ir.RefKind.constant and r.value >= -2147483648 and r.value <= 2147483647

## Whether `r` is a factor an unsigned checked multiply takes as an immediate
## (`checked_constant`): a constant from 2 up that fits one.
func constant_factor(r: ir.Ref) -> bool:
    return fits_immediate(r) and r.value >= 2

## Whether `bits` are a NaN's of float class `cls` (a single's in the low half).
func is_nan_bits(bits: u64, cls: ir.Class) -> bool:
    if cls == ir.Class.s:
        return (bits & 0x7fffffff) > 0x7f800000
    return (bits & 0x7fffffffffffffff) > 0x7ff0000000000000

## Whether an aggregate of `size` bytes ends in an eightbyte of other than four or eight.
func partial_eightbyte(size: u32) -> bool:
    return size > 0 and size % 8 != 0 and size % 8 != 4

## The xmm register's number in a name `%xmmN`, or 16 for any other name.
func xmm_number(reg: str) -> u8:
    if reg.length < 5 or reg.bytes[1] != 'x':
        return 16
    var n: u8 = reg.bytes[4] - '0'
    if reg.length == 6:
        n = n * 10 + (reg.bytes[5] - '0')
    return n

let xmm_names: str[16] = ["%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15"]

## Every integer register this generator names, in its four widths, for the views.
let all_q: str[14] = ["%rax", "%rcx", "%rdx", "%rbx", "%rsi", "%rdi", "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"]
let all_l: str[14] = ["%eax", "%ecx", "%edx", "%ebx", "%esi", "%edi", "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"]
let all_w: str[14] = ["%ax", "%cx", "%dx", "%bx", "%si", "%di", "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"]
let all_b: str[14] = ["%al", "%cl", "%dl", "%bl", "%sil", "%dil", "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"]

let argument_names: str[6] = ["%rdi", "%rsi", "%rdx", "%rcx", "%r8", "%r9"]
let float_argument_names: str[8] = ["%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7"]

## The index of `reg` among the integer registers, in any width, or 14.
func register_index(reg: str) -> usize:
    var k: usize = 0
    while k < 14:
        if all_q[k] == reg or all_l[k] == reg or all_w[k] == reg or all_b[k] == reg:
            return k
        k += 1
    return 14

func wide_name(reg: str) -> str:
    let k = register_index(reg)
    return all_q[k] if k < 14 else reg

func narrow_name(reg: str) -> str:
    let k = register_index(reg)
    return all_l[k] if k < 14 else reg

func word_name(reg: str) -> str:
    let k = register_index(reg)
    return all_w[k] if k < 14 else reg

func byte_name(reg: str) -> str:
    let k = register_index(reg)
    return all_b[k] if k < 14 else reg

## `reg` in the width of `width` bytes.
func register_of_width(reg: str, width: u64) -> str:
    if width == 8:
        return wide_name(reg)
    if width == 4:
        return narrow_name(reg)
    if width == 2:
        return word_name(reg)
    return byte_name(reg)

## Whether `reg` is a 32-bit name.
func is_narrow(reg: str) -> bool:
    let k = register_index(reg)
    return k < 14 and all_l[k] == reg

func is_int_class(c: ir.Class) -> bool:
    return c == ir.Class.w or c == ir.Class.l

## The register-to-register move of a class.
func register_move(cls: ir.Class) -> str:
    if cls == ir.Class.w:
        return "movl "
    if cls == ir.Class.l:
        return "movq "
    return "movaps "

func store_word_mnemonic(width: u64) -> str:
    if width == 8:
        return "movq "
    if width == 4:
        return "movl "
    if width == 2:
        return "movw "
    return "movb "

## The load that zero-extends `width` bytes into a register.
func zero_extending_load(width: u32) -> str:
    if width == 8:
        return "movq "
    if width == 4:
        return "movl "
    if width == 2:
        return "movzwl "
    return "movzbl "

func width_suffix(width: u32) -> str:
    if width == 1:
        return "b"
    if width == 2:
        return "w"
    if width == 4:
        return "l"
    return "q"

func count_bits(v: u8) -> u32:
    return (u32)(v & 1) + (u32)((v >> 1) & 1)

## A register name with its `%`, whether the source wrote one or not.
func with_percent(name: str) -> str:
    if name.length > 0 and name.bytes[0] == '%':
        return name
    var room: u8[32]
    let spelled = strings.format(room, f"%{name}") catch failure:
        return name
    let copy = new u8[spelled.length] --- catch failure:
        return name
    memory.copy(copy, spelled.bytes, spelled.length)
    return (str)copy

func load_mnemonic(op: ir.Op) -> str:
    match op:
        .loadsb: return "movsbl "
        .loadub: return "movzbl "
        .loadsh: return "movswl "
        .loaduh: return "movzwl "
        .loadsw: return "movslq "
        .loaduw: return "movl "
        .loads: return "movss "
        .loadd: return "movsd "
        _: return "movq "

func store_mnemonic(op: ir.Op) -> str:
    match op:
        .storew: return "movl "
        .stores: return "movss "
        .stored: return "movsd "
        _: return "movq "

func round_up(value: u64, align: u64) -> u64:
    if align <= 1:
        return value
    return (value + align - 1) // align * align

test "immediates, views, and byte moves assemble":
    var backing: u8[1048576]
    var arena = memory.FixedBuffer.over(backing)
    with arena:
        var u = try ir.Unit.create()
        var g = try Generator.create(&u)
        try g.load_immediate("%rax", 0)
        try g.load_immediate("%eax", -5)
        try g.load_immediate("%rax", 70000)
        try g.load_immediate("%rax", 4890909195324358656)
        try g.frame_address("%rax", 5000)
        try g.load_bytes("%rax", "%r10", 8, 3)
        try g.store_bytes("%rax", "%r10", 8, 7)
        let text = g.text()
        assert(text.length > 0)
        assert(narrow_name("%r12") == "%r12d")
        assert(byte_name("%rsi") == "%sil")
        assert(word_name("%eax") == "%ax")
        assert(wide_name("%ecx") == "%rcx")
        assert(register_of_width("%rdx", 1) == "%dl")
        assert(count_bits(3) == 2)
        assert(with_percent("rdi") == "%rdi")
        assert(with_percent("%xmm8") == "%xmm8")

## The move of a vector of `bytes` between memory and a register: unaligned, a quadword for
## the eight-byte form.
func vector_move(bytes: u32) -> str:
    return "movdqu " if bytes == 16 else "movq "

## `padd` on lanes of `bits`: `paddb`, `paddw`, `paddd`, `paddq`.
func lane_mnemonic(base: str, bits: u32) -> str:
    if base == "padd":
        return "paddb" if bits == 8 else ("paddw" if bits == 16 else ("paddd" if bits == 32 else "paddq"))
    if base == "psub":
        return "psubb" if bits == 8 else ("psubw" if bits == 16 else ("psubd" if bits == 32 else "psubq"))
    if base == "padds":
        return "paddsb" if bits == 8 else "paddsw"
    if base == "paddus":
        return "paddusb" if bits == 8 else "paddusw"
    if base == "psubs":
        return "psubsb" if bits == 8 else "psubsw"
    return "psubusb" if bits == 8 else "psubusw"

## The two-operand SSE2 instruction of a vector operation on lanes of `shape`.
func vector_mnemonic(op: ir.Op, shape: u32) -> str:
    let bits = ir.lane_bits(shape)
    let signed = ir.lanes_signed(shape)
    let wide = bits == 64
    match op:
        .vadd: return "addpd" if wide else "addps"
        .vsub: return "subpd" if wide else "subps"
        .vmul: return "mulpd" if wide else "mulps"
        .vdiv: return "divpd" if wide else "divps"
        .vand: return "pand"
        .vor: return "por"
        .vxor: return "pxor"
        .vaddw: return lane_mnemonic("padd", bits)
        .vsubw: return lane_mnemonic("psub", bits)
        .vmulw: return "pmullw"
        .vadds: return lane_mnemonic("padds" if signed else "paddus", bits)
        .vsubs: return lane_mnemonic("psubs" if signed else "psubus", bits)
        _: return "paddb"

## Half-float conversion without F16C, for levels below x86-64-v3: `eax` in, `eax` out,
## `ecx`, `edx`, `r10d`, and `r11d` clobbered, nothing on the stack but the return address.
## The single of a half: sign moved up, a normal half's exponent rebiased from 15 to 127, a
## subnormal's mantissa normalised by its top bit (`bsr`), infinity kept, NaN with the payload
## widened and made quiet, as the hardware conversion does. The half of a single, rounding to nearest even as the C compiler's `_Float16`
## does: NaN kept quiet with its payload narrowed, 65520 and above to infinity, a normal
## half from the rebiased exponent with the thirteen dropped bits deciding the rounding,
## a subnormal half from the mantissa with its implicit bit shifted right by the exponent's
## shortfall, and everything below 2^-25 to zero.
let half_routines_text: str = """
    .text
    .p2align 4
.Llb_half_to_single:
    movzwl %ax, %eax
    movl %eax, %edx
    andl $32768, %edx
    shll $16, %edx
    andl $32767, %eax
    cmpl $31744, %eax
    jae 2f
    testl $31744, %eax
    je 3f
    addl $114688, %eax
    shll $13, %eax
    orl %edx, %eax
    ret
2:
    andl $1023, %eax
    je 11f
    shll $13, %eax
    orl $2143289344, %eax
    orl %edx, %eax
    ret
11:
    movl $2139095040, %eax
    orl %edx, %eax
    ret
3:
    testl %eax, %eax
    jne 4f
    movl %edx, %eax
    ret
4:
    movl %eax, %r11d
    bsrl %eax, %ecx
    movl %ecx, %eax
    addl $103, %eax
    shll $23, %eax
    orl %edx, %eax
    negl %ecx
    addl $23, %ecx
    shll %cl, %r11d
    andl $8388607, %r11d
    orl %r11d, %eax
    ret
    .p2align 4
.Llb_single_to_half:
    movl %eax, %edx
    shrl $16, %edx
    andl $32768, %edx
    andl $2147483647, %eax
    cmpl $2139095040, %eax
    jb 2f
    movl %eax, %ecx
    andl $8388607, %ecx
    je 5f
    shrl $13, %ecx
    orl $512, %ecx
    orl $31744, %ecx
    movl %ecx, %eax
    orl %edx, %eax
    ret
5:
    movl $31744, %eax
    orl %edx, %eax
    ret
2:
    cmpl $1199566848, %eax
    jb 6f
    movl $31744, %eax
    orl %edx, %eax
    ret
6:
    cmpl $947912704, %eax
    jb 7f
    subl $939524096, %eax
    movl %eax, %ecx
    andl $8191, %ecx
    shrl $13, %eax
    cmpl $4096, %ecx
    jb 8f
    ja 9f
    testl $1, %eax
    je 8f
9:
    incl %eax
8:
    orl %edx, %eax
    ret
7:
    cmpl $855638016, %eax
    jb 10f
    movl %eax, %ecx
    shrl $23, %ecx
    andl $8388607, %eax
    orl $8388608, %eax
    movl %eax, %r11d
    negl %ecx
    addl $126, %ecx
    shrl %cl, %eax
    movl %eax, %r10d
    shll %cl, %r10d
    subl %r10d, %r11d
    decl %ecx
    movl $1, %r10d
    shll %cl, %r10d
    cmpl %r10d, %r11d
    jb 8b
    ja 9b
    testl $1, %eax
    je 8b
    jmp 9b
10:
    movl %edx, %eax
    ret
"""

## The argument register `%rdi`..`%r9` a name is, as its index, or -1.
func argument_index(name: str) -> i32:
    var k: i32 = 0
    while k < 6:
        if argument_names[(usize)k] == name:
            return k
        k += 1
    return -1