dymokomi/luce-base
Source of release 0.43.0
0.43.0 / src / back / c / emit / definitions.lucb
#==============================================================================================
#
# emit/definitions - Definitions and functions
#
# DESCRIPTION:
# Typedefs, records, globals, and witness tables as the worklist reaches them, and
# each function's prototype, frame, and body.
#
#==============================================================================================
extend Emitter:
# mark: Definitions ========================================================================
## Write a typedef for `id` after everything it holds by value.
func define_type(id: u32) -> !:
if contains_id(self.defined.span(), id):
return
let t = self.c.table.get(id)
match t.kind:
.pointer, .span, .atomic:
# only the pointee's name is needed; records are forward-declared
if not self.is_record(t.elem) or self.c.is_backed_enum(t.elem):
try self.define_type(t.elem)
try self.defined.push(id)
.array:
try self.define_type(t.elem)
try self.defined.push(id)
try self.line("typedef struct ")
try self.put_mangled_name(id)
try self.put(" { ")
try self.put_type(t.elem)
try self.put(" d[")
try self.put_u64(t.length)
try self.put("]; } ")
try self.put_mangled_name(id)
try self.put(";")
.optional:
try self.define_type(t.elem)
try self.defined.push(id)
if self.c.table.has_null_niche(t.elem):
return
try self.line("LB_OPT(")
try self.put_type(t.elem)
try self.put(", ")
try self.put_mangled_name(id)
try self.put(");")
.fallible:
try self.define_type(t.elem)
try self.defined.push(id)
if t.elem == types.unit_id or t.elem == types.never_id:
return
try self.line("LB_RES(")
try self.put_type(t.elem)
try self.put(", ")
try self.put_mangled_name(id)
try self.put(");")
.tuple:
var i: usize = 0
while i < t.args.length:
try self.define_type(t.args[i])
i += 1
try self.defined.push(id)
try self.line("typedef struct ")
try self.put_mangled_name(id)
try self.put(" {")
i = 0
while i < t.args.length:
try self.put(" ")
try self.put_type(t.args[i])
try self.put(" a")
try self.put_u64((u64)i)
try self.put(";")
i += 1
try self.put(" } ")
try self.put_mangled_name(id)
try self.put(";")
.func_:
var i: usize = 0
while i < t.args.length:
try self.define_type(t.args[i])
i += 1
try self.define_type(t.elem)
try self.defined.push(id)
try self.line("typedef ")
if t.elem == types.unit_id or t.elem == types.never_id:
try self.put("void")
else:
try self.put_type(t.elem)
try self.put(" (*")
try self.put_mangled_name(id)
try self.put(")(")
if t.args.length == 0:
try self.put("void")
i = 0
while i < t.args.length:
if i > 0:
try self.put(", ")
try self.put_type(t.args[i])
i += 1
try self.put(");")
.struct_, .union_, .enum_:
try self.defined.push(id)
if self.c.is_backed_enum(id):
return
let d = t.decl else return
if t.args.length > 0:
try self.define_record(d, t.args, id)
else:
try self.define_decl(d)
_:
try self.defined.push(id)
## A non-generic record, once, after its by-value members.
func define_decl(d: ast.Node*) -> !:
var i: usize = 0
while i < self.decls_done.count:
if self.decls_done.get(i) == d:
return
i += 1
try self.decls_done.push(d)
if check.generic_params_of(d) != none:
return
if d.kind == ast.Kind.enum_ and d.ty != none:
return
try self.define_record(d, try types.no_args(), d.type_id)
## ` { fields } name;` of record `id`, a struct's or a union's: each field with its own
## alignment, and a placeholder `int` when there is none, which C requires.
func record_fields(d: ast.Node*, id: u32) -> !:
try self.put(" {")
self.indent += 1
var any = false
var member = d.body
while let m = member:
if m.kind == ast.Kind.field:
any = true
try self.line("")
try self.put_type(try self.map(m.type_id))
try self.put(" ")
try self.put(try c_field_name(m.text))
if let al = m.right:
if al.kind == ast.Kind.literal:
try self.put(" __attribute__((aligned(")
try self.put(al.text)
try self.put(")))")
try self.put(";")
member = m.next
if not any:
try self.line("int unused;")
self.indent -= 1
try self.line("} ")
try self.put_record_name(id)
try self.put(";")
## Write the C definition of a record declaration with `args` substituted.
func define_record(d: ast.Node*, args: u32[], id: u32) -> !:
let saved_owner = self.generic.owner_decl
let saved_args = self.generic.owner_args
self.generic.owner_decl = d
self.generic.owner_args = args
# members held by value come first
var member = d.body
while let m = member:
if m.kind == ast.Kind.field:
try self.define_type(try self.map(m.type_id))
elif m.kind == ast.Kind.enum_case:
var p = m.body
while let q = p:
try self.define_type(try self.map(q.type_id))
p = q.next
member = m.next
if d.kind == ast.Kind.struct_ or d.kind == ast.Kind.extern_struct:
try self.line("typedef struct")
if d.has(ast.flag_packed):
try self.put(" __attribute__((packed))")
if let layout = d.right:
if layout.kind == ast.Kind.literal:
try self.put(" __attribute__((aligned(")
try self.put(layout.text)
try self.put(")))")
try self.put(" ")
try self.put_record_name(id)
try self.record_fields(d, id)
elif d.kind == ast.Kind.union_ or d.kind == ast.Kind.extern_union:
try self.line("typedef union ")
try self.put_record_name(id)
try self.record_fields(d, id)
elif d.kind == ast.Kind.enum_:
try self.line("typedef struct ")
try self.put_record_name(id)
try self.put(" {")
self.indent += 1
try self.line("int32_t tag;")
var any_payload = false
member = d.body
while let m = member:
if m.kind == ast.Kind.enum_case and m.body != none:
any_payload = true
member = m.next
if any_payload:
try self.line("union {")
self.indent += 1
member = d.body
while let m = member:
if m.kind == ast.Kind.enum_case and m.body != none:
try self.line("struct {")
self.indent += 1
var p = m.body
while let q = p:
try self.line("")
try self.put_type(try self.map(q.type_id))
try self.put(" ")
try self.put(try c_field_name(q.text))
try self.put(";")
p = q.next
self.indent -= 1
try self.line("} ")
try self.put(try c_field_name(m.text))
try self.put(";")
member = m.next
self.indent -= 1
try self.line("} u;")
self.indent -= 1
try self.line("} ")
try self.put_record_name(id)
try self.put(";")
self.generic.owner_decl = saved_owner
self.generic.owner_args = saved_args
## `typedef struct X X;` for every record the program defines.
func forward_declarations() -> !:
var i: usize = 0
while i < self.modules.count:
var cursor = self.modules.get(i).body
while let d = cursor:
if check.generic_params_of(d) == none:
if d.kind == ast.Kind.struct_ or d.kind == ast.Kind.extern_struct:
try self.forward_one(d, d.type_id, "struct")
elif d.kind == ast.Kind.union_ or d.kind == ast.Kind.extern_union:
try self.forward_one(d, d.type_id, "union")
elif d.kind == ast.Kind.enum_ and d.ty == none:
try self.forward_one(d, d.type_id, "struct")
cursor = d.next
i += 1
i = 0
while i < self.records.count:
let r = self.records.get(i)
let id = try self.c.table.nominal(self.c.table.kind(r.decl.type_id), r.decl, r.args)
if r.decl.kind == ast.Kind.enum_ and r.decl.ty != none:
i += 1
continue
try self.forward_one(r.decl, id, "union" if r.decl.kind == ast.Kind.union_ else "struct")
i += 1
func forward_one(d: ast.Node*, id: u32, tag: str) -> !:
if d.kind == ast.Kind.extern_struct or d.kind == ast.Kind.extern_union:
return
try self.line("typedef ")
try self.put(tag)
try self.put(" ")
try self.put_record_name(id)
try self.put(" ")
try self.put_record_name(id)
try self.put(";")
## Every typedef the bodies needed, in dependency order.
func type_definitions() -> !:
try self.line("LB_RES(size_t, lb_r_usize);")
let usize_res = try self.c.table.fallible(types.usize_id)
try self.defined.push(usize_res)
var i: usize = 0
while i < self.modules.count:
var cursor = self.modules.get(i).body
while let d = cursor:
if d.kind == ast.Kind.struct_ or d.kind == ast.Kind.extern_struct or d.kind == ast.Kind.union_ or d.kind == ast.Kind.extern_union or d.kind == ast.Kind.enum_:
if check.generic_params_of(d) == none:
try self.define_type(d.type_id)
cursor = d.next
i += 1
# `needed` grows while records define their members; loop until it is drained
var n: usize = 0
while n < self.needed.count:
try self.define_type(self.needed.get(n))
n += 1
# mark: Functions ==========================================================================
## The signature of a function or method instance; `define` opens the body.
## The attributes of §9.8 as one `__attribute__` prefix. `inline` is advice this backend
## leaves to the C compiler; a section name is passed as spelled, except that a Mach-O
## target places a name without a comma in `__DATA` or `__TEXT` (§9.8).
func attribute_prefix(d: ast.Node*, is_func: bool) -> !:
var first = true
var cursor = d.attrs
while let a = cursor:
let word = a.text
let skip = word == "inline" or word == "linked" or (not is_func and (word == "noinline" or word == "cold" or word == "naked"))
if not skip:
try self.put("__attribute__((" if first else ", ")
first = false
if word == "section":
try self.put("section(\"")
if let name = a.left:
try self.put(targets.section_name(literals.decode_text(name.text), is_func, self.c.build_target.os))
try self.put("\")")
else:
try self.put(word)
cursor = a.next
if not first:
try self.put(")) ")
func signature(f: ast.Node*, define: bool) -> !:
try self.line("")
if f.kind == ast.Kind.test_:
try self.put("lb_r_unit lb_test_")
let index = try self.test_index(f)
try self.put_u64((u64)index)
try self.put("(void)")
else:
# Standard functions belong to this artifact, unless explicitly exported
# or given linkage attributes. Internal linkage lets the host compiler
# omit unused platform code (for example AppKit in a console program).
if check.is_library_module(names.module_of(self.generic.owner_decl else f)) and not f.has(ast.flag_export) and f.attrs == none:
try self.put("static __attribute__((unused)) ")
try self.attribute_prefix(f, true)
try self.put_result_type(f)
try self.put(" ")
try self.put_func_name(f, self.generic.fn_args, self.generic.owner_decl, self.generic.owner_args)
try self.put("(")
var first = not try self.put_receiver(f)
var cursor = f.right
while let p = cursor:
if not first:
try self.put(", ")
first = false
try self.put_type(try self.map(p.type_id))
try self.put(" ")
try self.put_ident(p.text)
cursor = p.next
if first:
try self.put("void")
try self.put(")")
if not define:
try self.put(";")
return
try self.put(" {")
## The receiver of method `f` of the record being emitted, `T* self`, `const` unless
## the method mutates or initialises; whether there is one (a static method has none).
func put_receiver(f: ast.Node*) -> bool!:
let o = self.generic.owner_decl else return false
if f.has(ast.flag_static):
return false
if not (f.has(ast.flag_mutating) or f.text == "init"):
try self.put("const ")
try self.put_type(try self.map(o.type_id))
try self.put("* self")
return true
## The locals a body written into the scratch asked for, declared at its top: the format
## buffers of its formatted texts, and the arrays whose addresses it took.
func scratch_declarations() -> !:
self.indent += 1
var k: usize = 0
while k < self.formats.count:
try self.line("char ")
try self.put_tmp("fb", self.formats.get(k))
try self.put("[1024]; lb_fmtbuf ")
try self.put_tmp("ff", self.formats.get(k))
# a buffer that grew onto the heap is freed when the function returns
try self.put(" __attribute__((cleanup(lb_fmtbuf_release))) = { 0 };")
k += 1
k = 0
while k < self.arrays.count:
let h = self.arrays.get(k)
try self.line("")
try self.put_type(h.type_id)
try self.put(" ")
try self.put_tmp("ad", h.n)
try self.put(";")
k += 1
self.indent -= 1
## Emit one function instance into the body buffer.
func function(inst: instances.Instance) -> !:
let f = inst.decl
let saved_fn = self.current_fn
let saved_decl = self.generic.fn_decl
let saved_args = self.generic.fn_args
let saved_owner = self.generic.owner_decl
let saved_owner_args = self.generic.owner_args
let saved_file = self.src_file
self.current_fn = f
# a method's positions name its record's file
self.src_file = self.source_of(inst.owner else f)
self.generic.fn_decl = f
self.generic.fn_args = inst.args
self.generic.owner_decl = inst.owner
self.generic.owner_args = inst.owner_args
# the body first, into the scratch, so its format buffers can be declared at its top
self.target = to_scratch
self.scratch.clear()
self.formats.count = 0
self.arrays.count = 0
self.indent += 1
# the result type must exist as a typedef
if f.kind != ast.Kind.test_:
let ft = self.c.table.get(try self.map(f.type_id))
if f.has(ast.flag_fallible):
try self.note_if_typedef(ft.elem)
else:
try self.note_if_typedef(ft.elem)
let base = self.scopes.count
try self.push_scope(false, "")
let naked = ast.has_attribute(f, "naked")
if f.has(ast.flag_export) and not naked:
try self.check_foreign_parameters(f)
if naked:
try self.naked_body(f)
elif let body = f.body:
# the statement position a trap names is the caller's again once this returns
try self.line("const char* lb_saved_pos __attribute__((cleanup(lb_restore_pos), unused)) = lb_pos;")
var cursor = body.body
while let s = cursor:
try self.stmt(s)
cursor = s.next
try self.unwind(self.scopes.count - 1, false)
self.pop_scope()
if naked:
_ = 0
elif self.fn_fallible() and (try self.result_payload()) == types.unit_id:
try self.line("return ((lb_r_unit){ .failed = false });")
elif (try self.result_payload()) != types.unit_id and (try self.result_payload()) != types.never_id:
try self.line("lb_trap(\"unreachable\");")
elif (try self.result_payload()) == types.never_id:
try self.line("lb_trap(\"unreachable\");")
self.indent -= 1
try self.line("}")
self.target = to_body
try self.signature(f, true)
try self.scratch_declarations()
try self.body.put(self.scratch.view())
if names.export_wrapped(&self.c.table, f):
try self.export_wrapper(f)
_ = base
self.current_fn = saved_fn
self.src_file = saved_file
self.generic.fn_decl = saved_decl
self.generic.fn_args = saved_args
self.generic.owner_decl = saved_owner
self.generic.owner_args = saved_owner_args
## The C face of an export whose signature C cannot take as it is (§17.6): a span
## parameter arrives as a pointer and a length, `(NULL, n)` being the empty span, and a
## fallible result becomes an `int` status, 0 or the error's code, with the value
## written through a final out-pointer. The wrapper calls the function by its internal
## name.
func export_wrapper(f: ast.Node*) -> !:
let ft = self.c.table.get(try self.map(f.type_id))
let fallible = f.has(ast.flag_fallible)
let payload = self.elem(ft.elem) if fallible else ft.elem
let none_args = try types.no_args()
try self.line("")
if fallible:
try self.put("int")
else:
try self.put_result_type(f)
try self.put(" ")
try self.put(names.export_prefix)
if let o = self.generic.owner_decl:
try self.put(o.text)
try self.put("_")
try self.put(f.text)
try self.put("(")
var first = not try self.put_receiver(f)
var cursor = f.right
while let p = cursor:
if not first:
try self.put(", ")
first = false
let pt = try self.map(p.type_id)
if self.is_span(pt):
try self.put_element_pointer(pt)
try self.put(" ")
try self.put_ident(p.text)
try self.put(", size_t ")
try self.put_ident(p.text)
try self.put("_len")
else:
try self.put_type(pt)
try self.put(" ")
try self.put_ident(p.text)
cursor = p.next
if fallible and payload != types.unit_id:
if not first:
try self.put(", ")
first = false
try self.put_type(payload)
try self.put("* lb_out")
if first:
try self.put("void")
try self.put(") {")
self.indent += 1
try self.line("")
if fallible:
try self.put_type(ft.elem)
try self.put(" lb_r = ")
elif payload != types.unit_id and payload != types.never_id:
try self.put("return ")
try self.put_func_name(f, none_args, self.generic.owner_decl, none_args)
try self.put("(")
first = true
if let o = self.generic.owner_decl:
if not f.has(ast.flag_static):
try self.put("self")
first = false
cursor = f.right
while let p = cursor:
if not first:
try self.put(", ")
first = false
let pt = try self.map(p.type_id)
if self.is_span(pt):
try self.put("(")
try self.put_type(pt)
try self.put("){ ")
try self.put_ident(p.text)
try self.put(" != NULL ? (void*)")
try self.put_ident(p.text)
try self.put(" : (void*)8, ")
try self.put_ident(p.text)
try self.put(" != NULL ? ")
try self.put_ident(p.text)
try self.put("_len : 0 }")
else:
try self.put_ident(p.text)
cursor = p.next
try self.put(");")
if fallible:
# the status carries the code alone: the message is given back (§11.3)
try self.line("if (lb_r.failed) { lb_core_15message_handled(lb_message_of(lb_r.error)); return lb_r.error.code; }")
if payload != types.unit_id:
try self.line("*lb_out = lb_r.value;")
try self.line("return 0;")
self.indent -= 1
try self.line("}")
## Composite types spelled only inside bodies still need their typedefs.
func note_if_typedef(id: u32) -> !:
let k = self.kind(id)
if k == types.Kind.array or k == types.Kind.tuple or k == types.Kind.func_ or k == types.Kind.optional or k == types.Kind.fallible or k == types.Kind.struct_ or k == types.Kind.enum_ or k == types.Kind.union_:
try self.note(id)
# -- scopes and cleanup ---------------------------------------------------------------
func push_scope(loop: bool, label: str) -> !:
let exit = self.tmp() if loop else 0
try self.scopes.push(exits.Scope(defer_base = self.defers.count, loop = loop, label = label, restore_alloc = false, alloc_saved = 0, exit = exit))
## The label after a loop that its unlabelled `break`s jump to, when one did.
func loop_exit(sc: exits.Scope) -> !:
if sc.exit_used:
try self.line("")
try self.put_tmp("brk", sc.exit)
try self.put(": __attribute__((unused));")
## `goto` the exit of the loop at `target`, marking the label as needed.
func break_to(target: usize) -> !:
var sc = self.scopes.get(target)
sc.exit_used = true
self.scopes.set(target, sc)
try self.put("goto ")
try self.put_tmp("brk", sc.exit)
func pop_scope():
let sc = self.scopes.get(self.scopes.count - 1)
self.defers.count = sc.defer_base
self.scopes.count -= 1
## Run the deferred calls of scope `index` (last registered first) and
## restore its allocator; `failing` includes the `errdefer` calls.
func unwind(index: usize, failing: bool) -> !:
let sc = self.scopes.get(index)
var at = exits.deferred_end(&self.scopes, self.defers.count, index)
while let deferred = exits.next_deferred(&self.defers, sc.defer_base, &at, failing):
try self.block(deferred)
if sc.restore_alloc:
try self.line("lb_memory_allocator = ")
try self.put_tmp("as", sc.alloc_saved)
try self.put(";")
# a handler finished: its error's message is given back to the thread's room; a
# failure leaving it has already taken its place
if sc.handler and not failing:
try self.line("lb_core_15message_handled(lb_message_of(")
try self.put_tmp("fe", sc.handled)
try self.put("));")
## Unwind every scope from the innermost down to `from`, for an exit.
func unwind_from(start: usize, failing: bool) -> !:
var i = self.scopes.count
while i > start:
i -= 1
try self.unwind(i, failing)