dymokomi/luce-base
Source of release 0.43.0
0.43.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()