Brummel
171a986f82
Fieldtest F4 surfaced that the shipped STUB_AIL had only the
TypeDef + ctor; the spec's prep.3 § "Worked author example" wired
a `(fn new ...)` def into the stub and immediately exercised it
via the worked consumer's `(new StubT 42)`. The implementer
dropped the def during the Task 6 sweep (spec-review let it
through). Without the def, the stub's `Term::New` end-to-end
ratification story is broken — F4 demonstrated this with a
`new-type-not-constructible` diagnostic on a verbatim
worked-consumer paste.
Re-added the def per the spec's design:
(fn new
(doc "Construct StubT<Int> from an Int. Exercises Term::New end-to-end.")
(type (fn-type (params (con Int)) (ret (con StubT (con Int)))))
(params x)
(body (term-ctor StubT Stub x)))
IR snapshots refreshed because every binary now carries the `new`
function's IR (in addition to the `drop_kernel_stub_StubT` from
the original prep.3 close). All 664 workspace tests green.
This restores coherence between the spec, the design model, and
the shipped stub. The `Term::New` invocation `(new StubT 42)` is
still codegen-deferred (per spec § Architecture, raw-buf
milestone); but at least `ail check` now passes on the spec's
worked-consumer paste.
A related and more substantive bug (F3 — kernel-tier auto-import
not registering the module as a qualifier prefix, making
`kernel_stub.StubT` consumer-unreachable) is handled separately
via the debug skill.
308 lines
7.9 KiB
LLVM
308 lines
7.9 KiB
LLVM
; AILang generated workspace; entry: sum
|
|
source_filename = "sum.ail"
|
|
target triple = "<NORMALIZED>"
|
|
|
|
declare i32 @printf(ptr, ...)
|
|
declare i32 @fputs(ptr, ptr)
|
|
@stdout = external global ptr
|
|
declare ptr @ailang_rc_alloc(i64)
|
|
declare void @ailang_rc_inc(ptr)
|
|
declare void @ailang_rc_dec(ptr)
|
|
declare ptr @ailang_drop_worklist_new()
|
|
declare void @ailang_drop_worklist_push(ptr, ptr)
|
|
declare ptr @ailang_drop_worklist_pop(ptr)
|
|
declare void @ailang_drop_worklist_free(ptr)
|
|
declare i32 @strcmp(ptr, ptr)
|
|
declare zeroext i1 @ail_str_eq(ptr, ptr)
|
|
declare i32 @ail_str_compare(ptr, ptr)
|
|
declare ptr @ailang_int_to_str(i64)
|
|
declare ptr @ailang_float_to_str(double)
|
|
declare ptr @ailang_bool_to_str(i1)
|
|
declare ptr @ailang_str_clone(ptr)
|
|
declare ptr @ailang_str_concat(ptr, ptr)
|
|
declare i64 @llvm.fptosi.sat.i64.f64(double)
|
|
|
|
@ail_kernel_stub_new_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_kernel_stub_new_adapter, ptr null }
|
|
@ail_prelude_float_eq_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_float_eq_adapter, ptr null }
|
|
@ail_prelude_float_ne_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_float_ne_adapter, ptr null }
|
|
@ail_prelude_float_lt_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_float_lt_adapter, ptr null }
|
|
@ail_prelude_float_le_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_float_le_adapter, ptr null }
|
|
@ail_prelude_float_gt_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_float_gt_adapter, ptr null }
|
|
@ail_prelude_float_ge_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_float_ge_adapter, ptr null }
|
|
@ail_prelude_eq__Int_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_eq__Int_adapter, ptr null }
|
|
@ail_prelude_show__Int_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_show__Int_adapter, ptr null }
|
|
@ail_prelude_print__Int_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_prelude_print__Int_adapter, ptr null }
|
|
@ail_sum_sum_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_sum_sum_adapter, ptr null }
|
|
@ail_sum_main_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_sum_main_adapter, ptr null }
|
|
define ptr @ail_kernel_stub_new(i64 %arg_x) {
|
|
entry:
|
|
%v1 = call ptr @ailang_rc_alloc(i64 16)
|
|
store i64 0, ptr %v1, align 8
|
|
%v2 = getelementptr inbounds i8, ptr %v1, i64 8
|
|
store i64 %arg_x, ptr %v2, align 8
|
|
ret ptr %v1
|
|
}
|
|
|
|
define ptr @ail_kernel_stub_new_adapter(ptr %_env, i64 %a0) {
|
|
entry:
|
|
%r = call ptr @ail_kernel_stub_new(i64 %a0)
|
|
ret ptr %r
|
|
}
|
|
|
|
define void @drop_kernel_stub_StubT(ptr %p) {
|
|
entry:
|
|
%is_null = icmp eq ptr %p, null
|
|
br i1 %is_null, label %ret, label %live
|
|
live:
|
|
%tag = load i64, ptr %p, align 8
|
|
switch i64 %tag, label %dflt [
|
|
i64 0, label %arm_0
|
|
]
|
|
arm_0:
|
|
%a0 = getelementptr inbounds i8, ptr %p, i64 8
|
|
%v1 = load ptr, ptr %a0, align 8
|
|
call void @ailang_rc_dec(ptr %v1)
|
|
br label %join
|
|
dflt:
|
|
unreachable
|
|
join:
|
|
call void @ailang_rc_dec(ptr %p)
|
|
br label %ret
|
|
ret:
|
|
ret void
|
|
}
|
|
|
|
define void @partial_drop_kernel_stub_StubT(ptr %p, i64 %mask) {
|
|
entry:
|
|
%is_null = icmp eq ptr %p, null
|
|
br i1 %is_null, label %ret, label %live
|
|
live:
|
|
%tag = load i64, ptr %p, align 8
|
|
switch i64 %tag, label %dflt [
|
|
i64 0, label %arm_0
|
|
]
|
|
arm_0:
|
|
%b0 = and i64 %mask, 1
|
|
%s1 = icmp ne i64 %b0, 0
|
|
br i1 %s1, label %after_0_0, label %do_0_0
|
|
do_0_0:
|
|
%a2 = getelementptr inbounds i8, ptr %p, i64 8
|
|
%v3 = load ptr, ptr %a2, align 8
|
|
call void @ailang_rc_dec(ptr %v3)
|
|
br label %after_0_0
|
|
after_0_0:
|
|
br label %join
|
|
dflt:
|
|
unreachable
|
|
join:
|
|
call void @ailang_rc_dec(ptr %p)
|
|
br label %ret
|
|
ret:
|
|
ret void
|
|
}
|
|
|
|
define i1 @ail_prelude_float_eq(double %arg_x, double %arg_y) alwaysinline {
|
|
entry:
|
|
%v1 = fcmp oeq double %arg_x, %arg_y
|
|
ret i1 %v1
|
|
}
|
|
|
|
define i1 @ail_prelude_float_eq_adapter(ptr %_env, double %a0, double %a1) {
|
|
entry:
|
|
%r = call i1 @ail_prelude_float_eq(double %a0, double %a1)
|
|
ret i1 %r
|
|
}
|
|
|
|
define i1 @ail_prelude_float_ne(double %arg_x, double %arg_y) alwaysinline {
|
|
entry:
|
|
%v1 = fcmp une double %arg_x, %arg_y
|
|
ret i1 %v1
|
|
}
|
|
|
|
define i1 @ail_prelude_float_ne_adapter(ptr %_env, double %a0, double %a1) {
|
|
entry:
|
|
%r = call i1 @ail_prelude_float_ne(double %a0, double %a1)
|
|
ret i1 %r
|
|
}
|
|
|
|
define i1 @ail_prelude_float_lt(double %arg_x, double %arg_y) alwaysinline {
|
|
entry:
|
|
%v1 = fcmp olt double %arg_x, %arg_y
|
|
ret i1 %v1
|
|
}
|
|
|
|
define i1 @ail_prelude_float_lt_adapter(ptr %_env, double %a0, double %a1) {
|
|
entry:
|
|
%r = call i1 @ail_prelude_float_lt(double %a0, double %a1)
|
|
ret i1 %r
|
|
}
|
|
|
|
define i1 @ail_prelude_float_le(double %arg_x, double %arg_y) alwaysinline {
|
|
entry:
|
|
%v1 = fcmp ole double %arg_x, %arg_y
|
|
ret i1 %v1
|
|
}
|
|
|
|
define i1 @ail_prelude_float_le_adapter(ptr %_env, double %a0, double %a1) {
|
|
entry:
|
|
%r = call i1 @ail_prelude_float_le(double %a0, double %a1)
|
|
ret i1 %r
|
|
}
|
|
|
|
define i1 @ail_prelude_float_gt(double %arg_x, double %arg_y) alwaysinline {
|
|
entry:
|
|
%v1 = fcmp ogt double %arg_x, %arg_y
|
|
ret i1 %v1
|
|
}
|
|
|
|
define i1 @ail_prelude_float_gt_adapter(ptr %_env, double %a0, double %a1) {
|
|
entry:
|
|
%r = call i1 @ail_prelude_float_gt(double %a0, double %a1)
|
|
ret i1 %r
|
|
}
|
|
|
|
define i1 @ail_prelude_float_ge(double %arg_x, double %arg_y) alwaysinline {
|
|
entry:
|
|
%v1 = fcmp oge double %arg_x, %arg_y
|
|
ret i1 %v1
|
|
}
|
|
|
|
define i1 @ail_prelude_float_ge_adapter(ptr %_env, double %a0, double %a1) {
|
|
entry:
|
|
%r = call i1 @ail_prelude_float_ge(double %a0, double %a1)
|
|
ret i1 %r
|
|
}
|
|
|
|
define i1 @ail_prelude_eq__Int(i64 %arg_x, i64 %arg_y) alwaysinline {
|
|
entry:
|
|
%v1 = icmp eq i64 %arg_x, %arg_y
|
|
ret i1 %v1
|
|
}
|
|
|
|
define i1 @ail_prelude_eq__Int_adapter(ptr %_env, i64 %a0, i64 %a1) {
|
|
entry:
|
|
%r = call i1 @ail_prelude_eq__Int(i64 %a0, i64 %a1)
|
|
ret i1 %r
|
|
}
|
|
|
|
define ptr @ail_prelude_show__Int(i64 %arg_x) {
|
|
entry:
|
|
%v1 = call ptr @ailang_int_to_str(i64 %arg_x)
|
|
ret ptr %v1
|
|
}
|
|
|
|
define ptr @ail_prelude_show__Int_adapter(ptr %_env, i64 %a0) {
|
|
entry:
|
|
%r = call ptr @ail_prelude_show__Int(i64 %a0)
|
|
ret ptr %r
|
|
}
|
|
|
|
define i8 @ail_prelude_print__Int(i64 %arg_x) {
|
|
entry:
|
|
%v1 = call ptr @ail_prelude_show__Int(i64 %arg_x)
|
|
%v2 = getelementptr inbounds i8, ptr %v1, i64 8
|
|
%v3 = load ptr, ptr @stdout, align 8
|
|
call i32 @fputs(ptr %v2, ptr %v3)
|
|
call void @ailang_rc_dec(ptr %v1)
|
|
ret i8 0
|
|
}
|
|
|
|
define i8 @ail_prelude_print__Int_adapter(ptr %_env, i64 %a0) {
|
|
entry:
|
|
%r = call i8 @ail_prelude_print__Int(i64 %a0)
|
|
ret i8 %r
|
|
}
|
|
|
|
define void @drop_prelude_Ordering(ptr %p) {
|
|
entry:
|
|
%is_null = icmp eq ptr %p, null
|
|
br i1 %is_null, label %ret, label %live
|
|
live:
|
|
%tag = load i64, ptr %p, align 8
|
|
switch i64 %tag, label %dflt [
|
|
i64 0, label %arm_0
|
|
i64 1, label %arm_1
|
|
i64 2, label %arm_2
|
|
]
|
|
arm_0:
|
|
br label %join
|
|
arm_1:
|
|
br label %join
|
|
arm_2:
|
|
br label %join
|
|
dflt:
|
|
unreachable
|
|
join:
|
|
call void @ailang_rc_dec(ptr %p)
|
|
br label %ret
|
|
ret:
|
|
ret void
|
|
}
|
|
|
|
define void @partial_drop_prelude_Ordering(ptr %p, i64 %mask) {
|
|
entry:
|
|
%is_null = icmp eq ptr %p, null
|
|
br i1 %is_null, label %ret, label %live
|
|
live:
|
|
%tag = load i64, ptr %p, align 8
|
|
switch i64 %tag, label %dflt [
|
|
i64 0, label %arm_0
|
|
i64 1, label %arm_1
|
|
i64 2, label %arm_2
|
|
]
|
|
arm_0:
|
|
br label %join
|
|
arm_1:
|
|
br label %join
|
|
arm_2:
|
|
br label %join
|
|
dflt:
|
|
unreachable
|
|
join:
|
|
call void @ailang_rc_dec(ptr %p)
|
|
br label %ret
|
|
ret:
|
|
ret void
|
|
}
|
|
|
|
define i64 @ail_sum_sum(i64 %arg_n) {
|
|
entry:
|
|
%v1 = call i1 @ail_prelude_eq__Int(i64 %arg_n, i64 0)
|
|
br i1 %v1, label %then.2, label %else.2
|
|
then.2:
|
|
br label %join.2
|
|
else.2:
|
|
%v3 = sub i64 %arg_n, 1
|
|
%v4 = call i64 @ail_sum_sum(i64 %v3)
|
|
%v5 = add i64 %arg_n, %v4
|
|
br label %join.2
|
|
join.2:
|
|
%v6 = phi i64 [ 0, %then.2 ], [ %v5, %else.2 ]
|
|
ret i64 %v6
|
|
}
|
|
|
|
define i64 @ail_sum_sum_adapter(ptr %_env, i64 %a0) {
|
|
entry:
|
|
%r = call i64 @ail_sum_sum(i64 %a0)
|
|
ret i64 %r
|
|
}
|
|
|
|
define i8 @ail_sum_main() {
|
|
entry:
|
|
%v1 = call i64 @ail_sum_sum(i64 10)
|
|
%v2 = call i8 @ail_prelude_print__Int(i64 %v1)
|
|
ret i8 %v2
|
|
}
|
|
|
|
define i8 @ail_sum_main_adapter(ptr %_env) {
|
|
entry:
|
|
%r = call i8 @ail_sum_main()
|
|
ret i8 %r
|
|
}
|
|
|
|
|
|
define i32 @main() {
|
|
call i8 @ail_sum_main()
|
|
ret i32 0
|
|
}
|