diff options
| -rw-r--r-- | src/env.cff | 1 | ||||
| -rw-r--r-- | src/llvm.cff | 74 | ||||
| -rw-r--r-- | src/parse.cff | 1 | ||||
| -rw-r--r-- | x.ll | 309 |
4 files changed, 373 insertions, 12 deletions
diff --git a/src/env.cff b/src/env.cff index 04dc81d..d45e373 100644 --- a/src/env.cff +++ b/src/env.cff @@ -32,6 +32,7 @@ extern fn envput_alloc(env *Env, alloc *Allocator, decl Decl, old **const Decl) switch { case old.u.#tag == :Fn and decl.u.#tag == :Fn and decl.u.Fn.ty == old.u.Fn.ty and (old.u.Fn.body->empty() or decl.u.Fn.body->empty()); + decl.u.Fn.id = old.u.Fn.id; case old.u.#tag == :Ty and decl.u.#tag == :Ty and old.u.Ty == decl.u.Ty; diff --git a/src/llvm.cff b/src/llvm.cff index ba4b556..3dcebe6 100644 --- a/src/llvm.cff +++ b/src/llvm.cff @@ -19,6 +19,7 @@ struct Value { LocalRef *Var, GlobalRef *Var, Fn *Fn, + FnRef *Fn, } } @@ -90,7 +91,8 @@ fn gen(fmt *const u8, ...) void { case Ptr p; gen("ptr"); case Slice p; gen("{ %t, %t }", mkptrtype(p), ty_usize); case Arr arr; - gen("[%z x %t]", arr.length, arr.child); + assert(arr.length >= 0, "arr length"); + gen("[%z x %t]", arr.length, arr.child); case Agg; genagg(ty); case Enum enu; pritype(enu.intty); @@ -138,13 +140,17 @@ fn gen(fmt *const u8, ...) void { case 'I'; fprintf(outfp, "%lld", as(c_llong)ap->arg(i64)); case 'f'; - fprintf(outfp, "%.17f", ap->arg(f64)); + let f f64 = as(f32)ap->arg(f64); + fprintf(outfp, "%#.16llx", *as(*u64)&f); + case 'F'; + fprintf(outfp, "%e", ap->arg(f64)); case 'z'; fprintf(outfp, "%zu", ap->arg(usize)); case 'v'; - switch ap->arg(Value).u { + let val = ap->arg(Value); + switch val.u { case IImm i; gen("%I", i); - case FImm f; gen("%f", f); + case FImm f; gen(val.ty.size == 4 ? "%f" : "%F", f); case BImm b; gen("%d", as(int)b); case Null; gen("null"); case ZeroIni; gen("zeroinitializer"); @@ -164,6 +170,13 @@ fn gen(fmt *const u8, ...) void { } else { gen("@%s", decl.name); } + case FnRef f; + let decl = container_of(f, Decl, u.Fn); + if !decl.externp { + gen("@%s.%d", decl.name, f.id); + } else { + gen("@%s", decl.name); + } case StrConstRef id; gen("@.str.%d", id); @@ -206,6 +219,7 @@ fn genaddr(f *Fn, ex *Expr) Value { switch decl.u { case Let *var; return {mkptrtype(var.ty), :LocalRef(var)}; case Static *var; return {mkptrtype(var.ty), :GlobalRef(var)}; + case Fn *f; return {mkptrtype(f.ty), :FnRef(f)}; } case UnOp un; switch un.op { @@ -217,12 +231,19 @@ fn genaddr(f *Fn, ex *Expr) Value { } case Index idx; let lhs Value #?; - if idx.lhs.ty->is(:Arr) { + switch idx.lhs.ty.u { + case Arr arrty; let arr = genaddr(f, idx.lhs); lhs = mktmp(mkptrtype(ex.ty)); - gen("\t%v = getelementptr %t, %t %v, i32 0, i32 0\n", lhs, arr.ty.u.Arr.child, arr.ty, arr); - } else { + gen("\t%v = getelementptr %t, %t %v, i32 0, i32 0\n", lhs, idx.lhs.ty, arr.ty, arr); + case Ptr; lhs = genexpr(f, idx.lhs); + case Slice child; + let tmp = genexpr(f, idx.lhs); + lhs = mktmp(mkptrtype(child)); + gen("\t%v = extractvalue %t %v, 0\n", lhs, tmp.ty, tmp); + case else; + assert(#f, "index"); } let rhs = genexpr(f, idx.rhs), addr = mktmp(mkptrtype(ex.ty)); @@ -271,7 +292,20 @@ fn genaddr(f *Fn, ex *Expr) Value { case :Union; gen("\t%v = bitcast %t %v to %t\n", ptr, tmp.ty, tmp, ptr.ty); } - gen("\tstore %t %v, %t %v\n", fex.ty, convert(f, fld.ty, fex), ptr.ty, ptr); + gen("\tstore %t %v, %t %v\n", fld.ty, convert(f, fld.ty, fex), ptr.ty, ptr); + } + return tmp; + + case ArrIni ini; + let ty = mkarrtype(ini.maxn, #f, ex.ty.u.Arr.child); + let tmp = mktmp(mkptrtype(ty)); + gen("\t%v = alloca %t\n", tmp, ty); + gen("\tstore %t zeroinitializer, %t %v\n", ty, tmp.ty, tmp); + foreach(idx, i, ini.idxs) { + let fex = &ini.exs[i]; + let ptr = mktmp(mkptrtype(fex.ty)); + gen("\t%v = getelementptr %t, %t %v, i32 0, i32 %d\n", ptr, ty, tmp.ty, tmp, idx); + gen("\tstore %t %v, %t %v\n", fex.ty, convert(f, ty.u.Arr.child, fex), ptr.ty, ptr); } return tmp; } @@ -695,7 +729,16 @@ fn genexpr(f *Fn, ex *Expr) Value { case Slice sl; if sl.lhs.ty.u.#tag == :Arr { - assert(#f,""); + let addr = genaddr(f, sl.lhs); + let begin = convert(f, ty_usize, sl.begin); + let end = convert(f, ty_usize, sl.end); + let len = mktmp(ty_usize); + gen("\t%v = sub %t %v, %v\n", len, ty_usize, end, begin); + let tmp = mktmp(ex.ty); + gen("\t%v = insertvalue %t undef, %t %v, 0\n", tmp, ex.ty, addr.ty, addr); + let res = mktmp(ex.ty); + gen("\t%v = insertvalue %t %v, %t %v, 1\n", res, ex.ty, tmp, len.ty, len); + return res; } else if sl.lhs.ty.u.#tag == :Ptr { let addr = genexpr(f, sl.lhs); let begin = convert(f, ty_usize, sl.begin); @@ -755,6 +798,13 @@ fn genexpr(f *Fn, ex *Expr) Value { gen("\t%v = load %t, %t %v\n", val, ex.ty, tmp.ty, tmp); return val; + case ArrIni ini; + let ty = mkarrtype(ini.maxn, #f, ex.ty.u.Arr.child); + let tmp = genaddr(f, ex); + let val = mktmp(ty); + gen("\t%v = load %t, %t %v\n", val, ty, tmp.ty, tmp); + return val; + case EUnionIni ini; let t0 = mktmp(mkptrtype(ex.ty)); let vidx = ini.var - ex.ty.u.Agg.flds.#ptr; @@ -907,8 +957,8 @@ fn genstmt(f *Fn, block *Block, st *Stmt) void { gen("\tswitch %t %v, label %%ISx%d [", test.ty, test); foreach (c, i, sw.cs) { foreach_ptr (ex, _, c.es) { - let t = convert(f, test.ty, ex); - gen(" %t %v, label %%IS%d.%d ", t.ty, t, id, i); + assert(ex.u.#tag == :IntLit or ex.u.#tag == :EnumIni, "case"); + gen(" %t %I, label %%IS%d.%d ", test.ty, ex.u.IntLit.i, id, i); } } gen(" ]\n"); @@ -1043,7 +1093,7 @@ struct GloblKeyTraits { static globls Map<GloblKey, GloblEntry, GloblKeyTraits> = {}; extern fn llvm_addglobl(decl *Decl, staticp bool) void { - assert(decl.toplevel, "llvm-addfn"); + assert(decl.toplevel or decl.externp, "llvm-addfn %d", decl.u.#tag); let slot = globls->get_slot({decl.name, decl.externp}); if slot.t != :Def { slot.t = :Decl; diff --git a/src/parse.cff b/src/parse.cff index 0eb251d..3512c96 100644 --- a/src/parse.cff +++ b/src/parse.cff @@ -2584,6 +2584,7 @@ fn parsefn(P *Parser, loc Loc, toplevel bool, externp bool, name *const u8) *Dec Fn.id = ++id; // TODO tlalloc necessary for templates. but it leaks some memory let decl = putdecl_alloc(P, P.tlalloc, loc, decl); + let Fn = &decl.u.Fn; decl.toplevel = toplevel; if !lexmatch(P, #null, '{') { @@ -0,0 +1,309 @@ +target triple = "x86_64-pc-linux-gnu" +%.type.opaque = type opaque + +@xs.2 = internal global ptr zeroinitializer +define internal i32 @icmp.4(ptr %lhs, ptr %rhs, ptr %_) { +%lhs.0 = alloca ptr store ptr %lhs, ptr %lhs.0 +%rhs.1 = alloca ptr store ptr %rhs, ptr %rhs.1 +%_.2 = alloca ptr store ptr %_, ptr %_.2 + %lhs.3 = alloca i32 + %t1 = load ptr, ptr %lhs.0 + %t0 = bitcast ptr %t1 to ptr + %t2 = load i32, ptr %t0 + store i32 %t2, ptr %lhs.3 + %rhs.4 = alloca i32 + %t4 = load ptr, ptr %rhs.1 + %t3 = bitcast ptr %t4 to ptr + %t5 = load i32, ptr %t3 + store i32 %t5, ptr %rhs.4 + %t6 = load i32, ptr %lhs.3 + %t7 = load i32, ptr %rhs.4 + %t8 = sub i32 %t6, %t7 + ret i32 %t8 + ret i32 undef +} +define internal void @foo.5() { + ret void +} +define internal void @isort.3(ptr %xs, i64 %n) { +%xs.0 = alloca ptr store ptr %xs, ptr %xs.0 +%n.1 = alloca i64 store i64 %n, ptr %n.1 + %t1 = load ptr, ptr %xs.0 + %t0 = bitcast ptr %t1 to ptr + %t2 = load i64, ptr %n.1 + %t3 = sext i32 4 to i64 + call void(ptr, i64, i64, ptr) @qsort(ptr %t0, i64 %t2, i64 %t3, ptr @icmp.4) + %x.2 = alloca ptr + store ptr @foo.5, ptr %x.2 + %t4 = load ptr, ptr %x.2 + call ptr %t4() + ret void +} +define internal i64 @length.7(ptr %l) { +%l.0 = alloca ptr store ptr %l, ptr %l.0 + %n.1 = alloca i64 + store i64 0, ptr %n.1 + %t0 = load ptr, ptr %l.0 + %t1 = load { ptr, i32 }, ptr %t0 + call void({ ptr, i32 }) @ok.6({ ptr, i32 } %t1) + br label %Cont1 +Cont1: %t2 = bitcast i8 0 to i8 ; NOP + %t3 = load ptr, ptr %l.0 + %t4 = icmp ne ptr %t3, null + br i1 %t4, label %Next1, label %Brk1 +Next1: %t5 = bitcast i8 0 to i8 ; NOP + %t6 = load i64, ptr %n.1 + %t7 = add i64 %t6, 1 + store i64 %t7, ptr %n.1 + %t9 = load ptr, ptr %l.0 + %t10 = getelementptr { ptr, i32 }, ptr %t9, i32 0, i32 0 + %t8 = load ptr, ptr %t10 + store ptr %t8, ptr %l.0 + br label %Cont1 +Brk1: %t11 = bitcast i8 0 to i8 ; NOP + %t12 = load i64, ptr %n.1 + ret i64 %t12 + ret i64 undef +} +define internal void @ok.8({ ptr, i32 } %l) { +%l.0 = alloca { ptr, i32 } store { ptr, i32 } %l, ptr %l.0 + ret void +} +define internal float @mag.9({ float, float } %v) { +%v.0 = alloca { float, float } store { float, float } %v, ptr %v.0 + %t1 = getelementptr { float, float }, ptr %v.0, i32 0, i32 0 + %t0 = load float, ptr %t1 + %t3 = getelementptr { float, float }, ptr %v.0, i32 0, i32 0 + %t2 = load float, ptr %t3 + %t4 = fmul float %t0, %t2 + %t6 = getelementptr { float, float }, ptr %v.0, i32 0, i32 1 + %t5 = load float, ptr %t6 + %t8 = getelementptr { float, float }, ptr %v.0, i32 0, i32 1 + %t7 = load float, ptr %t8 + %t9 = fmul float %t5, %t7 + %t10 = fadd float %t4, %t9 + %t11 = call float(float) @sqrtf(float %t10) + ret float %t11 + ret float undef +} +define internal void @zero.11(ptr %v) { +%v.0 = alloca ptr store ptr %v, ptr %v.0 + %t0 = load ptr, ptr %v.0 + %t1 = getelementptr { float, float }, ptr %t0, i32 0, i32 0 + %t2 = sitofp i32 0 to float + store float %t2, ptr %t1 + %t3 = load ptr, ptr %v.0 + %t4 = getelementptr { float, float }, ptr %t3, i32 0, i32 1 + %t5 = sitofp i32 0 to float + store float %t5, ptr %t4 + ret void +} +define internal { ptr, i64 } @spanz.12(ptr %cstr) { +%cstr.0 = alloca ptr store ptr %cstr, ptr %cstr.0 + %t0 = load ptr, ptr %cstr.0 + %t1 = sext i32 0 to i64 + %t2 = load ptr, ptr %cstr.0 + %t3 = call i64(ptr) @strlen(ptr %t2) + %t4 = sub i64 %t3, %t1 + %t5 = insertvalue { ptr, i64 } undef, ptr %t0, 0 + %t6 = insertvalue { ptr, i64 } %t5, i64 %t4, 1 + ret { ptr, i64 } %t6 + ret { ptr, i64 } undef +} +define i32 @main(i32 %argc, ptr %argv) { +%argc.0 = alloca i32 store i32 %argc, ptr %argc.0 +%argv.1 = alloca ptr store ptr %argv, ptr %argv.1 + %colors.2 = alloca [3 x i16] + %t0 = alloca [3 x i16] + store [3 x i16] zeroinitializer, ptr %t0 + %t1 = getelementptr [3 x i16], ptr %t0, i32 0, i32 0 + store i16 0, ptr %t1 + %t2 = getelementptr [3 x i16], ptr %t0, i32 0, i32 1 + store i16 1, ptr %t2 + %t3 = getelementptr [3 x i16], ptr %t0, i32 0, i32 2 + store i16 2, ptr %t3 + %t4 = load [3 x i16], ptr %t0 + store [3 x i16] %t4, ptr %colors.2 + %x.3 = alloca { float, float } + %t5 = alloca { float, float } + store { float, float } zeroinitializer, ptr %t5 + %t6 = getelementptr { float, float }, ptr %t5, i32 0, i32 1 + %t7 = sitofp i32 1 to float + store float %t7, ptr %t6 + %t8 = getelementptr { float, float }, ptr %t5, i32 0, i32 0 + %t9 = fptrunc double 2.39999999999999991118216 to float + store float %t9, ptr %t8 + %t10 = load { float, float }, ptr %t5 + store { float, float } %t10, ptr %x.3 + %p.4 = alloca ptr + %t11 = bitcast ptr %x.3 to ptr + store ptr %t11, ptr %p.4 + %t12 = getelementptr [16 x i8], ptr @.str.0, i64 0, i64 0 + %t14 = getelementptr { float, float }, ptr %x.3, i32 0, i32 0 + %t13 = load float, ptr %t14 + %t16 = load ptr, ptr %p.4 + %t17 = getelementptr { float, float }, ptr %t16, i32 0, i32 1 + %t15 = load float, ptr %t17 + %t18 = call i32(ptr, ...) @printf(ptr %t12, float %t13, float %t15) + %t19 = getelementptr [10 x i8], ptr @.str.1, i64 0, i64 0 + %t20 = load { float, float }, ptr %x.3 + %t21 = call float({ float, float }) @mag.9({ float, float } %t20) + %t22 = call i32(ptr, ...) @printf(ptr %t19, float %t21) + call void(ptr) @zero.11(ptr %x.3) + %t23 = getelementptr [10 x i8], ptr @.str.2, i64 0, i64 0 + %t24 = load { float, float }, ptr %x.3 + %t25 = call float({ float, float }) @mag.9({ float, float } %t24) + %t26 = call i32(ptr, ...) @printf(ptr %t23, float %t25) + %x.5 = alloca { i8, i64 } + %t27 = alloca { i8, i64 } + store { i8, i64 } zeroinitializer, ptr %t27 + store i8 0, ptr %t27 + %t28 = load { i8, i64 }, ptr %t27 + store { i8, i64 } %t28, ptr %x.5 + %x.6 = alloca { i8, i64 } + %t29 = alloca { i8, i64 } + store { i8, i64 } zeroinitializer, ptr %t29 + store i8 1, ptr %t29 + %t30 = bitcast ptr %t29 to ptr + %t31 = getelementptr i64, ptr %t30, i32 1 + store i64 zeroinitializer, ptr %t31 + %t32 = load { i8, i64 }, ptr %t29 + store { i8, i64 } %t32, ptr %x.6 + %is.7 = alloca [6 x i32] + %t33 = alloca [6 x i32] + store [6 x i32] zeroinitializer, ptr %t33 + %t34 = getelementptr [6 x i32], ptr %t33, i32 0, i32 4 + store i32 1, ptr %t34 + %t35 = getelementptr [6 x i32], ptr %t33, i32 0, i32 5 + store i32 2, ptr %t35 + %t36 = getelementptr [6 x i32], ptr %t33, i32 0, i32 0 + store i32 3, ptr %t36 + %t37 = load [6 x i32], ptr %t33 + store [6 x i32] %t37, ptr %is.7 + %t38 = getelementptr [6 x i32], ptr %is.7, i64 0, i64 0 + call void(ptr, i64) @isort.3(ptr %t38, i64 6) + %i.8 = alloca i64 + store i64 0, ptr %i.8 + br label %Cont1 +Cont1: %t39 = bitcast i8 0 to i8 ; NOP + %t40 = load i64, ptr %i.8 + %t41 = icmp ult i64 %t40, 6 + %t42 = zext i1 %t41 to i8 + %t43 = icmp ne i8 %t42, 0 + br i1 %t43, label %Next1, label %Brk1 +Next1: %t44 = bitcast i8 0 to i8 ; NOP + %x.9 = alloca i32 + %t46 = getelementptr [6 x i32], ptr %is.7, i32 0, i32 0 + %t47 = load i64, ptr %i.8 + %t48 = getelementptr i32, ptr %t46, i64 %t47 + %t45 = load i32, ptr %t48 + store i32 %t45, ptr %x.9 + %t49 = getelementptr [4 x i8], ptr @.str.3, i64 0, i64 0 + %t50 = load i32, ptr %x.9 + %t51 = call i32(ptr, ...) @printf(ptr %t49, i32 %t50) + %t52 = load i64, ptr %i.8 + %t53 = add i64 %t52, 1 + store i64 %t53, ptr %i.8 + br label %Cont1 +Brk1: %t54 = bitcast i8 0 to i8 ; NOP + %i.10 = alloca i64 + store i64 0, ptr %i.10 + br label %Cont2 +Cont2: %t55 = bitcast i8 0 to i8 ; NOP + %t56 = load i64, ptr %i.10 + %t57 = icmp ult i64 %t56, 6 + %t58 = zext i1 %t57 to i8 + %t59 = icmp ne i8 %t58, 0 + br i1 %t59, label %Next2, label %Brk2 +Next2: %t60 = bitcast i8 0 to i8 ; NOP + %x.11 = alloca i32 + %t62 = getelementptr [6 x i32], ptr %is.7, i32 0, i32 0 + %t63 = load i64, ptr %i.10 + %t64 = getelementptr i32, ptr %t62, i64 %t63 + %t61 = load i32, ptr %t64 + store i32 %t61, ptr %x.11 + %t65 = getelementptr [4 x i8], ptr @.str.4, i64 0, i64 0 + %t66 = load i32, ptr %x.11 + %t67 = call i32(ptr, ...) @printf(ptr %t65, i32 %t66) + %t68 = load i64, ptr %i.10 + %t69 = add i64 %t68, 1 + store i64 %t69, ptr %i.10 + br label %Cont2 +Brk2: %t70 = bitcast i8 0 to i8 ; NOP + %slice.12 = alloca { ptr, i64 } + %t71 = sext i32 3 to i64 + %t72 = sext i32 5 to i64 + %t73 = sub i64 %t72, %t71 + %t74 = insertvalue { ptr, i64 } undef, ptr %is.7, 0 + %t75 = insertvalue { ptr, i64 } %t74, i64 %t73, 1 + store { ptr, i64 } %t75, ptr %slice.12 + %t76 = getelementptr [7 x i8], ptr @.str.5, i64 0, i64 0 + %t78 = load { ptr, i64 }, ptr %slice.12 + %t79 = extractvalue { ptr, i64 } %t78, 0 + %t80 = getelementptr i32, ptr %t79, i32 0 + %t77 = load i32, ptr %t80 + %t81 = call i32(ptr, ...) @printf(ptr %t76, i32 %t77) + %t82 = load { ptr, i64 }, ptr %slice.12 + %t83 = sext i32 1 to i64 + %t84 = sext i32 4 to i64 + %t85 = extractvalue { ptr, i64 } %t82, 0 %t86 = sub i64 %t84, %t83 + %t87 = insertvalue { ptr, i64 } undef, ptr %t85, 0 + %t88 = insertvalue { ptr, i64 } %t87, i64 %t86, 1 + store { ptr, i64 } %t88, ptr %slice.12 + %t89 = getelementptr [7 x i8], ptr @.str.6, i64 0, i64 0 + %t91 = load { ptr, i64 }, ptr %slice.12 + %t92 = extractvalue { ptr, i64 } %t91, 0 + %t93 = getelementptr i32, ptr %t92, i32 0 + %t90 = load i32, ptr %t93 + %t94 = call i32(ptr, ...) @printf(ptr %t89, i32 %t90) + %t95 = load { ptr, i64 }, ptr %slice.12 + %t96 = extractvalue { ptr, i64 } %t95, 1 + %v.13 = alloca { float, float } + store { float, float } zeroinitializer, ptr %v.13 + %t97 = getelementptr [18 x i8], ptr @.str.7, i64 0, i64 0 + %t98 = call i32(ptr, ...) @printf(ptr %t97, i64 24) + %t99 = getelementptr [20 x i8], ptr @.str.8, i64 0, i64 0 + %t100 = call i32(ptr, ...) @printf(ptr %t99, i64 8) + %t101 = getelementptr [18 x i8], ptr @.str.9, i64 0, i64 0 + %t102 = call i32(ptr, ...) @printf(ptr %t101, i64 8) + %t103 = getelementptr [14 x i8], ptr @.str.10, i64 0, i64 0 + %t105 = alloca { float } + store { float } zeroinitializer, ptr %t105 + %t106 = bitcast ptr %t105 to ptr + store float 1.19999999999999995559108, ptr %t106 + %t107 = bitcast ptr %t105 to ptr %t104 = load i32, ptr %t107 + %t108 = call i32(ptr, ...) @printf(ptr %t103, i32 %t104) + switch i64 6, label %ISx0 [ i64 0, label %IS0.0 i64 1, label %IS0.0 i64 3, label %IS0.1 ] +IS0.0: %t109 = icmp ult i64 6, 2 + %t110 = zext i1 %t109 to i8 + br label %ISe0 +IS0.1: br label %ISe0 +ISx0: br label %ISe0 +ISe0: %t111 = bitcast i8 0 to i8 ; NOP + %t113 = getelementptr [3 x i16], ptr %colors.2, i32 0, i32 0 + %t114 = getelementptr i16, ptr %t113, i32 0 + %t112 = load i16, ptr %t114 + switch i16 %t112, label %ISx0 [ i16 0, label %IS1.0 ] +IS1.0: br label %ISe1 +ISx1: br label %ISe1 +ISe1: %t115 = bitcast i8 0 to i8 ; NOP + ret i32 0 + ret i32 undef +} +@.str.0 = internal constant [16 x i8] c"v = { %g, %g }\0A\00"; +@.str.1 = internal constant [10 x i8] c"mag = %g\0A\00"; +@.str.2 = internal constant [10 x i8] c"mag = %g\0A\00"; +@.str.3 = internal constant [4 x i8] c"%d\0A\00"; +@.str.4 = internal constant [4 x i8] c"%d\0A\00"; +@.str.5 = internal constant [7 x i8] c"sl %d\0A\00"; +@.str.6 = internal constant [7 x i8] c"sl %d\0A\00"; +@.str.7 = internal constant [18 x i8] c"sizeof(is) = %zu\0A\00"; +@.str.8 = internal constant [20 x i8] c"sizeof *void = %zu\0A\00"; +@.str.9 = internal constant [18 x i8] c"alignof f64= %zu\0A\00"; +@.str.10 = internal constant [14 x i8] c"1.2 -> %#.8x\0A\00"; +declare float @sqrtf(float); +@stderr = external global ptr +declare i32 @printf(ptr, ...); +declare i64 @strlen(ptr); +@stdin = external global ptr +declare void @qsort(ptr, i64, i64, ptr); |