Brummel
8ac8756682
Ships RawBuf end-to-end as a consumer of the raw-buf.3 scope-qualified
intrinsic mechanism, plus the general Term::New construction sugar.
Working subset committed; the drop-CALL ratification (no-leak) is
re-carved to raw-buf.5 (see b49f57d) — the flat drop FUNCTION ships here,
its call-insertion needs a codegen resolution mechanism.
What ships (all green):
- raw_buf kernel-tier submodule (crates/ailang-kernel/src/raw_buf/):
RawBuf TypeDef (param-in {Int,Float,Bool}, ctor B a) + four
(intrinsic) ops new/get/set/size. parse_raw_buf + workspace injection
(kernel-tier auto-imported); workspace count 4 -> 5.
- 12 scope-qualified INTERCEPTS entries RawBuf_{new,get,set,size}__{Int,
Float,Bool} + emit fns: new allocs an @ailang_rc_alloc slab
(8-byte i64 size header + n*width element bytes), get/set
getelementptr+load/store at offset 8 + i*width, size loads the header.
Mechanical on the raw-buf.3 naming + bijection machinery; bijection
green (4 markers -> 12 entries).
- Term::New desugar (crates/ailang-core/src/desugar.rs): (new T <types>
<values>) -> (app T.new <values>), runs before check so the
type-scoped callee flows through the raw-buf.3 scope threading to
RawBuf_new__T; drops the NewArg::Type (element type inferred from
use). Both codegen Term::New deferral arms removed (replaced with
unreachable!). Ratified by new_stubt_builds_and_runs.
- Flat intrinsic-storage drop FUNCTION @drop_raw_buf_RawBuf (single
@ailang_rc_dec on the slab), emitted for any TypeDef whose new op is
(intrinsic)-bodied — distinguishes RawBuf (intrinsic new) from StubT
(real-body new -> generic ADT drop).
- E2E: raw_buf_int (-> 60), raw_buf_float (-> 4.0), raw_buf_bool
(-> 42), raw_buf_param_in_reject (param-not-in-restricted-set).
In-scope additions beyond the literal plan (both sound, ratified):
- qualify_workspace_term now normalises a monomorphic cross-module
type-scoped callee (StubT.new) to <home>.f; without it
new_stubt_builds_and_runs cannot build (StubT.new is monomorphic, so
the raw-buf.3 poly-mono path mints no symbol). Same-module + polymorphic
callees carved out.
- diagnostic-behaviour: (new T ..) missing-new-op now surfaces
type-scoped-member-not-found (desugar runs before check, bypassing
synth's Term::New arm); new-arg-kind-mismatch obsoleted. Two unit
tests updated to the new behaviour. param-in reject unaffected.
The 5 .ll snapshots gained @drop_raw_buf_RawBuf (+ partial) — injecting
raw_buf emits its drop fn into every program; benign, regenerated to the
final IR. (The plan's "snapshots stay green" assumption was wrong.)
Verification (orchestrator, this session): cargo test --workspace 676
passed / 0 failed / 2 ignored. raw_buf_int_e2e prints 60; bijection,
round-trip, new_stubt, float/bool/reject all green. The raw_buf_no_leak
test is NOT in this commit — it moves to raw-buf.5 with the drop-call
resolution that makes it pass (the slab currently leaks at scope close;
tracked, fixed next iter; milestone not released until close).
319 lines
8.1 KiB
LLVM
319 lines
8.1 KiB
LLVM
; AILang generated workspace; entry: ws_main
|
|
source_filename = "ws_main.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_kernel_stub_answer_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_kernel_stub_answer_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_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_ws_lib_add_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_ws_lib_add_adapter, ptr null }
|
|
@ail_ws_main_main_clos = private unnamed_addr constant { ptr, ptr } { ptr @ail_ws_main_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 i64 @ail_kernel_stub_answer() {
|
|
entry:
|
|
ret i64 42
|
|
}
|
|
|
|
define i64 @ail_kernel_stub_answer_adapter(ptr %_env) {
|
|
entry:
|
|
%r = call i64 @ail_kernel_stub_answer()
|
|
ret i64 %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 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 void @drop_raw_buf_RawBuf(ptr %p) {
|
|
entry:
|
|
%is_null = icmp eq ptr %p, null
|
|
br i1 %is_null, label %ret, label %live
|
|
live:
|
|
call void @ailang_rc_dec(ptr %p)
|
|
br label %ret
|
|
ret:
|
|
ret void
|
|
}
|
|
|
|
define void @partial_drop_raw_buf_RawBuf(ptr %p, i64 %mask) {
|
|
entry:
|
|
%is_null = icmp eq ptr %p, null
|
|
br i1 %is_null, label %ret, label %live
|
|
live:
|
|
call void @ailang_rc_dec(ptr %p)
|
|
br label %ret
|
|
ret:
|
|
ret void
|
|
}
|
|
|
|
define i64 @ail_ws_lib_add(i64 %arg_a, i64 %arg_b) {
|
|
entry:
|
|
%v1 = add i64 %arg_a, %arg_b
|
|
ret i64 %v1
|
|
}
|
|
|
|
define i64 @ail_ws_lib_add_adapter(ptr %_env, i64 %a0, i64 %a1) {
|
|
entry:
|
|
%r = call i64 @ail_ws_lib_add(i64 %a0, i64 %a1)
|
|
ret i64 %r
|
|
}
|
|
|
|
define i8 @ail_ws_main_main() {
|
|
entry:
|
|
%v1 = call i64 @ail_ws_lib_add(i64 2, i64 3)
|
|
%v2 = call i8 @ail_prelude_print__Int(i64 %v1)
|
|
ret i8 %v2
|
|
}
|
|
|
|
define i8 @ail_ws_main_main_adapter(ptr %_env) {
|
|
entry:
|
|
%r = call i8 @ail_ws_main_main()
|
|
ret i8 %r
|
|
}
|
|
|
|
|
|
define i32 @main() {
|
|
call i8 @ail_ws_main_main()
|
|
ret i32 0
|
|
}
|