Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.43.0

0.43.0 / src / back / ir / irtext.lucb

#==============================================================================================
#
#   irtext - The IR as text (`--emit=ir`)
#
#   DESCRIPTION:
#       Writes a `ir.Unit` in a form modelled on QBE's: one function per block, temporaries
#       as `%tN`, stack slots as `#N`, symbols as `$name`, text literals as `"index"`, labels
#       as `@LN`, and one instruction per line, `%t3 =w add %t1, %t2`. The text is what the
#       optimisation suite measures and what a reader inspects when a backend misbehaves; it
#       is not read back.
#
#==============================================================================================

import back.ir.ir
import support.buffer

# mark: The unit as text ======================================================================

## The whole unit as text.
pub func render(program: ir.Unit*) -> str!:
    var out = try buffer.Buffer.create(65536)
    var i: usize = 0
    while i < program.functions.count:
        let f = &program.functions.items[i]
        try function(&out, f)
        i += 1
    return out.view()

## One function: its header, slots, and instructions.
func function(out: buffer.Buffer*, f: ir.Function*) -> !:
    try out.put("function ")
    if f.exported:
        try out.put("export ")
    try out.put("$")
    try out.put(f.name)
    try out.put("(")
    var i: usize = 0
    while i < f.params.count:
        let p = f.params.get(i)
        if i > 0:
            try out.put(", ")
        try out.put(class_name(p.cls))
        try out.put(" #")
        try out.put_u64((u64)p.slot)
        i += 1
    try out.put(")")
    if f.has_result:
        try out.put(" -> ")
        try out.put(class_name(f.result_cls))
    try out.put(":\n")
    i = 0
    while i < f.slots.count:
        let s = f.slots.get(i)
        try out.put("    slot #")
        try out.put_u64((u64)i)
        try out.put(" ")
        try out.put_u64((u64)s.size)
        try out.put(" align ")
        try out.put_u64((u64)s.align)
        if s.level > 0:
            try out.put(" level ")
            try out.put_u64((u64)s.level)
            try out.put(" at ")
            try out.put_u64((u64)s.offset)
        try out.put("\n")
        i += 1
    i = 0
    while i < f.instrs.count:
        try instruction(out, f, f.instrs.get(i))
        i += 1
    try out.put("\n")

## A `switch`'s operands: `switch %t, @default, low [@L, @L, ...]`.
func jump_table(out: buffer.Buffer*, f: ir.Function*, x: ir.Instr) -> !:
    let table = f.jump_tables.get((usize)x.extra2)
    try out.put(" ")
    try operand(out, x.a)
    try out.put(", @L")
    try out.put_u64((u64)x.extra)
    try out.put(", ")
    try out.put_i64(table.low)
    try out.put(" [")
    let targets = f.table_targets(x.extra2)
    for k in 0..<targets.length:
        try out.put("@L" if k == 0 else ", @L")
        try out.put_u64((u64)targets[k])
    try out.put("]")

## A call's callee and its arguments, each with its class.
func call(out: buffer.Buffer*, f: ir.Function*, x: ir.Instr) -> !:
    try out.put(" ")
    try operand(out, x.a)
    try out.put("(")
    let info = f.calls.get((usize)x.extra)
    var k: usize = 0
    while k < (usize)info.args_count:
        let a = f.args.get((usize)info.args_start + k)
        if k > 0:
            try out.put(", ")
        try out.put(class_name(a.cls))
        try out.put(" ")
        try operand(out, a.value)
        k += 1
    try out.put(")")

func instruction(out: buffer.Buffer*, f: ir.Function*, x: ir.Instr) -> !:
    if x.op == ir.Op.label:
        try out.put("@L")
        try out.put_u64((u64)x.extra)
        try out.put(":\n")
        return
    try out.put("    ")
    if x.dst != 0:
        try out.put("%t")
        try out.put_u64((u64)x.dst)
        try out.put(" =")
        try out.put(class_name(x.cls))
        try out.put(" ")
    try out.put(op_name(x.op))
    match x.op:
        .jmp:
            try out.put(" @L")
            try out.put_u64((u64)x.extra)
        .jnz:
            try out.put(" ")
            try operand(out, x.a)
            try out.put(", @L")
            try out.put_u64((u64)x.extra)
            try out.put(", @L")
            try out.put_u64((u64)x.extra2)
        .switch_:
            try jump_table(out, f, x)
        .ret:
            if x.a.kind != ir.RefKind.none_:
                try out.put(" ")
                try operand(out, x.a)
            var k: u32 = 0
            while k < x.extra2:
                try out.put(", " if k > 0 else " ")
                try operand(out, f.args.get((usize)(x.extra + k)).value)
                k += 1
        .word, .reserve:
            try out.put(" ")
            try out.put_u64((u64)x.extra)
        .call:
            try call(out, f, x)
        .blit, .zero, .fill:
            try out.put(" ")
            try operand(out, x.a)
            if x.op != ir.Op.zero:
                try out.put(", ")
                try operand(out, x.b)
            try out.put(", ")
            try out.put_u64((u64)x.extra)
        .addo, .subo, .mulo, .bounds:
            try out.put(" ")
            try operand(out, x.a)
            try out.put(", ")
            try operand(out, x.b)
            if x.op == ir.Op.bounds and x.extra == 1:
                try out.put(", one past")
        .phi:
            var k: u32 = 0
            while k < x.extra2:
                let arg = f.phi_args.get((usize)(x.extra + k))
                try out.put(" " if k == 0 else ", ")
                try out.put("@L")
                try out.put_u64((u64)arg.pred)
                try out.put(" ")
                try operand(out, arg.value)
                k += 1
        _:
            if x.a.kind != ir.RefKind.none_:
                try out.put(" ")
                try operand(out, x.a)
            if x.b.kind != ir.RefKind.none_:
                try out.put(", ")
                try operand(out, x.b)
            if x.op == ir.Op.fma or x.op == ir.Op.select:
                try out.put(", ")
                try operand(out, f.args.get((usize)x.extra2).value)
            if ir.is_vector_op(x.op):
                # the lane shape: `[4 x s32]`, `[2 x f64]`
                try out.put(" [")
                try out.put_u64((u64)ir.lane_count(x.extra))
                try out.put(" x ")
                try out.put("f" if ir.lanes_float(x.extra) else ("s" if ir.lanes_signed(x.extra) else "u"))
                try out.put_u64((u64)ir.lane_bits(x.extra))
                try out.put("]")
                if x.op == ir.Op.vinsert or x.op == ir.Op.vextract:
                    try out.put(" lane ")
                    try out.put_u64((u64)x.extra2)
            elif x.extra != 0 and x.op != ir.Op.trap_:
                try out.put(" [")
                try out.put_u64((u64)x.extra)
                try out.put("]")
    try out.put("\n")

func operand(out: buffer.Buffer*, r: ir.Ref) -> !:
    match r.kind:
        .temp:
            try out.put("%t")
            try out.put_u64((u64)r.index)
        .constant:
            try out.put_i64(r.value)
        .slot:
            try out.put("#")
            try out.put_u64((u64)r.index)
        .global, .function:
            try out.put("$")
            try out.put(r.name)
        .text:
            try out.put("\"")
            try out.put_u64((u64)r.index)
            try out.put("\"")
        _:
            try out.put("_")

# mark: Class and op names ====================================================================

func class_name(c: ir.Class) -> str:
    match c:
        .w: return "w"
        .l: return "l"
        .s: return "s"
        .d: return "d"
        .h: return "h"
        .v: return "v"
        _: return "?"

func op_name(op: ir.Op) -> str:
    match op:
        .copy: return "copy"
        .add: return "add"
        .sub: return "sub"
        .mul: return "mul"
        .sdiv: return "sdiv"
        .udiv: return "udiv"
        .srem: return "srem"
        .urem: return "urem"
        .and_: return "and"
        .or_: return "or"
        .xor: return "xor"
        .shl: return "shl"
        .lshr: return "lshr"
        .ashr: return "ashr"
        .neg: return "neg"
        .fsqrt: return "fsqrt"
        .ffloor: return "ffloor"
        .fceil: return "fceil"
        .ftrunc: return "ftrunc"
        .fround: return "fround"
        .fabs: return "fabs"
        .ceq: return "ceq"
        .cne: return "cne"
        .cslt: return "cslt"
        .csle: return "csle"
        .csgt: return "csgt"
        .csge: return "csge"
        .cult: return "cult"
        .cule: return "cule"
        .cugt: return "cugt"
        .cuge: return "cuge"
        .loadsb: return "loadsb"
        .loadub: return "loadub"
        .loadsh: return "loadsh"
        .loaduh: return "loaduh"
        .loadsw: return "loadsw"
        .loaduw: return "loaduw"
        .loadl: return "loadl"
        .loads: return "loads"
        .loadd: return "loadd"
        .loadhf: return "loadhf"
        .storeb: return "storeb"
        .storeh: return "storeh"
        .storew: return "storew"
        .storel: return "storel"
        .stores: return "stores"
        .stored: return "stored"
        .storehf: return "storehf"
        .extsb: return "extsb"
        .extub: return "extub"
        .extsh: return "extsh"
        .extuh: return "extuh"
        .extsw: return "extsw"
        .extuw: return "extuw"
        .exts: return "exts"
        .truncd: return "truncd"
        .stosi: return "stosi"
        .stoui: return "stoui"
        .dtosi: return "dtosi"
        .dtoui: return "dtoui"
        .swtof: return "swtof"
        .uwtof: return "uwtof"
        .sltof: return "sltof"
        .ultof: return "ultof"
        .cast: return "cast"
        .exth: return "exth"
        .truncs: return "truncs"
        .addr: return "addr"
        .blit: return "blit"
        .zero: return "zero"
        .fill: return "fill"
        .call: return "call"
        .word: return "word"
        .reserve: return "reserve"
        .alloca: return "alloca"
        .label: return "label"
        .jmp: return "jmp"
        .jnz: return "jnz"
        .switch_: return "switch"
        .ret: return "ret"
        .trap_: return "trap"
        .bounds: return "bounds"
        .addo: return "addo"
        .subo: return "subo"
        .mulo: return "mulo"
        .addr_tls: return "addr_tls"
        .asm_: return "asm"
        .atomic_load: return "atomic_load"
        .atomic_store: return "atomic_store"
        .atomic_add: return "atomic_add"
        .atomic_sub: return "atomic_sub"
        .atomic_or: return "atomic_or"
        .atomic_and_not: return "atomic_and_not"
        .atomic_xor: return "atomic_xor"
        .atomic_swap: return "atomic_swap"
        .atomic_max: return "atomic_max"
        .atomic_min: return "atomic_min"
        .atomic_cas: return "atomic_cas"
        .fence: return "fence"
        .frame: return "frame"
        .set_reg: return "set_reg"
        .get_reg: return "get_reg"
        .phi: return "phi"
        .loadv: return "loadv"
        .storev: return "storev"
        .vadd: return "vadd"
        .vsub: return "vsub"
        .vmul: return "vmul"
        .vdiv: return "vdiv"
        .vand: return "vand"
        .vor: return "vor"
        .vxor: return "vxor"
        .vneg: return "vneg"
        .vnot: return "vnot"
        .vaddw: return "vaddw"
        .vsubw: return "vsubw"
        .vmulw: return "vmulw"
        .vaddo: return "vaddo"
        .vsubo: return "vsubo"
        .vadds: return "vadds"
        .vsubs: return "vsubs"
        .vshl: return "vshl"
        .vshr: return "vshr"
        .vsplat: return "vsplat"
        .vinsert: return "vinsert"
        .vextract: return "vextract"
        .vsqrt: return "vsqrt"
        .vexts: return "vexts"
        .vtruncd: return "vtruncd"
        .fma: return "fma"
        .select: return "select"
        .dbg: return "dbg"
        _: return "?"