Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.42.0

0.42.0 / src / back / ir / lower / statements.lucb

#==============================================================================================
#
#   lower/statements - Statements
#
#   DESCRIPTION:
#       Blocks, bindings, assignments, loops, returns, and failure.
#
#==============================================================================================
extend Lowerer:
    # mark: Statements =========================================================================

    func block(b: ast.Node*) -> !:
        try self.push_scope(false, "", 0, 0)
        var cursor = b.body
        while let s = cursor:
            try self.stmt(s)
            cursor = s.next
        try self.unwind(self.scopes.count - 1, false)
        self.pop_scope()

    func stmt(s: ast.Node*) -> !:
        # the format buffers this statement takes are free again when it is lowered, and
        # their levels of the dynamic area once it has run
        let pooled = self.pool_used
        try self.statement(s)
        if self.pool_used != pooled:
            self.pool_used = pooled
            let count = self.f.instrs.count
            if count == 0 or not ir.is_terminator(self.f.instrs.get(count - 1).op):
                try self.reserve_levels()

    ## `reserve`: the dynamic area holds the levels of the format buffers taken so far.
    func reserve_levels() -> !:
        try self.f.emit(ir.Op.reserve, ir.Class.l, 0, ir.none_ref(), ir.none_ref(), u32(self.pool_used))

    func statement(s: ast.Node*) -> !:
        if s.kind != ast.Kind.block:
            self.set_position(s)
        if self.f.debug and s.kind != ast.Kind.block and s.line > 0:
            try self.f.points.push(ir.DebugPoint(instruction = self.f.instrs.count, file = self.at_file, line = self.at_line, column = self.at_column))
            # `--debug`: the descriptor, the line, and the frame, before the statement runs
            let start = u32(self.f.args.count)
            try self.f.args.push(ir.Arg(value = try self.descriptor_ref(), cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
            try self.f.args.push(ir.Arg(value = ir.const_ref((i64)s.line), cls = ir.Class.w, size = 0, align = 4, type_id = types.u32_id, shape = 0))
            let frame = try self.f.unary(ir.Op.frame, ir.Class.l, ir.none_ref())
            try self.f.args.push(ir.Arg(value = frame, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
            try self.debug_call("lb_debug_at", start, 3)
        match s.kind:
            .block:
                try self.block(s)
            .let_, .var_:
                try self.binding(s)
            .assign:
                try self.assign(s)
            .if_:
                try self.if_stmt(s)
            .while_:
                try self.while_stmt(s)
            .for_:
                try self.for_stmt(s)
            .match_:
                try self.match_stmt(s, false)
            .return_:
                try self.return_stmt(s)
            .break_, .continue_:
                try self.jump(s)
            .defer_, .errdefer_:
                try self.defers.push(s)
            .recover_:
                try self.recover_stmt(s)
            .free_:
                try self.free_stmt(s)
            .with_:
                try self.with_stmt(s)
            .expr_stmt:
                let e = s.left else return
                if calls.is_error_call(e):
                    try self.error_return(e)
                else:
                    _ = try self.expr(e)
            .asm_:
                try self.asm_stmt(s)
            _:
                return try self.fail(s, "native_unsupported statement in the native backend")

    func binding(s: ast.Node*) -> !:
        if s.body != none:
            let init = s.left else return
            let v = try self.expr(init)
            let t = self.c.table.get(v.type_id)
            let base = try self.address_of_value(v)
            var offset: u64 = 0
            var i: usize = 0
            var cursor = s.body
            while let name = cursor:
                let mt = t.args[i]
                offset = lower_round_up(offset, self.c.table.align_of(mt))
                if name.text != "_":
                    let slot = try self.bind_local(name, mt)
                    let member = try self.load_from(try self.offset_address(base, offset), mt)
                    try self.store_to(try self.slot_address(slot), member)
                offset += self.c.table.size_of(mt)
                i += 1
                cursor = name.next
            return
        let t = try self.map(s.type_id)
        let slot = try self.bind_local(s, t)
        if s.has(ast.flag_uninit):
            if self.diagnostic:
                # the diagnostic profile fills `---` storage with a pattern (§19.4)
                try self.f.emit(ir.Op.fill, ir.Class.l, 0, try self.slot_address(slot), ir.const_ref(170), self.size(t))
            return
        let address = try self.slot_address(slot)
        if let init = s.left:
            let v = try self.value(init, t)
            try self.store_to(address, v)
        else:
            try self.f.zero_bytes(address, self.size(t))

    func assign(s: ast.Node*) -> !:
        let place = s.left else return
        let value = s.right else return
        if place.kind == ast.Kind.member and place.text == "allocator":
            if let owner = place.left:
                if self.kind(owner.type_id) == types.Kind.module:
                    let view = try self.allocator_view(value)
                    try self.f.copy_bytes(try self.allocator_global(), view, 16)
                    return
        let pt = try self.ty(place)
        let address = try self.place(place)
        if self.kind(pt) == types.Kind.atomic:
            try self.atomic_assign(s, address, self.elem(pt), value)
            return
        if s.text == "=":
            let v = try self.value(value, pt)
            try self.store_to(address, v)
            return
        let op = (str)s.text.bytes[..<s.text.length - 1]
        let old = try self.load_from(address, pt)
        if self.is_ptr(pt):
            # `p += n`: element-scaled, as `p + n` (§7.7)
            let rt = try self.ty(value)
            let rv = try self.expr(value)
            let scaled = try self.f.binary(ir.Op.mul, ir.Class.l, try self.to_word(rv.ref, rt), ir.const_ref((i64)self.c.table.size_of(self.elem(pt))))
            let moved = try self.f.binary(ir.Op.add if op == "+" else ir.Op.sub, ir.Class.l, old.ref, scaled)
            try self.f.store(ir.Op.storel, moved, address)
            return
        let rhs = try self.value(value, pt)
        let result = try self.arithmetic(op, pt, old.ref, rhs.ref, s)
        try self.f.store(ir.store_op(self.scalar_size(pt), self.is_float(pt)), result, address)

    ## `=` on an `@T` is the sequentially consistent store; `+=` `-=` `|=` `&=` `^=` are the
    ## read-modify-write instructions and wrap (§15.1). `&=` is `and-not` of the complement.
    func atomic_assign(s: ast.Node*, address: ir.Ref, et: u32, value: ast.Node*) -> !:
        let cls = self.class_of(et)
        let width = u32(self.scalar_size(et))
        let vv = try self.value(value, et)
        if s.text == "=":
            try self.f.instrs.push(ir.Instr(op = ir.Op.atomic_store, cls = cls, dst = 0, a = vv.ref, b = address, extra = width, extra2 = 5, line = 0, file = 0, scope = 0, site = 0))
            return
        let op = (str)s.text.bytes[..<s.text.length - 1]
        var operand = vv.ref
        var instr = ir.Op.atomic_add
        if op == "-":
            instr = ir.Op.atomic_sub
        elif op == "|":
            instr = ir.Op.atomic_or
        elif op == "^":
            instr = ir.Op.atomic_xor
        elif op == "&":
            instr = ir.Op.atomic_and_not
            operand = try self.f.binary(ir.Op.xor, cls, vv.ref, ir.const_ref(-1))
        let t = try self.f.temp(cls)
        try self.f.instrs.push(ir.Instr(op = instr, cls = cls, dst = t, a = operand, b = address, extra = width, extra2 = 5, line = 0, file = 0, scope = 0, site = 0))

    func if_stmt(s: ast.Node*) -> !:
        let then_label = self.f.label()
        let else_label = self.f.label()
        let end_label = self.f.label()
        try self.push_scope(false, "", 0, 0)
        try self.condition(s, then_label, else_label)
        try self.f.place_label(then_label)
        if let body = s.body:
            try self.block(body)
        try self.unwind(self.scopes.count - 1, false)
        self.pop_scope()
        try self.f.jump(end_label)
        try self.f.place_label(else_label)
        if let rest = s.right:
            if rest.kind == ast.Kind.if_:
                self.set_position(rest)
                try self.if_stmt(rest)
            else:
                try self.block(rest)
        try self.f.place_label(end_label)

    ## Branch on a condition, binding an `if let` name in the then scope.
    func condition(s: ast.Node*, then_label: u32, else_label: u32) -> !:
        let c = s.left else return
        if s.has(ast.flag_if_let):
            let init = c.left else return
            let v = try self.expr(init)
            let ot = v.type_id
            let payload = self.elem(ot)
            let slot = try self.bind_local(c, payload)
            if self.is_tagged_opt(ot) or self.is_nullable_view(ot):
                let present = try self.f.load(ir.Op.loadl, ir.Class.l, v.ref) if self.is_nullable_view(ot) else try self.f.load(ir.Op.loadub, ir.Class.w, try self.offset_address(v.ref, self.c.table.size_of(payload)))
                let take = self.f.label()
                try self.f.branch(present, take, else_label)
                try self.f.place_label(take)
                let inner = try self.load_from(v.ref, payload)
                try self.store_to(try self.slot_address(slot), inner)
                try self.f.jump(then_label)
            else:
                let take = self.f.label()
                try self.f.branch(v.ref, take, else_label)
                try self.f.place_label(take)
                try self.f.store(ir.Op.storel, v.ref, try self.slot_address(slot))
                try self.f.jump(then_label)
            return
        try self.branch_on(c, then_label, else_label)

    ## Branch to `then_label` when `e` holds, else to `else_label`: `and`, `or` and `not` as
    ## jumps, so that `while a < b and c <= d:` branches on each comparison as it is made
    ## rather than on a byte the two leave in a slot, the value `and` has in an expression.
    func branch_on(e: ast.Node*, then_label: u32, else_label: u32) -> !:
        if e.kind == ast.Kind.group:
            let inner = e.left else return try self.fail(e, "empty group")
            try self.branch_on(inner, then_label, else_label)
            return
        if e.kind == ast.Kind.binary and (e.text == "and" or e.text == "or") and not self.is_vector(try self.ty(e)):
            let l = e.left else return try self.fail(e, "no operand")
            let r = e.right else return try self.fail(e, "no operand")
            let more = self.f.label()
            if e.text == "and":
                try self.branch_on(l, more, else_label)
            else:
                try self.branch_on(l, then_label, more)
            try self.f.place_label(more)
            try self.branch_on(r, then_label, else_label)
            return
        if e.kind == ast.Kind.unary and e.text == "not" and not self.is_vector(try self.ty(e)):
            let inner = e.left else return try self.fail(e, "no operand")
            try self.branch_on(inner, else_label, then_label)
            return
        let v = try self.value(e, types.bool_id)
        try self.f.branch(v.ref, then_label, else_label)

    func while_stmt(s: ast.Node*) -> !:
        let head = self.f.label()
        let body_label = self.f.label()
        let end_label = self.f.label()
        try self.push_scope(true, s.text, end_label, head)
        try self.f.place_label(head)
        try self.condition(s, body_label, end_label)
        try self.f.place_label(body_label)
        if let body = s.body:
            try self.block(body)
        try self.f.jump(head)
        try self.f.place_label(end_label)
        try self.unwind(self.scopes.count - 1, false)
        self.pop_scope()

    ## `for binding in seq`: a counted loop over a range, or a walk over an array, a span,
    ## or text by index.
    func for_stmt(s: ast.Node*) -> !:
        let binding = s.left else return
        let seq = s.right else return
        let head = self.f.label()
        let body_label = self.f.label()
        let step = self.f.label()
        let end_label = self.f.label()
        let l = LowerLoop(head = head, body = body_label, step = step, exit = end_label)
        try self.push_scope(true, s.text, end_label, step)
        if seq.kind == ast.Kind.binary and (seq.text == "..<" or seq.text == "..="):
            let lo = seq.left else return
            let hi = seq.right else return
            try self.range_loop(s, binding, lo, hi, seq.text == "..=", l)
        else:
            try self.sequence_loop(s, binding, seq, l)
        try self.f.place_label(end_label)
        try self.unwind(self.scopes.count - 1, false)
        self.pop_scope()

    ## The blocks of `for i in lo..<hi` or `lo..=hi`, up to the jump back to its test: the
    ## binding counts in its own type up to a limit computed once.
    func range_loop(s: ast.Node*, binding: ast.Node*, lo: ast.Node*, hi: ast.Node*, closed: bool, l: LowerLoop) -> !:
        let t = try self.map(binding.type_id)
        let slot = try self.bind_local(binding, t)
        let counter = try self.slot_address(slot)
        let start = try self.value(lo, t)
        try self.store_to(counter, start)
        let limit_slot = try self.new_slot(t)
        let limit_address = try self.slot_address(limit_slot)
        let limit = try self.value(hi, t)
        try self.store_to(limit_address, limit)
        try self.f.place_label(l.head)
        let current = try self.load_from(counter, t)
        let bound = try self.load_from(limit_address, t)
        let op = (ir.Op.csle if closed else ir.Op.cslt) if self.signed_of(t) else (ir.Op.cule if closed else ir.Op.cult)
        let go = try self.f.binary(op, self.class_of(t), current.ref, bound.ref)
        try self.f.branch(go, l.body, l.exit)
        try self.f.place_label(l.body)
        if let body = s.body:
            try self.block(body)
        try self.f.place_label(l.step)
        let again = try self.load_from(counter, t)
        if closed:
            # the last value is visited before the increment, so `..=T.max` cannot wrap
            let last = try self.load_from(limit_address, t)
            let at_last = try self.f.binary(ir.Op.ceq, self.class_of(t), again.ref, last.ref)
            let more = self.f.label()
            try self.f.branch(at_last, l.exit, more)
            try self.f.place_label(more)
        let next = try self.f.binary(ir.Op.add, self.class_of(t), again.ref, ir.const_ref(1))
        try self.f.store(ir.store_op(self.scalar_size(t), false), next, counter)
        try self.f.jump(l.head)

    ## The blocks of a loop over an array, a span, or text, up to the jump back to its
    ## test: the index steps by one element, or by one scalar's width over text.
    func sequence_loop(s: ast.Node*, binding: ast.Node*, seq: ast.Node*, l: LowerLoop) -> !:
        # `items.indexed()` walks the span of `items` by index: no pairs are made (§8.3)
        let indexed = calls.indexed_receiver(seq)
        var it = try self.ty(seq)
        var sequence = LowerValue(ref = ir.none_ref(), type_id = types.unit_id, in_memory = false)
        if let receiver = indexed:
            let rt = try self.ty(receiver)
            it = rt if self.is_span(rt) else try self.c.table.span(self.elem(rt), false)
            sequence = try self.value(receiver, it)
        else:
            sequence = try self.expr(seq)
        var w = try self.walk(sequence, it)
        try self.f.store(ir.Op.storel, ir.const_ref(0), try self.slot_address(w.index_slot))
        try self.f.place_label(l.head)
        let i = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(w.index_slot))
        w.count = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(w.count_slot))
        let go = try self.f.binary(ir.Op.cult, ir.Class.l, i, w.count)
        try self.f.branch(go, l.body, l.exit)
        try self.f.place_label(l.body)
        w.base = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(w.data_slot))
        w.index = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(w.index_slot))
        let scaled = try self.f.binary(ir.Op.mul, ir.Class.l, w.index, ir.const_ref((i64)w.stride))
        w.address = try self.f.binary(ir.Op.add, ir.Class.l, w.base, scaled)
        try self.walk_bindings(s, binding, indexed != none, it, w)
        if let body = s.body:
            try self.block(body)
        try self.f.place_label(l.step)
        let i3 = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(w.index_slot))
        var advance = ir.const_ref(1)
        if it == types.str_id:
            advance = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(w.width_slot))
        let next = try self.f.binary(ir.Op.add, ir.Class.l, i3, advance)
        try self.f.store(ir.Op.storel, next, try self.slot_address(w.index_slot))
        try self.f.jump(l.head)

    ## The slots of a walk over `sequence` of type `it`, its data pointer and count stored
    ## in them, and its elements' type and stride.
    func walk(sequence: LowerValue, it: u32) -> LowerWalk!:
        # the data pointer and the count, in slots that outlive the loop's blocks
        let data_slot = try self.f.slot(8, 8)
        let count_slot = try self.f.slot(8, 8)
        let index_slot = try self.f.slot(8, 8)
        # text is walked by scalar (§5.5): the width of the last one steps the index
        let width_slot = try self.f.slot(8, 8)
        var element_type = types.u8_id
        var stride: u64 = 1
        if self.is_array(it):
            element_type = self.elem(it)
            stride = self.c.table.size_of(element_type)
            try self.f.store(ir.Op.storel, sequence.ref, try self.slot_address(data_slot))
            try self.f.store(ir.Op.storel, ir.const_ref((i64)self.c.table.get(it).length), try self.slot_address(count_slot))
        else:
            if it != types.str_id:
                element_type = self.elem(it)
                stride = self.c.table.size_of(element_type)
            let data = try self.f.load(ir.Op.loadl, ir.Class.l, sequence.ref)
            let count = try self.f.load(ir.Op.loadl, ir.Class.l, try self.offset_address(sequence.ref, 8))
            try self.f.store(ir.Op.storel, data, try self.slot_address(data_slot))
            try self.f.store(ir.Op.storel, count, try self.slot_address(count_slot))
        let none_ref = ir.none_ref()
        return LowerWalk(data_slot = data_slot, count_slot = count_slot, index_slot = index_slot, width_slot = width_slot, element_type = element_type, stride = stride, base = none_ref, count = none_ref, index = none_ref, address = none_ref)

    ## The bindings at the top of a walk's body: the element by value or by pointer, the
    ## members of its tuple, `(index, element)` under `indexed()`, or text's scalar.
    func walk_bindings(s: ast.Node*, binding: ast.Node*, indexed: bool, it: u32, w: LowerWalk) -> !:
        if binding.body != none and indexed:
            # `(index, element)`
            let index_name = binding.body else return
            if index_name.text != "_":
                let slot = try self.bind_local(index_name, types.usize_id)
                try self.f.store(ir.Op.storel, w.index, try self.slot_address(slot))
            if let element_name = index_name.next:
                if element_name.text != "_":
                    let slot = try self.bind_local(element_name, w.element_type)
                    try self.store_to(try self.slot_address(slot), try self.load_from(w.address, w.element_type))
        elif binding.body != none:
            let et = self.c.table.get(w.element_type)
            var offset: u64 = 0
            var k: usize = 0
            var cursor = binding.body
            while let name = cursor:
                let mt = et.args[k]
                offset = lower_round_up(offset, self.c.table.align_of(mt))
                if name.text != "_":
                    let slot = try self.bind_local(name, mt)
                    let member = try self.load_from(try self.offset_address(w.address, offset), mt)
                    try self.store_to(try self.slot_address(slot), member)
                offset += self.c.table.size_of(mt)
                k += 1
                cursor = name.next
        elif s.has(ast.flag_by_pointer):
            let slot = try self.bind_local(binding, try self.map(binding.type_id))
            try self.f.store(ir.Op.storel, w.address, try self.slot_address(slot))
        elif it == types.str_id:
            let slot = try self.bind_local(binding, types.char_id)
            let scalar = try self.utf8_scalar(w.base, w.count, w.index, try self.slot_address(w.width_slot))
            try self.f.store(ir.Op.storew, scalar, try self.slot_address(slot))
        else:
            let bt = try self.map(binding.type_id)
            let slot = try self.bind_local(binding, bt)
            let element = try self.load_from(w.address, w.element_type)
            try self.store_to(try self.slot_address(slot), element)

    ## `core.utf8_scalar(data, count, index, &width)`: the scalar at a byte of valid UTF-8.
    func utf8_scalar(data: ir.Ref, count: ir.Ref, index: ir.Ref, width: ir.Ref) -> ir.Ref!:
        let start = u32(self.f.args.count)
        try self.f.args.push(ir.Arg(value = data, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
        try self.f.args.push(ir.Arg(value = count, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
        try self.f.args.push(ir.Arg(value = index, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
        try self.f.args.push(ir.Arg(value = width, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
        return try self.call_named("lb_core_11utf8_scalar", start, 4, ir.Class.w, true, types.char_id)

    func jump(s: ast.Node*) -> !:
        let target = exits.innermost_loop(&self.scopes, s.text)
        try self.unwind_from(target + 1, false)
        let sc = self.scopes.get(target)
        try self.f.jump(sc.exit if s.kind == ast.Kind.break_ else sc.continue_label)
        # what follows is unreachable; a fresh label keeps the block structure sound
        try self.f.place_label(self.f.label())

    # -- returns and failure --------------------------------------------------------------

    func return_stmt(s: ast.Node*) -> !:
        if let v = s.left:
            if calls.is_trap_call(v):
                _ = try self.expr(v)
                return
            if calls.is_error_call(v):
                try self.error_return(v)
                return
            if lower_never_valued(v):
                _ = try self.expr(v)
                try self.trap_with("unreachable")
                return
            let want = self.result_payload()
            if want == types.unit_id or want == types.never_id:
                _ = try self.expr(v)
            else:
                let value = try self.value(v, want)
                try self.store_to(try self.slot_address(self.result_slot), value)
        try self.leave(false)

    ## Leave the function: mark success when fallible, run cleanup, return the result slot.
    func leave(failing: bool) -> !:
        try self.release_grown(0)
        if self.f.has_result:
            let r = try self.slot_address(self.result_slot)
            if self.fn_fallible():
                try self.f.store(ir.Op.storeb, ir.const_ref(1 if failing else 0), try self.offset_address(r, self.failed_offset(self.f.result_type)))
            if failing:
                try self.unwind_keeping_failure()
            else:
                try self.unwind_from(0, failing)
            try self.debug_leave()
            let again = try self.slot_address(self.result_slot)
            let out = try self.load_from(again, self.f.result_type)
            try self.f.emit(ir.Op.ret, ir.Class.l, 0, out.ref, ir.none_ref(), 0)
        else:
            try self.unwind_from(0, failing)
            try self.debug_leave()
            try self.f.emit(ir.Op.ret, ir.Class.l, 0, ir.none_ref(), ir.none_ref(), 0)
        try self.f.place_label(self.f.label())

    ## Run the cleanup of a failing exit with the error kept: deferred code may fail and
    ## recover inside itself, which writes `core.failure` over the error on its way out.
    func unwind_keeping_failure() -> !:
        if self.defers.count == 0:
            try self.unwind_from(0, true)
            return
        let kept = try self.f.slot(24, 8)
        try self.f.copy_bytes(try self.slot_address(kept), try self.failure_address(), 24)
        try self.unwind_from(0, true)
        try self.f.copy_bytes(try self.failure_address(), try self.slot_address(kept), 24)

    func debug_leave() -> !:
        if self.f.debug:
            try self.debug_call("lb_debug_leave", u32(self.f.args.count), 0)

    ## `error(code, message)`, raised here, and `error(failure)`, a caught failure passed on
    ## whole: the failing result leaves the function.
    func error_return(e: ast.Node*) -> !:
        let first = e.body else return
        let code = first.left else return
        # the code and the message first: reaching `core.failure` may set up the thread's
        # storage, which can change errno before a code computed from it is read
        let else_replaced = self.else_replaced
        self.else_replaced = 0
        var c = ir.none_ref()
        var m = LowerValue(ref = ir.none_ref(), type_id = types.str_id, in_memory = true)
        var literal = false
        var passed_at: ir.Ref? = none
        var passed_called = ir.none_ref()
        if let second = first.next:
            let message = second.left else return
            c = (try self.value(code, types.error_code_id)).ref
            m = try self.value(message, types.str_id)
            literal = calls.is_text_literal(message)
        else:
            let failure = try self.value(code, types.error_value_id)
            c = try self.f.load(ir.Op.loadsw, ir.Class.w, failure.ref)
            m = try self.message_of(failure.ref)
            passed_at = try self.f.load(ir.Op.loadsw, ir.Class.w, try self.offset_address(failure.ref, 4))
            passed_called = try self.f.load(ir.Op.loadsw, ir.Class.w, try self.offset_address(failure.ref, 20))
        # the message is copied into the thread's room before cleanup can free what it was
        # made from, in place of a handled error's message the failure leaves behind (§11.3)
        var replaced = try self.replaced_message()
        if replaced == none and else_replaced != 0:
            replaced = LowerValue(ref = try self.slot_address(else_replaced - 1), type_id = types.str_id, in_memory = true)
        if literal:
            if let old = replaced:
                try self.message_handled(old)
        else:
            m = try self.message_raised(m, replaced)
        let err = try self.slot_address(self.failure_slot) if self.failure_target != 0 else try self.failure_address()
        try self.f.store(ir.Op.storew, c, err)
        try self.f.copy_bytes(try self.offset_address(err, 8), m.ref, 16)
        # where it was raised: this statement, or where the failure passed on was raised and
        # the call it came out of; a new message leaves `called_at` unset
        if let raised = passed_at:
            try self.f.store(ir.Op.storew, raised, try self.offset_address(err, 4))
            try self.f.store(ir.Op.storew, passed_called, try self.offset_address(err, 20))
        else:
            try self.store_origin(err)
        if self.failure_target != 0:
            try self.release_grown(self.failure_grown)
            try self.unwind_from(self.failure_scope, true)
            try self.f.jump(self.failure_target)
        else:
            try self.leave(true)

    ## Pass on the failure of a result at `source`: to the enclosing handler, which takes
    ## the error from `core.failure`, or out of the function with the error left there.
    func propagate(source: ir.Ref, source_type: u32) -> !:
        _ = source
        _ = source_type
        # a failure leaving a handler takes the place of the handled error's message, its
        # `called_at` kept
        if let replaced = try self.replaced_message():
            let called = try self.f.load(ir.Op.loadsw, ir.Class.w, try self.offset_address(try self.failure_address(), 20))
            let moved = try self.message_raised(try self.message_of(try self.failure_address()), replaced)
            try self.f.copy_bytes(try self.offset_address(try self.failure_address(), 8), moved.ref, 16)
            try self.f.store(ir.Op.storew, called, try self.offset_address(try self.failure_address(), 20))
        if self.failure_target != 0:
            try self.f.copy_bytes(try self.slot_address(self.failure_slot), try self.failure_address(), 24)
            try self.release_grown(self.failure_grown)
            try self.unwind_from(self.failure_scope, true)
            try self.f.jump(self.failure_target)
            return
        try self.leave(true)

    ## The message of the error handled by the outermost `catch` handler a failure raised
    ## here leaves, the oldest message it gives up, or `none` when it leaves no handler.
    func replaced_message() -> LowerValue?!:
        let start = self.failure_scope if self.failure_target != 0 else 0
        let handler = exits.outermost_handler(&self.scopes, start) else return none
        # where the message starts is all `core.message_raised` reads of it
        return LowerValue(ref = try self.offset_address(try self.slot_address(handler.handled), 8), type_id = types.str_id, in_memory = true)

    ## `core.message_raised(message, replaces)`: the message copied into the thread's room,
    ## over `replaces` when it is given (§11.3).
    func message_raised(message: LowerValue, replaces: LowerValue?) -> LowerValue!:
        let old = replaces else try self.span_of(ir.const_ref(0), ir.const_ref(0), types.str_id)
        let start = u32(self.f.args.count)
        try self.f.args.push(try self.arg_of(message))
        try self.f.args.push(try self.arg_of(old))
        return try self.call_aggregate("lb_core_14message_raised", start, 2, types.str_id)

    ## `core.message_handled(message)`: a handled error's message given back to the room.
    func message_handled(message: LowerValue) -> !:
        let start = u32(self.f.args.count)
        try self.f.args.push(try self.arg_of(message))
        _ = try self.call_named("lb_core_15message_handled", start, 1, ir.Class.w, false, types.unit_id)

    ## The message of the error in `core.failure`.
    ## Its length word holds `called_at` too: `core.message_handled` and a `replaces` read
    ## where the message starts and nothing else, and the rest reads it by `message_of`.
    func failure_message() -> LowerValue!:
        return LowerValue(ref = try self.offset_address(try self.failure_address(), 8), type_id = types.str_id, in_memory = true)

    func recover_stmt(s: ast.Node*) -> !:
        let v = s.left else return
        if self.catch_payload != types.unit_id and self.catch_payload != types.never_id:
            let value = try self.value(v, self.catch_payload)
            try self.store_to(try self.slot_address(self.catch_slot), value)
        else:
            _ = try self.expr(v)
        try self.unwind_from(self.catch_scope, false)
        try self.f.jump(self.catch_done)
        try self.f.place_label(self.f.label())

    func free_stmt(s: ast.Node*) -> !:
        let v = s.left else return
        let t = try self.ty(v)
        let block = try self.expr(v)
        let view = try self.allocator_of(s.right)
        var span_slot = try self.f.slot(16, 8)
        let span = try self.slot_address(span_slot)
        if self.is_ptr(t):
            try self.f.store(ir.Op.storel, block.ref, span)
            try self.f.store(ir.Op.storel, ir.const_ref((i64)self.c.table.size_of(self.elem(t))), try self.offset_address(span, 8))
        else:
            let data = try self.f.load(ir.Op.loadl, ir.Class.l, block.ref)
            let length = try self.f.load(ir.Op.loadl, ir.Class.l, try self.offset_address(block.ref, 8))
            let bytes = try self.f.binary(ir.Op.mulo, ir.Class.l, length, ir.const_ref((i64)self.c.table.size_of(self.elem(t))))
            try self.mark_signed(false)
            try self.mark_position()
            try self.f.store(ir.Op.storel, data, span)
            try self.f.store(ir.Op.storel, bytes, try self.offset_address(span, 8))
        try self.allocator_release(view, span)

    func with_stmt(s: ast.Node*) -> !:
        let a = s.left else return
        let saved = try self.f.slot(16, 8)
        try self.f.copy_bytes(try self.slot_address(saved), try self.allocator_global(), 16)
        let view = try self.allocator_view(a)
        try self.f.copy_bytes(try self.allocator_global(), view, 16)
        try self.push_scope(false, "", 0, 0)
        var sc = self.scopes.get(self.scopes.count - 1)
        sc.restore_alloc = true
        sc.alloc_saved = saved
        self.scopes.set(self.scopes.count - 1, sc)
        if let body = s.body:
            try self.block(body)
        try self.unwind(self.scopes.count - 1, false)
        self.pop_scope()

    ## Inline assembly (§16.7): each `in`/`inout` operand is moved into its named register
    ## before the block, each `out`/`inout` register stored back after it. The raw lines name
    ## the registers directly, so a specific register (`x0`, `d1`) is required, not `reg`.
    func asm_stmt(s: ast.Node*) -> !:
        # the block for another architecture is not this build's (§8.9)
        if s.text != self.arch_name():
            return
        var chosen = try AsmRegisters.choose(s, self.target.arch)
        # the inputs are computed first, then moved into their registers together, so that
        # computing one cannot touch a register another already holds
        var values: LowerValue[16] = ---
        var outputs: ir.Ref[16] = ---
        var output_count: usize = 0
        var count: usize = 0
        var operand = s.right
        while let o = operand:
            if o.text == "in" or o.text == "inout":
                if count >= 16:
                    return try self.fail(o, "at most sixteen asm inputs")
                let value = o.left else return try self.fail(o, "an asm operand needs a value")
                values[count] = try self.value(value, self.asm_operand_type(chosen.place_of(o)))
                count += 1
            operand = o.next
        # Compute output addresses before installing input registers. The get_reg
        # instructions must immediately follow the block, and evaluating an address
        # after the block could itself overwrite a register holding an output.
        operand = s.right
        while let o = operand:
            if o.text == "out" or o.text == "inout":
                if output_count >= 16:
                    return try self.fail(o, "at most sixteen asm outputs")
                let target = o.left else return try self.fail(o, "an asm output needs a place")
                outputs[output_count] = ir.none_ref() if target.text == "_" else try self.place(target)
                output_count += 1
            operand = o.next
        count = 0
        operand = s.right
        while let o = operand:
            if o.text == "in" or o.text == "inout":
                let place = chosen.place_of(o)
                try self.f.emit(ir.Op.set_reg, self.class_of(self.asm_operand_type(place)), 0, values[count].ref, ir.text_ref(try self.program_unit.text(place)), 0)
                count += 1
            operand = o.next
        var text = try buffer.Buffer.create(64)
        var lines = s.body
        while let l = lines:
            try chosen.substitute(l.text, &text)
            try text.put("\n")
            lines = l.next
        let arch = try self.program_unit.text(s.text)
        let body = try self.program_unit.text(try names.keep(&text))
        try self.f.emit(ir.Op.asm_, ir.Class.l, 0, ir.text_ref(arch), ir.text_ref(body), 0)
        # outputs, from their registers back into the named places
        output_count = 0
        operand = s.right
        while let o = operand:
            if o.text == "out" or o.text == "inout":
                let place = chosen.place_of(o)
                let target = o.left else return try self.fail(o, "an asm output needs a place")
                if target.text != "_":
                    let want = self.asm_operand_type(place)
                    let address = outputs[output_count]
                    try self.f.emit(ir.Op.get_reg, self.class_of(want), 0, address, ir.text_ref(try self.program_unit.text(place)), 0)
                else:
                    # a discarded output names a register the block writes; the generator
                    # stores nothing but may need to save the register around the block
                    try self.f.emit(ir.Op.get_reg, ir.Class.l, 0, ir.none_ref(), ir.text_ref(try self.program_unit.text(place)), 0)
                output_count += 1
            operand = o.next

    ## The type an asm operand's register carries, which the instruction set says (`isa`):
    ## a float of the register's width, or an unsigned integer of it.
    func asm_operand_type(place: str) -> u32:
        let r = isa.register_of(self.target.arch, place)
        if r.is_float:
            return types.f64_id if r.bits == 64 else types.f32_id
        return types.u64_id if r.bits == 64 else types.u32_id

    ## The architecture's name in `asm ARCH` (§8.9).
    func arch_name() -> str:
        return self.target.arch_name()