dymokomi/luce-base
Source of release 0.43.0
0.43.0 / src / back / c / emit / calls.lucb
#==============================================================================================
#
# emit/calls - Calls
#
# DESCRIPTION:
# Calls to functions, methods, function values, and interfaces, with their arguments
# evaluated in the order §7.1 fixes.
#
#==============================================================================================
extend Emitter:
# mark: Calls ==============================================================================
func call(e: ast.Node*) -> !:
let callee = e.left else return
if let d = e.resolved:
if self.c.is_memory_frame(d):
try self.frame_storage(e)
return
# core functions
if callee.kind == ast.Kind.name and callee.resolved == none and check.scalar_id(callee.text) == types.none_id:
try self.intrinsic(e, callee.text)
return
# `T(x)` conversions and constructions
if callee.has(ast.flag_type_ref):
try self.construct_or_convert(e, callee)
return
if callee.kind == ast.Kind.member:
try self.member_call(e, callee)
return
if let d = e.resolved:
if d.kind == ast.Kind.func_ or d.kind == ast.Kind.extern_func:
try self.direct_call(e, d, none, try types.no_args())
return
try self.value_call(e, callee)
## `f(args)` where `f` is a function value: a local, a field, or a module's global.
func value_call(e: ast.Node*, callee: ast.Node*) -> !:
let ordered = try self.receiver_first(callee, try self.ty(callee), e.body, false)
let hoisted = try self.begin_sequence(e.body, try self.ty(callee), none)
try self.put("(")
if ordered != 0:
try self.put_tmp("rv", ordered)
else:
try self.expr(callee)
try self.put(")(")
try self.arguments(e.body, try self.ty(callee), none, try types.no_args())
try self.put(")")
try self.end_sequence(hoisted)
try self.receiver_done(ordered)
## Base evaluates arguments left to right (§7.1); C promises no order. When a call has
## more than one argument and any of them may have an effect, every given argument is
## computed into a temporary first, in order, inside a statement expression the call
## then closes (`end_sequence`), and the call reads the temporaries. Answers how many
## were hoisted, 0 when the call is emitted as it is.
func begin_sequence(args: ast.Node*?, fn: u32, decl: ast.Node*?) -> usize!:
var given: usize = 0
var effects = false
var cursor = args
while let a = cursor:
given += 1
if let v = a.left:
if may_have_effect(v):
effects = true
cursor = a.next
if given < 2 or not effects:
return 0
let f = self.c.table.get(fn)
var hoisted: usize = 0
try self.put("({ ")
if let d = decl:
# named arguments are matched to parameters by the declaration, as `arguments` does
var position: usize = 0
cursor = args
while let a = cursor:
let v = a.left else return hoisted
var pi: usize = 0
var found: usize = 0
var param = d.right
var matched = false
if a.text.length > 0:
while let p = param:
if p.text == a.text:
found = pi
matched = true
pi += 1
param = p.next
else:
found = position
position += 1
matched = found < f.args.length
let want = f.args[found] if matched and found < f.args.length else types.none_id
if want != types.none_id and (matched or not f.variadic):
hoisted += try self.hoist(v, want)
cursor = a.next
else:
var i: usize = 0
cursor = args
while let a = cursor:
let v = a.left else return hoisted
if i < f.args.length:
hoisted += try self.hoist(v, f.args[i])
i += 1
cursor = a.next
return hoisted
## §7.1: the receiver, or the function value, is evaluated before the arguments. C
## promises no order between them, so when both may have an effect the receiver goes
## into a temporary first (its pointer, or the address of its place); answers the
## temporary's number, 0 when the receiver is read where it stands.
func receiver_first(target: ast.Node*, t: u32, args: ast.Node*?, as_address: bool) -> u32!:
if not may_have_effect(target) or not arguments_have_effect(args):
return 0
let n = self.tmp()
try self.put("({ ")
try self.put_type(t)
try self.put(" ")
try self.put_tmp("rv", n)
try self.put(" = ")
if as_address:
try self.address(target)
else:
try self.expr(target)
try self.put("; ")
return n
func receiver_done(n: u32) -> !:
if n != 0:
try self.put("; })")
## `T _lb_sqN = value;` for one argument, remembered for `argument_value`.
func hoist(v: ast.Node*, want: u32) -> usize!:
let n = self.tmp()
try self.put_type(want)
try self.put(" ")
try self.put_tmp("sq", n)
try self.put(" __attribute__((unused)) = ")
try self.argument_value(v, want)
try self.put("; ")
try self.sequenced.push(Sequenced(node = v, id = n))
return 1
func end_sequence(hoisted: usize) -> !:
if hoisted == 0:
return
try self.put("; })")
self.sequenced.count -= hoisted
## The temporary an argument was computed into, when it was.
func sequenced_id(v: ast.Node*) -> u32?:
var i = self.sequenced.count
while i > 0:
i -= 1
let s = self.sequenced.get(i)
if s.node == v:
return s.id
return none
## The arguments of a call, each converted to its parameter type.
func arguments(args: ast.Node*?, fn: u32, decl: ast.Node*?, decl_args: u32[]) -> !:
let f = self.c.table.get(fn)
var i: usize = 0
var cursor = args
var first = true
# named arguments are matched to parameters by the declaration
if let d = decl:
var pi: usize = 0
var param = d.right
while let p = param:
if not first:
try self.put(", ")
first = false
let given = calls.given_argument(args, p, pi)
let want = f.args[pi] if pi < f.args.length else types.none_id
if let g = given:
let v = g.left else return
try self.argument_value(v, want)
elif let default = p.left:
try self.value(default, want)
else:
try self.put("0")
pi += 1
param = p.next
if f.variadic:
# extra arguments after the declared ones
var position: usize = 0
var a = args
while let arg = a:
if arg.text.length == 0:
if position >= pi:
try self.put(", ")
let v = arg.left else return
try self.variadic_value(v)
position += 1
a = arg.next
_ = decl_args
return
while let a = cursor:
if not first:
try self.put(", ")
first = false
let v = a.left else return
try self.argument_value(v, f.args[i] if i < f.args.length else types.none_id)
i += 1
cursor = a.next
## An argument: its parameter's type, with text passed as bytes where wanted.
func argument_value(v: ast.Node*, want: u32) -> !:
if let id = self.sequenced_id(v):
try self.put_tmp("sq", id)
return
let have = try self.ty(v)
if want != types.none_id and self.is_span(want) and self.elem(want) == types.u8_id and (have == types.str_id or have == types.fmt_id):
if v.kind == ast.Kind.formatted:
try self.formatted_bytes(v)
else:
try self.text_as_bytes(v)
return
if want == types.cstr_id and have == types.str_id:
try self.value(v, want)
return
try self.value(v, want)
## A variadic C argument: text becomes a C string, integers promote as C does.
func variadic_value(v: ast.Node*) -> !:
let have = try self.ty(v)
if have == types.str_id and v.kind == ast.Kind.literal:
try self.put_c_string(literals.decode_text(v.text))
return
if have == types.str_id:
try self.put("(")
try self.expr(v)
try self.put(".data)")
return
try self.expr(v)
## A call of a known function or method instance.
func direct_call(e: ast.Node*, d: ast.Node*, owner: ast.Node*?, owner_args: u32[]) -> !:
var args = try types.no_args()
if let t = e.ty:
args = try self.type_args(t)
var fn = try self.map(d.type_id)
if let o = owner:
fn = try self.c.substitute(fn, o, owner_args)
if args.length > 0:
fn = try self.c.substitute(fn, d, args)
if d.kind == ast.Kind.func_:
_ = try self.add_func(d, args, owner, owner_args)
if d.kind == ast.Kind.extern_func and has_out_params(d):
try self.extern_out_call(e, d, fn)
return
# a bare pointer, handle, or `c.str` from C must not be null: the one boundary check (§17.1)
let rt = self.c.table.get(fn).elem
let checked = d.kind == ast.Kind.extern_func and (self.is_ptr(rt) or rt == types.cstr_id or self.c.table.is_opaque_handle(rt))
let hoisted = try self.begin_sequence(e.body, fn, d)
if checked:
try self.put("({ ")
try self.put_type(rt)
try self.put(" _lb_fr = ")
try self.put_func_name(d, args, owner, owner_args)
try self.put("(")
try self.arguments(e.body, fn, d, args)
try self.put(")")
if checked:
try self.put("; if (!_lb_fr) lb_trap(\"null_foreign\"); _lb_fr; })")
try self.end_sequence(hoisted)
## A zero arriving from C in a bare pointer, handle, or `c.str` parameter of an export
## traps `null_foreign`: the one boundary check, in this direction (§17.1).
func check_foreign_parameters(f: ast.Node*) -> !:
var cursor = f.right
while let p = cursor:
let pt = try self.map(p.type_id)
if self.is_ptr(pt) or pt == types.cstr_id or self.c.table.is_opaque_handle(pt):
try self.line("if (!")
try self.put_ident(p.text)
try self.put(") lb_trap(\"null_foreign\");")
cursor = p.next
## `({ int32_t o0; double r = frexp(x, &o0); (tuple){ r, o0 }; })`: an extern's `out`
## parameters are locals passed by address and answered after the declared result (§17.1).
func extern_out_call(e: ast.Node*, d: ast.Node*, fn: u32) -> !:
let n = self.tmp()
let declared = declared_result(d)
try self.put("({ ")
var outs: u32 = 0
var param = d.right
while let p = param:
if p.has(ast.flag_out):
try self.put_type(p.type_id)
try self.put(" ")
try self.put_out_local(n, outs)
try self.put("; ")
outs += 1
param = p.next
if declared != types.unit_id:
try self.put_type(declared)
try self.put(" ")
try self.put_tmp("or", n)
try self.put(" = ")
try self.put_extern_callee(d)
try self.put("(")
try self.arguments_with_outs(e.body, fn, d, n)
try self.put("); ")
let answered = self.c.table.get(fn).elem
if self.kind(answered) == types.Kind.tuple:
try self.put("((")
try self.put_type(answered)
try self.put("){ ")
var first = true
if declared != types.unit_id:
try self.put_tmp("or", n)
first = false
var k: u32 = 0
while k < outs:
if not first:
try self.put(", ")
first = false
try self.put_out_local(n, k)
k += 1
try self.put(" }); })")
elif declared != types.unit_id:
try self.put_tmp("or", n)
try self.put("; })")
else:
try self.put_out_local(n, 0)
try self.put("; })")
## `_lb_oN_k`: the local an `out` parameter is written through.
func put_out_local(n: u32, k: u32) -> !:
try self.put_tmp("o", n)
try self.put("_")
try self.put_u64((u64)k)
## The arguments of an extern call whose `out` parameters take the address of a local.
func arguments_with_outs(args: ast.Node*?, fn: u32, d: ast.Node*, n: u32) -> !:
let f = self.c.table.get(fn)
var first = true
var pi: usize = 0
var outs: u32 = 0
var cursor = args
var param = d.right
while let p = param:
if not first:
try self.put(", ")
first = false
if p.has(ast.flag_out):
try self.put("&")
try self.put_out_local(n, outs)
outs += 1
else:
let a = cursor else return error(backend, "an extern call is short of arguments")
let v = a.left else return
try self.argument_value(v, f.args[pi] if pi < f.args.length else types.none_id)
pi += 1
cursor = a.next
param = p.next
## `x.method(args)`, `Type.static(args)`, `module.func(args)`, and the builtin
## methods of the standard records.
func member_call(e: ast.Node*, callee: ast.Node*) -> !:
let receiver = callee.left else return
let rt_raw = try self.ty(receiver)
if self.kind(rt_raw) == types.Kind.module:
try self.module_call(e, callee, rt_raw)
return
if receiver.has(ast.flag_type_ref):
try self.static_call(e, callee, rt_raw)
return
let rt = self.elem(rt_raw) if self.is_ptr(rt_raw) else rt_raw
# atomics
if self.is_atomic(rt):
try self.atomic_call(e, callee, receiver, rt, self.is_ptr(rt_raw))
return
# builtin members of spans and floats
if callee.has(ast.flag_static) and callee.resolved == none:
try self.builtin_method(e, callee, receiver, rt)
return
let method = callee.resolved else return try self.put("0")
if method.kind == ast.Kind.field:
# `holder.callback(args)`: a field of function type, called through its value
try self.value_call(e, callee)
return
if self.is_iface(rt):
try self.interface_call(e, receiver, method, rt, rt_raw)
return
# a method on a generic parameter's constraint resolves to the concrete type's method
let t = self.c.table.get(rt)
if t.decl == none and method.text == "compare":
# `T: Comparable` at a number, `char`, or `str`: the builtin ordering (§14.4)
try self.builtin_method(e, callee, receiver, rt)
return
try self.method_call(e, receiver, method, rt, rt_raw)
## `module.func(args)`: a module's function or construction, or a global of function
## type the module declares or re-exports, called through its value.
func module_call(e: ast.Node*, callee: ast.Node*, rt_raw: u32) -> !:
let m = self.decl_of(rt_raw) else return
if let d = e.resolved:
if d.has(ast.flag_builtin) and (m.text == "atomic" or m.text == "c"):
try self.std_call(e, m.text, callee.text, d)
return
try self.direct_call(e, d, none, try types.no_args())
return
try self.value_call(e, callee)
## `Type.static(args)`: a static method or a payload case through the type, an error
## code's number, or a float's `bits`.
func static_call(e: ast.Node*, callee: ast.Node*, rt_raw: u32) -> !:
if let resolved = callee.resolved:
if resolved.kind == ast.Kind.enum_case:
try self.enum_value(e)
return
if let d = callee.resolved:
let t = self.c.table.get(rt_raw)
try self.direct_call(e, d, t.decl, t.args)
return
if rt_raw == types.error_code_id:
let first = e.body else return
let v = first.left else return
try self.put("((uint32_t)(")
try self.expr(v)
try self.put("))")
return
if self.is_float(rt_raw) and callee.text == "bits":
try self.float_from_bits(e, rt_raw)
return
try self.put("0")
## `f64.bits(x)`: constant bits are spelled as a float constant, so `f64.bits(...)` can
## initialise a global (§6.4) under GCC, which has no bit cast in C; other bits are
## copied at the float's width.
func float_from_bits(e: ast.Node*, rt_raw: u32) -> !:
let first = e.body else return
let v = first.left else return
if let bits = self.c.constant_u64(v):
try self.float_constant(rt_raw, bits)
return
try self.put("({ ")
try self.put_type(self.c.bits_type(rt_raw))
try self.put(" _lb_b = (")
try self.put_type(self.c.bits_type(rt_raw))
try self.put(")(")
try self.expr(v)
try self.put("); ")
try self.put_type(rt_raw)
try self.put(" _lb_f; __builtin_memcpy(&_lb_f, &_lb_b, sizeof _lb_f); _lb_f; })")
## A method of an interface view, dispatched through its table; `view.method()` on a
## `Writer*` auto-dereferences (§7.3), so the fat pointer is copied out of the pointee
## first.
func interface_call(e: ast.Node*, receiver: ast.Node*, method: ast.Node*, rt: u32, rt_raw: u32) -> !:
let n = self.tmp()
let fn = try self.map(method.type_id)
let i = self.decl_of(rt) else return
try self.put("({ lb_iface ")
try self.put_tmp("if", n)
try self.put(" = ")
if self.is_ptr(rt_raw):
try self.put("(*(")
try self.expr(receiver)
try self.put("))")
else:
try self.expr(receiver)
try self.put("; ")
let hoisted = try self.begin_sequence(e.body, fn, method)
try self.put("((lb_vt_")
try self.put(i.text)
try self.put("*)")
try self.put_tmp("if", n)
try self.put(".vtable)->")
try self.put(method.text)
try self.put("(")
try self.put_tmp("if", n)
try self.put(".data")
if e.body != none:
try self.put(", ")
try self.arguments(e.body, fn, method, try types.no_args())
try self.put(")")
try self.end_sequence(hoisted)
try self.put("; })")
## `x.method(args)` on a record, enum, or generic parameter: the concrete method,
## instantiated for the owner's and the call's type arguments, with its receiver.
func method_call(e: ast.Node*, receiver: ast.Node*, method: ast.Node*, rt: u32, rt_raw: u32) -> !:
let t = self.c.table.get(rt)
var owner = t.decl
var owner_args = t.args
var impl = method
if let od = owner:
if let found = check.find_member(od, method.text, ast.Kind.func_):
impl = found
var fn = try self.map(impl.type_id)
if let o = owner:
fn = try self.c.substitute(fn, o, owner_args)
var args = try types.no_args()
if let ta = e.ty:
args = try self.type_args(ta)
if args.length > 0:
fn = try self.c.substitute(fn, impl, args)
_ = try self.add_func(impl, args, owner, owner_args)
# a value receiver, `Flags.a.name()` or a call's result, is held in a temporary
let by_value = not impl.has(ast.flag_static) and not self.is_ptr(rt_raw) and not self.c.is_place(receiver)
if by_value:
try self.put("({ ")
try self.put_type(rt)
try self.put(" _lb_rc = ")
try self.value(receiver, rt)
try self.put("; ")
# the receiver before the arguments (§7.1): a pointer or a place with an effect of
# its own is computed first, into a temporary, when an argument has one too
var ordered: u32 = 0
if not impl.has(ast.flag_static) and not by_value:
# a place's address is typed as the method's `self`: a pointer to const unless the
# method mutates, since the place may be reached through a `const T*`
let reads_only = not (impl.has(ast.flag_mutating) or impl.text == "init")
let receiver_type = rt_raw if self.is_ptr(rt_raw) else try self.c.table.pointer(rt, reads_only, false)
ordered = try self.receiver_first(receiver, receiver_type, e.body, not self.is_ptr(rt_raw))
let hoisted = try self.begin_sequence(e.body, fn, impl)
try self.put_func_name(impl, args, owner, owner_args)
try self.put("(")
if not impl.has(ast.flag_static):
if ordered != 0:
try self.put_tmp("rv", ordered)
elif self.is_ptr(rt_raw):
try self.expr(receiver)
elif by_value:
try self.put("&_lb_rc")
else:
try self.address(receiver)
if e.body != none or impl.right != none:
try self.put(", ")
try self.arguments(e.body, fn, impl, args)
try self.put(")")
try self.end_sequence(hoisted)
try self.receiver_done(ordered)
if by_value:
try self.put("; })")
## A function named without a call, `f`, `module.f` or `Type.method`: a function value
## of the instance.
func func_value(e: ast.Node*, d: ast.Node*) -> !:
let named = try self.named_instance(e, d)
try self.put_func_name(named.decl, named.args, named.owner, named.owner_args)
## The instance function `d`, named as a value by `e`, stands for, registered to be
## generated: a method is the one of the record its owner names; anything else takes the
## type arguments the name gives.
func named_instance(e: ast.Node*, d: ast.Node*) -> instances.Instance!:
var args = try types.no_args()
if e.kind == ast.Kind.member and d.kind != ast.Kind.extern_func:
let owner = e.left else return error(backend, "a member names no owner")
let ot = try self.ty(owner)
if self.kind(ot) != types.Kind.module:
let t = self.c.table.get(self.elem(ot) if self.is_ptr(ot) else ot)
_ = try self.add_func(d, args, t.decl, t.args)
return instances.Instance(decl = d, args = args, owner = t.decl, owner_args = t.args, done = true)
if let t = e.ty:
args = try self.type_args(t)
if d.kind != ast.Kind.extern_func:
_ = try self.add_func(d, args, none, try types.no_args())
return instances.Instance(decl = d, args = args, owner = none, owner_args = try types.no_args(), done = true)
## A named function where a function type taking `T*` is wanted and its own reads
## through the `const T*` (§5.6): the name of an adapter of exactly the wanted type that
## calls it, one per function and type. Calling a function through a pointer of another
## type is undefined in C, and Clang's function sanitizer stops the program that does.
func adapted_value(e: ast.Node*, want: u32) -> !:
let d = e.resolved else return error(backend, "a converted function names no declaration")
let target = try self.named_instance(e, d)
let wanted = try self.map(want)
var i: usize = 0
while i < self.adapters.count:
let a = self.adapters.get(i)
if a.want == wanted and a.target.decl == target.decl and a.target.owner == target.owner and types.same_args(a.target.args, target.args) and types.same_args(a.target.owner_args, target.owner_args):
break
i += 1
if i == self.adapters.count:
try self.adapters.push(Adapter(target = target, want = wanted))
try self.put("lb_adapt_")
try self.put_u64((u64)i)
## Every adapter the program's converted functions need, after the prototypes of the
## functions they call: `static R lb_adapt_N(A a0, B a1) { return f(a0, a1); }`, each
## argument converting as C converts `T*` to `const T*`.
func adapters_defined() -> !:
var i: usize = 0
while i < self.adapters.count:
let a = self.adapters.get(i)
let t = self.c.table.get(a.want)
let returns = t.elem != types.unit_id and t.elem != types.never_id
try self.line("static ")
if returns:
try self.put_type(t.elem)
else:
try self.put("void")
try self.put(" lb_adapt_")
try self.put_u64((u64)i)
try self.put("(")
if t.args.length == 0:
try self.put("void")
var k: usize = 0
while k < t.args.length:
if k > 0:
try self.put(", ")
try self.put_type(t.args[k])
try self.put(" a")
try self.put_u64((u64)k)
k += 1
try self.put(") { ")
if returns:
try self.put("return ")
try self.put_func_name(a.target.decl, a.target.args, a.target.owner, a.target.owner_args)
try self.put("(")
k = 0
while k < t.args.length:
if k > 0:
try self.put(", ")
try self.put("a")
try self.put_u64((u64)k)
k += 1
try self.put("); }")
i += 1
## `first()` and `last()` on spans; `bits()` on floats.
## `a.compare(b)` on a number, `char`, or `str`: negative, zero, or positive (§14.4).
func compare_call(e: ast.Node*, receiver: ast.Node*, rt: u32) -> !:
let first = e.body else return
let other = first.left else return
if rt == types.str_id:
try self.put("((int64_t)lb_str_compare(")
try self.receiver_value(receiver, rt)
try self.put(", ")
try self.value(other, rt)
try self.put("))")
return
try self.put("({ ")
try self.put_type(rt)
try self.put(" _lb_ca = ")
try self.receiver_value(receiver, rt)
try self.put("; ")
try self.put_type(rt)
try self.put(" _lb_cb = ")
try self.value(other, rt)
try self.put("; (_lb_ca < _lb_cb) ? (int64_t)-1 : ((_lb_ca > _lb_cb) ? (int64_t)1 : (int64_t)0); })")
## The raw lines of an `asm` block as C string text; extended asm doubles `%`.
func asm_lines(lines: ast.Node*?, extended: bool) -> !:
var cursor = lines
while let l = cursor:
var in_name = false
for b in l.text.bytes:
if b == '{' and extended:
# `{name}` is the named operand `%[name]`
try self.put("%[")
in_name = true
elif b == '}' and in_name:
try self.put("]")
in_name = false
elif b == '%' and extended:
try self.put("%%")
elif b == '"':
try self.put("\\\"")
elif b == '\\':
try self.put("\\\\")
elif b == '\n':
try self.put("\\n")
else:
try self.put_byte(b)
try self.put("\\n")
cursor = l.next
## A module-level `asm arm64:` block (§8.9): the lines verbatim at file scope.
func module_asm(d: ast.Node*) -> !:
try self.line("#if defined(__aarch64__)")
try self.line("__asm__(\"")
try self.asm_lines(d.body, false)
try self.put("\");")
try self.line("#endif")
## A `naked func` body: its asm blocks and nothing else, since C admits no other
## statement in a naked function (§9.8).
func naked_body(f: ast.Node*) -> !:
let body = f.body else return
var cursor = body.body
while let s = cursor:
if s.kind == ast.Kind.asm_ and s.text == "arm64":
try self.line("__asm__ volatile(\"")
try self.asm_lines(s.body, false)
try self.put("\");")
cursor = s.next
## The receiver of a method the compiler supplies, as a value of type `rt`: a pointer
## receiver (`key.bits()` with `key: const f32*`) is read through.
func receiver_value(receiver: ast.Node*, rt: u32) -> !:
let have = try self.ty(receiver)
if self.is_ptr(have) and not self.is_ptr(rt):
try self.put("(*(")
try self.expr(receiver)
try self.put("))")
return
try self.value(receiver, rt)
## `a.mul_add(b, c)` (§7.2): the C library's `fma`, rounded once, on a scalar or on each
## lane of a vector.
func mul_add(e: ast.Node*, receiver: ast.Node*, rt: u32, n: u32) -> !:
let first = e.body else return
let second = first.next else return
let b = first.left else return
let c = second.left else return
let is_vector = self.is_array(rt)
let et = self.elem(rt) if is_vector else rt
let function = "__builtin_fmaf(" if et == types.f32_id else "__builtin_fma("
if not is_vector:
try self.put(function)
try self.receiver_value(receiver, rt)
try self.put(", ")
try self.value(b, rt)
try self.put(", ")
try self.value(c, rt)
try self.put(")")
return
let operands: str[3] = ["ma", "mb", "mc"]
try self.put("({ ")
for k in 0..<3:
try self.put_type(rt)
try self.put(" ")
try self.put_tmp(operands[k], n)
try self.put(" = ")
if k == 0:
try self.receiver_value(receiver, rt)
else:
try self.value(b if k == 1 else c, rt)
try self.put("; ")
try self.put_type(rt)
try self.put(" ")
try self.put_tmp("mr", n)
try self.put("; for (size_t _i = 0; _i < ")
try self.put_u64(self.c.table.get(rt).length)
try self.put("; _i++) ")
try self.put_tmp("mr", n)
try self.put(".d[_i] = ")
try self.put(function)
for k in 0..<3:
try self.put_tmp(operands[k], n)
try self.put(".d[_i]" if k == 2 else ".d[_i], ")
try self.put("); ")
try self.put_tmp("mr", n)
try self.put("; })")
func builtin_method(e: ast.Node*, callee: ast.Node*, receiver: ast.Node*, rt: u32) -> !:
if callee.text == "compare":
try self.compare_call(e, receiver, rt)
return
if callee.text == "sum" or callee.text == "min" or callee.text == "max":
try self.vector_fold(e, callee, receiver, rt)
return
let n = self.tmp()
if callee.text == "mul_add":
try self.mul_add(e, receiver, rt, n)
return
if callee.text == "bits":
try self.put("({ ")
try self.put_type(rt)
try self.put(" ")
try self.put_tmp("fv", n)
try self.put(" = ")
try self.receiver_value(receiver, rt)
try self.put("; ")
try self.put_type(self.c.bits_type(rt))
try self.put(" ")
try self.put_tmp("fb", n)
try self.put("; memcpy(&")
try self.put_tmp("fb", n)
try self.put(", &")
try self.put_tmp("fv", n)
try self.put(", sizeof(")
try self.put_tmp("fb", n)
try self.put(")); ")
try self.put_tmp("fb", n)
try self.put("; })")
return
let result = try self.ty(e)
# `first` and `last` are the span's (§5.4): an array receiver is read as the span it
# converts to; `indexed` is a `for` of its own (`for_stmt`)
let st = rt if self.is_span(rt) else try self.c.table.span(self.elem(rt), false)
try self.put("({ ")
try self.put_type(st)
try self.put(" ")
try self.put_tmp("sq", n)
try self.put(" = ")
try self.value(receiver, st)
try self.put("; ")
let et = self.elem(rt)
# first / last
try self.put_type(result)
try self.put(" ")
try self.put_tmp("fo", n)
try self.put("; if (")
try self.put_tmp("sq", n)
try self.put(".length == 0) { ")
try self.put_tmp("fo", n)
try self.put(" = ")
try self.none_of(result)
try self.put("; } else { ")
if self.is_tagged_opt(result):
try self.put_tmp("fo", n)
try self.put(".present = true; ")
try self.put_tmp("fo", n)
try self.put(".value = ")
else:
try self.put_tmp("fo", n)
try self.put(" = ")
try self.put("((")
try self.put_type(et)
try self.put("*)")
try self.put_tmp("sq", n)
try self.put(".data)[")
if callee.text == "last":
try self.put_tmp("sq", n)
try self.put(".length - 1")
else:
try self.put("0")
try self.put("]; } ")
try self.put_tmp("fo", n)
try self.put("; })")
# -- constructions and conversions ----------------------------------------------------
## `Name(...)`: a struct value, an `init` call, or a checked scalar conversion.
func construct_or_convert(e: ast.Node*, callee: ast.Node*) -> !:
let target = try self.ty(e)
if self.is_vector(target):
try self.splat(e, target)
return
let payload = self.elem(target) if self.is_fail(target) else target
if let init = e.resolved:
if init.kind == ast.Kind.func_ and init.text == "init":
try self.init_call(e, init, payload)
return
if self.kind(payload) == types.Kind.struct_:
try self.constructor(e, payload)
return
if target == types.str_id or (self.is_fail(target) and payload == types.str_id):
let first = e.body else return
let v = first.left else return
try self.str_conversion(v, self.is_fail(target))
return
let first = e.body else return
let v = first.left else return
try self.conversion(v, target, true)
_ = callee
## `(lb_Name){ .field = value, ... }` with defaults for what was omitted.
func constructor(e: ast.Node*, id: u32) -> !:
let d = self.decl_of(id) else return try self.put("{}")
let t = self.c.table.get(id)
var effects = arguments_have_effect(e.body)
var member = d.body
while let f = member:
if f.kind == ast.Kind.field:
if let default = f.left:
effects = effects or may_have_effect(default)
member = f.next
# Global initializers have already been checked as constants; calls such
# as `sizeof` must remain valid C constant expressions at file scope.
effects = effects and self.current_fn != none
var hoisted: usize = 0
if effects:
try self.put("({ ")
var argument = e.body
while let given = argument:
let field = given.resolved else return
let expression = given.left else return
let want = try self.map(try self.c.substitute(field.type_id, d, t.args))
hoisted += try self.hoist(expression, want)
argument = given.next
member = d.body
while let field = member:
if field.kind == ast.Kind.field and not calls.supplies(e, field):
if let default = field.left:
let want = try self.map(try self.c.substitute(field.type_id, d, t.args))
hoisted += try self.hoist(default, want)
member = field.next
# a static initialiser takes braces alone: a compound literal is not a constant
# expression to every C compiler
if self.folding:
try self.put("{")
else:
try self.put("((")
try self.put_type(id)
try self.put("){")
var first = true
var position: usize = 0
var field = d.body
while let f = field:
if f.kind != ast.Kind.field:
field = f.next
continue
var given: ast.Node*? = none
var pos: usize = 0
var a = e.body
while let arg = a:
if arg.text.length > 0:
if arg.text == f.text:
given = arg
else:
if pos == position:
given = arg
pos += 1
a = arg.next
let want = try self.c.substitute(f.type_id, d, t.args)
if let g = given:
let v = g.left else return
if not first:
try self.put(", ")
first = false
try self.put(".")
try self.put(try c_field_name(f.text))
try self.put(" = ")
try self.argument_value(v, try self.map(want))
elif let default = f.left:
if not first:
try self.put(", ")
first = false
try self.put(".")
try self.put(try c_field_name(f.text))
try self.put(" = ")
try self.argument_value(default, try self.map(want))
position += 1
field = f.next
try self.put("}" if self.folding else "})")
try self.end_sequence(hoisted)
## A struct with its own `init`: zero the value, run `init`, yield the value or its failure.
func init_call(e: ast.Node*, init: ast.Node*, id: u32) -> !:
let t = self.c.table.get(id)
let n = self.tmp()
var fn = try self.map(init.type_id)
if let o = t.decl:
fn = try self.c.substitute(fn, o, t.args)
_ = try self.add_func(init, try types.no_args(), t.decl, t.args)
try self.put("({ ")
try self.put_type(id)
try self.put(" ")
try self.put_tmp("iv", n)
# Empty braces zero every field, including an initial zero-sized unit.
try self.put(" = {}; ")
if init.has(ast.flag_fallible):
try self.put("lb_r_unit ")
try self.put_tmp("ir", n)
try self.put(" = ")
let hoisted = try self.begin_sequence(e.body, fn, init)
try self.put_func_name(init, try types.no_args(), t.decl, t.args)
try self.put("(&")
try self.put_tmp("iv", n)
if init.right != none:
try self.put(", ")
try self.arguments(e.body, fn, init, try types.no_args())
try self.put(")")
try self.end_sequence(hoisted)
try self.put("; ")
if init.has(ast.flag_fallible):
let res = try self.c.table.fallible(id)
try self.note(res)
try self.put_type(res)
try self.put(" ")
try self.put_tmp("io", n)
try self.put("; if (")
try self.put_tmp("ir", n)
try self.put(".failed) { ")
try self.put_tmp("io", n)
try self.put(".failed = true; ")
try self.put_tmp("io", n)
try self.put(".error = ")
try self.put_tmp("ir", n)
try self.put(".error; } else { ")
try self.put_tmp("io", n)
try self.put(".failed = false; ")
try self.put_tmp("io", n)
try self.put(".value = ")
try self.put_tmp("iv", n)
try self.put("; } ")
try self.put_tmp("io", n)
try self.put("; })")
return
try self.put_tmp("iv", n)
try self.put("; })")
# -- core functions -------------------------------------------------------------------
## `memory.frame[T](count, most)` (§12.7): `count` elements from `alloca` in the frame of
## the function the call is in, after a trap when `count` is past `most`. The diagnostic
## profile fills the elements with its pattern (§19.4).
func frame_storage(e: ast.Node*) -> !:
let result = try self.ty(e)
let first = e.body else return
let second = first.next else return
let count = first.left else return
let most_node = second.left else return
let most = self.c.constant_u64(most_node) else return
let n = self.tmp()
try self.put("({ size_t ")
try self.put_tmp("fn", n)
try self.put(" = (size_t)(")
try self.value(count, types.usize_id)
try self.put("); if (")
try self.put_tmp("fn", n)
try self.put(" > ")
try self.put_u64(most)
try self.put("u) lb_trap(\"memory.frame count is past its most\"); size_t ")
try self.put_tmp("fb", n)
try self.put(" = ")
try self.put_tmp("fn", n)
try self.put(" * sizeof(")
try self.put_type(self.elem(result))
try self.put("); void* ")
try self.put_tmp("fp", n)
try self.put(" = __builtin_alloca(")
try self.put_tmp("fb", n)
try self.put("); ")
if self.diagnostic:
try self.put("memset(")
try self.put_tmp("fp", n)
try self.put(", 0xAA, ")
try self.put_tmp("fb", n)
try self.put("); ")
try self.put("(")
try self.put_type(result)
try self.put("){ ")
try self.put_tmp("fp", n)
try self.put(", ")
try self.put_tmp("fn", n)
try self.put(" }; })")
## A call the compiler answers: the core `print`, `assert`, `trap`, and `error`,
## `strings.format`, `value.hash()`, and `memory.size_of`, `align_of`, and `offset_of`.
func intrinsic(e: ast.Node*, name: str) -> !:
let first = e.body
var arg: ast.Node*? = none
var second: ast.Node*? = none
if let f = first:
arg = f.left
if let s = f.next:
second = s.left
if name == "print":
let v = arg else return
try self.print_call(v)
return
if name == "format":
let buf = arg else return
let msg = second else return
try self.format_call(buf, msg)
return
if name == "assert":
let cond = arg else return
try self.assert_call(e, cond, second)
return
if name == "trap":
try self.trap_call(arg)
return
if name == "error":
# as an expression (in `else error(...)`): the function leaves
try self.put("{")
self.indent += 1
try self.error_return(e)
self.indent -= 1
try self.line("}")
return
if name == "hash":
let v = arg else return
try self.hash_of(try self.ty(v), v)
return
if name == "size_of" or name == "align_of":
let v = arg else return
let t = try self.map(v.type_id)
try self.put("((size_t)sizeof(" if name == "size_of" else "((size_t)_Alignof(")
try self.put_type(t)
try self.put("))")
return
if name == "offset_of":
let tv = arg else return
let fv = second else return
try self.put("((size_t)offsetof(")
try self.put_type(try self.map(tv.type_id))
try self.put(", ")
try self.put(try c_field_name(fv.text))
try self.put("))")
return
try self.put("0")
## `print(v)`: a formatted text streamed to stdout, or a text and a newline.
func print_call(v: ast.Node*) -> !:
if v.kind == ast.Kind.formatted:
try self.put("(")
try self.stream_formatted(v, false)
try self.put(", fputc('\\n', stdout))")
return
try self.put("lb_print_str(")
try self.expr(v)
try self.put(")")
## `assert(cond)` and `assert(cond, msg)`: a trap naming the condition, and the
## message when one is given, unless it holds.
func assert_call(e: ast.Node*, cond: ast.Node*, message: ast.Node*?) -> !:
if e.has(ast.flag_test_assert):
return try self.test_assert(e, cond, message)
try self.put("((void)((")
try self.value(cond, types.bool_id)
if let msg = message:
try self.put(") ? 0 : (lb_trap_detail(")
try self.put_assert_text(e)
try self.put(", ")
try self.expr(msg)
else:
try self.put(") ? 0 : (lb_trap(")
try self.put_assert_text(e)
try self.put("), 0)))")
## A false `assert` in a test's own body: `core.test_assert` makes the failure, and the
## test leaves with it as with an `error` (§16.5).
func test_assert(e: ast.Node*, cond: ast.Node*, message: ast.Node*?) -> !:
let result = self.tmp()
let n = self.tmp()
try self.put("({ if (!(")
try self.value(cond, types.bool_id)
try self.put(")) {")
self.indent += 1
try self.line("lb_r_unit ")
try self.put_tmp("ta", result)
# Base's `c.str` is `char*` in C, which the literals and `lb_pos` are not
try self.put(" = lb_core_11test_assert((char*)lb_pos, (char*)(")
try self.put_assert_text(e)
try self.put(")")
if let msg = message:
try self.put(", ")
try self.expr(msg)
try self.put(", true);")
else:
try self.put(", (lb_str){ 0 }, false);")
try self.line("lb_error ")
try self.put_tmp("err", n)
try self.put(" = ")
try self.put_tmp("ta", result)
try self.put(".error;")
try self.leave_failing(n)
self.indent -= 1
try self.line("} (void)0; })")
## `trap()`, `trap(text)`, and `trap(f"...")`, the last streamed to stderr.
func trap_call(message: ast.Node*?) -> !:
let msg = message else return try self.put("lb_trap(\"trap\")")
if msg.kind == ast.Kind.formatted:
try self.put("(lb_trap_begin(), ")
try self.stream_formatted(msg, true)
try self.put(", lb_trap_end())")
return
try self.put("lb_trap_text(")
try self.expr(msg)
try self.put(")")