Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.41.0

0.41.0 / src / back / native / arm64 / registers.lucb

#==============================================================================================
#
#   arm64/registers - Registers and immediates
#
#   DESCRIPTION:
#       The register each class and number names, immediates that fit, and a slot's
#       or a temporary's place in the frame.
#
#==============================================================================================
extend Generator:
    # mark: Registers and immediates ===========================================================

    ## `movz`/`movk` for any 64-bit value.
    func load_immediate(reg: str, value: i64) -> !:
        let bits = (u64)value
        if bits == 0:
            try self.writer.line("mov ")
            try self.writer.put(reg)
            try self.writer.put(", #0")
            return
        # a negative number is shorter with movn
        if value < 0 and value >= -65536:
            try self.writer.line("movn ")
            try self.writer.put(reg)
            try self.writer.put(", #")
            try self.writer.put_u64((u64)(-1 - value))
            return
        var first = true
        var shift: u64 = 0
        while shift < 64:
            let piece = (bits >> shift) & 65535
            if piece != 0 or (first and shift == 48):
                try self.writer.line("movz " if first else "movk ")
                try self.writer.put(reg)
                try self.writer.put(", #")
                try self.writer.put_u64(piece)
                if shift > 0:
                    try self.writer.put(", lsl #")
                    try self.writer.put_u64(shift)
                first = false
            shift += 16

    ## The memory operand `[sp, #n]` for the frame home `offset` bytes below x29, for an
    ## access of `width` bytes: the scaled unsigned form reaches 4095 units of the width.
    ## The frame is laid out before any instruction is emitted, so `frame` is known.
    func frame_fits(offset: u64, width: u64) -> bool:
        if offset > self.fr.size:
            return false
        let n = self.fr.size - offset + self.frame_bias()
        return n % width == 0 and n // width <= 4095

    func frame_operand(offset: u64) -> !:
        try self.writer.put("[x28, #" if self.frame_base else "[sp, #")
        try self.writer.put_u64(self.fr.size - offset + self.frame_bias())
        try self.writer.put("]")

    ## How far below the frame's bottom sp is: none through x28 (`frame_base`).
    func frame_bias() -> u64:
        if self.frame_base:
            return 0
        return self.sp_shift + self.dynamic_shift

    ## `reg` stored to or loaded from the frame home `offset`: through sp when the offset
    ## reaches, else through an address in x16.
    ## A half register stores through its single view, so its home's whole word is written
    ## and a reinterpretation as an integer reads zeros above the half.
    func frame_store(reg: str, offset: u64) -> !:
        let spelled = single_view(reg)
        if self.frame_fits(offset, access_width_of(spelled)):
            try self.writer.line3("str ", spelled, ", ")
            try self.frame_operand(offset)
            return
        try self.frame_address("x16", offset)
        try self.writer.line3("str ", spelled, ", [x16]")

    func frame_load(reg: str, offset: u64) -> !:
        if self.frame_fits(offset, access_width_of(reg)):
            try self.writer.line3("ldr ", reg, ", ")
            try self.frame_operand(offset)
            return
        try self.frame_address("x16", offset)
        try self.writer.line3("ldr ", reg, ", [x16]")

    ## How far below the frame pointer the bytes that `address` names lie, when it is a
    ## slot or a frame address formed at its use (`remat`), for an access by `op` that
    ## addresses the frame directly; none for any other address, or a half's access.
    func frame_place(address: ir.Ref, op: ir.Op) -> u64?:
        if op == ir.Op.loadhf or op == ir.Op.storehf:
            return none
        if address.kind == ir.RefKind.slot:
            return self.slot_home(address.index)
        if address.kind == ir.RefKind.temp and self.fr.temp_regs.get((usize)address.index - 1) == 0:
            return self.fr.rematerialised(address.index)
        return none

    ## A load or store at `base + offset`, the add that formed the address folded into it
    ## (`selection.offset_access`).
    func offset_access(n: ir.Instr, base: ir.Ref, offset: i64) -> !:
        if (u8)n.op <= (u8)ir.Op.loadd:
            let lc = ir.load_class(n.op)
            let d = self.target(n.dst, lc, load_register(n.op))
            let b = try self.source(base, ir.Class.l, "x10")
            try self.writer.line4(load_mnemonic(n.op), " ", d, ", [")
            try self.writer.put(b)
            try self.writer.put(", #")
            try self.writer.put_i64(offset)
            try self.writer.put("]")
            try self.finish(n.dst, lc, d)
            return
        let cls = ir.store_class(n.op)
        let v = try self.source(n.a, cls, scratch_register(cls, 0))
        let b = try self.source(base, ir.Class.l, "x10")
        try self.writer.line4(store_mnemonic(n.op), " ", v, ", [")
        try self.writer.put(b)
        try self.writer.put(", #")
        try self.writer.put_i64(offset)
        try self.writer.put("]")

    ## Emit instructions `at` to `at + 2` as one scaled-index access when they are one
    ## (`selection.scaled_access`), and the widening after when the access is a signed
    ## word's load (`access_at`); how many instructions that was.
    func scaled_access_at(at: usize, uses: u32[], index: usize) -> usize?!:
        let scaled = selection.scaled_access(self.f, at, uses) else return none
        let (base, scaled_index, shift) = scaled
        if self.fr.is_rematerialised(self.f.instrs.get(at).dst) or self.fr.is_rematerialised(self.f.instrs.get(at + 1).dst):
            return none
        if let dw = self.dw:
            try dw.mark(&self.writer.out, self.f, &self.fr, index, at + 2)
        let (access, widened) = self.access_at(at + 2, uses)
        try self.indexed_access(access, base, scaled_index, shift)
        return 3 + widened

    ## `add d, other, x, lsl #shift` for a shift and the add of it after
    ## (`selection.shifted_add`).
    func shifted_add(n: ir.Instr, fused: (ir.Ref, ir.Ref, u32)) -> !:
        let (other, shifted, shift) = fused
        let o = try self.source(other, n.cls, scratch_register(n.cls, 0))
        let x = try self.source(shifted, n.cls, scratch_register(n.cls, 1))
        let d = self.target(n.dst, n.cls, scratch_register(n.cls, 0))
        try self.writer.line5("add ", d, ", ", o, ", ")
        try self.writer.put(x)
        try self.writer.put(", lsl #")
        try self.writer.put_u64((u64)shift)
        try self.finish(n.dst, n.cls, d)

    ## Emit instructions `at` and `at + 1` as one register-offset access when they are one
    ## (`selection.summed_access`), and the widening after as `scaled_access_at` does; how
    ## many instructions that was.
    func summed_access_at(at: usize, uses: u32[], index: usize) -> usize?!:
        let summed = selection.summed_access(self.f, at, uses) else return none
        let (base, offset) = summed
        if self.fr.is_rematerialised(self.f.instrs.get(at).dst):
            return none
        if let dw = self.dw:
            try dw.mark(&self.writer.out, self.f, &self.fr, index, at + 1)
        let (access, widened) = self.access_at(at + 1, uses)
        try self.indexed_access(access, base, offset, 0)
        return 2 + widened

    ## A load or store through `base + (index << shift)` (`selection.scaled_access`), the
    ## scaling and the sum done by the addressing: `ldr w0, [x1, x2, lsl #2]`.
    func indexed_access(n: ir.Instr, base: ir.Ref, index: ir.Ref, shift: u32) -> !:
        let b = try self.source(base, ir.Class.l, "x10")
        let x = try self.source(index, ir.Class.l, "x11")
        if (u8)n.op <= (u8)ir.Op.loadd:
            let lc = ir.load_class(n.op)
            let d = self.target(n.dst, lc, load_register(n.op))
            try self.writer.line4(load_mnemonic(n.op), " ", d, ", [")
            try self.writer.put(b)
            try self.writer.put(", ")
            try self.writer.put(x)
            if shift != 0:
                try self.writer.put(", lsl #")
                try self.writer.put_u64((u64)shift)
            try self.writer.put("]")
            try self.finish(n.dst, lc, d)
            return
        let cls = ir.store_class(n.op)
        let v = try self.source(n.a, cls, scratch_register(cls, 0))
        try self.writer.line4(store_mnemonic(n.op), " ", v, ", [")
        try self.writer.put(b)
        try self.writer.put(", ")
        try self.writer.put(x)
        if shift != 0:
            try self.writer.put(", lsl #")
            try self.writer.put_u64((u64)shift)
        try self.writer.put("]")

    ## `mnemonic reg` to or from the frame `below` bytes under x29, `width` bytes wide:
    ## through sp when the scaled offset reaches, else x29 with an unscaled one, else an
    ## address in x16.
    func frame_access(mnemonic: str, reg: str, below: u64, width: u32) -> !:
        if self.frame_fits(below, (u64)width):
            try self.writer.line4(mnemonic, " ", reg, ", ")
            try self.frame_operand(below)
        elif below <= 256:
            try self.writer.line4(mnemonic, " ", reg, ", [x29, #-")
            try self.writer.put_u64(below)
            try self.writer.put("]")
        else:
            try self.frame_address("x16", below)
            try self.writer.line4(mnemonic, " ", reg, ", [x16]")

    ## `reg = x29 - offset`.
    func frame_address(reg: str, offset: u64) -> !:
        if offset <= 4095:
            try self.writer.line("sub ")
            try self.writer.put(reg)
            try self.writer.put(", x29, #")
            try self.writer.put_u64(offset)
            return
        try self.load_immediate("x16", (i64)offset)
        try self.writer.line("sub ")
        try self.writer.put(reg)
        try self.writer.put(", x29, x16")

    ## Before the barrier at instruction `at`: each temporary that keeps a caller-saved
    ## register across it goes to its home (`frame.Frame.crossings`).
    func save_crossing(at: usize) -> !:
        while self.crossing < self.fr.crossings.count and (usize)self.fr.crossings.get(self.crossing).at < at:
            self.crossing += 1
        var k = self.crossing
        while k < self.fr.crossings.count and (usize)self.fr.crossings.get(k).at == at:
            let c = self.fr.crossings.get(k)
            let code = self.fr.temp_regs.get((usize)c.temp - 1)
            let cls = self.f.temp_class(c.temp)
            try self.frame_store(class_name(code, cls), self.temp_home(c.temp))
            k += 1

    ## After it: each comes back from its home.
    func restore_crossing(at: usize) -> !:
        while self.crossing < self.fr.crossings.count and (usize)self.fr.crossings.get(self.crossing).at == at:
            let c = self.fr.crossings.get(self.crossing)
            let code = self.fr.temp_regs.get((usize)c.temp - 1)
            let cls = self.f.temp_class(c.temp)
            try self.frame_load(class_name(code, cls), self.temp_home(c.temp))
            self.crossing += 1

    func temp_home(t: u32) -> u64:
        return self.fr.temp_home(t)

    func slot_home(s: u32) -> u64:
        return self.fr.slot_home(s)

    ## A homogeneous floating-point aggregate (AAPCS64 ยง6.4.2): one to four floats of one
    ## width, one after the other with nothing between; how many, or 0 when the shape is
    ## not one.
    func hfa(shape: u32) -> u32:
        let leaves = self.program_unit.leaves_of(shape)
        if leaves.length == 0 or leaves.length > 4:
            return 0
        let first = leaves[0]
        if not ir.is_float_class(first.cls):
            return 0
        var k: usize = 0
        while k < leaves.length:
            let leaf = leaves[k]
            if leaf.cls != first.cls or leaf.size != first.size or (u64)leaf.offset != (u64)k * (u64)first.size:
                return 0
            k += 1
        return u32(leaves.length)

    ## Load a temporary into `reg`: a register move when it lives in one, else from its home.
    ## A float register moves with `fmov`, an integer one with `mov`; the width follows `reg`.
    ## The register holding `r` as class `cls` when `r` is a temporary living in one of the
    ## right kind, else `scratch` after loading it there. Instructions then read operands
    ## where they are rather than through a scratch register.
    func source(r: ir.Ref, cls: ir.Class, scratch: str) -> str!:
        if r.kind == ir.RefKind.temp:
            let code = self.fr.temp_regs.get((usize)r.index - 1)
            if code != 0 and self.fr.float_code(code) == (ir.is_float_class(cls) or cls == ir.Class.v):
                return class_name(code, cls)
        try self.operand(scratch, cls, r)
        return scratch

    ## The register to compute temporary `dst` into: its own when it lives in one of the
    ## right kind, else `scratch`, which `finish` then stores.
    func target(dst: u32, cls: ir.Class, scratch: str) -> str:
        if dst == 0:
            return scratch
        let code = self.fr.temp_regs.get((usize)dst - 1)
        if code != 0 and self.fr.float_code(code) == (ir.is_float_class(cls) or cls == ir.Class.v):
            return class_name(code, cls)
        return scratch

    ## After a result landed in `reg`: nothing when that is the temporary's own register.
    func finish(dst: u32, cls: ir.Class, reg: str) -> !:
        if dst == 0:
            return
        let code = self.fr.temp_regs.get((usize)dst - 1)
        if code != 0 and class_name(code, cls) == reg:
            return
        try self.store_temp(reg, dst)

    func load_temp(reg: str, cls: ir.Class, t: u32) -> !:
        let code = self.fr.temp_regs.get((usize)t - 1)
        if code != 0:
            let home = register_view(reg, code)
            if home != reg:
                try self.register_move(reg, home, code)
            return
        if let below = self.fr.rematerialised(t):
            # a frame address, formed here (`remat`)
            if reg.bytes[0] == 'x' or reg.bytes[0] == 'w':
                try self.frame_address(as_x(reg), below)
            else:
                try self.frame_address("x16", below)
                try self.fmove(reg, "x16")
            return
        try self.frame_load(reg, self.temp_home(t))

    func store_temp(reg: str, t: u32) -> !:
        let code = self.fr.temp_regs.get((usize)t - 1)
        if code != 0:
            let home = register_view(reg, code)
            if home != reg:
                try self.register_move(home, reg, code)
            return
        try self.frame_store(reg, self.temp_home(t))

    ## `fmov to, from` between float registers, halves included (FEAT_FP16).
    func fmove(target_reg: str, from_reg: str) -> !:
        try self.writer.line("fmov ")
        try self.writer.put(target_reg)
        try self.writer.put(", ")
        try self.writer.put(from_reg)

    ## `to = from` between registers: `mov` for integers, `fmov` for floats, and the whole
    ## vector for a `q` view.
    func register_move(target_reg: str, from_reg: str, code: u8) -> !:
        if target_reg.bytes[0] == 'q':
            try self.writer.line("mov ")
            try self.writer.put(vector_view(target_reg))
            try self.writer.put(".16b, ")
            try self.writer.put(vector_view(from_reg))
            try self.writer.put(".16b")
            return
        if self.fr.float_code(code):
            try self.fmove(target_reg, from_reg)
            return
        try self.writer.line("mov ")
        try self.writer.put(target_reg)
        try self.writer.put(", ")
        try self.writer.put(from_reg)

    ## An operand into a scratch register of class `cls`.
    func operand(reg: str, cls: ir.Class, r: ir.Ref) -> !:
        if r.kind == ir.RefKind.temp:
            let tc = self.f.temp_class(r.index)
            if tc == cls or (is_int_class(tc) and is_int_class(cls)):
                try self.load_temp(reg, cls, r.index)
                return
            # a float temporary read as an integer word or the reverse: reinterpret the home's bytes
            try self.load_temp(reg, cls, r.index)
            return
        if r.kind == ir.RefKind.constant:
            if ir.is_float_class(cls):
                try self.load_immediate("x16", r.value)
                try self.fmove(reg, "x16" if cls == ir.Class.d else "w16")
                return
            try self.load_immediate(as_x(reg), r.value)
            return
        try self.address_operand(as_x(reg), r)

    ## The address a slot, global, function, or text refers to, into an x register.
    func address_operand(reg: str, r: ir.Ref) -> !:
        if r.kind == ir.RefKind.slot:
            try self.frame_address(reg, self.slot_home(r.index))
        elif r.kind == ir.RefKind.global and r.value == 0:
            try object.page_address(&self.object_format, &self.writer.out, reg, r.name, true)
        elif r.kind == ir.RefKind.global or r.kind == ir.RefKind.function:
            # a function's address, or another image's data (`import_ref`), goes through the
            # GOT, so a symbol defined in a linked shared library resolves
            try object.got_address(&self.object_format, &self.writer.out, reg, r.name)
        elif r.kind == ir.RefKind.text:
            try object.page_address(&self.object_format, &self.writer.out, reg, try self.text_label_name(r.index), false)
        elif r.kind == ir.RefKind.temp:
            try self.load_temp(reg, ir.Class.l, r.index)
        elif r.kind == ir.RefKind.constant:
            try self.load_immediate(reg, r.value)
        else:
            try self.writer.line("mov ")
            try self.writer.put(reg)
            try self.writer.put(", #0")

## The register name of class `cls` for scratch number `n` (0, 1, 2).
func scratch_register(cls: ir.Class, n: u32) -> str:
    if cls == ir.Class.w:
        return "w9" if n == 0 else ("w10" if n == 1 else "w11")
    if cls == ir.Class.l:
        return "x9" if n == 0 else ("x10" if n == 1 else "x11")
    if cls == ir.Class.s:
        return "s16" if n == 0 else ("s17" if n == 1 else "s18")
    if cls == ir.Class.h:
        return "h16" if n == 0 else ("h17" if n == 1 else "h18")
    return "d16" if n == 0 else ("d17" if n == 1 else "d18")

## `w9` -> `x9`; a 64-bit immediate load wants the wide name.
func as_x(reg: str) -> str:
    let b = reg.bytes
    if b[0] == 'w':
        if reg == "w9":
            return "x9"
        if reg == "w10":
            return "x10"
        if reg == "w11":
            return "x11"
        if reg == "w16":
            return "x16"
        if reg == "w0":
            return "x0"
        if reg == "w1":
            return "x1"
        if reg == "w2":
            return "x2"
        if reg == "w3":
            return "x3"
        if reg == "w4":
            return "x4"
        if reg == "w5":
            return "x5"
        if reg == "w6":
            return "x6"
        if reg == "w7":
            return "x7"
    return reg