From f801372074ee9497973650338649e96107ed42d7 Mon Sep 17 00:00:00 2001 From: Christoffer Lerno Date: Mon, 6 Jan 2025 04:03:54 +0100 Subject: [PATCH] Optimize temp variables in LLVM. --- src/compiler/ast.c | 1 + src/compiler/compiler_internal.h | 1 + src/compiler/llvm_codegen_stmt.c | 11 + test/test_suite/any/variant_assign.c3t | 194 +++-- test/test_suite/any/variant_test.c3t | 25 +- test/test_suite/bitstruct/bitstruct_be.c3t | 494 +++++++------ test/test_suite/debug_symbols/foreach.c3t | 45 +- test/test_suite/errors/error_regression_2.c3t | 167 +++-- test/test_suite/expressions/elvis.c3t | 45 +- .../expressions/incdec_overload.c3t | 278 ++++--- test/test_suite/expressions/ternary_bool.c3t | 47 +- test/test_suite/functions/multisplat.c3t | 62 +- test/test_suite/functions/raw_splat.c3t | 82 +-- test/test_suite/generic/generic_over_fn.c3t | 70 +- .../test_suite/macros/macro_typed_varargs.c3t | 140 ++-- test/test_suite/macros/macro_vasplat.c3t | 683 +++++++++--------- .../methods/operator_assign_mutate.c3t | 72 +- test/test_suite/methods/operator_inc.c3t | 33 +- .../statements/comparison_widening.c3t | 5 +- .../statements/custom_foreach_with_ref.c3t | 528 +++++++------- test/test_suite/statements/foreach_custom.c3t | 33 +- .../statements/foreach_custom_macro.c3t | 33 +- .../statements/foreach_distinct_iterable.c3t | 34 +- .../foreach_more_implementations.c3t | 110 ++- .../switch/switch_in_defer_macro.c3t | 103 ++- 25 files changed, 1588 insertions(+), 1708 deletions(-) diff --git a/src/compiler/ast.c b/src/compiler/ast.c index 99cba5ce4..8552cb084 100644 --- a/src/compiler/ast.c +++ b/src/compiler/ast.c @@ -172,6 +172,7 @@ Decl *decl_new_generated_var(Type *type, VarDeclKind kind, SourceSpan span) decl->span = span; decl->name = NULL; decl->var.kind = kind; + decl->var.is_temp = true; decl->type = type; decl->alignment = type ? type_alloca_alignment(type) : 0; ASSERT0(!type || !type_is_user_defined(type) || type->decl->resolve_status == RESOLVE_DONE); diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h index 55dd5598f..fda8b783c 100644 --- a/src/compiler/compiler_internal.h +++ b/src/compiler/compiler_internal.h @@ -420,6 +420,7 @@ typedef struct VarDecl_ bool no_alias : 1; bool bit_is_expr : 1; bool is_self : 1; + bool is_temp : 1; union { Expr *init_expr; diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c index 7a5266c6d..aa40c2065 100644 --- a/src/compiler/llvm_codegen_stmt.c +++ b/src/compiler/llvm_codegen_stmt.c @@ -113,6 +113,17 @@ void llvm_emit_local_decl(GenContext *c, Decl *decl, BEValue *value) // Create a local alloca ASSERT0(!decl->backend_ref); + Type *type_low = type_lowering(decl->type); + if (decl->var.is_temp && !IS_OPTIONAL(decl) && !decl->var.is_addr && !decl->var.is_written && !type_is_user_defined( + type_low) && type_low->type_kind != TYPE_ARRAY) + { + assert(decl->var.init_expr); + llvm_emit_expr(c, value, decl->var.init_expr); + llvm_value_rvalue(c, value); + decl->backend_value = value->value; + decl->is_value = true; + return; + } llvm_emit_local_var_alloca(c, decl); // Create optional storage diff --git a/test/test_suite/any/variant_assign.c3t b/test/test_suite/any/variant_assign.c3t index e6e59e9c0..6e1aab1fa 100644 --- a/test/test_suite/any/variant_assign.c3t +++ b/test/test_suite/any/variant_assign.c3t @@ -146,87 +146,85 @@ switch.exit: ; preds = %switch.default, %sw define void @foo.test2(i64 %0, ptr %1) #0 { entry: %y = alloca %any, align 8 - %.anon = alloca %any, align 8 %switch = alloca i64, align 8 %z = alloca ptr, align 8 %taddr = alloca i32, align 4 - %z10 = alloca ptr, align 8 + %z9 = alloca ptr, align 8 store i64 %0, ptr %y, align 8 %ptradd = getelementptr inbounds i8, ptr %y, i64 8 store ptr %1, ptr %ptradd, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %.anon, ptr align 8 %y, i32 16, i1 false) - %ptradd1 = getelementptr inbounds i8, ptr %y, i64 8 - %2 = load i64, ptr %ptradd1, align 8 - store i64 %2, ptr %switch, align 8 + %2 = load %any, ptr %y, align 8 + %3 = extractvalue %any %2, 1 + store i64 %3, ptr %switch, align 8 br label %switch.entry switch.entry: ; preds = %entry - %3 = load i64, ptr %switch, align 8 + %4 = load i64, ptr %switch, align 8 br label %check_subtype check_subtype: ; preds = %parent_type_block, %switch.entry - %4 = phi i64 [ %3, %switch.entry ], [ %typeid.parent, %parent_type_block ] - %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %4 + %5 = phi i64 [ %4, %switch.entry ], [ %typeid.parent, %parent_type_block ] + %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %5 br i1 %eq, label %result_block, label %parent_type_block parent_type_block: ; preds = %check_subtype - %5 = inttoptr i64 %4 to ptr - %ptradd2 = getelementptr inbounds i8, ptr %5, i64 8 - %typeid.parent = load i64, ptr %ptradd2, align 8 - %6 = icmp eq i64 %typeid.parent, 0 - br i1 %6, label %result_block, label %check_subtype + %6 = inttoptr i64 %5 to ptr + %ptradd1 = getelementptr inbounds i8, ptr %6, i64 8 + %typeid.parent = load i64, ptr %ptradd1, align 8 + %7 = icmp eq i64 %typeid.parent, 0 + br i1 %7, label %result_block, label %check_subtype result_block: ; preds = %parent_type_block, %check_subtype - %7 = phi i1 [ false, %parent_type_block ], [ true, %check_subtype ] - br i1 %7, label %switch.case, label %next_if + %8 = phi i1 [ false, %parent_type_block ], [ true, %check_subtype ] + br i1 %8, label %switch.case, label %next_if switch.case: ; preds = %result_block - %8 = load ptr, ptr %.anon, align 8 - store ptr %8, ptr %z, align 8 + %9 = extractvalue %any %2, 0 + store ptr %9, ptr %z, align 8 store i32 12, ptr %taddr, align 4 - %9 = insertvalue %any undef, ptr %taddr, 0 - %10 = insertvalue %any %9, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %10, ptr %y, align 8 - %11 = load ptr, ptr %z, align 8 - %12 = load i32, ptr %11, align 4 - call void (ptr, ...) @printf(ptr @.str.3, i32 %12) + %10 = insertvalue %any undef, ptr %taddr, 0 + %11 = insertvalue %any %10, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %11, ptr %y, align 8 + %12 = load ptr, ptr %z, align 8 + %13 = load i32, ptr %12, align 4 + call void (ptr, ...) @printf(ptr @.str.3, i32 %13) br label %switch.exit next_if: ; preds = %result_block - br label %check_subtype3 - -check_subtype3: ; preds = %parent_type_block5, %next_if - %13 = phi i64 [ %3, %next_if ], [ %typeid.parent7, %parent_type_block5 ] - %eq4 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %13 - br i1 %eq4, label %result_block8, label %parent_type_block5 - -parent_type_block5: ; preds = %check_subtype3 - %14 = inttoptr i64 %13 to ptr - %ptradd6 = getelementptr inbounds i8, ptr %14, i64 8 - %typeid.parent7 = load i64, ptr %ptradd6, align 8 - %15 = icmp eq i64 %typeid.parent7, 0 - br i1 %15, label %result_block8, label %check_subtype3 - -result_block8: ; preds = %parent_type_block5, %check_subtype3 - %16 = phi i1 [ false, %parent_type_block5 ], [ true, %check_subtype3 ] - br i1 %16, label %switch.case9, label %next_if11 - -switch.case9: ; preds = %result_block8 - %17 = load ptr, ptr %.anon, align 8 - store ptr %17, ptr %z10, align 8 - %18 = load ptr, ptr %z10, align 8 - %19 = load double, ptr %18, align 8 - call void (ptr, ...) @printf(ptr @.str.4, double %19) + br label %check_subtype2 + +check_subtype2: ; preds = %parent_type_block4, %next_if + %14 = phi i64 [ %4, %next_if ], [ %typeid.parent6, %parent_type_block4 ] + %eq3 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %14 + br i1 %eq3, label %result_block7, label %parent_type_block4 + +parent_type_block4: ; preds = %check_subtype2 + %15 = inttoptr i64 %14 to ptr + %ptradd5 = getelementptr inbounds i8, ptr %15, i64 8 + %typeid.parent6 = load i64, ptr %ptradd5, align 8 + %16 = icmp eq i64 %typeid.parent6, 0 + br i1 %16, label %result_block7, label %check_subtype2 + +result_block7: ; preds = %parent_type_block4, %check_subtype2 + %17 = phi i1 [ false, %parent_type_block4 ], [ true, %check_subtype2 ] + br i1 %17, label %switch.case8, label %next_if10 + +switch.case8: ; preds = %result_block7 + %18 = extractvalue %any %2, 0 + store ptr %18, ptr %z9, align 8 + %19 = load ptr, ptr %z9, align 8 + %20 = load double, ptr %19, align 8 + call void (ptr, ...) @printf(ptr @.str.4, double %20) br label %switch.exit -next_if11: ; preds = %result_block8 +next_if10: ; preds = %result_block7 br label %switch.default -switch.default: ; preds = %next_if11 +switch.default: ; preds = %next_if10 call void (ptr, ...) @printf(ptr @.str.5) br label %switch.exit -switch.exit: ; preds = %switch.default, %switch.case9, %switch.case +switch.exit: ; preds = %switch.default, %switch.case8, %switch.case ret void } @@ -234,82 +232,80 @@ switch.exit: ; preds = %switch.default, %sw define void @foo.test3(i64 %0, ptr %1) #0 { entry: %y = alloca %any, align 8 - %.anon = alloca %any, align 8 %switch = alloca i64, align 8 %z = alloca i32, align 4 - %z10 = alloca double, align 8 + %z9 = alloca double, align 8 store i64 %0, ptr %y, align 8 %ptradd = getelementptr inbounds i8, ptr %y, i64 8 store ptr %1, ptr %ptradd, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %.anon, ptr align 8 %y, i32 16, i1 false) - %ptradd1 = getelementptr inbounds i8, ptr %y, i64 8 - %2 = load i64, ptr %ptradd1, align 8 - store i64 %2, ptr %switch, align 8 + %2 = load %any, ptr %y, align 8 + %3 = extractvalue %any %2, 1 + store i64 %3, ptr %switch, align 8 br label %switch.entry switch.entry: ; preds = %entry - %3 = load i64, ptr %switch, align 8 + %4 = load i64, ptr %switch, align 8 br label %check_subtype check_subtype: ; preds = %parent_type_block, %switch.entry - %4 = phi i64 [ %3, %switch.entry ], [ %typeid.parent, %parent_type_block ] - %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %4 + %5 = phi i64 [ %4, %switch.entry ], [ %typeid.parent, %parent_type_block ] + %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %5 br i1 %eq, label %result_block, label %parent_type_block parent_type_block: ; preds = %check_subtype - %5 = inttoptr i64 %4 to ptr - %ptradd2 = getelementptr inbounds i8, ptr %5, i64 8 - %typeid.parent = load i64, ptr %ptradd2, align 8 - %6 = icmp eq i64 %typeid.parent, 0 - br i1 %6, label %result_block, label %check_subtype + %6 = inttoptr i64 %5 to ptr + %ptradd1 = getelementptr inbounds i8, ptr %6, i64 8 + %typeid.parent = load i64, ptr %ptradd1, align 8 + %7 = icmp eq i64 %typeid.parent, 0 + br i1 %7, label %result_block, label %check_subtype result_block: ; preds = %parent_type_block, %check_subtype - %7 = phi i1 [ false, %parent_type_block ], [ true, %check_subtype ] - br i1 %7, label %switch.case, label %next_if + %8 = phi i1 [ false, %parent_type_block ], [ true, %check_subtype ] + br i1 %8, label %switch.case, label %next_if switch.case: ; preds = %result_block - %8 = load ptr, ptr %.anon, align 8 - %9 = load i32, ptr %8, align 4 - store i32 %9, ptr %z, align 4 - %10 = load i32, ptr %z, align 4 - call void (ptr, ...) @printf(ptr @.str.6, i32 %10) + %9 = extractvalue %any %2, 0 + %10 = load i32, ptr %9, align 4 + store i32 %10, ptr %z, align 4 + %11 = load i32, ptr %z, align 4 + call void (ptr, ...) @printf(ptr @.str.6, i32 %11) br label %switch.exit next_if: ; preds = %result_block - br label %check_subtype3 - -check_subtype3: ; preds = %parent_type_block5, %next_if - %11 = phi i64 [ %3, %next_if ], [ %typeid.parent7, %parent_type_block5 ] - %eq4 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %11 - br i1 %eq4, label %result_block8, label %parent_type_block5 - -parent_type_block5: ; preds = %check_subtype3 - %12 = inttoptr i64 %11 to ptr - %ptradd6 = getelementptr inbounds i8, ptr %12, i64 8 - %typeid.parent7 = load i64, ptr %ptradd6, align 8 - %13 = icmp eq i64 %typeid.parent7, 0 - br i1 %13, label %result_block8, label %check_subtype3 - -result_block8: ; preds = %parent_type_block5, %check_subtype3 - %14 = phi i1 [ false, %parent_type_block5 ], [ true, %check_subtype3 ] - br i1 %14, label %switch.case9, label %next_if11 - -switch.case9: ; preds = %result_block8 - %15 = load ptr, ptr %.anon, align 8 - %16 = load double, ptr %15, align 8 - store double %16, ptr %z10, align 8 - %17 = load double, ptr %z10, align 8 - call void (ptr, ...) @printf(ptr @.str.7, double %17) + br label %check_subtype2 + +check_subtype2: ; preds = %parent_type_block4, %next_if + %12 = phi i64 [ %4, %next_if ], [ %typeid.parent6, %parent_type_block4 ] + %eq3 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %12 + br i1 %eq3, label %result_block7, label %parent_type_block4 + +parent_type_block4: ; preds = %check_subtype2 + %13 = inttoptr i64 %12 to ptr + %ptradd5 = getelementptr inbounds i8, ptr %13, i64 8 + %typeid.parent6 = load i64, ptr %ptradd5, align 8 + %14 = icmp eq i64 %typeid.parent6, 0 + br i1 %14, label %result_block7, label %check_subtype2 + +result_block7: ; preds = %parent_type_block4, %check_subtype2 + %15 = phi i1 [ false, %parent_type_block4 ], [ true, %check_subtype2 ] + br i1 %15, label %switch.case8, label %next_if10 + +switch.case8: ; preds = %result_block7 + %16 = extractvalue %any %2, 0 + %17 = load double, ptr %16, align 8 + store double %17, ptr %z9, align 8 + %18 = load double, ptr %z9, align 8 + call void (ptr, ...) @printf(ptr @.str.7, double %18) br label %switch.exit -next_if11: ; preds = %result_block8 +next_if10: ; preds = %result_block7 br label %switch.default -switch.default: ; preds = %next_if11 +switch.default: ; preds = %next_if10 call void (ptr, ...) @printf(ptr @.str.8) br label %switch.exit -switch.exit: ; preds = %switch.default, %switch.case9, %switch.case +switch.exit: ; preds = %switch.default, %switch.case8, %switch.case ret void } diff --git a/test/test_suite/any/variant_test.c3t b/test/test_suite/any/variant_test.c3t index dacf55d4f..cbb329af0 100644 --- a/test/test_suite/any/variant_test.c3t +++ b/test/test_suite/any/variant_test.c3t @@ -192,35 +192,32 @@ define void @foo.test_all(ptr %0, i64 %1) #0 { entry: %y = alloca %"any[]", align 8 %.anon = alloca i64, align 8 - %.anon2 = alloca i64, align 8 %element = alloca %any, align 8 store ptr %0, ptr %y, align 8 %ptradd = getelementptr inbounds i8, ptr %y, i64 8 store i64 %1, ptr %ptradd, align 8 %ptradd1 = getelementptr inbounds i8, ptr %y, i64 8 %2 = load i64, ptr %ptradd1, align 8 - store i64 %2, ptr %.anon, align 8 - store i64 0, ptr %.anon2, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %loop.body, %entry - %3 = load i64, ptr %.anon2, align 8 - %4 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %3, %4 + %3 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %3, %2 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %5 = load ptr, ptr %y, align 8 - %6 = load i64, ptr %.anon2, align 8 - %ptroffset = getelementptr inbounds [16 x i8], ptr %5, i64 %6 + %4 = load ptr, ptr %y, align 8 + %5 = load i64, ptr %.anon, align 8 + %ptroffset = getelementptr inbounds [16 x i8], ptr %4, i64 %5 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %element, ptr align 8 %ptroffset, i32 16, i1 false) %lo = load i64, ptr %element, align 8 - %ptradd3 = getelementptr inbounds i8, ptr %element, i64 8 - %hi = load ptr, ptr %ptradd3, align 8 + %ptradd2 = getelementptr inbounds i8, ptr %element, i64 8 + %hi = load ptr, ptr %ptradd2, align 8 call void @foo.test(i64 %lo, ptr %hi) - %7 = load i64, ptr %.anon2, align 8 - %addnuw = add nuw i64 %7, 1 - store i64 %addnuw, ptr %.anon2, align 8 + %6 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %6, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t index 2fdeef613..5e20ec6eb 100644 --- a/test/test_suite/bitstruct/bitstruct_be.c3t +++ b/test/test_suite/bitstruct/bitstruct_be.c3t @@ -62,39 +62,37 @@ fn void main() store ptr %abc, ptr %z, align 8 store ptr %abc2, ptr %z2, align 8 %9 = load ptr, ptr %z2, align 8 - store ptr %9, ptr %.anon, align 8 - store i64 0, ptr %.anon1, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %loop.body, %entry - %10 = load i64, ptr %.anon1, align 8 + %10 = load i64, ptr %.anon, align 8 %gt = icmp ugt i64 4, %10 br i1 %gt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %11 = load ptr, ptr %.anon, align 8 - %12 = load i64, ptr %.anon1, align 8 - %ptradd2 = getelementptr inbounds i8, ptr %11, i64 %12 - %13 = load i8, ptr %ptradd2, align 1 - store i8 %13, ptr %d, align 1 - %14 = insertvalue %any undef, ptr %d, 0 - %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - store %any %15, ptr %varargslots3, align 16 - %16 = call i64 @std.io.printf(ptr %retparam4, ptr @.str.1, i64 3, ptr %varargslots3, i64 1) - %17 = load i64, ptr %.anon1, align 8 - %addnuw = add nuw i64 %17, 1 - store i64 %addnuw, ptr %.anon1, align 8 + %11 = load i64, ptr %.anon, align 8 + %ptradd1 = getelementptr inbounds i8, ptr %9, i64 %11 + %12 = load i8, ptr %ptradd1, align 1 + store i8 %12, ptr %d, align 1 + %13 = insertvalue %any undef, ptr %d, 0 + %14 = insertvalue %any %13, i64 ptrtoint (ptr @"$ct.char" to i64), 1 + store %any %14, ptr %varargslots2, align 16 + %15 = call i64 @std.io.printf(ptr %retparam3, ptr @.str.1, i64 3, ptr %varargslots2, i64 1) + %16 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %16, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - %18 = call ptr @std.io.stdout() - %19 = call i64 @std.io.File.write(ptr %retparam6, ptr %18, ptr null, i64 0) - %not_err = icmp eq i64 %19, 0 - %20 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %20, label %after_check, label %assign_optional + %17 = call ptr @std.io.stdout() + %18 = call i64 @std.io.File.write(ptr %retparam5, ptr %17, ptr null, i64 0) + %not_err = icmp eq i64 %18, 0 + %19 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %19, label %after_check, label %assign_optional assign_optional: ; preds = %loop.exit - store i64 %19, ptr %error_var, align 8 + store i64 %18, ptr %error_var, align 8 br label %guard_block after_check: ; preds = %loop.exit @@ -104,251 +102,247 @@ guard_block: ; preds = %assign_optional br label %voiderr noerr_block: ; preds = %after_check - %21 = load i64, ptr %retparam6, align 8 - store i64 %21, ptr %len, align 8 - %22 = call i64 @std.io.File.write_byte(ptr %18, i8 zeroext 10) - %not_err8 = icmp eq i64 %22, 0 - %23 = call i1 @llvm.expect.i1(i1 %not_err8, i1 true) - br i1 %23, label %after_check10, label %assign_optional9 + %20 = load i64, ptr %retparam5, align 8 + store i64 %20, ptr %len, align 8 + %21 = call i64 @std.io.File.write_byte(ptr %17, i8 zeroext 10) + %not_err7 = icmp eq i64 %21, 0 + %22 = call i1 @llvm.expect.i1(i1 %not_err7, i1 true) + br i1 %22, label %after_check9, label %assign_optional8 -assign_optional9: ; preds = %noerr_block - store i64 %22, ptr %error_var7, align 8 - br label %guard_block11 +assign_optional8: ; preds = %noerr_block + store i64 %21, ptr %error_var6, align 8 + br label %guard_block10 -after_check10: ; preds = %noerr_block - br label %noerr_block12 +after_check9: ; preds = %noerr_block + br label %noerr_block11 -guard_block11: ; preds = %assign_optional9 +guard_block10: ; preds = %assign_optional8 br label %voiderr -noerr_block12: ; preds = %after_check10 - %24 = call i64 @std.io.File.flush(ptr %18) - %not_err14 = icmp eq i64 %24, 0 - %25 = call i1 @llvm.expect.i1(i1 %not_err14, i1 true) - br i1 %25, label %after_check16, label %assign_optional15 +noerr_block11: ; preds = %after_check9 + %23 = call i64 @std.io.File.flush(ptr %17) + %not_err13 = icmp eq i64 %23, 0 + %24 = call i1 @llvm.expect.i1(i1 %not_err13, i1 true) + br i1 %24, label %after_check15, label %assign_optional14 -assign_optional15: ; preds = %noerr_block12 - store i64 %24, ptr %error_var13, align 8 - br label %guard_block17 +assign_optional14: ; preds = %noerr_block11 + store i64 %23, ptr %error_var12, align 8 + br label %guard_block16 -after_check16: ; preds = %noerr_block12 - br label %noerr_block18 +after_check15: ; preds = %noerr_block11 + br label %noerr_block17 -guard_block17: ; preds = %assign_optional15 +guard_block16: ; preds = %assign_optional14 br label %voiderr -noerr_block18: ; preds = %after_check16 - %26 = load i64, ptr %len, align 8 - %add = add i64 %26, 1 +noerr_block17: ; preds = %after_check15 + %25 = load i64, ptr %len, align 8 + %add = add i64 %25, 1 br label %voiderr -voiderr: ; preds = %noerr_block18, %guard_block17, %guard_block11, %guard_block - %27 = load ptr, ptr %z, align 8 - store ptr %27, ptr %.anon19, align 8 - store i64 0, ptr %.anon20, align 8 - br label %loop.cond21 - -loop.cond21: ; preds = %loop.body23, %voiderr - %28 = load i64, ptr %.anon20, align 8 - %gt22 = icmp ugt i64 4, %28 - br i1 %gt22, label %loop.body23, label %loop.exit31 - -loop.body23: ; preds = %loop.cond21 - %29 = load ptr, ptr %.anon19, align 8 - %30 = load i64, ptr %.anon20, align 8 - %ptradd25 = getelementptr inbounds i8, ptr %29, i64 %30 - %31 = load i8, ptr %ptradd25, align 1 - store i8 %31, ptr %d24, align 1 - %32 = insertvalue %any undef, ptr %d24, 0 - %33 = insertvalue %any %32, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - store %any %33, ptr %varargslots26, align 16 - %34 = call i64 @std.io.printf(ptr %retparam27, ptr @.str.2, i64 3, ptr %varargslots26, i64 1) - %35 = load i64, ptr %.anon20, align 8 - %addnuw30 = add nuw i64 %35, 1 - store i64 %addnuw30, ptr %.anon20, align 8 - br label %loop.cond21 - -loop.exit31: ; preds = %loop.cond21 - %36 = call ptr @std.io.stdout() - %37 = call i64 @std.io.File.write(ptr %retparam35, ptr %36, ptr null, i64 0) - %not_err36 = icmp eq i64 %37, 0 - %38 = call i1 @llvm.expect.i1(i1 %not_err36, i1 true) - br i1 %38, label %after_check38, label %assign_optional37 - -assign_optional37: ; preds = %loop.exit31 - store i64 %37, ptr %error_var33, align 8 - br label %guard_block39 - -after_check38: ; preds = %loop.exit31 - br label %noerr_block40 - -guard_block39: ; preds = %assign_optional37 - br label %voiderr54 - -noerr_block40: ; preds = %after_check38 - %39 = load i64, ptr %retparam35, align 8 - store i64 %39, ptr %len32, align 8 - %40 = call i64 @std.io.File.write_byte(ptr %36, i8 zeroext 10) - %not_err42 = icmp eq i64 %40, 0 - %41 = call i1 @llvm.expect.i1(i1 %not_err42, i1 true) - br i1 %41, label %after_check44, label %assign_optional43 - -assign_optional43: ; preds = %noerr_block40 - store i64 %40, ptr %error_var41, align 8 - br label %guard_block45 - -after_check44: ; preds = %noerr_block40 - br label %noerr_block46 - -guard_block45: ; preds = %assign_optional43 - br label %voiderr54 - -noerr_block46: ; preds = %after_check44 - %42 = call i64 @std.io.File.flush(ptr %36) - %not_err48 = icmp eq i64 %42, 0 - %43 = call i1 @llvm.expect.i1(i1 %not_err48, i1 true) - br i1 %43, label %after_check50, label %assign_optional49 - -assign_optional49: ; preds = %noerr_block46 - store i64 %42, ptr %error_var47, align 8 - br label %guard_block51 - -after_check50: ; preds = %noerr_block46 - br label %noerr_block52 - -guard_block51: ; preds = %assign_optional49 - br label %voiderr54 - -noerr_block52: ; preds = %after_check50 - %44 = load i64, ptr %len32, align 8 - %add53 = add i64 %44, 1 - br label %voiderr54 - -voiderr54: ; preds = %noerr_block52, %guard_block51, %guard_block45, %guard_block39 - %45 = load i32, ptr %abc, align 4 - %46 = call i32 @llvm.bswap.i32(i32 %45) - %47 = and i32 65535, %46 - %trunc = trunc i32 %47 to i16 - store i16 %trunc, ptr %taddr56, align 2 - %48 = insertvalue %any undef, ptr %taddr56, 0 - %49 = insertvalue %any %48, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 - store %any %49, ptr %varargslots55, align 16 - %50 = call i64 @std.io.printfn(ptr %retparam57, ptr @.str.3, i64 10, ptr %varargslots55, i64 1) - %51 = load i32, ptr %abc, align 4 - %52 = call i32 @llvm.bswap.i32(i32 %51) - %53 = and i32 %52, -65536 - %54 = or i32 %53, 4660 +voiderr: ; preds = %noerr_block17, %guard_block16, %guard_block10, %guard_block + %26 = load ptr, ptr %z, align 8 + store i64 0, ptr %.anon18, align 8 + br label %loop.cond19 + +loop.cond19: ; preds = %loop.body21, %voiderr + %27 = load i64, ptr %.anon18, align 8 + %gt20 = icmp ugt i64 4, %27 + br i1 %gt20, label %loop.body21, label %loop.exit29 + +loop.body21: ; preds = %loop.cond19 + %28 = load i64, ptr %.anon18, align 8 + %ptradd23 = getelementptr inbounds i8, ptr %26, i64 %28 + %29 = load i8, ptr %ptradd23, align 1 + store i8 %29, ptr %d22, align 1 + %30 = insertvalue %any undef, ptr %d22, 0 + %31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.char" to i64), 1 + store %any %31, ptr %varargslots24, align 16 + %32 = call i64 @std.io.printf(ptr %retparam25, ptr @.str.2, i64 3, ptr %varargslots24, i64 1) + %33 = load i64, ptr %.anon18, align 8 + %addnuw28 = add nuw i64 %33, 1 + store i64 %addnuw28, ptr %.anon18, align 8 + br label %loop.cond19 + +loop.exit29: ; preds = %loop.cond19 + %34 = call ptr @std.io.stdout() + %35 = call i64 @std.io.File.write(ptr %retparam33, ptr %34, ptr null, i64 0) + %not_err34 = icmp eq i64 %35, 0 + %36 = call i1 @llvm.expect.i1(i1 %not_err34, i1 true) + br i1 %36, label %after_check36, label %assign_optional35 + +assign_optional35: ; preds = %loop.exit29 + store i64 %35, ptr %error_var31, align 8 + br label %guard_block37 + +after_check36: ; preds = %loop.exit29 + br label %noerr_block38 + +guard_block37: ; preds = %assign_optional35 + br label %voiderr52 + +noerr_block38: ; preds = %after_check36 + %37 = load i64, ptr %retparam33, align 8 + store i64 %37, ptr %len30, align 8 + %38 = call i64 @std.io.File.write_byte(ptr %34, i8 zeroext 10) + %not_err40 = icmp eq i64 %38, 0 + %39 = call i1 @llvm.expect.i1(i1 %not_err40, i1 true) + br i1 %39, label %after_check42, label %assign_optional41 + +assign_optional41: ; preds = %noerr_block38 + store i64 %38, ptr %error_var39, align 8 + br label %guard_block43 + +after_check42: ; preds = %noerr_block38 + br label %noerr_block44 + +guard_block43: ; preds = %assign_optional41 + br label %voiderr52 + +noerr_block44: ; preds = %after_check42 + %40 = call i64 @std.io.File.flush(ptr %34) + %not_err46 = icmp eq i64 %40, 0 + %41 = call i1 @llvm.expect.i1(i1 %not_err46, i1 true) + br i1 %41, label %after_check48, label %assign_optional47 + +assign_optional47: ; preds = %noerr_block44 + store i64 %40, ptr %error_var45, align 8 + br label %guard_block49 + +after_check48: ; preds = %noerr_block44 + br label %noerr_block50 + +guard_block49: ; preds = %assign_optional47 + br label %voiderr52 + +noerr_block50: ; preds = %after_check48 + %42 = load i64, ptr %len30, align 8 + %add51 = add i64 %42, 1 + br label %voiderr52 + +voiderr52: ; preds = %noerr_block50, %guard_block49, %guard_block43, %guard_block37 + %43 = load i32, ptr %abc, align 4 + %44 = call i32 @llvm.bswap.i32(i32 %43) + %45 = and i32 65535, %44 + %trunc = trunc i32 %45 to i16 + store i16 %trunc, ptr %taddr54, align 2 + %46 = insertvalue %any undef, ptr %taddr54, 0 + %47 = insertvalue %any %46, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 + store %any %47, ptr %varargslots53, align 16 + %48 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.3, i64 10, ptr %varargslots53, i64 1) + %49 = load i32, ptr %abc, align 4 + %50 = call i32 @llvm.bswap.i32(i32 %49) + %51 = and i32 %50, -65536 + %52 = or i32 %51, 4660 + %53 = call i32 @llvm.bswap.i32(i32 %52) + store i32 %53, ptr %abc, align 4 + %54 = load i32, ptr %abc, align 4 %55 = call i32 @llvm.bswap.i32(i32 %54) - store i32 %55, ptr %abc, align 4 - %56 = load i32, ptr %abc, align 4 - %57 = call i32 @llvm.bswap.i32(i32 %56) - %58 = and i32 %57, 65535 - %59 = or i32 %58, 1450704896 + %56 = and i32 %55, 65535 + %57 = or i32 %56, 1450704896 + %58 = call i32 @llvm.bswap.i32(i32 %57) + store i32 %58, ptr %abc, align 4 + %59 = load i32, ptr %abc, align 4 %60 = call i32 @llvm.bswap.i32(i32 %59) - store i32 %60, ptr %abc, align 4 - %61 = load i32, ptr %abc, align 4 - %62 = call i32 @llvm.bswap.i32(i32 %61) - %63 = and i32 65535, %62 - %trunc61 = trunc i32 %63 to i16 - store i16 %trunc61, ptr %taddr62, align 2 - %64 = insertvalue %any undef, ptr %taddr62, 0 - %65 = insertvalue %any %64, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 - store %any %65, ptr %varargslots60, align 16 - %66 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.4, i64 12, ptr %varargslots60, i64 1) - %67 = load ptr, ptr %z, align 8 - store ptr %67, ptr %.anon66, align 8 - store i64 0, ptr %.anon67, align 8 - br label %loop.cond68 - -loop.cond68: ; preds = %loop.body70, %voiderr54 - %68 = load i64, ptr %.anon67, align 8 - %gt69 = icmp ugt i64 4, %68 - br i1 %gt69, label %loop.body70, label %loop.exit78 - -loop.body70: ; preds = %loop.cond68 - %69 = load ptr, ptr %.anon66, align 8 - %70 = load i64, ptr %.anon67, align 8 - %ptradd72 = getelementptr inbounds i8, ptr %69, i64 %70 - %71 = load i8, ptr %ptradd72, align 1 - store i8 %71, ptr %d71, align 1 - %72 = insertvalue %any undef, ptr %d71, 0 - %73 = insertvalue %any %72, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - store %any %73, ptr %varargslots73, align 16 - %74 = call i64 @std.io.printf(ptr %retparam74, ptr @.str.5, i64 3, ptr %varargslots73, i64 1) - %75 = load i64, ptr %.anon67, align 8 - %addnuw77 = add nuw i64 %75, 1 - store i64 %addnuw77, ptr %.anon67, align 8 - br label %loop.cond68 - -loop.exit78: ; preds = %loop.cond68 - %76 = call ptr @std.io.stdout() - %77 = call i64 @std.io.File.write(ptr %retparam82, ptr %76, ptr null, i64 0) - %not_err83 = icmp eq i64 %77, 0 - %78 = call i1 @llvm.expect.i1(i1 %not_err83, i1 true) - br i1 %78, label %after_check85, label %assign_optional84 - -assign_optional84: ; preds = %loop.exit78 - store i64 %77, ptr %error_var80, align 8 - br label %guard_block86 - -after_check85: ; preds = %loop.exit78 - br label %noerr_block87 - -guard_block86: ; preds = %assign_optional84 - br label %voiderr101 - -noerr_block87: ; preds = %after_check85 - %79 = load i64, ptr %retparam82, align 8 - store i64 %79, ptr %len79, align 8 - %80 = call i64 @std.io.File.write_byte(ptr %76, i8 zeroext 10) - %not_err89 = icmp eq i64 %80, 0 - %81 = call i1 @llvm.expect.i1(i1 %not_err89, i1 true) - br i1 %81, label %after_check91, label %assign_optional90 - -assign_optional90: ; preds = %noerr_block87 - store i64 %80, ptr %error_var88, align 8 - br label %guard_block92 - -after_check91: ; preds = %noerr_block87 - br label %noerr_block93 - -guard_block92: ; preds = %assign_optional90 - br label %voiderr101 - -noerr_block93: ; preds = %after_check91 - %82 = call i64 @std.io.File.flush(ptr %76) - %not_err95 = icmp eq i64 %82, 0 - %83 = call i1 @llvm.expect.i1(i1 %not_err95, i1 true) - br i1 %83, label %after_check97, label %assign_optional96 - -assign_optional96: ; preds = %noerr_block93 - store i64 %82, ptr %error_var94, align 8 - br label %guard_block98 - -after_check97: ; preds = %noerr_block93 - br label %noerr_block99 - -guard_block98: ; preds = %assign_optional96 - br label %voiderr101 - -noerr_block99: ; preds = %after_check97 - %84 = load i64, ptr %len79, align 8 - %add100 = add i64 %84, 1 - br label %voiderr101 - -voiderr101: ; preds = %noerr_block99, %guard_block98, %guard_block92, %guard_block86 + %61 = and i32 65535, %60 + %trunc59 = trunc i32 %61 to i16 + store i16 %trunc59, ptr %taddr60, align 2 + %62 = insertvalue %any undef, ptr %taddr60, 0 + %63 = insertvalue %any %62, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 + store %any %63, ptr %varargslots58, align 16 + %64 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.4, i64 12, ptr %varargslots58, i64 1) + %65 = load ptr, ptr %z, align 8 + store i64 0, ptr %.anon64, align 8 + br label %loop.cond65 + +loop.cond65: ; preds = %loop.body67, %voiderr52 + %66 = load i64, ptr %.anon64, align 8 + %gt66 = icmp ugt i64 4, %66 + br i1 %gt66, label %loop.body67, label %loop.exit75 + +loop.body67: ; preds = %loop.cond65 + %67 = load i64, ptr %.anon64, align 8 + %ptradd69 = getelementptr inbounds i8, ptr %65, i64 %67 + %68 = load i8, ptr %ptradd69, align 1 + store i8 %68, ptr %d68, align 1 + %69 = insertvalue %any undef, ptr %d68, 0 + %70 = insertvalue %any %69, i64 ptrtoint (ptr @"$ct.char" to i64), 1 + store %any %70, ptr %varargslots70, align 16 + %71 = call i64 @std.io.printf(ptr %retparam71, ptr @.str.5, i64 3, ptr %varargslots70, i64 1) + %72 = load i64, ptr %.anon64, align 8 + %addnuw74 = add nuw i64 %72, 1 + store i64 %addnuw74, ptr %.anon64, align 8 + br label %loop.cond65 + +loop.exit75: ; preds = %loop.cond65 + %73 = call ptr @std.io.stdout() + %74 = call i64 @std.io.File.write(ptr %retparam79, ptr %73, ptr null, i64 0) + %not_err80 = icmp eq i64 %74, 0 + %75 = call i1 @llvm.expect.i1(i1 %not_err80, i1 true) + br i1 %75, label %after_check82, label %assign_optional81 + +assign_optional81: ; preds = %loop.exit75 + store i64 %74, ptr %error_var77, align 8 + br label %guard_block83 + +after_check82: ; preds = %loop.exit75 + br label %noerr_block84 + +guard_block83: ; preds = %assign_optional81 + br label %voiderr98 + +noerr_block84: ; preds = %after_check82 + %76 = load i64, ptr %retparam79, align 8 + store i64 %76, ptr %len76, align 8 + %77 = call i64 @std.io.File.write_byte(ptr %73, i8 zeroext 10) + %not_err86 = icmp eq i64 %77, 0 + %78 = call i1 @llvm.expect.i1(i1 %not_err86, i1 true) + br i1 %78, label %after_check88, label %assign_optional87 + +assign_optional87: ; preds = %noerr_block84 + store i64 %77, ptr %error_var85, align 8 + br label %guard_block89 + +after_check88: ; preds = %noerr_block84 + br label %noerr_block90 + +guard_block89: ; preds = %assign_optional87 + br label %voiderr98 + +noerr_block90: ; preds = %after_check88 + %79 = call i64 @std.io.File.flush(ptr %73) + %not_err92 = icmp eq i64 %79, 0 + %80 = call i1 @llvm.expect.i1(i1 %not_err92, i1 true) + br i1 %80, label %after_check94, label %assign_optional93 + +assign_optional93: ; preds = %noerr_block90 + store i64 %79, ptr %error_var91, align 8 + br label %guard_block95 + +after_check94: ; preds = %noerr_block90 + br label %noerr_block96 + +guard_block95: ; preds = %assign_optional93 + br label %voiderr98 + +noerr_block96: ; preds = %after_check94 + %81 = load i64, ptr %len76, align 8 + %add97 = add i64 %81, 1 + br label %voiderr98 + +voiderr98: ; preds = %noerr_block96, %guard_block95, %guard_block89, %guard_block83 store i32 0, ptr %y, align 4 - %85 = load i32, ptr %y, align 4 + %82 = load i32, ptr %y, align 4 store i32 123, ptr %y, align 4 - %86 = insertvalue %any undef, ptr %y, 0 + %83 = insertvalue %any undef, ptr %y, 0 + %84 = insertvalue %any %83, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %84, ptr %varargslots99, align 16 + %85 = load i32, ptr %y, align 4 + store i32 %85, ptr %taddr100, align 4 + %86 = insertvalue %any undef, ptr %taddr100, 0 %87 = insertvalue %any %86, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %87, ptr %varargslots102, align 16 - %88 = load i32, ptr %y, align 4 - store i32 %88, ptr %taddr103, align 4 - %89 = insertvalue %any undef, ptr %taddr103, 0 - %90 = insertvalue %any %89, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd104 = getelementptr inbounds i8, ptr %varargslots102, i64 16 - store %any %90, ptr %ptradd104, align 16 - %91 = call i64 @std.io.printf(ptr %retparam105, ptr @.str.6, i64 18, ptr %varargslots102, i64 2) + %ptradd101 = getelementptr inbounds i8, ptr %varargslots99, i64 16 + store %any %87, ptr %ptradd101, align 16 + %88 = call i64 @std.io.printf(ptr %retparam102, ptr @.str.6, i64 18, ptr %varargslots99, i64 2) ret void } \ No newline at end of file diff --git a/test/test_suite/debug_symbols/foreach.c3t b/test/test_suite/debug_symbols/foreach.c3t index a56de8d63..12b9cd963 100644 --- a/test/test_suite/debug_symbols/foreach.c3t +++ b/test/test_suite/debug_symbols/foreach.c3t @@ -16,49 +16,46 @@ define void @test.foo(ptr %0, i64 %1) #0 !dbg !8 { entry: %args = alloca %"char[][]", align 8 %.anon = alloca i64, align 8 - %.anon2 = alloca i64, align 8 %a = alloca %"char[]", align 8 %x = alloca i32, align 4 store ptr %0, ptr %args, align 8 %ptradd = getelementptr inbounds i8, ptr %args, i64 8 store i64 %1, ptr %ptradd, align 8 - %ptradd1 = getelementptr inbounds i8, ptr %args, i64 8, !dbg !30 - %2 = load i64, ptr %ptradd1, align 8, !dbg !30 - store i64 %2, ptr %.anon, align 8, !dbg !30 - store i64 0, ptr %.anon2, align 8, !dbg !30 - br label %loop.cond, !dbg !30 + %ptradd1 = getelementptr inbounds i8, ptr %args, i64 8, !dbg !28 + %2 = load i64, ptr %ptradd1, align 8, !dbg !28 + store i64 0, ptr %.anon, align 8, !dbg !28 + br label %loop.cond, !dbg !28 loop.cond: ; preds = %loop.body, %entry - %3 = load i64, ptr %.anon2, align 8, !dbg !30 - %4 = load i64, ptr %.anon, align 8, !dbg !30 - %lt = icmp ult i64 %3, %4, !dbg !30 - br i1 %lt, label %loop.body, label %loop.exit, !dbg !30 + %3 = load i64, ptr %.anon, align 8, !dbg !28 + %lt = icmp ult i64 %3, %2, !dbg !28 + br i1 %lt, label %loop.body, label %loop.exit, !dbg !28 loop.body: ; preds = %loop.cond - %5 = load ptr, ptr %args, align 8, !dbg !34 - %6 = load i64, ptr %.anon2, align 8, !dbg !34 - %ptroffset = getelementptr inbounds [16 x i8], ptr %5, i64 %6, !dbg !34 + %4 = load ptr, ptr %args, align 8, !dbg !34 + %5 = load i64, ptr %.anon, align 8, !dbg !34 + %ptroffset = getelementptr inbounds [16 x i8], ptr %4, i64 %5, !dbg !34 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %a, ptr align 8 %ptroffset, i32 16, i1 false), !dbg !34 - %ptradd3 = getelementptr inbounds i8, ptr %a, i64 8, !dbg !39 - %7 = load i64, ptr %ptradd3, align 8, !dbg !39 - %trunc = trunc i64 %7 to i32, !dbg !39 + %ptradd2 = getelementptr inbounds i8, ptr %a, i64 8, !dbg !39 + %6 = load i64, ptr %ptradd2, align 8, !dbg !39 + %trunc = trunc i64 %6 to i32, !dbg !39 store i32 %trunc, ptr %x, align 4, !dbg !39 - %8 = load i64, ptr %.anon2, align 8, !dbg !30 - %addnuw = add nuw i64 %8, 1, !dbg !30 - store i64 %addnuw, ptr %.anon2, align 8, !dbg !30 - br label %loop.cond, !dbg !30 + %7 = load i64, ptr %.anon, align 8, !dbg !28 + %addnuw = add nuw i64 %7, 1, !dbg !28 + store i64 %addnuw, ptr %.anon, align 8, !dbg !28 + br label %loop.cond, !dbg !28 loop.exit: ; preds = %loop.cond - ret void, !dbg !30 + ret void, !dbg !28 } !24 = !DIDerivedType(tag: DW_TAG_member, name: "len", scope: !11, baseType: !22, size: 64, align: 64, offset: 64) !25 = !{} !26 = !DILocalVariable(name: "args", arg: 1, scope: !8, file: !7, line: 3, type: !11) !27 = !DILocation(line: 3, column: 22, scope: !8) -!28 = !DILocalVariable(name: ".temp", scope: !29, file: !7, line: 5, type: !22, align: 8) +!28 = !DILocation(line: 5, column: 15, scope: !29) !29 = distinct !DILexicalBlock(scope: !8, file: !7, line: 5, column: 2) -!30 = !DILocation(line: 5, column: 15, scope: !29) +!30 = !DILocalVariable(name: ".temp", scope: !29, file: !7, line: 5, type: !22, align: 8) !31 = !DILocalVariable(name: "a", scope: !32, file: !7, line: 5, type: !15, align: 8) !32 = distinct !DILexicalBlock(scope: !29, file: !7, line: 6, column: 2) !33 = !DILocation(line: 5, column: 11, scope: !32) @@ -67,4 +64,4 @@ loop.exit: ; preds = %loop.cond !36 = distinct !DILexicalBlock(scope: !32, file: !7, line: 6, column: 2) !37 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed) !38 = !DILocation(line: 7, column: 7, scope: !36) -!39 = !DILocation(line: 7, column: 11, scope: !36) +!39 = !DILocation(line: 7, column: 11, scope: !36) \ No newline at end of file diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t index 2e97e2b96..7344d1460 100644 --- a/test/test_suite/errors/error_regression_2.c3t +++ b/test/test_suite/errors/error_regression_2.c3t @@ -683,7 +683,6 @@ switch.default: ; preds = %next_if6 define void @test.main() #0 { entry: %.anon = alloca i64, align 8 - %.anon1 = alloca i64, align 8 %url = alloca %"char[]", align 8 %summary = alloca %Summary, align 8 %result = alloca %Summary, align 8 @@ -694,110 +693,108 @@ entry: %blockret = alloca i64, align 8 %f = alloca i64, align 8 %0 = load i64, ptr getelementptr inbounds (i8, ptr @main.URLS, i64 8), align 8 - store i64 %0, ptr %.anon, align 8 - store i64 0, ptr %.anon1, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond -loop.cond: - %1 = load i64, ptr %.anon1, align 8 - %2 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %1, %2 +loop.cond: ; preds = %phi_block19, %entry + %1 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %1, %0 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %3 = load ptr, ptr @main.URLS, align 8 - %4 = load i64, ptr %.anon1, align 8 - %ptroffset = getelementptr inbounds [16 x i8], ptr %3, i64 %4 + %2 = load ptr, ptr @main.URLS, align 8 + %3 = load i64, ptr %.anon, align 8 + %ptroffset = getelementptr inbounds [16 x i8], ptr %2, i64 %3 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %url, ptr align 8 %ptroffset, i32 16, i1 false) %ptradd = getelementptr inbounds i8, ptr %url, i64 8 - %5 = load i64, ptr %ptradd, align 8 - %trunc = trunc i64 %5 to i32 - %6 = load ptr, ptr %url, align 8 - %7 = call i32 (ptr, ...) @printf(ptr @.str.21, i32 %trunc, ptr %6) + %4 = load i64, ptr %ptradd, align 8 + %trunc = trunc i64 %4 to i32 + %5 = load ptr, ptr %url, align 8 + %6 = call i32 (ptr, ...) @printf(ptr @.str.21, i32 %trunc, ptr %5) %lo = load ptr, ptr %url, align 8 - %ptradd2 = getelementptr inbounds i8, ptr %url, i64 8 - %hi = load i64, ptr %ptradd2, align 8 - %8 = call { ptr, i8 } @test.readAndBuildSummary(ptr %lo, i64 %hi) - store { ptr, i8 } %8, ptr %result, align 8 + %ptradd1 = getelementptr inbounds i8, ptr %url, i64 8 + %hi = load i64, ptr %ptradd1, align 8 + %7 = call { ptr, i8 } @test.readAndBuildSummary(ptr %lo, i64 %hi) + store { ptr, i8 } %7, ptr %result, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %summary, ptr align 8 %result, i32 16, i1 false) - %9 = call i32 (ptr, ...) @printf(ptr @.str.22) - %10 = load ptr, ptr @__stdoutp, align 8 - call void @test.Summary.print(ptr %summary, ptr %10) - %11 = call i32 (ptr, ...) @printf(ptr @.str.23) - %12 = load ptr, ptr %summary, align 8 - %i2b = icmp ne ptr %12, null + %8 = call i32 (ptr, ...) @printf(ptr @.str.22) + %9 = load ptr, ptr @__stdoutp, align 8 + call void @test.Summary.print(ptr %summary, ptr %9) + %10 = call i32 (ptr, ...) @printf(ptr @.str.23) + %11 = load ptr, ptr %summary, align 8 + %i2b = icmp ne ptr %11, null br i1 %i2b, label %cond.lhs, label %cond.rhs cond.lhs: ; preds = %loop.body - %13 = load ptr, ptr %summary, align 8 - %14 = load %"char[]", ptr %13, align 8 + %12 = load ptr, ptr %summary, align 8 + %13 = load %"char[]", ptr %12, align 8 br label %cond.phi cond.rhs: ; preds = %loop.body br label %cond.phi cond.phi: ; preds = %cond.rhs, %cond.lhs - %val = phi %"char[]" [ %14, %cond.lhs ], [ zeroinitializer, %cond.rhs ] + %val = phi %"char[]" [ %13, %cond.lhs ], [ zeroinitializer, %cond.rhs ] store %"char[]" %val, ptr %title_sure, align 8 - %ptradd3 = getelementptr inbounds i8, ptr %title_sure, i64 8 - %15 = load i64, ptr %ptradd3, align 8 - %trunc4 = trunc i64 %15 to i32 - %16 = load ptr, ptr %title_sure, align 8 - %17 = call i32 (ptr, ...) @printf(ptr @.str.24, i32 %trunc4, ptr %16) - %lo5 = load ptr, ptr %url, align 8 - %ptradd6 = getelementptr inbounds i8, ptr %url, i64 8 - %hi7 = load i64, ptr %ptradd6, align 8 - %18 = call i64 @test.readWhetherTitleNonEmpty(ptr %retparam, ptr %lo5, i64 %hi7) - %not_err = icmp eq i64 %18, 0 - %19 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %19, label %after_check, label %assign_optional + %ptradd2 = getelementptr inbounds i8, ptr %title_sure, i64 8 + %14 = load i64, ptr %ptradd2, align 8 + %trunc3 = trunc i64 %14 to i32 + %15 = load ptr, ptr %title_sure, align 8 + %16 = call i32 (ptr, ...) @printf(ptr @.str.24, i32 %trunc3, ptr %15) + %lo4 = load ptr, ptr %url, align 8 + %ptradd5 = getelementptr inbounds i8, ptr %url, i64 8 + %hi6 = load i64, ptr %ptradd5, align 8 + %17 = call i64 @test.readWhetherTitleNonEmpty(ptr %retparam, ptr %lo4, i64 %hi6) + %not_err = icmp eq i64 %17, 0 + %18 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %18, label %after_check, label %assign_optional assign_optional: ; preds = %cond.phi - store i64 %18, ptr %has_title.f, align 8 + store i64 %17, ptr %has_title.f, align 8 br label %after_assign after_check: ; preds = %cond.phi - %20 = load i8, ptr %retparam, align 1 - store i8 %20, ptr %has_title, align 1 + %19 = load i8, ptr %retparam, align 1 + store i8 %19, ptr %has_title, align 1 store i64 0, ptr %has_title.f, align 8 br label %after_assign after_assign: ; preds = %after_check, %assign_optional %optval = load i64, ptr %has_title.f, align 8 - %not_err8 = icmp eq i64 %optval, 0 - %21 = call i1 @llvm.expect.i1(i1 %not_err8, i1 true) - br i1 %21, label %after_check9, label %else_block + %not_err7 = icmp eq i64 %optval, 0 + %20 = call i1 @llvm.expect.i1(i1 %not_err7, i1 true) + br i1 %20, label %after_check8, label %else_block -after_check9: ; preds = %after_assign - %22 = load i8, ptr %has_title, align 1 - %23 = call ptr @test.bool_to_string(i8 zeroext %22) +after_check8: ; preds = %after_assign + %21 = load i8, ptr %has_title, align 1 + %22 = call ptr @test.bool_to_string(i8 zeroext %21) br label %phi_block else_block: ; preds = %after_assign br label %testblock testblock: ; preds = %else_block - %optval10 = load i64, ptr %has_title.f, align 8 - %not_err11 = icmp eq i64 %optval10, 0 - %24 = call i1 @llvm.expect.i1(i1 %not_err11, i1 true) - br i1 %24, label %after_check13, label %assign_optional12 + %optval9 = load i64, ptr %has_title.f, align 8 + %not_err10 = icmp eq i64 %optval9, 0 + %23 = call i1 @llvm.expect.i1(i1 %not_err10, i1 true) + br i1 %23, label %after_check12, label %assign_optional11 -assign_optional12: ; preds = %testblock - store i64 %optval10, ptr %f, align 8 +assign_optional11: ; preds = %testblock + store i64 %optval9, ptr %f, align 8 br label %end_block -after_check13: ; preds = %testblock +after_check12: ; preds = %testblock store i64 0, ptr %f, align 8 br label %end_block -end_block: ; preds = %after_check13, %assign_optional12 - %25 = load i64, ptr %f, align 8 - %i2b14 = icmp ne i64 %25, 0 - br i1 %i2b14, label %if.then, label %if.exit +end_block: ; preds = %after_check12, %assign_optional11 + %24 = load i64, ptr %f, align 8 + %i2b13 = icmp ne i64 %24, 0 + br i1 %i2b13, label %if.then, label %if.exit if.then: ; preds = %end_block - %26 = load i64, ptr %f, align 8 - store i64 %26, ptr %blockret, align 8 + %25 = load i64, ptr %f, align 8 + store i64 %25, ptr %blockret, align 8 br label %expr_block.exit if.exit: ; preds = %end_block @@ -805,32 +802,32 @@ if.exit: ; preds = %end_block br label %expr_block.exit expr_block.exit: ; preds = %if.exit, %if.then - %27 = load i64, ptr %blockret, align 8 - %28 = call ptr @test.nameFromError(i64 %27) + %26 = load i64, ptr %blockret, align 8 + %27 = call ptr @test.nameFromError(i64 %26) br label %phi_block -phi_block: ; preds = %expr_block.exit, %after_check9 - %val15 = phi ptr [ %23, %after_check9 ], [ %28, %expr_block.exit ] - %optval16 = load i64, ptr %has_title.f, align 8 - %not_err17 = icmp eq i64 %optval16, 0 - %29 = call i1 @llvm.expect.i1(i1 %not_err17, i1 true) - br i1 %29, label %after_check18, label %else_block19 - -after_check18: ; preds = %phi_block - %30 = load i8, ptr %has_title, align 1 - %31 = trunc i8 %30 to i1 - br label %phi_block20 - -else_block19: ; preds = %phi_block - br label %phi_block20 - -phi_block20: ; preds = %else_block19, %after_check18 - %val21 = phi i1 [ %31, %after_check18 ], [ false, %else_block19 ] - %ternary = select i1 %val21, ptr @.str.26, ptr @.str.27 - %32 = call i32 (ptr, ...) @printf(ptr @.str.25, ptr %val15, ptr %ternary) - %33 = load i64, ptr %.anon1, align 8 - %addnuw = add nuw i64 %33, 1 - store i64 %addnuw, ptr %.anon1, align 8 +phi_block: ; preds = %expr_block.exit, %after_check8 + %val14 = phi ptr [ %22, %after_check8 ], [ %27, %expr_block.exit ] + %optval15 = load i64, ptr %has_title.f, align 8 + %not_err16 = icmp eq i64 %optval15, 0 + %28 = call i1 @llvm.expect.i1(i1 %not_err16, i1 true) + br i1 %28, label %after_check17, label %else_block18 + +after_check17: ; preds = %phi_block + %29 = load i8, ptr %has_title, align 1 + %30 = trunc i8 %29 to i1 + br label %phi_block19 + +else_block18: ; preds = %phi_block + br label %phi_block19 + +phi_block19: ; preds = %else_block18, %after_check17 + %val20 = phi i1 [ %30, %after_check17 ], [ false, %else_block18 ] + %ternary = select i1 %val20, ptr @.str.26, ptr @.str.27 + %31 = call i32 (ptr, ...) @printf(ptr @.str.25, ptr %val14, ptr %ternary) + %32 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %32, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond diff --git a/test/test_suite/expressions/elvis.c3t b/test/test_suite/expressions/elvis.c3t index 832e8e374..aad8390f9 100644 --- a/test/test_suite/expressions/elvis.c3t +++ b/test/test_suite/expressions/elvis.c3t @@ -20,75 +20,62 @@ fn bool elvis3(bool x, bool y) define ptr @elvis.elvis(ptr %0, ptr %1) #0 { entry: - %.anon = alloca ptr, align 8 - store ptr %0, ptr %.anon, align 8 %i2b = icmp ne ptr %0, null br i1 %i2b, label %cond.lhs, label %cond.rhs cond.lhs: ; preds = %entry - %2 = load ptr, ptr %.anon, align 8 br label %cond.phi cond.rhs: ; preds = %entry br label %cond.phi cond.phi: ; preds = %cond.rhs, %cond.lhs - %val = phi ptr [ %2, %cond.lhs ], [ %1, %cond.rhs ] + %val = phi ptr [ %0, %cond.lhs ], [ %1, %cond.rhs ] ret ptr %val } ; Function Attrs: nounwind uwtable define ptr @elvis.elvis2(ptr %0, ptr %1) #0 { entry: - %.anon = alloca ptr, align 8 - %.anon1 = alloca ptr, align 8 - store ptr %0, ptr %.anon, align 8 %i2b = icmp ne ptr %0, null br i1 %i2b, label %cond.lhs, label %cond.rhs cond.lhs: ; preds = %entry - %2 = load ptr, ptr %.anon, align 8 - br label %cond.phi5 + br label %cond.phi4 cond.rhs: ; preds = %entry - store ptr %1, ptr %.anon1, align 8 - %i2b2 = icmp ne ptr %1, null - br i1 %i2b2, label %cond.lhs3, label %cond.rhs4 + %i2b1 = icmp ne ptr %1, null + br i1 %i2b1, label %cond.lhs2, label %cond.rhs3 -cond.lhs3: ; preds = %cond.rhs - %3 = load ptr, ptr %.anon1, align 8 +cond.lhs2: ; preds = %cond.rhs br label %cond.phi -cond.rhs4: ; preds = %cond.rhs +cond.rhs3: ; preds = %cond.rhs br label %cond.phi -cond.phi: ; preds = %cond.rhs4, %cond.lhs3 - %val = phi ptr [ %3, %cond.lhs3 ], [ %0, %cond.rhs4 ] - br label %cond.phi5 +cond.phi: ; preds = %cond.rhs3, %cond.lhs2 + %val = phi ptr [ %1, %cond.lhs2 ], [ %0, %cond.rhs3 ] + br label %cond.phi4 -cond.phi5: ; preds = %cond.phi, %cond.lhs - %val6 = phi ptr [ %2, %cond.lhs ], [ %val, %cond.phi ] - ret ptr %val6 +cond.phi4: ; preds = %cond.phi, %cond.lhs + %val5 = phi ptr [ %0, %cond.lhs ], [ %val, %cond.phi ] + ret ptr %val5 } define zeroext i8 @elvis.elvis3(i8 zeroext %0, i8 zeroext %1) #0 { entry: - %.anon = alloca i8, align 1 - store i8 %0, ptr %.anon, align 1 %2 = trunc i8 %0 to i1 br i1 %2, label %cond.lhs, label %cond.rhs cond.lhs: ; preds = %entry - %3 = load i8, ptr %.anon, align 1 - %4 = trunc i8 %3 to i1 br label %cond.phi cond.rhs: ; preds = %entry - %5 = trunc i8 %1 to i1 + %3 = trunc i8 %1 to i1 br label %cond.phi cond.phi: ; preds = %cond.rhs, %cond.lhs - %val = phi i1 [ %4, %cond.lhs ], [ %5, %cond.rhs ] - %6 = zext i1 %val to i8 - ret i8 %6 + %val = phi i1 [ %2, %cond.lhs ], [ %3, %cond.rhs ] + %4 = zext i1 %val to i8 + ret i8 %4 } diff --git a/test/test_suite/expressions/incdec_overload.c3t b/test/test_suite/expressions/incdec_overload.c3t index 9a4e5bf8a..a9a6fa585 100644 --- a/test/test_suite/expressions/incdec_overload.c3t +++ b/test/test_suite/expressions/incdec_overload.c3t @@ -21,177 +21,161 @@ define i64 @test.main() #0 { entry: %x = alloca i32, align 4 %x.f = alloca i64, align 8 - %.anon = alloca ptr, align 8 - %.anon1 = alloca i32, align 4 - %.anon2 = alloca i32, align 4 + %.anon = alloca i32, align 4 %anon.f = alloca i64, align 8 %retparam = alloca i32, align 4 - %.anon3 = alloca i32, align 4 - %anon.f4 = alloca i64, align 8 - %.anon20 = alloca ptr, align 8 - %.anon21 = alloca i32, align 4 - %.anon22 = alloca i32, align 4 - %anon.f23 = alloca i64, align 8 - %retparam24 = alloca i32, align 4 - %.anon31 = alloca i32, align 4 - %anon.f32 = alloca i64, align 8 + %.anon1 = alloca i32, align 4 + %anon.f2 = alloca i64, align 8 + %.anon18 = alloca i32, align 4 + %anon.f19 = alloca i64, align 8 + %retparam20 = alloca i32, align 4 + %.anon27 = alloca i32, align 4 + %anon.f28 = alloca i64, align 8 %0 = call i8 @"std_collections_map$int$int$.HashMap.set"(ptr @test.m, i32 3, i32 100) - store ptr @test.m, ptr %.anon, align 8 - store i32 3, ptr %.anon1, align 4 - %1 = load ptr, ptr %.anon, align 8 - %2 = load i32, ptr %.anon1, align 4 - %3 = call i64 @"std_collections_map$int$int$.HashMap.get"(ptr %retparam, ptr %1, i32 %2) - %not_err = icmp eq i64 %3, 0 - %4 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %4, label %after_check, label %assign_optional + %1 = call i64 @"std_collections_map$int$int$.HashMap.get"(ptr %retparam, ptr @test.m, i32 3) + %not_err = icmp eq i64 %1, 0 + %2 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %2, label %after_check, label %assign_optional assign_optional: ; preds = %entry - store i64 %3, ptr %anon.f, align 8 + store i64 %1, ptr %anon.f, align 8 br label %optional_assign_jump after_check: ; preds = %entry - %5 = load i32, ptr %retparam, align 4 - store i32 %5, ptr %.anon2, align 4 + %3 = load i32, ptr %retparam, align 4 + store i32 %3, ptr %.anon, align 4 store i64 0, ptr %anon.f, align 8 br label %after_assign optional_assign_jump: ; preds = %assign_optional %reload_err = load i64, ptr %anon.f, align 8 store i64 %reload_err, ptr %x.f, align 8 - br label %after_assign19 + br label %after_assign17 after_assign: ; preds = %after_check %optval = load i64, ptr %anon.f, align 8 - %not_err5 = icmp eq i64 %optval, 0 - %6 = call i1 @llvm.expect.i1(i1 %not_err5, i1 true) - br i1 %6, label %after_check7, label %assign_optional6 - -assign_optional6: ; preds = %after_assign - store i64 %optval, ptr %anon.f4, align 8 - br label %optional_assign_jump8 - -after_check7: ; preds = %after_assign - %7 = load i32, ptr %.anon2, align 4 - %sub = sub i32 %7, 1 - store i32 %sub, ptr %.anon2, align 4 - store i32 %7, ptr %.anon3, align 4 - store i64 0, ptr %anon.f4, align 8 - br label %after_assign10 - -optional_assign_jump8: ; preds = %assign_optional6 - %reload_err9 = load i64, ptr %anon.f4, align 8 - store i64 %reload_err9, ptr %x.f, align 8 - br label %after_assign19 - -after_assign10: ; preds = %after_check7 - %optval11 = load i64, ptr %anon.f, align 8 - %not_err12 = icmp eq i64 %optval11, 0 - %8 = call i1 @llvm.expect.i1(i1 %not_err12, i1 true) - br i1 %8, label %after_check14, label %assign_optional13 - -assign_optional13: ; preds = %after_assign10 - store i64 %optval11, ptr %x.f, align 8 - br label %after_assign19 - -after_check14: ; preds = %after_assign10 - %9 = load ptr, ptr %.anon, align 8 + %not_err3 = icmp eq i64 %optval, 0 + %4 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true) + br i1 %4, label %after_check5, label %assign_optional4 + +assign_optional4: ; preds = %after_assign + store i64 %optval, ptr %anon.f2, align 8 + br label %optional_assign_jump6 + +after_check5: ; preds = %after_assign + %5 = load i32, ptr %.anon, align 4 + %sub = sub i32 %5, 1 + store i32 %sub, ptr %.anon, align 4 + store i32 %5, ptr %.anon1, align 4 + store i64 0, ptr %anon.f2, align 8 + br label %after_assign8 + +optional_assign_jump6: ; preds = %assign_optional4 + %reload_err7 = load i64, ptr %anon.f2, align 8 + store i64 %reload_err7, ptr %x.f, align 8 + br label %after_assign17 + +after_assign8: ; preds = %after_check5 + %optval9 = load i64, ptr %anon.f, align 8 + %not_err10 = icmp eq i64 %optval9, 0 + %6 = call i1 @llvm.expect.i1(i1 %not_err10, i1 true) + br i1 %6, label %after_check12, label %assign_optional11 + +assign_optional11: ; preds = %after_assign8 + store i64 %optval9, ptr %x.f, align 8 + br label %after_assign17 + +after_check12: ; preds = %after_assign8 + %7 = load i32, ptr %.anon, align 4 + %8 = call i8 @"std_collections_map$int$int$.HashMap.set"(ptr @test.m, i32 3, i32 %7) + %optval13 = load i64, ptr %anon.f2, align 8 + %not_err14 = icmp eq i64 %optval13, 0 + %9 = call i1 @llvm.expect.i1(i1 %not_err14, i1 true) + br i1 %9, label %after_check16, label %assign_optional15 + +assign_optional15: ; preds = %after_check12 + store i64 %optval13, ptr %x.f, align 8 + br label %after_assign17 + +after_check16: ; preds = %after_check12 %10 = load i32, ptr %.anon1, align 4 - %11 = load i32, ptr %.anon2, align 4 - %12 = call i8 @"std_collections_map$int$int$.HashMap.set"(ptr %9, i32 %10, i32 %11) - %optval15 = load i64, ptr %anon.f4, align 8 - %not_err16 = icmp eq i64 %optval15, 0 - %13 = call i1 @llvm.expect.i1(i1 %not_err16, i1 true) - br i1 %13, label %after_check18, label %assign_optional17 - -assign_optional17: ; preds = %after_check14 - store i64 %optval15, ptr %x.f, align 8 - br label %after_assign19 - -after_check18: ; preds = %after_check14 - %14 = load i32, ptr %.anon3, align 4 - store i32 %14, ptr %x, align 4 + store i32 %10, ptr %x, align 4 store i64 0, ptr %x.f, align 8 - br label %after_assign19 - -after_assign19: ; preds = %after_check18, %assign_optional17, %assign_optional13, %optional_assign_jump8, %optional_assign_jump - store ptr @test.m, ptr %.anon20, align 8 - store i32 3, ptr %.anon21, align 4 - %15 = load ptr, ptr %.anon20, align 8 - %16 = load i32, ptr %.anon21, align 4 - %17 = call i64 @"std_collections_map$int$int$.HashMap.get"(ptr %retparam24, ptr %15, i32 %16) - %not_err25 = icmp eq i64 %17, 0 - %18 = call i1 @llvm.expect.i1(i1 %not_err25, i1 true) - br i1 %18, label %after_check27, label %assign_optional26 - -assign_optional26: ; preds = %after_assign19 - store i64 %17, ptr %anon.f23, align 8 - br label %optional_assign_jump28 - -after_check27: ; preds = %after_assign19 - %19 = load i32, ptr %retparam24, align 4 - store i32 %19, ptr %.anon22, align 4 - store i64 0, ptr %anon.f23, align 8 - br label %after_assign30 - -optional_assign_jump28: ; preds = %assign_optional26 - %reload_err29 = load i64, ptr %anon.f23, align 8 - store i64 %reload_err29, ptr %x.f, align 8 - br label %after_assign48 - -after_assign30: ; preds = %after_check27 - %optval33 = load i64, ptr %anon.f23, align 8 - %not_err34 = icmp eq i64 %optval33, 0 - %20 = call i1 @llvm.expect.i1(i1 %not_err34, i1 true) - br i1 %20, label %after_check36, label %assign_optional35 - -assign_optional35: ; preds = %after_assign30 - store i64 %optval33, ptr %anon.f32, align 8 - br label %optional_assign_jump37 - -after_check36: ; preds = %after_assign30 - %21 = load i32, ptr %.anon22, align 4 - %add = add i32 %21, 1 - store i32 %add, ptr %.anon22, align 4 - store i32 %add, ptr %.anon31, align 4 - store i64 0, ptr %anon.f32, align 8 - br label %after_assign39 - -optional_assign_jump37: ; preds = %assign_optional35 - %reload_err38 = load i64, ptr %anon.f32, align 8 - store i64 %reload_err38, ptr %x.f, align 8 - br label %after_assign48 - -after_assign39: ; preds = %after_check36 - %optval40 = load i64, ptr %anon.f23, align 8 + br label %after_assign17 + +after_assign17: ; preds = %after_check16, %assign_optional15, %assign_optional11, %optional_assign_jump6, %optional_assign_jump + %11 = call i64 @"std_collections_map$int$int$.HashMap.get"(ptr %retparam20, ptr @test.m, i32 3) + %not_err21 = icmp eq i64 %11, 0 + %12 = call i1 @llvm.expect.i1(i1 %not_err21, i1 true) + br i1 %12, label %after_check23, label %assign_optional22 + +assign_optional22: ; preds = %after_assign17 + store i64 %11, ptr %anon.f19, align 8 + br label %optional_assign_jump24 + +after_check23: ; preds = %after_assign17 + %13 = load i32, ptr %retparam20, align 4 + store i32 %13, ptr %.anon18, align 4 + store i64 0, ptr %anon.f19, align 8 + br label %after_assign26 + +optional_assign_jump24: ; preds = %assign_optional22 + %reload_err25 = load i64, ptr %anon.f19, align 8 + store i64 %reload_err25, ptr %x.f, align 8 + br label %after_assign44 + +after_assign26: ; preds = %after_check23 + %optval29 = load i64, ptr %anon.f19, align 8 + %not_err30 = icmp eq i64 %optval29, 0 + %14 = call i1 @llvm.expect.i1(i1 %not_err30, i1 true) + br i1 %14, label %after_check32, label %assign_optional31 + +assign_optional31: ; preds = %after_assign26 + store i64 %optval29, ptr %anon.f28, align 8 + br label %optional_assign_jump33 + +after_check32: ; preds = %after_assign26 + %15 = load i32, ptr %.anon18, align 4 + %add = add i32 %15, 1 + store i32 %add, ptr %.anon18, align 4 + store i32 %add, ptr %.anon27, align 4 + store i64 0, ptr %anon.f28, align 8 + br label %after_assign35 + +optional_assign_jump33: ; preds = %assign_optional31 + %reload_err34 = load i64, ptr %anon.f28, align 8 + store i64 %reload_err34, ptr %x.f, align 8 + br label %after_assign44 + +after_assign35: ; preds = %after_check32 + %optval36 = load i64, ptr %anon.f19, align 8 + %not_err37 = icmp eq i64 %optval36, 0 + %16 = call i1 @llvm.expect.i1(i1 %not_err37, i1 true) + br i1 %16, label %after_check39, label %assign_optional38 + +assign_optional38: ; preds = %after_assign35 + store i64 %optval36, ptr %x.f, align 8 + br label %after_assign44 + +after_check39: ; preds = %after_assign35 + %17 = load i32, ptr %.anon18, align 4 + %18 = call i8 @"std_collections_map$int$int$.HashMap.set"(ptr @test.m, i32 3, i32 %17) + %optval40 = load i64, ptr %anon.f28, align 8 %not_err41 = icmp eq i64 %optval40, 0 - %22 = call i1 @llvm.expect.i1(i1 %not_err41, i1 true) - br i1 %22, label %after_check43, label %assign_optional42 + %19 = call i1 @llvm.expect.i1(i1 %not_err41, i1 true) + br i1 %19, label %after_check43, label %assign_optional42 -assign_optional42: ; preds = %after_assign39 +assign_optional42: ; preds = %after_check39 store i64 %optval40, ptr %x.f, align 8 - br label %after_assign48 - -after_check43: ; preds = %after_assign39 - %23 = load ptr, ptr %.anon20, align 8 - %24 = load i32, ptr %.anon21, align 4 - %25 = load i32, ptr %.anon22, align 4 - %26 = call i8 @"std_collections_map$int$int$.HashMap.set"(ptr %23, i32 %24, i32 %25) - %optval44 = load i64, ptr %anon.f32, align 8 - %not_err45 = icmp eq i64 %optval44, 0 - %27 = call i1 @llvm.expect.i1(i1 %not_err45, i1 true) - br i1 %27, label %after_check47, label %assign_optional46 - -assign_optional46: ; preds = %after_check43 - store i64 %optval44, ptr %x.f, align 8 - br label %after_assign48 - -after_check47: ; preds = %after_check43 - %28 = load i32, ptr %.anon31, align 4 - store i32 %28, ptr %x, align 4 + br label %after_assign44 + +after_check43: ; preds = %after_check39 + %20 = load i32, ptr %.anon27, align 4 + store i32 %20, ptr %x, align 4 store i64 0, ptr %x.f, align 8 - br label %after_assign48 + br label %after_assign44 -after_assign48: ; preds = %after_check47, %assign_optional46, %assign_optional42, %optional_assign_jump37, %optional_assign_jump28 +after_assign44: ; preds = %after_check43, %assign_optional42, %assign_optional38, %optional_assign_jump33, %optional_assign_jump24 ret i64 0 } diff --git a/test/test_suite/expressions/ternary_bool.c3t b/test/test_suite/expressions/ternary_bool.c3t index aa112b403..568f46535 100644 --- a/test/test_suite/expressions/ternary_bool.c3t +++ b/test/test_suite/expressions/ternary_bool.c3t @@ -19,8 +19,6 @@ define void @ternary_bool.main() #0 { entry: %b = alloca i8, align 1 %c = alloca ptr, align 8 - %.anon = alloca i8, align 1 - %.anon13 = alloca i8, align 1 store i8 1, ptr %b, align 1 store ptr %b, ptr %c, align 8 %0 = load ptr, ptr %c, align 8 @@ -64,43 +62,42 @@ if.then5: ; preds = %cond.phi3 if.exit6: ; preds = %if.then5, %cond.phi3 %15 = load ptr, ptr %c, align 8 %16 = load i8, ptr %15, align 1 - store i8 %16, ptr %.anon, align 1 %17 = trunc i8 %16 to i1 br i1 %17, label %cond.lhs7, label %cond.rhs8 cond.lhs7: ; preds = %if.exit6 - %18 = load i8, ptr %.anon, align 1 - %19 = trunc i8 %18 to i1 br label %cond.phi9 cond.rhs8: ; preds = %if.exit6 - %20 = load ptr, ptr %c, align 8 - %21 = load i8, ptr %20, align 1 - %22 = trunc i8 %21 to i1 + %18 = load ptr, ptr %c, align 8 + %19 = load i8, ptr %18, align 1 + %20 = trunc i8 %19 to i1 br label %cond.phi9 cond.phi9: ; preds = %cond.rhs8, %cond.lhs7 - %val10 = phi i1 [ %19, %cond.lhs7 ], [ %22, %cond.rhs8 ] + %val10 = phi i1 [ %17, %cond.lhs7 ], [ %20, %cond.rhs8 ] br i1 %val10, label %if.then11, label %if.exit12 if.then11: ; preds = %cond.phi9 call void (ptr, ...) @printf(ptr @.str.2) br label %if.exit12 if.exit12: ; preds = %if.then11, %cond.phi9 + %21 = load i8, ptr %b, align 1 + %22 = trunc i8 %21 to i1 + br i1 %22, label %cond.lhs13, label %cond.rhs14 + +cond.lhs13: ; preds = %if.exit12 + br label %cond.phi15 + +cond.rhs14: ; preds = %if.exit12 %23 = load i8, ptr %b, align 1 - store i8 %23, ptr %.anon13, align 1 %24 = trunc i8 %23 to i1 - br i1 %24, label %cond.lhs14, label %cond.rhs15 -cond.lhs14: ; preds = %if.exit12 - %25 = load i8, ptr %.anon13, align 1 - %26 = trunc i8 %25 to i1 - br label %cond.phi16 -cond.rhs15: ; preds = %if.exit12 - %27 = load i8, ptr %b, align 1 - %28 = trunc i8 %27 to i1 - br label %cond.phi16 -cond.phi16: ; preds = %cond.rhs15, %cond.lhs14 - %val17 = phi i1 [ %26, %cond.lhs14 ], [ %28, %cond.rhs15 ] - br i1 %val17, label %if.then18, label %if.exit19 -if.then18: ; preds = %cond.phi16 + br label %cond.phi15 + +cond.phi15: ; preds = %cond.rhs14, %cond.lhs13 + %val16 = phi i1 [ %22, %cond.lhs13 ], [ %24, %cond.rhs14 ] + br i1 %val16, label %if.then17, label %if.exit18 + +if.then17: ; preds = %cond.phi15 call void (ptr, ...) @printf(ptr @.str.3) - br label %if.exit19 -if.exit19: ; preds = %if.then18, %cond.phi16 + br label %if.exit18 + +if.exit18: ; preds = %if.then17, %cond.phi15 ret void } diff --git a/test/test_suite/functions/multisplat.c3t b/test/test_suite/functions/multisplat.c3t index 70943449a..313a72b08 100644 --- a/test/test_suite/functions/multisplat.c3t +++ b/test/test_suite/functions/multisplat.c3t @@ -24,11 +24,9 @@ entry: %.anon5 = alloca [3 x i32], align 4 %z = alloca %"int[]", align 8 %varargslots11 = alloca [2 x %any], align 16 - %.anon12 = alloca %"int[]", align 8 - %varargslots16 = alloca [4 x %any], align 16 - %taddr17 = alloca i32, align 4 - %.anon18 = alloca %"int[]", align 8 - %taddr23 = alloca i32, align 4 + %varargslots15 = alloca [4 x %any], align 16 + %taddr16 = alloca i32, align 4 + %taddr21 = alloca i32, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y, ptr align 4 @.__const, i32 12, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %.anon, ptr align 4 %y, i32 12, i1 false) %0 = insertvalue %any undef, ptr %.anon, 0 @@ -70,47 +68,45 @@ entry: store %"int[]" %15, ptr %z, align 8 %16 = load %"int[]", ptr %z, align 8 %17 = extractvalue %"int[]" %16, 0 - %ptradd13 = getelementptr inbounds i8, ptr %17, i64 4 - %18 = insertvalue %"int[]" undef, ptr %ptradd13, 0 + %ptradd12 = getelementptr inbounds i8, ptr %17, i64 4 + %18 = insertvalue %"int[]" undef, ptr %ptradd12, 0 %19 = insertvalue %"int[]" %18, i64 2, 1 - store %"int[]" %19, ptr %.anon12, align 8 - %20 = load ptr, ptr %.anon12, align 8 + %20 = extractvalue %"int[]" %19, 0 %21 = insertvalue %any undef, ptr %20, 0 %22 = insertvalue %any %21, i64 ptrtoint (ptr @"$ct.int" to i64), 1 store %any %22, ptr %varargslots11, align 16 - %23 = load ptr, ptr %.anon12, align 8 - %ptradd14 = getelementptr inbounds i8, ptr %23, i64 4 - %24 = insertvalue %any undef, ptr %ptradd14, 0 + %23 = extractvalue %"int[]" %19, 0 + %ptradd13 = getelementptr inbounds i8, ptr %23, i64 4 + %24 = insertvalue %any undef, ptr %ptradd13, 0 %25 = insertvalue %any %24, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd15 = getelementptr inbounds i8, ptr %varargslots11, i64 16 - store %any %25, ptr %ptradd15, align 16 + %ptradd14 = getelementptr inbounds i8, ptr %varargslots11, i64 16 + store %any %25, ptr %ptradd14, align 16 call void @foo(ptr %varargslots11, i64 2) - store i32 1, ptr %taddr17, align 4 - %26 = insertvalue %any undef, ptr %taddr17, 0 + store i32 1, ptr %taddr16, align 4 + %26 = insertvalue %any undef, ptr %taddr16, 0 %27 = insertvalue %any %26, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %27, ptr %varargslots16, align 16 + store %any %27, ptr %varargslots15, align 16 %28 = load %"int[]", ptr %z, align 8 %29 = extractvalue %"int[]" %28, 0 - %ptradd19 = getelementptr inbounds i8, ptr %29, i64 4 - %30 = insertvalue %"int[]" undef, ptr %ptradd19, 0 + %ptradd17 = getelementptr inbounds i8, ptr %29, i64 4 + %30 = insertvalue %"int[]" undef, ptr %ptradd17, 0 %31 = insertvalue %"int[]" %30, i64 2, 1 - store %"int[]" %31, ptr %.anon18, align 8 - %32 = load ptr, ptr %.anon18, align 8 + %32 = extractvalue %"int[]" %31, 0 %33 = insertvalue %any undef, ptr %32, 0 %34 = insertvalue %any %33, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd20 = getelementptr inbounds i8, ptr %varargslots16, i64 16 - store %any %34, ptr %ptradd20, align 16 - %35 = load ptr, ptr %.anon18, align 8 - %ptradd21 = getelementptr inbounds i8, ptr %35, i64 4 - %36 = insertvalue %any undef, ptr %ptradd21, 0 + %ptradd18 = getelementptr inbounds i8, ptr %varargslots15, i64 16 + store %any %34, ptr %ptradd18, align 16 + %35 = extractvalue %"int[]" %31, 0 + %ptradd19 = getelementptr inbounds i8, ptr %35, i64 4 + %36 = insertvalue %any undef, ptr %ptradd19, 0 %37 = insertvalue %any %36, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd22 = getelementptr inbounds i8, ptr %varargslots16, i64 32 - store %any %37, ptr %ptradd22, align 16 - store i32 5, ptr %taddr23, align 4 - %38 = insertvalue %any undef, ptr %taddr23, 0 + %ptradd20 = getelementptr inbounds i8, ptr %varargslots15, i64 32 + store %any %37, ptr %ptradd20, align 16 + store i32 5, ptr %taddr21, align 4 + %38 = insertvalue %any undef, ptr %taddr21, 0 %39 = insertvalue %any %38, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd24 = getelementptr inbounds i8, ptr %varargslots16, i64 48 - store %any %39, ptr %ptradd24, align 16 - call void @foo(ptr %varargslots16, i64 4) + %ptradd22 = getelementptr inbounds i8, ptr %varargslots15, i64 48 + store %any %39, ptr %ptradd22, align 16 + call void @foo(ptr %varargslots15, i64 4) ret void } diff --git a/test/test_suite/functions/raw_splat.c3t b/test/test_suite/functions/raw_splat.c3t index 83c3be48b..ccd1b8959 100644 --- a/test/test_suite/functions/raw_splat.c3t +++ b/test/test_suite/functions/raw_splat.c3t @@ -33,12 +33,10 @@ entry: %.anon12 = alloca i32, align 4 %.anon14 = alloca i32, align 4 %z = alloca %"int[]", align 8 - %.anon22 = alloca %"int[]", align 8 - %.anon24 = alloca i32, align 4 - %.anon26 = alloca i32, align 4 - %.anon31 = alloca %"int[]", align 8 + %.anon23 = alloca i32, align 4 + %.anon25 = alloca i32, align 4 + %.anon31 = alloca i32, align 4 %.anon33 = alloca i32, align 4 - %.anon35 = alloca i32, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y, ptr align 4 @.__const, i32 12, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %.anon, ptr align 4 %y, i32 12, i1 false) %0 = load i32, ptr %.anon, align 4 @@ -96,55 +94,53 @@ entry: store %"int[]" %20, ptr %z, align 8 %21 = load %"int[]", ptr %z, align 8 %22 = extractvalue %"int[]" %21, 0 - %ptradd23 = getelementptr inbounds i8, ptr %22, i64 4 - %23 = insertvalue %"int[]" undef, ptr %ptradd23, 0 + %ptradd22 = getelementptr inbounds i8, ptr %22, i64 4 + %23 = insertvalue %"int[]" undef, ptr %ptradd22, 0 %24 = insertvalue %"int[]" %23, i64 2, 1 - store %"int[]" %24, ptr %.anon22, align 8 - %25 = load ptr, ptr %.anon22, align 8 + %25 = extractvalue %"int[]" %24, 0 %26 = load i32, ptr %25, align 4 - store i32 %26, ptr %.anon24, align 4 - %27 = load ptr, ptr %.anon22, align 8 - %ptradd25 = getelementptr inbounds i8, ptr %27, i64 4 - %28 = load i32, ptr %ptradd25, align 4 - store i32 %28, ptr %.anon26, align 4 + store i32 %26, ptr %.anon23, align 4 + %27 = extractvalue %"int[]" %24, 0 + %ptradd24 = getelementptr inbounds i8, ptr %27, i64 4 + %28 = load i32, ptr %ptradd24, align 4 + store i32 %28, ptr %.anon25, align 4 %29 = load i32, ptr @rawsplat.x, align 4 - %30 = load i32, ptr %.anon24, align 4 - %mul27 = mul i32 %30, 0 - %add28 = add i32 %29, %mul27 - store i32 %add28, ptr @rawsplat.x, align 4 + %30 = load i32, ptr %.anon23, align 4 + %mul26 = mul i32 %30, 0 + %add27 = add i32 %29, %mul26 + store i32 %add27, ptr @rawsplat.x, align 4 %31 = load i32, ptr @rawsplat.x, align 4 - %32 = load i32, ptr %.anon26, align 4 - %mul29 = mul i32 %32, 1 - %add30 = add i32 %31, %mul29 - store i32 %add30, ptr @rawsplat.x, align 4 + %32 = load i32, ptr %.anon25, align 4 + %mul28 = mul i32 %32, 1 + %add29 = add i32 %31, %mul28 + store i32 %add29, ptr @rawsplat.x, align 4 %33 = load %"int[]", ptr %z, align 8 %34 = extractvalue %"int[]" %33, 0 - %ptradd32 = getelementptr inbounds i8, ptr %34, i64 4 - %35 = insertvalue %"int[]" undef, ptr %ptradd32, 0 + %ptradd30 = getelementptr inbounds i8, ptr %34, i64 4 + %35 = insertvalue %"int[]" undef, ptr %ptradd30, 0 %36 = insertvalue %"int[]" %35, i64 2, 1 - store %"int[]" %36, ptr %.anon31, align 8 - %37 = load ptr, ptr %.anon31, align 8 + %37 = extractvalue %"int[]" %36, 0 %38 = load i32, ptr %37, align 4 - store i32 %38, ptr %.anon33, align 4 - %39 = load ptr, ptr %.anon31, align 8 - %ptradd34 = getelementptr inbounds i8, ptr %39, i64 4 - %40 = load i32, ptr %ptradd34, align 4 - store i32 %40, ptr %.anon35, align 4 + store i32 %38, ptr %.anon31, align 4 + %39 = extractvalue %"int[]" %36, 0 + %ptradd32 = getelementptr inbounds i8, ptr %39, i64 4 + %40 = load i32, ptr %ptradd32, align 4 + store i32 %40, ptr %.anon33, align 4 %41 = load i32, ptr @rawsplat.x, align 4 - %add36 = add i32 %41, 0 - store i32 %add36, ptr @rawsplat.x, align 4 + %add34 = add i32 %41, 0 + store i32 %add34, ptr @rawsplat.x, align 4 %42 = load i32, ptr @rawsplat.x, align 4 - %43 = load i32, ptr %.anon33, align 4 - %mul37 = mul i32 %43, 1 - %add38 = add i32 %42, %mul37 - store i32 %add38, ptr @rawsplat.x, align 4 + %43 = load i32, ptr %.anon31, align 4 + %mul35 = mul i32 %43, 1 + %add36 = add i32 %42, %mul35 + store i32 %add36, ptr @rawsplat.x, align 4 %44 = load i32, ptr @rawsplat.x, align 4 - %45 = load i32, ptr %.anon35, align 4 - %mul39 = mul i32 %45, 2 - %add40 = add i32 %44, %mul39 - store i32 %add40, ptr @rawsplat.x, align 4 + %45 = load i32, ptr %.anon33, align 4 + %mul37 = mul i32 %45, 2 + %add38 = add i32 %44, %mul37 + store i32 %add38, ptr @rawsplat.x, align 4 %46 = load i32, ptr @rawsplat.x, align 4 - %add41 = add i32 %46, 15 - store i32 %add41, ptr @rawsplat.x, align 4 + %add39 = add i32 %46, 15 + store i32 %add39, ptr @rawsplat.x, align 4 ret void } diff --git a/test/test_suite/generic/generic_over_fn.c3t b/test/test_suite/generic/generic_over_fn.c3t index 0a45cd42f..0c9eff922 100644 --- a/test/test_suite/generic/generic_over_fn.c3t +++ b/test/test_suite/generic/generic_over_fn.c3t @@ -67,7 +67,6 @@ entry: %literal5 = alloca [3 x i32], align 4 %literal7 = alloca [3 x i32], align 4 %.anon = alloca i64, align 8 - %.anon9 = alloca i64, align 8 %tc = alloca %"int[]", align 8 %list = alloca %"int[]", align 8 %len = alloca i64, align 8 @@ -97,34 +96,32 @@ entry: store %"int[][]" %9, ptr %tcases, align 8 %ptradd8 = getelementptr inbounds i8, ptr %tcases, i64 8 %10 = load i64, ptr %ptradd8, align 8 - store i64 %10, ptr %.anon, align 8 - store i64 0, ptr %.anon9, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %loop.body, %entry - %11 = load i64, ptr %.anon9, align 8 - %12 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %11, %12 + %11 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %11, %10 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %13 = load ptr, ptr %tcases, align 8 - %14 = load i64, ptr %.anon9, align 8 - %ptroffset = getelementptr inbounds [16 x i8], ptr %13, i64 %14 + %12 = load ptr, ptr %tcases, align 8 + %13 = load i64, ptr %.anon, align 8 + %ptroffset = getelementptr inbounds [16 x i8], ptr %12, i64 %13 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %tc, ptr align 8 %ptroffset, i32 16, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %list, ptr align 8 %tc, i32 16, i1 false) - %ptradd10 = getelementptr inbounds i8, ptr %list, i64 8 - %15 = load i64, ptr %ptradd10, align 8 - store i64 %15, ptr %len, align 8 - %16 = load i64, ptr %len, align 8 - %sub = sub i64 %16, 1 + %ptradd9 = getelementptr inbounds i8, ptr %list, i64 8 + %14 = load i64, ptr %ptradd9, align 8 + store i64 %14, ptr %len, align 8 + %15 = load i64, ptr %len, align 8 + %sub = sub i64 %15, 1 %lo = load ptr, ptr %list, align 8 - %ptradd11 = getelementptr inbounds i8, ptr %list, i64 8 - %hi = load i64, ptr %ptradd11, align 8 + %ptradd10 = getelementptr inbounds i8, ptr %list, i64 8 + %hi = load i64, ptr %ptradd10, align 8 call void @"test_generic$sa$int$fn$int$int$$int$$.sort"(ptr %lo, i64 %hi, i64 0, i64 %sub, ptr @sort_test.cmp_int_value) - %17 = load i64, ptr %.anon9, align 8 - %addnuw = add nuw i64 %17, 1 - store i64 %addnuw, ptr %.anon9, align 8 + %16 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %16, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond @@ -141,7 +138,6 @@ entry: %literal5 = alloca [3 x i32], align 4 %literal7 = alloca [3 x i32], align 4 %.anon = alloca i64, align 8 - %.anon9 = alloca i64, align 8 %tc = alloca %"int[]", align 8 %list = alloca %"int[]", align 8 %len = alloca i64, align 8 @@ -171,34 +167,32 @@ entry: store %"int[][]" %9, ptr %tcases, align 8 %ptradd8 = getelementptr inbounds i8, ptr %tcases, i64 8 %10 = load i64, ptr %ptradd8, align 8 - store i64 %10, ptr %.anon, align 8 - store i64 0, ptr %.anon9, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %loop.body, %entry - %11 = load i64, ptr %.anon9, align 8 - %12 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %11, %12 + %11 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %11, %10 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %13 = load ptr, ptr %tcases, align 8 - %14 = load i64, ptr %.anon9, align 8 - %ptroffset = getelementptr inbounds [16 x i8], ptr %13, i64 %14 + %12 = load ptr, ptr %tcases, align 8 + %13 = load i64, ptr %.anon, align 8 + %ptroffset = getelementptr inbounds [16 x i8], ptr %12, i64 %13 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %tc, ptr align 8 %ptroffset, i32 16, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %list, ptr align 8 %tc, i32 16, i1 false) - %ptradd10 = getelementptr inbounds i8, ptr %list, i64 8 - %15 = load i64, ptr %ptradd10, align 8 - store i64 %15, ptr %len, align 8 - %16 = load i64, ptr %len, align 8 - %sub = sub i64 %16, 1 + %ptradd9 = getelementptr inbounds i8, ptr %list, i64 8 + %14 = load i64, ptr %ptradd9, align 8 + store i64 %14, ptr %len, align 8 + %15 = load i64, ptr %len, align 8 + %sub = sub i64 %15, 1 %lo = load ptr, ptr %list, align 8 - %ptradd11 = getelementptr inbounds i8, ptr %list, i64 8 - %hi = load i64, ptr %ptradd11, align 8 + %ptradd10 = getelementptr inbounds i8, ptr %list, i64 8 + %hi = load i64, ptr %ptradd10, align 8 call void @"test_generic$sa$int$fn$int$int$$int$$.sort"(ptr %lo, i64 %hi, i64 0, i64 %sub, ptr @sort_test.cmp_int_value2) - %17 = load i64, ptr %.anon9, align 8 - %addnuw = add nuw i64 %17, 1 - store i64 %addnuw, ptr %.anon9, align 8 + %16 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %16, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond diff --git a/test/test_suite/macros/macro_typed_varargs.c3t b/test/test_suite/macros/macro_typed_varargs.c3t index 967e306e2..05b34eb17 100644 --- a/test/test_suite/macros/macro_typed_varargs.c3t +++ b/test/test_suite/macros/macro_typed_varargs.c3t @@ -33,102 +33,96 @@ entry: %literal = alloca [4 x i32], align 16 %x = alloca %"int[]", align 8 %.anon = alloca i64, align 8 - %.anon1 = alloca i64, align 8 %i = alloca i32, align 4 %varargslots = alloca [1 x %any], align 16 %retparam = alloca i64, align 8 - %literal2 = alloca [4 x %any], align 16 + %literal1 = alloca [4 x %any], align 16 %taddr = alloca i32, align 4 - %taddr4 = alloca i32, align 4 - %taddr6 = alloca i32, align 4 - %taddr8 = alloca i32, align 4 - %x9 = alloca %"any[]", align 8 + %taddr3 = alloca i32, align 4 + %taddr5 = alloca i32, align 4 + %taddr7 = alloca i32, align 4 + %x8 = alloca %"any[]", align 8 %.anon10 = alloca i64, align 8 - %.anon12 = alloca i64, align 8 - %i16 = alloca %any, align 8 - %varargslots18 = alloca [1 x %any], align 16 - %retparam19 = alloca i64, align 8 + %i14 = alloca %any, align 8 + %varargslots16 = alloca [1 x %any], align 16 + %retparam17 = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal, ptr align 16 @.__const, i32 16, i1 false) %0 = insertvalue %"int[]" undef, ptr %literal, 0 %1 = insertvalue %"int[]" %0, i64 4, 1 store %"int[]" %1, ptr %x, align 8 %ptradd = getelementptr inbounds i8, ptr %x, i64 8 %2 = load i64, ptr %ptradd, align 8 - store i64 %2, ptr %.anon, align 8 - store i64 0, ptr %.anon1, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %loop.body, %entry - %3 = load i64, ptr %.anon1, align 8 - %4 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %3, %4 + %3 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %3, %2 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %5 = load ptr, ptr %x, align 8 - %6 = load i64, ptr %.anon1, align 8 - %ptroffset = getelementptr inbounds [4 x i8], ptr %5, i64 %6 - %7 = load i32, ptr %ptroffset, align 4 - store i32 %7, ptr %i, align 4 - %8 = insertvalue %any undef, ptr %i, 0 - %9 = insertvalue %any %8, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %9, ptr %varargslots, align 16 - %10 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) - %11 = load i64, ptr %.anon1, align 8 - %addnuw = add nuw i64 %11, 1 - store i64 %addnuw, ptr %.anon1, align 8 + %4 = load ptr, ptr %x, align 8 + %5 = load i64, ptr %.anon, align 8 + %ptroffset = getelementptr inbounds [4 x i8], ptr %4, i64 %5 + %6 = load i32, ptr %ptroffset, align 4 + store i32 %6, ptr %i, align 4 + %7 = insertvalue %any undef, ptr %i, 0 + %8 = insertvalue %any %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %8, ptr %varargslots, align 16 + %9 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) + %10 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %10, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond store i32 1, ptr %taddr, align 4 - %12 = insertvalue %any undef, ptr %taddr, 0 - %13 = insertvalue %any %12, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %13, ptr %literal2, align 8 - %ptradd3 = getelementptr inbounds i8, ptr %literal2, i64 16 - store i32 -1, ptr %taddr4, align 4 - %14 = insertvalue %any undef, ptr %taddr4, 0 - %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %15, ptr %ptradd3, align 8 - %ptradd5 = getelementptr inbounds i8, ptr %literal2, i64 32 - store i32 3141, ptr %taddr6, align 4 - %16 = insertvalue %any undef, ptr %taddr6, 0 - %17 = insertvalue %any %16, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %17, ptr %ptradd5, align 8 - %ptradd7 = getelementptr inbounds i8, ptr %literal2, i64 48 - store i32 1000, ptr %taddr8, align 4 - %18 = insertvalue %any undef, ptr %taddr8, 0 - %19 = insertvalue %any %18, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %19, ptr %ptradd7, align 8 - %20 = insertvalue %"any[]" undef, ptr %literal2, 0 - %21 = insertvalue %"any[]" %20, i64 4, 1 - store %"any[]" %21, ptr %x9, align 8 - %ptradd11 = getelementptr inbounds i8, ptr %x9, i64 8 - %22 = load i64, ptr %ptradd11, align 8 - store i64 %22, ptr %.anon10, align 8 - store i64 0, ptr %.anon12, align 8 - br label %loop.cond13 + %11 = insertvalue %any undef, ptr %taddr, 0 + %12 = insertvalue %any %11, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %12, ptr %literal1, align 8 + %ptradd2 = getelementptr inbounds i8, ptr %literal1, i64 16 + store i32 -1, ptr %taddr3, align 4 + %13 = insertvalue %any undef, ptr %taddr3, 0 + %14 = insertvalue %any %13, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %14, ptr %ptradd2, align 8 + %ptradd4 = getelementptr inbounds i8, ptr %literal1, i64 32 + store i32 3141, ptr %taddr5, align 4 + %15 = insertvalue %any undef, ptr %taddr5, 0 + %16 = insertvalue %any %15, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %16, ptr %ptradd4, align 8 + %ptradd6 = getelementptr inbounds i8, ptr %literal1, i64 48 + store i32 1000, ptr %taddr7, align 4 + %17 = insertvalue %any undef, ptr %taddr7, 0 + %18 = insertvalue %any %17, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %18, ptr %ptradd6, align 8 + %19 = insertvalue %"any[]" undef, ptr %literal1, 0 + %20 = insertvalue %"any[]" %19, i64 4, 1 + store %"any[]" %20, ptr %x8, align 8 + %ptradd9 = getelementptr inbounds i8, ptr %x8, i64 8 + %21 = load i64, ptr %ptradd9, align 8 + store i64 0, ptr %.anon10, align 8 + br label %loop.cond11 -loop.cond13: ; preds = %loop.body15, %loop.exit - %23 = load i64, ptr %.anon12, align 8 - %24 = load i64, ptr %.anon10, align 8 - %lt14 = icmp ult i64 %23, %24 - br i1 %lt14, label %loop.body15, label %loop.exit21 +loop.cond11: ; preds = %loop.body13, %loop.exit + %22 = load i64, ptr %.anon10, align 8 + %lt12 = icmp ult i64 %22, %21 + br i1 %lt12, label %loop.body13, label %loop.exit19 -loop.body15: ; preds = %loop.cond13 - %25 = load ptr, ptr %x9, align 8 - %26 = load i64, ptr %.anon12, align 8 - %ptroffset17 = getelementptr inbounds [16 x i8], ptr %25, i64 %26 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %i16, ptr align 8 %ptroffset17, i32 16, i1 false) - %27 = load ptr, ptr %i16, align 8 - %28 = insertvalue %any undef, ptr %27, 0 - %29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %29, ptr %varargslots18, align 16 - %30 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.1, i64 2, ptr %varargslots18, i64 1) - %31 = load i64, ptr %.anon12, align 8 - %addnuw20 = add nuw i64 %31, 1 - store i64 %addnuw20, ptr %.anon12, align 8 - br label %loop.cond13 +loop.body13: ; preds = %loop.cond11 + %23 = load ptr, ptr %x8, align 8 + %24 = load i64, ptr %.anon10, align 8 + %ptroffset15 = getelementptr inbounds [16 x i8], ptr %23, i64 %24 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %i14, ptr align 8 %ptroffset15, i32 16, i1 false) + %25 = load ptr, ptr %i14, align 8 + %26 = insertvalue %any undef, ptr %25, 0 + %27 = insertvalue %any %26, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %27, ptr %varargslots16, align 16 + %28 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.1, i64 2, ptr %varargslots16, i64 1) + %29 = load i64, ptr %.anon10, align 8 + %addnuw18 = add nuw i64 %29, 1 + store i64 %addnuw18, ptr %.anon10, align 8 + br label %loop.cond11 -loop.exit21: ; preds = %loop.cond13 +loop.exit19: ; preds = %loop.cond11 ret void } diff --git a/test/test_suite/macros/macro_vasplat.c3t b/test/test_suite/macros/macro_vasplat.c3t index 0a07b4850..537b93d02 100644 --- a/test/test_suite/macros/macro_vasplat.c3t +++ b/test/test_suite/macros/macro_vasplat.c3t @@ -71,71 +71,69 @@ entry: %varargslots = alloca [2 x %any], align 16 %retparam = alloca i64, align 8 %a1 = alloca [1 x i32], align 4 - %.anon2 = alloca i64, align 8 - %i3 = alloca i64, align 8 - %x4 = alloca i32, align 4 - %varargslots5 = alloca [2 x %any], align 16 - %retparam7 = alloca i64, align 8 - %a8 = alloca [4 x i32], align 16 - %.anon9 = alloca i64, align 8 - %i13 = alloca i64, align 8 - %x14 = alloca i32, align 4 - %varargslots16 = alloca [2 x %any], align 16 - %retparam18 = alloca i64, align 8 - %a21 = alloca [2 x i32], align 4 - %.anon22 = alloca i64, align 8 - %i26 = alloca i64, align 8 - %x27 = alloca i32, align 4 - %varargslots29 = alloca [2 x %any], align 16 - %retparam31 = alloca i64, align 8 - %a34 = alloca [3 x i32], align 4 - %.anon35 = alloca i64, align 8 - %i39 = alloca i64, align 8 - %x40 = alloca i32, align 4 - %varargslots42 = alloca [2 x %any], align 16 - %retparam44 = alloca i64, align 8 - %a47 = alloca [1 x i32], align 4 - %.anon48 = alloca i64, align 8 - %i49 = alloca i64, align 8 - %x50 = alloca i32, align 4 - %varargslots51 = alloca [2 x %any], align 16 - %retparam53 = alloca i64, align 8 - %a54 = alloca [2 x i32], align 4 - %.anon55 = alloca i64, align 8 - %i59 = alloca i64, align 8 - %x60 = alloca i32, align 4 - %varargslots62 = alloca [2 x %any], align 16 - %retparam64 = alloca i64, align 8 - %a67 = alloca [5 x i32], align 16 - %.anon68 = alloca i64, align 8 - %i72 = alloca i64, align 8 - %x73 = alloca i32, align 4 - %varargslots75 = alloca [2 x %any], align 16 - %retparam77 = alloca i64, align 8 - %a80 = alloca [8 x i32], align 16 - %.anon81 = alloca i64, align 8 - %i85 = alloca i64, align 8 - %x86 = alloca i32, align 4 - %varargslots88 = alloca [2 x %any], align 16 - %retparam90 = alloca i64, align 8 + %i2 = alloca i64, align 8 + %x3 = alloca i32, align 4 + %varargslots4 = alloca [2 x %any], align 16 + %retparam6 = alloca i64, align 8 + %a7 = alloca [4 x i32], align 16 + %.anon8 = alloca i64, align 8 + %i12 = alloca i64, align 8 + %x13 = alloca i32, align 4 + %varargslots15 = alloca [2 x %any], align 16 + %retparam17 = alloca i64, align 8 + %a20 = alloca [2 x i32], align 4 + %.anon21 = alloca i64, align 8 + %i25 = alloca i64, align 8 + %x26 = alloca i32, align 4 + %varargslots28 = alloca [2 x %any], align 16 + %retparam30 = alloca i64, align 8 + %a33 = alloca [3 x i32], align 4 + %.anon34 = alloca i64, align 8 + %i38 = alloca i64, align 8 + %x39 = alloca i32, align 4 + %varargslots41 = alloca [2 x %any], align 16 + %retparam43 = alloca i64, align 8 + %a46 = alloca [1 x i32], align 4 + %i47 = alloca i64, align 8 + %x48 = alloca i32, align 4 + %varargslots49 = alloca [2 x %any], align 16 + %retparam51 = alloca i64, align 8 + %a52 = alloca [2 x i32], align 4 + %.anon53 = alloca i64, align 8 + %i57 = alloca i64, align 8 + %x58 = alloca i32, align 4 + %varargslots60 = alloca [2 x %any], align 16 + %retparam62 = alloca i64, align 8 + %a65 = alloca [5 x i32], align 16 + %.anon66 = alloca i64, align 8 + %i70 = alloca i64, align 8 + %x71 = alloca i32, align 4 + %varargslots73 = alloca [2 x %any], align 16 + %retparam75 = alloca i64, align 8 + %a78 = alloca [8 x i32], align 16 + %.anon79 = alloca i64, align 8 + %i83 = alloca i64, align 8 + %x84 = alloca i32, align 4 + %varargslots86 = alloca [2 x %any], align 16 + %retparam88 = alloca i64, align 8 %b = alloca [7 x i32], align 16 - %.anon93 = alloca i64, align 8 - %i97 = alloca i64, align 8 - %x98 = alloca i32, align 4 - %varargslots100 = alloca [2 x %any], align 16 - %retparam102 = alloca i64, align 8 + %.anon91 = alloca i64, align 8 + %i95 = alloca i64, align 8 + %x96 = alloca i32, align 4 + %varargslots98 = alloca [2 x %any], align 16 + %retparam100 = alloca i64, align 8 %c = alloca [8 x i32], align 16 - %.anon105 = alloca i64, align 8 - %i109 = alloca i64, align 8 - %x110 = alloca i32, align 4 - %varargslots112 = alloca [2 x %any], align 16 - %retparam114 = alloca i64, align 8 - %a117 = alloca [6 x i32], align 16 - %.anon118 = alloca i64, align 8 - %i122 = alloca i64, align 8 - %x123 = alloca i32, align 4 - %varargslots125 = alloca [2 x %any], align 16 - %retparam127 = alloca i64, align 8 + %.anon103 = alloca i64, align 8 + %i107 = alloca i64, align 8 + %x108 = alloca i32, align 4 + %varargslots110 = alloca [2 x %any], align 16 + %retparam112 = alloca i64, align 8 + %a115 = alloca [6 x i32], align 16 + %.anon116 = alloca i64, align 8 + %i120 = alloca i64, align 8 + %x121 = alloca i32, align 4 + %varargslots123 = alloca [2 x %any], align 16 + %retparam125 = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const, i32 12, i1 false) store i64 0, ptr %.anon, align 8 br label %loop.cond @@ -164,275 +162,298 @@ loop.body: ; preds = %loop.cond br label %loop.cond loop.exit: ; preds = %loop.cond call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a1, ptr align 4 @.__const.1, i32 4, i1 false) - store i64 0, ptr %.anon2, align 8 - %10 = load i64, ptr %.anon2, align 8 - store i64 %10, ptr %i3, align 8 - %11 = load i32, ptr %a1, align 4 - store i32 %11, ptr %x4, align 4 - %12 = insertvalue %any undef, ptr %i3, 0 - %13 = insertvalue %any %12, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %13, ptr %varargslots5, align 16 - %14 = insertvalue %any undef, ptr %x4, 0 - %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd6 = getelementptr inbounds i8, ptr %varargslots5, i64 16 - store %any %15, ptr %ptradd6, align 16 - %16 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.2, i64 8, ptr %varargslots5, i64 2) - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a8, ptr align 16 @.__const.3, i32 16, i1 false) - store i64 0, ptr %.anon9, align 8 - br label %loop.cond10 -loop.cond10: ; preds = %loop.body12, %loop.exit - %17 = load i64, ptr %.anon9, align 8 - %gt11 = icmp ugt i64 4, %17 - br i1 %gt11, label %loop.body12, label %loop.exit20 -loop.body12: ; preds = %loop.cond10 - %18 = load i64, ptr %.anon9, align 8 - store i64 %18, ptr %i13, align 8 - %19 = load i64, ptr %.anon9, align 8 - %ptroffset15 = getelementptr inbounds [4 x i8], ptr %a8, i64 %19 - %20 = load i32, ptr %ptroffset15, align 4 - store i32 %20, ptr %x14, align 4 - %21 = insertvalue %any undef, ptr %i13, 0 - %22 = insertvalue %any %21, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %22, ptr %varargslots16, align 16 - %23 = insertvalue %any undef, ptr %x14, 0 - %24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd17 = getelementptr inbounds i8, ptr %varargslots16, i64 16 - store %any %24, ptr %ptradd17, align 16 - %25 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.4, i64 6, ptr %varargslots16, i64 2) - %26 = load i64, ptr %.anon9, align 8 - %addnuw19 = add nuw i64 %26, 1 - store i64 %addnuw19, ptr %.anon9, align 8 - br label %loop.cond10 -loop.exit20: ; preds = %loop.cond10 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a21, ptr align 4 @.__const.5, i32 8, i1 false) - store i64 0, ptr %.anon22, align 8 - br label %loop.cond23 -loop.cond23: ; preds = %loop.body25, %loop.exit20 - %27 = load i64, ptr %.anon22, align 8 - %gt24 = icmp ugt i64 2, %27 - br i1 %gt24, label %loop.body25, label %loop.exit33 -loop.body25: ; preds = %loop.cond23 - %28 = load i64, ptr %.anon22, align 8 - store i64 %28, ptr %i26, align 8 - %29 = load i64, ptr %.anon22, align 8 - %ptroffset28 = getelementptr inbounds [4 x i8], ptr %a21, i64 %29 - %30 = load i32, ptr %ptroffset28, align 4 - store i32 %30, ptr %x27, align 4 - %31 = insertvalue %any undef, ptr %i26, 0 - %32 = insertvalue %any %31, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %32, ptr %varargslots29, align 16 - %33 = insertvalue %any undef, ptr %x27, 0 - %34 = insertvalue %any %33, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd30 = getelementptr inbounds i8, ptr %varargslots29, i64 16 - store %any %34, ptr %ptradd30, align 16 - %35 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.6, i64 6, ptr %varargslots29, i64 2) - %36 = load i64, ptr %.anon22, align 8 - %addnuw32 = add nuw i64 %36, 1 - store i64 %addnuw32, ptr %.anon22, align 8 - br label %loop.cond23 -loop.exit33: ; preds = %loop.cond23 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a34, ptr align 4 @.__const.7, i32 12, i1 false) - store i64 0, ptr %.anon35, align 8 - br label %loop.cond36 -loop.cond36: ; preds = %loop.body38, %loop.exit33 - %37 = load i64, ptr %.anon35, align 8 - %gt37 = icmp ugt i64 3, %37 - br i1 %gt37, label %loop.body38, label %loop.exit46 -loop.body38: ; preds = %loop.cond36 - %38 = load i64, ptr %.anon35, align 8 - store i64 %38, ptr %i39, align 8 - %39 = load i64, ptr %.anon35, align 8 - %ptroffset41 = getelementptr inbounds [4 x i8], ptr %a34, i64 %39 - %40 = load i32, ptr %ptroffset41, align 4 - store i32 %40, ptr %x40, align 4 - %41 = insertvalue %any undef, ptr %i39, 0 - %42 = insertvalue %any %41, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %42, ptr %varargslots42, align 16 - %43 = insertvalue %any undef, ptr %x40, 0 - %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd43 = getelementptr inbounds i8, ptr %varargslots42, i64 16 - store %any %44, ptr %ptradd43, align 16 - %45 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.8, i64 8, ptr %varargslots42, i64 2) - %46 = load i64, ptr %.anon35, align 8 - %addnuw45 = add nuw i64 %46, 1 - store i64 %addnuw45, ptr %.anon35, align 8 - br label %loop.cond36 -loop.exit46: ; preds = %loop.cond36 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a47, ptr align 4 @.__const.9, i32 4, i1 false) - store i64 0, ptr %.anon48, align 8 - %47 = load i64, ptr %.anon48, align 8 - store i64 %47, ptr %i49, align 8 - %48 = load i32, ptr %a47, align 4 - store i32 %48, ptr %x50, align 4 - %49 = insertvalue %any undef, ptr %i49, 0 - %50 = insertvalue %any %49, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %50, ptr %varargslots51, align 16 - %51 = insertvalue %any undef, ptr %x50, 0 - %52 = insertvalue %any %51, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd52 = getelementptr inbounds i8, ptr %varargslots51, i64 16 - store %any %52, ptr %ptradd52, align 16 - %53 = call i64 @std.io.printfn(ptr %retparam53, ptr @.str.10, i64 8, ptr %varargslots51, i64 2) - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a54, ptr align 4 @.__const.11, i32 8, i1 false) - store i64 0, ptr %.anon55, align 8 - br label %loop.cond56 -loop.cond56: ; preds = %loop.body58, %loop.exit46 - %54 = load i64, ptr %.anon55, align 8 - %gt57 = icmp ugt i64 2, %54 - br i1 %gt57, label %loop.body58, label %loop.exit66 -loop.body58: ; preds = %loop.cond56 - %55 = load i64, ptr %.anon55, align 8 - store i64 %55, ptr %i59, align 8 - %56 = load i64, ptr %.anon55, align 8 - %ptroffset61 = getelementptr inbounds [4 x i8], ptr %a54, i64 %56 - %57 = load i32, ptr %ptroffset61, align 4 - store i32 %57, ptr %x60, align 4 - %58 = insertvalue %any undef, ptr %i59, 0 - %59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %59, ptr %varargslots62, align 16 - %60 = insertvalue %any undef, ptr %x60, 0 - %61 = insertvalue %any %60, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd63 = getelementptr inbounds i8, ptr %varargslots62, i64 16 - store %any %61, ptr %ptradd63, align 16 - %62 = call i64 @std.io.printfn(ptr %retparam64, ptr @.str.12, i64 8, ptr %varargslots62, i64 2) - %63 = load i64, ptr %.anon55, align 8 - %addnuw65 = add nuw i64 %63, 1 - store i64 %addnuw65, ptr %.anon55, align 8 - br label %loop.cond56 -loop.exit66: ; preds = %loop.cond56 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a67, ptr align 16 @.__const.13, i32 20, i1 false) - store i64 0, ptr %.anon68, align 8 - br label %loop.cond69 -loop.cond69: ; preds = %loop.body71, %loop.exit66 - %64 = load i64, ptr %.anon68, align 8 - %gt70 = icmp ugt i64 5, %64 - br i1 %gt70, label %loop.body71, label %loop.exit79 -loop.body71: ; preds = %loop.cond69 - %65 = load i64, ptr %.anon68, align 8 - store i64 %65, ptr %i72, align 8 - %66 = load i64, ptr %.anon68, align 8 - %ptroffset74 = getelementptr inbounds [4 x i8], ptr %a67, i64 %66 - %67 = load i32, ptr %ptroffset74, align 4 - store i32 %67, ptr %x73, align 4 - %68 = insertvalue %any undef, ptr %i72, 0 - %69 = insertvalue %any %68, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %69, ptr %varargslots75, align 16 - %70 = insertvalue %any undef, ptr %x73, 0 - %71 = insertvalue %any %70, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd76 = getelementptr inbounds i8, ptr %varargslots75, i64 16 - store %any %71, ptr %ptradd76, align 16 - %72 = call i64 @std.io.printfn(ptr %retparam77, ptr @.str.14, i64 8, ptr %varargslots75, i64 2) - %73 = load i64, ptr %.anon68, align 8 - %addnuw78 = add nuw i64 %73, 1 - store i64 %addnuw78, ptr %.anon68, align 8 - br label %loop.cond69 -loop.exit79: ; preds = %loop.cond69 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a80, ptr align 16 @.__const.15, i32 32, i1 false) - store i64 0, ptr %.anon81, align 8 - br label %loop.cond82 -loop.cond82: ; preds = %loop.body84, %loop.exit79 - %74 = load i64, ptr %.anon81, align 8 - %gt83 = icmp ugt i64 8, %74 - br i1 %gt83, label %loop.body84, label %loop.exit92 -loop.body84: ; preds = %loop.cond82 - %75 = load i64, ptr %.anon81, align 8 - store i64 %75, ptr %i85, align 8 - %76 = load i64, ptr %.anon81, align 8 - %ptroffset87 = getelementptr inbounds [4 x i8], ptr %a80, i64 %76 - %77 = load i32, ptr %ptroffset87, align 4 - store i32 %77, ptr %x86, align 4 - %78 = insertvalue %any undef, ptr %i85, 0 - %79 = insertvalue %any %78, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %79, ptr %varargslots88, align 16 - %80 = insertvalue %any undef, ptr %x86, 0 - %81 = insertvalue %any %80, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd89 = getelementptr inbounds i8, ptr %varargslots88, i64 16 - store %any %81, ptr %ptradd89, align 16 - %82 = call i64 @std.io.printfn(ptr %retparam90, ptr @.str.16, i64 8, ptr %varargslots88, i64 2) - %83 = load i64, ptr %.anon81, align 8 - %addnuw91 = add nuw i64 %83, 1 - store i64 %addnuw91, ptr %.anon81, align 8 - br label %loop.cond82 -loop.exit92: ; preds = %loop.cond82 + store i64 0, ptr %i2, align 8 + %10 = load i32, ptr %a1, align 4 + store i32 %10, ptr %x3, align 4 + %11 = insertvalue %any undef, ptr %i2, 0 + %12 = insertvalue %any %11, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %12, ptr %varargslots4, align 16 + %13 = insertvalue %any undef, ptr %x3, 0 + %14 = insertvalue %any %13, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd5 = getelementptr inbounds i8, ptr %varargslots4, i64 16 + store %any %14, ptr %ptradd5, align 16 + %15 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.2, i64 8, ptr %varargslots4, i64 2) + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a7, ptr align 16 @.__const.3, i32 16, i1 false) + store i64 0, ptr %.anon8, align 8 + br label %loop.cond9 + +loop.cond9: ; preds = %loop.body11, %loop.exit + %16 = load i64, ptr %.anon8, align 8 + %gt10 = icmp ugt i64 4, %16 + br i1 %gt10, label %loop.body11, label %loop.exit19 + +loop.body11: ; preds = %loop.cond9 + %17 = load i64, ptr %.anon8, align 8 + store i64 %17, ptr %i12, align 8 + %18 = load i64, ptr %.anon8, align 8 + %ptroffset14 = getelementptr inbounds [4 x i8], ptr %a7, i64 %18 + %19 = load i32, ptr %ptroffset14, align 4 + store i32 %19, ptr %x13, align 4 + %20 = insertvalue %any undef, ptr %i12, 0 + %21 = insertvalue %any %20, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %21, ptr %varargslots15, align 16 + %22 = insertvalue %any undef, ptr %x13, 0 + %23 = insertvalue %any %22, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd16 = getelementptr inbounds i8, ptr %varargslots15, i64 16 + store %any %23, ptr %ptradd16, align 16 + %24 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.4, i64 6, ptr %varargslots15, i64 2) + %25 = load i64, ptr %.anon8, align 8 + %addnuw18 = add nuw i64 %25, 1 + store i64 %addnuw18, ptr %.anon8, align 8 + br label %loop.cond9 + +loop.exit19: ; preds = %loop.cond9 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a20, ptr align 4 @.__const.5, i32 8, i1 false) + store i64 0, ptr %.anon21, align 8 + br label %loop.cond22 + +loop.cond22: ; preds = %loop.body24, %loop.exit19 + %26 = load i64, ptr %.anon21, align 8 + %gt23 = icmp ugt i64 2, %26 + br i1 %gt23, label %loop.body24, label %loop.exit32 + +loop.body24: ; preds = %loop.cond22 + %27 = load i64, ptr %.anon21, align 8 + store i64 %27, ptr %i25, align 8 + %28 = load i64, ptr %.anon21, align 8 + %ptroffset27 = getelementptr inbounds [4 x i8], ptr %a20, i64 %28 + %29 = load i32, ptr %ptroffset27, align 4 + store i32 %29, ptr %x26, align 4 + %30 = insertvalue %any undef, ptr %i25, 0 + %31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %31, ptr %varargslots28, align 16 + %32 = insertvalue %any undef, ptr %x26, 0 + %33 = insertvalue %any %32, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd29 = getelementptr inbounds i8, ptr %varargslots28, i64 16 + store %any %33, ptr %ptradd29, align 16 + %34 = call i64 @std.io.printfn(ptr %retparam30, ptr @.str.6, i64 6, ptr %varargslots28, i64 2) + %35 = load i64, ptr %.anon21, align 8 + %addnuw31 = add nuw i64 %35, 1 + store i64 %addnuw31, ptr %.anon21, align 8 + br label %loop.cond22 + +loop.exit32: ; preds = %loop.cond22 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a33, ptr align 4 @.__const.7, i32 12, i1 false) + store i64 0, ptr %.anon34, align 8 + br label %loop.cond35 + +loop.cond35: ; preds = %loop.body37, %loop.exit32 + %36 = load i64, ptr %.anon34, align 8 + %gt36 = icmp ugt i64 3, %36 + br i1 %gt36, label %loop.body37, label %loop.exit45 + +loop.body37: ; preds = %loop.cond35 + %37 = load i64, ptr %.anon34, align 8 + store i64 %37, ptr %i38, align 8 + %38 = load i64, ptr %.anon34, align 8 + %ptroffset40 = getelementptr inbounds [4 x i8], ptr %a33, i64 %38 + %39 = load i32, ptr %ptroffset40, align 4 + store i32 %39, ptr %x39, align 4 + %40 = insertvalue %any undef, ptr %i38, 0 + %41 = insertvalue %any %40, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %41, ptr %varargslots41, align 16 + %42 = insertvalue %any undef, ptr %x39, 0 + %43 = insertvalue %any %42, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd42 = getelementptr inbounds i8, ptr %varargslots41, i64 16 + store %any %43, ptr %ptradd42, align 16 + %44 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.8, i64 8, ptr %varargslots41, i64 2) + %45 = load i64, ptr %.anon34, align 8 + %addnuw44 = add nuw i64 %45, 1 + store i64 %addnuw44, ptr %.anon34, align 8 + br label %loop.cond35 + +loop.exit45: ; preds = %loop.cond35 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a46, ptr align 4 @.__const.9, i32 4, i1 false) + store i64 0, ptr %i47, align 8 + %46 = load i32, ptr %a46, align 4 + store i32 %46, ptr %x48, align 4 + %47 = insertvalue %any undef, ptr %i47, 0 + %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %48, ptr %varargslots49, align 16 + %49 = insertvalue %any undef, ptr %x48, 0 + %50 = insertvalue %any %49, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd50 = getelementptr inbounds i8, ptr %varargslots49, i64 16 + store %any %50, ptr %ptradd50, align 16 + %51 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.10, i64 8, ptr %varargslots49, i64 2) + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a52, ptr align 4 @.__const.11, i32 8, i1 false) + store i64 0, ptr %.anon53, align 8 + br label %loop.cond54 + +loop.cond54: ; preds = %loop.body56, %loop.exit45 + %52 = load i64, ptr %.anon53, align 8 + %gt55 = icmp ugt i64 2, %52 + br i1 %gt55, label %loop.body56, label %loop.exit64 + +loop.body56: ; preds = %loop.cond54 + %53 = load i64, ptr %.anon53, align 8 + store i64 %53, ptr %i57, align 8 + %54 = load i64, ptr %.anon53, align 8 + %ptroffset59 = getelementptr inbounds [4 x i8], ptr %a52, i64 %54 + %55 = load i32, ptr %ptroffset59, align 4 + store i32 %55, ptr %x58, align 4 + %56 = insertvalue %any undef, ptr %i57, 0 + %57 = insertvalue %any %56, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %57, ptr %varargslots60, align 16 + %58 = insertvalue %any undef, ptr %x58, 0 + %59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd61 = getelementptr inbounds i8, ptr %varargslots60, i64 16 + store %any %59, ptr %ptradd61, align 16 + %60 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.12, i64 8, ptr %varargslots60, i64 2) + %61 = load i64, ptr %.anon53, align 8 + %addnuw63 = add nuw i64 %61, 1 + store i64 %addnuw63, ptr %.anon53, align 8 + br label %loop.cond54 + +loop.exit64: ; preds = %loop.cond54 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a65, ptr align 16 @.__const.13, i32 20, i1 false) + store i64 0, ptr %.anon66, align 8 + br label %loop.cond67 + +loop.cond67: ; preds = %loop.body69, %loop.exit64 + %62 = load i64, ptr %.anon66, align 8 + %gt68 = icmp ugt i64 5, %62 + br i1 %gt68, label %loop.body69, label %loop.exit77 + +loop.body69: ; preds = %loop.cond67 + %63 = load i64, ptr %.anon66, align 8 + store i64 %63, ptr %i70, align 8 + %64 = load i64, ptr %.anon66, align 8 + %ptroffset72 = getelementptr inbounds [4 x i8], ptr %a65, i64 %64 + %65 = load i32, ptr %ptroffset72, align 4 + store i32 %65, ptr %x71, align 4 + %66 = insertvalue %any undef, ptr %i70, 0 + %67 = insertvalue %any %66, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %67, ptr %varargslots73, align 16 + %68 = insertvalue %any undef, ptr %x71, 0 + %69 = insertvalue %any %68, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd74 = getelementptr inbounds i8, ptr %varargslots73, i64 16 + store %any %69, ptr %ptradd74, align 16 + %70 = call i64 @std.io.printfn(ptr %retparam75, ptr @.str.14, i64 8, ptr %varargslots73, i64 2) + %71 = load i64, ptr %.anon66, align 8 + %addnuw76 = add nuw i64 %71, 1 + store i64 %addnuw76, ptr %.anon66, align 8 + br label %loop.cond67 + +loop.exit77: ; preds = %loop.cond67 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a78, ptr align 16 @.__const.15, i32 32, i1 false) + store i64 0, ptr %.anon79, align 8 + br label %loop.cond80 + +loop.cond80: ; preds = %loop.body82, %loop.exit77 + %72 = load i64, ptr %.anon79, align 8 + %gt81 = icmp ugt i64 8, %72 + br i1 %gt81, label %loop.body82, label %loop.exit90 + +loop.body82: ; preds = %loop.cond80 + %73 = load i64, ptr %.anon79, align 8 + store i64 %73, ptr %i83, align 8 + %74 = load i64, ptr %.anon79, align 8 + %ptroffset85 = getelementptr inbounds [4 x i8], ptr %a78, i64 %74 + %75 = load i32, ptr %ptroffset85, align 4 + store i32 %75, ptr %x84, align 4 + %76 = insertvalue %any undef, ptr %i83, 0 + %77 = insertvalue %any %76, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %77, ptr %varargslots86, align 16 + %78 = insertvalue %any undef, ptr %x84, 0 + %79 = insertvalue %any %78, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd87 = getelementptr inbounds i8, ptr %varargslots86, i64 16 + store %any %79, ptr %ptradd87, align 16 + %80 = call i64 @std.io.printfn(ptr %retparam88, ptr @.str.16, i64 8, ptr %varargslots86, i64 2) + %81 = load i64, ptr %.anon79, align 8 + %addnuw89 = add nuw i64 %81, 1 + store i64 %addnuw89, ptr %.anon79, align 8 + br label %loop.cond80 + +loop.exit90: ; preds = %loop.cond80 call void @llvm.memcpy.p0.p0.i32(ptr align 16 %b, ptr align 16 @.__const.17, i32 28, i1 false) - store i64 0, ptr %.anon93, align 8 - br label %loop.cond94 -loop.cond94: ; preds = %loop.body96, %loop.exit92 - %84 = load i64, ptr %.anon93, align 8 - %gt95 = icmp ugt i64 7, %84 - br i1 %gt95, label %loop.body96, label %loop.exit104 -loop.body96: ; preds = %loop.cond94 - %85 = load i64, ptr %.anon93, align 8 - store i64 %85, ptr %i97, align 8 - %86 = load i64, ptr %.anon93, align 8 - %ptroffset99 = getelementptr inbounds [4 x i8], ptr %b, i64 %86 - %87 = load i32, ptr %ptroffset99, align 4 - store i32 %87, ptr %x98, align 4 - %88 = insertvalue %any undef, ptr %i97, 0 - %89 = insertvalue %any %88, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %89, ptr %varargslots100, align 16 - %90 = insertvalue %any undef, ptr %x98, 0 - %91 = insertvalue %any %90, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd101 = getelementptr inbounds i8, ptr %varargslots100, i64 16 - store %any %91, ptr %ptradd101, align 16 - %92 = call i64 @std.io.printfn(ptr %retparam102, ptr @.str.18, i64 8, ptr %varargslots100, i64 2) - %93 = load i64, ptr %.anon93, align 8 - %addnuw103 = add nuw i64 %93, 1 - store i64 %addnuw103, ptr %.anon93, align 8 - br label %loop.cond94 -loop.exit104: ; preds = %loop.cond94 + store i64 0, ptr %.anon91, align 8 + br label %loop.cond92 + +loop.cond92: ; preds = %loop.body94, %loop.exit90 + %82 = load i64, ptr %.anon91, align 8 + %gt93 = icmp ugt i64 7, %82 + br i1 %gt93, label %loop.body94, label %loop.exit102 + +loop.body94: ; preds = %loop.cond92 + %83 = load i64, ptr %.anon91, align 8 + store i64 %83, ptr %i95, align 8 + %84 = load i64, ptr %.anon91, align 8 + %ptroffset97 = getelementptr inbounds [4 x i8], ptr %b, i64 %84 + %85 = load i32, ptr %ptroffset97, align 4 + store i32 %85, ptr %x96, align 4 + %86 = insertvalue %any undef, ptr %i95, 0 + %87 = insertvalue %any %86, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %87, ptr %varargslots98, align 16 + %88 = insertvalue %any undef, ptr %x96, 0 + %89 = insertvalue %any %88, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd99 = getelementptr inbounds i8, ptr %varargslots98, i64 16 + store %any %89, ptr %ptradd99, align 16 + %90 = call i64 @std.io.printfn(ptr %retparam100, ptr @.str.18, i64 8, ptr %varargslots98, i64 2) + %91 = load i64, ptr %.anon91, align 8 + %addnuw101 = add nuw i64 %91, 1 + store i64 %addnuw101, ptr %.anon91, align 8 + br label %loop.cond92 + +loop.exit102: ; preds = %loop.cond92 call void @llvm.memcpy.p0.p0.i32(ptr align 16 %c, ptr align 16 @.__const.19, i32 32, i1 false) - store i64 0, ptr %.anon105, align 8 - br label %loop.cond106 -loop.cond106: ; preds = %loop.body108, %loop.exit104 - %94 = load i64, ptr %.anon105, align 8 - %gt107 = icmp ugt i64 8, %94 - br i1 %gt107, label %loop.body108, label %loop.exit116 -loop.body108: ; preds = %loop.cond106 - %95 = load i64, ptr %.anon105, align 8 - store i64 %95, ptr %i109, align 8 - %96 = load i64, ptr %.anon105, align 8 - %ptroffset111 = getelementptr inbounds [4 x i8], ptr %c, i64 %96 - %97 = load i32, ptr %ptroffset111, align 4 - store i32 %97, ptr %x110, align 4 - %98 = insertvalue %any undef, ptr %i109, 0 - %99 = insertvalue %any %98, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %99, ptr %varargslots112, align 16 - %100 = insertvalue %any undef, ptr %x110, 0 - %101 = insertvalue %any %100, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd113 = getelementptr inbounds i8, ptr %varargslots112, i64 16 - store %any %101, ptr %ptradd113, align 16 - %102 = call i64 @std.io.printfn(ptr %retparam114, ptr @.str.20, i64 9, ptr %varargslots112, i64 2) - %103 = load i64, ptr %.anon105, align 8 - %addnuw115 = add nuw i64 %103, 1 - store i64 %addnuw115, ptr %.anon105, align 8 - br label %loop.cond106 -loop.exit116: ; preds = %loop.cond106 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a117, ptr align 16 @.__const.21, i32 24, i1 false) - store i64 0, ptr %.anon118, align 8 - br label %loop.cond119 -loop.cond119: ; preds = %loop.body121, %loop.exit116 - %104 = load i64, ptr %.anon118, align 8 - %gt120 = icmp ugt i64 6, %104 - br i1 %gt120, label %loop.body121, label %loop.exit129 -loop.body121: ; preds = %loop.cond119 - %105 = load i64, ptr %.anon118, align 8 - store i64 %105, ptr %i122, align 8 - %106 = load i64, ptr %.anon118, align 8 - %ptroffset124 = getelementptr inbounds [4 x i8], ptr %a117, i64 %106 - %107 = load i32, ptr %ptroffset124, align 4 - store i32 %107, ptr %x123, align 4 - %108 = insertvalue %any undef, ptr %i122, 0 - %109 = insertvalue %any %108, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - store %any %109, ptr %varargslots125, align 16 - %110 = insertvalue %any undef, ptr %x123, 0 - %111 = insertvalue %any %110, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %ptradd126 = getelementptr inbounds i8, ptr %varargslots125, i64 16 - store %any %111, ptr %ptradd126, align 16 - %112 = call i64 @std.io.printfn(ptr %retparam127, ptr @.str.22, i64 6, ptr %varargslots125, i64 2) - %113 = load i64, ptr %.anon118, align 8 - %addnuw128 = add nuw i64 %113, 1 - store i64 %addnuw128, ptr %.anon118, align 8 - br label %loop.cond119 -loop.exit129: ; preds = %loop.cond119 + store i64 0, ptr %.anon103, align 8 + br label %loop.cond104 + +loop.cond104: ; preds = %loop.body106, %loop.exit102 + %92 = load i64, ptr %.anon103, align 8 + %gt105 = icmp ugt i64 8, %92 + br i1 %gt105, label %loop.body106, label %loop.exit114 + +loop.body106: ; preds = %loop.cond104 + %93 = load i64, ptr %.anon103, align 8 + store i64 %93, ptr %i107, align 8 + %94 = load i64, ptr %.anon103, align 8 + %ptroffset109 = getelementptr inbounds [4 x i8], ptr %c, i64 %94 + %95 = load i32, ptr %ptroffset109, align 4 + store i32 %95, ptr %x108, align 4 + %96 = insertvalue %any undef, ptr %i107, 0 + %97 = insertvalue %any %96, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %97, ptr %varargslots110, align 16 + %98 = insertvalue %any undef, ptr %x108, 0 + %99 = insertvalue %any %98, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd111 = getelementptr inbounds i8, ptr %varargslots110, i64 16 + store %any %99, ptr %ptradd111, align 16 + %100 = call i64 @std.io.printfn(ptr %retparam112, ptr @.str.20, i64 9, ptr %varargslots110, i64 2) + %101 = load i64, ptr %.anon103, align 8 + %addnuw113 = add nuw i64 %101, 1 + store i64 %addnuw113, ptr %.anon103, align 8 + br label %loop.cond104 + +loop.exit114: ; preds = %loop.cond104 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a115, ptr align 16 @.__const.21, i32 24, i1 false) + store i64 0, ptr %.anon116, align 8 + br label %loop.cond117 + +loop.cond117: ; preds = %loop.body119, %loop.exit114 + %102 = load i64, ptr %.anon116, align 8 + %gt118 = icmp ugt i64 6, %102 + br i1 %gt118, label %loop.body119, label %loop.exit127 + +loop.body119: ; preds = %loop.cond117 + %103 = load i64, ptr %.anon116, align 8 + store i64 %103, ptr %i120, align 8 + %104 = load i64, ptr %.anon116, align 8 + %ptroffset122 = getelementptr inbounds [4 x i8], ptr %a115, i64 %104 + %105 = load i32, ptr %ptroffset122, align 4 + store i32 %105, ptr %x121, align 4 + %106 = insertvalue %any undef, ptr %i120, 0 + %107 = insertvalue %any %106, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 + store %any %107, ptr %varargslots123, align 16 + %108 = insertvalue %any undef, ptr %x121, 0 + %109 = insertvalue %any %108, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %ptradd124 = getelementptr inbounds i8, ptr %varargslots123, i64 16 + store %any %109, ptr %ptradd124, align 16 + %110 = call i64 @std.io.printfn(ptr %retparam125, ptr @.str.22, i64 6, ptr %varargslots123, i64 2) + %111 = load i64, ptr %.anon116, align 8 + %addnuw126 = add nuw i64 %111, 1 + store i64 %addnuw126, ptr %.anon116, align 8 + br label %loop.cond117 + +loop.exit127: ; preds = %loop.cond117 ret void } diff --git a/test/test_suite/methods/operator_assign_mutate.c3t b/test/test_suite/methods/operator_assign_mutate.c3t index 3b7535e71..0d9a1ac60 100644 --- a/test/test_suite/methods/operator_assign_mutate.c3t +++ b/test/test_suite/methods/operator_assign_mutate.c3t @@ -28,16 +28,10 @@ fn void main() { define void @test.main() #0 { entry: %z = alloca %Foo, align 4 - %.anon = alloca ptr, align 8 - %.anon3 = alloca i32, align 4 - %.anon4 = alloca i32, align 4 + %.anon = alloca i32, align 4 %coerce = alloca %Foo, align 8 - %.anon6 = alloca i32, align 4 - %.anon9 = alloca ptr, align 8 - %.anon10 = alloca i32, align 4 - %.anon11 = alloca i32, align 4 - %coerce13 = alloca %Foo, align 8 - %.anon17 = alloca i32, align 4 + %.anon5 = alloca i32, align 4 + %coerce6 = alloca %Foo, align 8 call void @"std_collections_list$long$.List.push"(ptr @test.stones, i64 1) #2 call void @"std_collections_list$long$.List.push"(ptr @test.stones, i64 100) #2 %0 = call ptr @"std_collections_list$long$.List.get_ref"(ptr @test.stones, i64 0) #2 @@ -57,45 +51,27 @@ entry: store i32 0, ptr %ptradd, align 4 %ptradd2 = getelementptr inbounds i8, ptr %z, i64 8 store i32 0, ptr %ptradd2, align 4 - store ptr %z, ptr %.anon, align 8 - store i32 1, ptr %.anon3, align 4 - %6 = load ptr, ptr %.anon, align 8 - %7 = load i32, ptr %.anon3, align 4 - %sext = sext i32 %7 to i64 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %coerce, ptr align 4 %6, i32 12, i1 false) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %coerce, ptr align 4 %z, i32 12, i1 false) %lo = load i64, ptr %coerce, align 8 - %ptradd5 = getelementptr inbounds i8, ptr %coerce, i64 8 - %hi = load i32, ptr %ptradd5, align 8 - %8 = call i32 @test.Foo.get(i64 %lo, i32 %hi, i64 %sext) - store i32 %8, ptr %.anon4, align 4 - %9 = load i32, ptr %.anon4, align 4 - %add7 = add i32 %9, 5 - store i32 %add7, ptr %.anon4, align 4 - store i32 %add7, ptr %.anon6, align 4 - %10 = load i32, ptr %.anon3, align 4 - %sext8 = sext i32 %10 to i64 - %11 = load ptr, ptr %.anon, align 8 - %12 = load i32, ptr %.anon4, align 4 - call void @test.Foo.set(ptr %11, i64 %sext8, i32 %12) - store ptr %z, ptr %.anon9, align 8 - store i32 1, ptr %.anon10, align 4 - %13 = load ptr, ptr %.anon9, align 8 - %14 = load i32, ptr %.anon10, align 4 - %sext12 = sext i32 %14 to i64 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %coerce13, ptr align 4 %13, i32 12, i1 false) - %lo14 = load i64, ptr %coerce13, align 8 - %ptradd15 = getelementptr inbounds i8, ptr %coerce13, i64 8 - %hi16 = load i32, ptr %ptradd15, align 8 - %15 = call i32 @test.Foo.get(i64 %lo14, i32 %hi16, i64 %sext12) - store i32 %15, ptr %.anon11, align 4 - %16 = load i32, ptr %.anon11, align 4 - %mul18 = mul i32 %16, 3 - store i32 %mul18, ptr %.anon11, align 4 - store i32 %mul18, ptr %.anon17, align 4 - %17 = load i32, ptr %.anon10, align 4 - %sext19 = sext i32 %17 to i64 - %18 = load ptr, ptr %.anon9, align 8 - %19 = load i32, ptr %.anon11, align 4 - call void @test.Foo.set(ptr %18, i64 %sext19, i32 %19) + %ptradd3 = getelementptr inbounds i8, ptr %coerce, i64 8 + %hi = load i32, ptr %ptradd3, align 8 + %6 = call i32 @test.Foo.get(i64 %lo, i32 %hi, i64 1) + store i32 %6, ptr %.anon, align 4 + %7 = load i32, ptr %.anon, align 4 + %add4 = add i32 %7, 5 + store i32 %add4, ptr %.anon, align 4 + %8 = load i32, ptr %.anon, align 4 + call void @test.Foo.set(ptr %z, i64 1, i32 %8) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %coerce6, ptr align 4 %z, i32 12, i1 false) + %lo7 = load i64, ptr %coerce6, align 8 + %ptradd8 = getelementptr inbounds i8, ptr %coerce6, i64 8 + %hi9 = load i32, ptr %ptradd8, align 8 + %9 = call i32 @test.Foo.get(i64 %lo7, i32 %hi9, i64 1) + store i32 %9, ptr %.anon5, align 4 + %10 = load i32, ptr %.anon5, align 4 + %mul10 = mul i32 %10, 3 + store i32 %mul10, ptr %.anon5, align 4 + %11 = load i32, ptr %.anon5, align 4 + call void @test.Foo.set(ptr %z, i64 1, i32 %11) ret void } diff --git a/test/test_suite/methods/operator_inc.c3t b/test/test_suite/methods/operator_inc.c3t index 586d68c2a..ffb18b837 100644 --- a/test/test_suite/methods/operator_inc.c3t +++ b/test/test_suite/methods/operator_inc.c3t @@ -36,30 +36,17 @@ entry: define void @test.main() #0 { entry: %x = alloca i32, align 4 - %.anon = alloca ptr, align 8 - %.anon1 = alloca i32, align 4 - %.anon2 = alloca i32, align 4 + %.anon = alloca i32, align 4 %indirectarg = alloca %Foo, align 8 - %.anon3 = alloca i32, align 4 store i32 100, ptr getelementptr inbounds (i8, ptr @test.m, i64 12), align 4 - store ptr @test.m, ptr %.anon, align 8 - store i32 3, ptr %.anon1, align 4 - %0 = load ptr, ptr %.anon, align 8 - %1 = load i32, ptr %.anon1, align 4 - %sext = sext i32 %1 to i64 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 4 %0, i32 20, i1 false) - %2 = call i32 @test.Foo.get(ptr byval(%Foo) align 8 %indirectarg, i64 %sext) - store i32 %2, ptr %.anon2, align 4 - %3 = load i32, ptr %.anon2, align 4 - %sub = sub i32 %3, 1 - store i32 %sub, ptr %.anon2, align 4 - store i32 %3, ptr %.anon3, align 4 - %4 = load i32, ptr %.anon1, align 4 - %sext4 = sext i32 %4 to i64 - %5 = load ptr, ptr %.anon, align 8 - %6 = load i32, ptr %.anon2, align 4 - call void @test.Foo.set(ptr %5, i64 %sext4, i32 %6) - %7 = load i32, ptr %.anon3, align 4 - store i32 %7, ptr %x, align 4 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 4 @test.m, i32 20, i1 false) + %0 = call i32 @test.Foo.get(ptr byval(%Foo) align 8 %indirectarg, i64 3) + store i32 %0, ptr %.anon, align 4 + %1 = load i32, ptr %.anon, align 4 + %sub = sub i32 %1, 1 + store i32 %sub, ptr %.anon, align 4 + %2 = load i32, ptr %.anon, align 4 + call void @test.Foo.set(ptr @test.m, i64 3, i32 %2) + store i32 %1, ptr %x, align 4 ret void } diff --git a/test/test_suite/statements/comparison_widening.c3t b/test/test_suite/statements/comparison_widening.c3t index d0d88a2e6..0fb2b4fa8 100644 --- a/test/test_suite/statements/comparison_widening.c3t +++ b/test/test_suite/statements/comparison_widening.c3t @@ -16,7 +16,6 @@ entry: %b = alloca i32, align 4 %c = alloca i8, align 1 %d = alloca i32, align 4 - %.anon = alloca i32, align 4 store i8 1, ptr %a, align 1 store i32 2, ptr %b, align 4 %0 = load i32, ptr %b, align 4 @@ -28,19 +27,17 @@ entry: %ternary = select i1 %siui-gt, i8 1, i8 0 store i8 %ternary, ptr %c, align 1 %2 = load i32, ptr %b, align 4 - store i32 %2, ptr %.anon, align 4 %i2b = icmp ne i32 %2, 0 br i1 %i2b, label %cond.lhs, label %cond.rhs cond.lhs: ; preds = %entry - %3 = load i32, ptr %.anon, align 4 br label %cond.phi cond.rhs: ; preds = %entry br label %cond.phi cond.phi: ; preds = %cond.rhs, %cond.lhs - %val = phi i32 [ %3, %cond.lhs ], [ 1, %cond.rhs ] + %val = phi i32 [ %2, %cond.lhs ], [ 1, %cond.rhs ] store i32 %val, ptr %d, align 4 ret void } \ No newline at end of file diff --git a/test/test_suite/statements/custom_foreach_with_ref.c3t b/test/test_suite/statements/custom_foreach_with_ref.c3t index 37c4db08b..6fd71a8fe 100644 --- a/test/test_suite/statements/custom_foreach_with_ref.c3t +++ b/test/test_suite/statements/custom_foreach_with_ref.c3t @@ -127,46 +127,39 @@ entry: define void @foo.main() #0 { entry: %x = alloca %Foo, align 4 - %.anon = alloca ptr, align 8 - %.anon2 = alloca i32, align 4 - %.anon3 = alloca i32, align 4 + %.anon = alloca i32, align 4 %i = alloca i32, align 4 %y = alloca i32, align 4 %a = alloca i32, align 4 - %.anon4 = alloca i32, align 4 - %.anon5 = alloca i32, align 4 - %i9 = alloca i32, align 4 - %y10 = alloca ptr, align 8 - %a11 = alloca i32, align 4 - %.anon16 = alloca i32, align 4 - %.anon17 = alloca i32, align 4 - %i21 = alloca i32, align 4 - %y22 = alloca i32, align 4 - %a23 = alloca i32, align 4 - %.anon28 = alloca i32, align 4 - %.anon29 = alloca i32, align 4 - %i33 = alloca i32, align 4 - %y34 = alloca i32, align 4 - %a35 = alloca i32, align 4 - %.anon40 = alloca i32, align 4 - %.anon41 = alloca i32, align 4 - %i45 = alloca i32, align 4 - %y46 = alloca i32, align 4 - %a47 = alloca i32, align 4 - %.anon53 = alloca [5 x i32], align 16 - %.anon54 = alloca i64, align 8 - %i57 = alloca i64, align 8 - %y58 = alloca i32, align 4 - %.anon62 = alloca [5 x i32], align 16 - %.anon63 = alloca i64, align 8 - %i67 = alloca i64, align 8 - %y68 = alloca i32, align 4 - %.anon72 = alloca ptr, align 8 + %.anon2 = alloca i32, align 4 + %i6 = alloca i32, align 4 + %y7 = alloca ptr, align 8 + %a8 = alloca i32, align 4 + %.anon13 = alloca i32, align 4 + %i17 = alloca i32, align 4 + %y18 = alloca i32, align 4 + %a19 = alloca i32, align 4 + %.anon24 = alloca i32, align 4 + %i28 = alloca i32, align 4 + %y29 = alloca i32, align 4 + %a30 = alloca i32, align 4 + %.anon35 = alloca i32, align 4 + %i39 = alloca i32, align 4 + %y40 = alloca i32, align 4 + %a41 = alloca i32, align 4 + %.anon47 = alloca [5 x i32], align 16 + %.anon48 = alloca i64, align 8 + %i51 = alloca i64, align 8 + %y52 = alloca i32, align 4 + %.anon56 = alloca [5 x i32], align 16 + %.anon57 = alloca i64, align 8 + %i61 = alloca i64, align 8 + %y62 = alloca i32, align 4 %sretparam = alloca [5 x i32], align 4 - %.anon73 = alloca i64, align 8 - %i77 = alloca i64, align 8 - %y78 = alloca i32, align 4 - %y83 = alloca ptr, align 8 + %.anon66 = alloca i64, align 8 + %i70 = alloca i64, align 8 + %y71 = alloca i32, align 4 + %y76 = alloca ptr, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const.2, i32 12, i1 false) %ptradd = getelementptr inbounds i8, ptr %x, i64 4 %ptradd1 = getelementptr inbounds i8, ptr %x, i64 8 @@ -175,254 +168,239 @@ entry: %2 = load i32, ptr %ptradd1, align 4 call void (ptr, ...) @printf(ptr @.str.3, i32 %0, i32 %1, i32 %2) %3 = call ptr @foo.call(ptr %x) - store ptr %3, ptr %.anon, align 8 - %4 = load ptr, ptr %.anon, align 8 - store i32 3, ptr %.anon2, align 4 - store i32 0, ptr %.anon3, align 4 + store i32 0, ptr %.anon, align 4 br label %loop.cond loop.cond: ; preds = %loop.body, %entry - %5 = load i32, ptr %.anon3, align 4 - %6 = load i32, ptr %.anon2, align 4 - %lt = icmp slt i32 %5, %6 + %4 = load i32, ptr %.anon, align 4 + %lt = icmp slt i32 %4, 3 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %7 = load i32, ptr %.anon3, align 4 - store i32 %7, ptr %i, align 4 - %8 = load ptr, ptr %.anon, align 8 - %9 = load i32, ptr %.anon3, align 4 - store i32 %9, ptr %a, align 4 - %10 = load i32, ptr %a, align 4 - %sext = sext i32 %10 to i64 - %ptroffset = getelementptr inbounds [4 x i8], ptr %8, i64 %sext - %11 = load i32, ptr %ptroffset, align 4 - store i32 %11, ptr %y, align 4 - %12 = load i32, ptr %i, align 4 - %13 = load i32, ptr %y, align 4 - call void (ptr, ...) @printf(ptr @.str.4, i32 %12, i32 %13) - %14 = load i32, ptr %.anon3, align 4 - %addnsw = add nsw i32 %14, 1 - store i32 %addnsw, ptr %.anon3, align 4 + %5 = load i32, ptr %.anon, align 4 + store i32 %5, ptr %i, align 4 + %6 = load i32, ptr %.anon, align 4 + store i32 %6, ptr %a, align 4 + %7 = load i32, ptr %a, align 4 + %sext = sext i32 %7 to i64 + %ptroffset = getelementptr inbounds [4 x i8], ptr %3, i64 %sext + %8 = load i32, ptr %ptroffset, align 4 + store i32 %8, ptr %y, align 4 + %9 = load i32, ptr %i, align 4 + %10 = load i32, ptr %y, align 4 + call void (ptr, ...) @printf(ptr @.str.4, i32 %9, i32 %10) + %11 = load i32, ptr %.anon, align 4 + %addnsw = add nsw i32 %11, 1 + store i32 %addnsw, ptr %.anon, align 4 br label %loop.cond loop.exit: ; preds = %loop.cond - store i32 3, ptr %.anon4, align 4 - store i32 0, ptr %.anon5, align 4 - br label %loop.cond6 - -loop.cond6: ; preds = %loop.body8, %loop.exit - %15 = load i32, ptr %.anon5, align 4 - %16 = load i32, ptr %.anon4, align 4 - %lt7 = icmp slt i32 %15, %16 - br i1 %lt7, label %loop.body8, label %loop.exit15 - -loop.body8: ; preds = %loop.cond6 - %17 = load i32, ptr %.anon5, align 4 - store i32 %17, ptr %i9, align 4 - %18 = load i32, ptr %.anon5, align 4 - store i32 %18, ptr %a11, align 4 - %19 = load i32, ptr %a11, align 4 - %sext12 = sext i32 %19 to i64 - %ptroffset13 = getelementptr inbounds [4 x i8], ptr %x, i64 %sext12 - store ptr %ptroffset13, ptr %y10, align 8 - %20 = load ptr, ptr %y10, align 8 - %21 = load i32, ptr %20, align 4 - %add = add i32 %21, 1 - store i32 %add, ptr %20, align 4 - %22 = load ptr, ptr %y10, align 8 - %23 = load i32, ptr %i9, align 4 - %24 = load i32, ptr %22, align 4 - call void (ptr, ...) @printf(ptr @.str.5, i32 %23, i32 %24) - %25 = load i32, ptr %.anon5, align 4 - %addnsw14 = add nsw i32 %25, 1 - store i32 %addnsw14, ptr %.anon5, align 4 - br label %loop.cond6 - -loop.exit15: ; preds = %loop.cond6 - store i32 3, ptr %.anon16, align 4 - store i32 0, ptr %.anon17, align 4 - br label %loop.cond18 - -loop.cond18: ; preds = %loop.body20, %loop.exit15 - %26 = load i32, ptr %.anon17, align 4 - %27 = load i32, ptr %.anon16, align 4 - %lt19 = icmp slt i32 %26, %27 - br i1 %lt19, label %loop.body20, label %loop.exit27 - -loop.body20: ; preds = %loop.cond18 - %28 = load i32, ptr %.anon17, align 4 - store i32 %28, ptr %i21, align 4 - %29 = load i32, ptr %.anon17, align 4 - store i32 %29, ptr %a23, align 4 - %30 = load i32, ptr %a23, align 4 - %sext24 = sext i32 %30 to i64 - %ptroffset25 = getelementptr inbounds [4 x i8], ptr %x, i64 %sext24 - %31 = load i32, ptr %ptroffset25, align 4 - store i32 %31, ptr %y22, align 4 - %32 = load i32, ptr %i21, align 4 - %33 = load i32, ptr %y22, align 4 - call void (ptr, ...) @printf(ptr @.str.6, i32 %32, i32 %33) - %34 = load i32, ptr %.anon17, align 4 - %addnsw26 = add nsw i32 %34, 1 - store i32 %addnsw26, ptr %.anon17, align 4 - br label %loop.cond18 - -loop.exit27: ; preds = %loop.cond18 - store i32 3, ptr %.anon28, align 4 - store i32 0, ptr %.anon29, align 4 - br label %loop.cond30 - -loop.cond30: ; preds = %loop.body32, %loop.exit27 - %35 = load i32, ptr %.anon29, align 4 - %36 = load i32, ptr %.anon28, align 4 - %lt31 = icmp slt i32 %35, %36 - br i1 %lt31, label %loop.body32, label %loop.exit39 - -loop.body32: ; preds = %loop.cond30 - %37 = load i32, ptr %.anon29, align 4 - store i32 %37, ptr %i33, align 4 - %38 = load i32, ptr %.anon29, align 4 - store i32 %38, ptr %a35, align 4 - %39 = load i32, ptr %a35, align 4 - %sext36 = sext i32 %39 to i64 - %ptroffset37 = getelementptr inbounds [4 x i8], ptr %x, i64 %sext36 - %40 = load i32, ptr %ptroffset37, align 4 - store i32 %40, ptr %y34, align 4 - %41 = load i32, ptr %i33, align 4 - %42 = load i32, ptr %y34, align 4 - call void (ptr, ...) @printf(ptr @.str.7, i32 %41, i32 %42) - %43 = load i32, ptr %.anon29, align 4 - %addnsw38 = add nsw i32 %43, 1 - store i32 %addnsw38, ptr %.anon29, align 4 - br label %loop.cond30 - -loop.exit39: ; preds = %loop.cond30 - store i32 3, ptr %.anon40, align 4 - store i32 0, ptr %.anon41, align 4 - br label %loop.cond42 - -loop.cond42: ; preds = %loop.body44, %loop.exit39 - %44 = load i32, ptr %.anon41, align 4 - %45 = load i32, ptr %.anon40, align 4 - %lt43 = icmp slt i32 %44, %45 - br i1 %lt43, label %loop.body44, label %loop.exit52 - -loop.body44: ; preds = %loop.cond42 - %46 = load i32, ptr %.anon41, align 4 - store i32 %46, ptr %i45, align 4 - %47 = load i32, ptr %.anon41, align 4 - store i32 %47, ptr %a47, align 4 - %48 = load i32, ptr %a47, align 4 - %sext48 = sext i32 %48 to i64 - %ptroffset49 = getelementptr inbounds [4 x i8], ptr %x, i64 %sext48 - %49 = load i32, ptr %ptroffset49, align 4 - store i32 %49, ptr %y46, align 4 - %50 = load i32, ptr %i45, align 4 - %51 = load i32, ptr %y46, align 4 - call void (ptr, ...) @printf(ptr @.str.8, i32 %50, i32 %51) - %52 = load i32, ptr %i45, align 4 - %add50 = add i32 %52, 1 - store i32 %add50, ptr %i45, align 4 - %53 = load i32, ptr %.anon41, align 4 - %addnsw51 = add nsw i32 %53, 1 - store i32 %addnsw51, ptr %.anon41, align 4 - br label %loop.cond42 - -loop.exit52: ; preds = %loop.cond42 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %.anon53, ptr align 16 @.__const.9, i32 20, i1 false) - store i64 0, ptr %.anon54, align 8 - br label %loop.cond55 - -loop.cond55: ; preds = %loop.body56, %loop.exit52 - %54 = load i64, ptr %.anon54, align 8 - %gt = icmp ugt i64 5, %54 - br i1 %gt, label %loop.body56, label %loop.exit61 - -loop.body56: ; preds = %loop.cond55 - %55 = load i64, ptr %.anon54, align 8 - store i64 %55, ptr %i57, align 8 - %56 = load i64, ptr %.anon54, align 8 - %ptroffset59 = getelementptr inbounds [4 x i8], ptr %.anon53, i64 %56 - %57 = load i32, ptr %ptroffset59, align 4 - store i32 %57, ptr %y58, align 4 - %58 = load i64, ptr %i57, align 8 - %59 = load i32, ptr %y58, align 4 - call void (ptr, ...) @printf(ptr @.str.10, i64 %58, i32 %59) - %60 = load i64, ptr %i57, align 8 - %add60 = add i64 %60, 1 - store i64 %add60, ptr %i57, align 8 - %61 = load i64, ptr %.anon54, align 8 - %addnuw = add nuw i64 %61, 1 - store i64 %addnuw, ptr %.anon54, align 8 - br label %loop.cond55 - -loop.exit61: ; preds = %loop.cond55 - call void @foo.getFields(ptr sret([5 x i32]) align 4 %.anon62) - store i64 0, ptr %.anon63, align 8 - br label %loop.cond64 - -loop.cond64: ; preds = %loop.body66, %loop.exit61 - %62 = load i64, ptr %.anon63, align 8 - %gt65 = icmp ugt i64 5, %62 - br i1 %gt65, label %loop.body66, label %loop.exit71 - -loop.body66: ; preds = %loop.cond64 - %63 = load i64, ptr %.anon63, align 8 - store i64 %63, ptr %i67, align 8 - %64 = load i64, ptr %.anon63, align 8 - %ptroffset69 = getelementptr inbounds [4 x i8], ptr %.anon62, i64 %64 - %65 = load i32, ptr %ptroffset69, align 4 - store i32 %65, ptr %y68, align 4 - %66 = load i64, ptr %i67, align 8 - %67 = load i32, ptr %y68, align 4 - call void (ptr, ...) @printf(ptr @.str.11, i64 %66, i32 %67) - %68 = load i64, ptr %.anon63, align 8 - %addnuw70 = add nuw i64 %68, 1 - store i64 %addnuw70, ptr %.anon63, align 8 - br label %loop.cond64 - -loop.exit71: ; preds = %loop.cond64 + store i32 0, ptr %.anon2, align 4 + br label %loop.cond3 + +loop.cond3: ; preds = %loop.body5, %loop.exit + %12 = load i32, ptr %.anon2, align 4 + %lt4 = icmp slt i32 %12, 3 + br i1 %lt4, label %loop.body5, label %loop.exit12 + +loop.body5: ; preds = %loop.cond3 + %13 = load i32, ptr %.anon2, align 4 + store i32 %13, ptr %i6, align 4 + %14 = load i32, ptr %.anon2, align 4 + store i32 %14, ptr %a8, align 4 + %15 = load i32, ptr %a8, align 4 + %sext9 = sext i32 %15 to i64 + %ptroffset10 = getelementptr inbounds [4 x i8], ptr %x, i64 %sext9 + store ptr %ptroffset10, ptr %y7, align 8 + %16 = load ptr, ptr %y7, align 8 + %17 = load i32, ptr %16, align 4 + %add = add i32 %17, 1 + store i32 %add, ptr %16, align 4 + %18 = load ptr, ptr %y7, align 8 + %19 = load i32, ptr %i6, align 4 + %20 = load i32, ptr %18, align 4 + call void (ptr, ...) @printf(ptr @.str.5, i32 %19, i32 %20) + %21 = load i32, ptr %.anon2, align 4 + %addnsw11 = add nsw i32 %21, 1 + store i32 %addnsw11, ptr %.anon2, align 4 + br label %loop.cond3 + +loop.exit12: ; preds = %loop.cond3 + store i32 0, ptr %.anon13, align 4 + br label %loop.cond14 + +loop.cond14: ; preds = %loop.body16, %loop.exit12 + %22 = load i32, ptr %.anon13, align 4 + %lt15 = icmp slt i32 %22, 3 + br i1 %lt15, label %loop.body16, label %loop.exit23 + +loop.body16: ; preds = %loop.cond14 + %23 = load i32, ptr %.anon13, align 4 + store i32 %23, ptr %i17, align 4 + %24 = load i32, ptr %.anon13, align 4 + store i32 %24, ptr %a19, align 4 + %25 = load i32, ptr %a19, align 4 + %sext20 = sext i32 %25 to i64 + %ptroffset21 = getelementptr inbounds [4 x i8], ptr %x, i64 %sext20 + %26 = load i32, ptr %ptroffset21, align 4 + store i32 %26, ptr %y18, align 4 + %27 = load i32, ptr %i17, align 4 + %28 = load i32, ptr %y18, align 4 + call void (ptr, ...) @printf(ptr @.str.6, i32 %27, i32 %28) + %29 = load i32, ptr %.anon13, align 4 + %addnsw22 = add nsw i32 %29, 1 + store i32 %addnsw22, ptr %.anon13, align 4 + br label %loop.cond14 + +loop.exit23: ; preds = %loop.cond14 + store i32 0, ptr %.anon24, align 4 + br label %loop.cond25 + +loop.cond25: ; preds = %loop.body27, %loop.exit23 + %30 = load i32, ptr %.anon24, align 4 + %lt26 = icmp slt i32 %30, 3 + br i1 %lt26, label %loop.body27, label %loop.exit34 + +loop.body27: ; preds = %loop.cond25 + %31 = load i32, ptr %.anon24, align 4 + store i32 %31, ptr %i28, align 4 + %32 = load i32, ptr %.anon24, align 4 + store i32 %32, ptr %a30, align 4 + %33 = load i32, ptr %a30, align 4 + %sext31 = sext i32 %33 to i64 + %ptroffset32 = getelementptr inbounds [4 x i8], ptr %x, i64 %sext31 + %34 = load i32, ptr %ptroffset32, align 4 + store i32 %34, ptr %y29, align 4 + %35 = load i32, ptr %i28, align 4 + %36 = load i32, ptr %y29, align 4 + call void (ptr, ...) @printf(ptr @.str.7, i32 %35, i32 %36) + %37 = load i32, ptr %.anon24, align 4 + %addnsw33 = add nsw i32 %37, 1 + store i32 %addnsw33, ptr %.anon24, align 4 + br label %loop.cond25 + +loop.exit34: ; preds = %loop.cond25 + store i32 0, ptr %.anon35, align 4 + br label %loop.cond36 + +loop.cond36: ; preds = %loop.body38, %loop.exit34 + %38 = load i32, ptr %.anon35, align 4 + %lt37 = icmp slt i32 %38, 3 + br i1 %lt37, label %loop.body38, label %loop.exit46 + +loop.body38: ; preds = %loop.cond36 + %39 = load i32, ptr %.anon35, align 4 + store i32 %39, ptr %i39, align 4 + %40 = load i32, ptr %.anon35, align 4 + store i32 %40, ptr %a41, align 4 + %41 = load i32, ptr %a41, align 4 + %sext42 = sext i32 %41 to i64 + %ptroffset43 = getelementptr inbounds [4 x i8], ptr %x, i64 %sext42 + %42 = load i32, ptr %ptroffset43, align 4 + store i32 %42, ptr %y40, align 4 + %43 = load i32, ptr %i39, align 4 + %44 = load i32, ptr %y40, align 4 + call void (ptr, ...) @printf(ptr @.str.8, i32 %43, i32 %44) + %45 = load i32, ptr %i39, align 4 + %add44 = add i32 %45, 1 + store i32 %add44, ptr %i39, align 4 + %46 = load i32, ptr %.anon35, align 4 + %addnsw45 = add nsw i32 %46, 1 + store i32 %addnsw45, ptr %.anon35, align 4 + br label %loop.cond36 + +loop.exit46: ; preds = %loop.cond36 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %.anon47, ptr align 16 @.__const.9, i32 20, i1 false) + store i64 0, ptr %.anon48, align 8 + br label %loop.cond49 + +loop.cond49: ; preds = %loop.body50, %loop.exit46 + %47 = load i64, ptr %.anon48, align 8 + %gt = icmp ugt i64 5, %47 + br i1 %gt, label %loop.body50, label %loop.exit55 + +loop.body50: ; preds = %loop.cond49 + %48 = load i64, ptr %.anon48, align 8 + store i64 %48, ptr %i51, align 8 + %49 = load i64, ptr %.anon48, align 8 + %ptroffset53 = getelementptr inbounds [4 x i8], ptr %.anon47, i64 %49 + %50 = load i32, ptr %ptroffset53, align 4 + store i32 %50, ptr %y52, align 4 + %51 = load i64, ptr %i51, align 8 + %52 = load i32, ptr %y52, align 4 + call void (ptr, ...) @printf(ptr @.str.10, i64 %51, i32 %52) + %53 = load i64, ptr %i51, align 8 + %add54 = add i64 %53, 1 + store i64 %add54, ptr %i51, align 8 + %54 = load i64, ptr %.anon48, align 8 + %addnuw = add nuw i64 %54, 1 + store i64 %addnuw, ptr %.anon48, align 8 + br label %loop.cond49 + +loop.exit55: ; preds = %loop.cond49 + call void @foo.getFields(ptr sret([5 x i32]) align 4 %.anon56) + store i64 0, ptr %.anon57, align 8 + br label %loop.cond58 + +loop.cond58: ; preds = %loop.body60, %loop.exit55 + %55 = load i64, ptr %.anon57, align 8 + %gt59 = icmp ugt i64 5, %55 + br i1 %gt59, label %loop.body60, label %loop.exit65 + +loop.body60: ; preds = %loop.cond58 + %56 = load i64, ptr %.anon57, align 8 + store i64 %56, ptr %i61, align 8 + %57 = load i64, ptr %.anon57, align 8 + %ptroffset63 = getelementptr inbounds [4 x i8], ptr %.anon56, i64 %57 + %58 = load i32, ptr %ptroffset63, align 4 + store i32 %58, ptr %y62, align 4 + %59 = load i64, ptr %i61, align 8 + %60 = load i32, ptr %y62, align 4 + call void (ptr, ...) @printf(ptr @.str.11, i64 %59, i32 %60) + %61 = load i64, ptr %.anon57, align 8 + %addnuw64 = add nuw i64 %61, 1 + store i64 %addnuw64, ptr %.anon57, align 8 + br label %loop.cond58 + +loop.exit65: ; preds = %loop.cond58 call void @foo.getFields(ptr sret([5 x i32]) align 4 %sretparam) - store ptr %sretparam, ptr %.anon72, align 8 - store i64 0, ptr %.anon73, align 8 - br label %loop.cond74 - -loop.cond74: ; preds = %loop.body76, %loop.exit71 - %69 = load i64, ptr %.anon73, align 8 - %gt75 = icmp ugt i64 5, %69 - br i1 %gt75, label %loop.body76, label %loop.exit81 - -loop.body76: ; preds = %loop.cond74 - %70 = load i64, ptr %.anon73, align 8 - store i64 %70, ptr %i77, align 8 - %71 = load ptr, ptr %.anon72, align 8 - %72 = load i64, ptr %.anon73, align 8 - %ptroffset79 = getelementptr inbounds [4 x i8], ptr %71, i64 %72 - %73 = load i32, ptr %ptroffset79, align 4 - store i32 %73, ptr %y78, align 4 - %74 = load i64, ptr %i77, align 8 - %75 = load i32, ptr %y78, align 4 - call void (ptr, ...) @printf(ptr @.str.12, i64 %74, i32 %75) - %76 = load i64, ptr %.anon73, align 8 - %addnuw80 = add nuw i64 %76, 1 - store i64 %addnuw80, ptr %.anon73, align 8 - br label %loop.cond74 - -loop.exit81: ; preds = %loop.cond74 - %ptradd82 = getelementptr inbounds i8, ptr %x, i64 4 - %77 = load i32, ptr %x, align 4 - %78 = load i32, ptr %ptradd82, align 4 - call void (ptr, ...) @printf(ptr @.str.13, i32 %77, i32 %78) - %ptradd84 = getelementptr inbounds i8, ptr %x, i64 4 - store ptr %ptradd84, ptr %y83, align 8 - %79 = load ptr, ptr %y83, align 8 - %80 = load i32, ptr %79, align 4 - %add85 = add i32 %80, 1 - store i32 %add85, ptr %79, align 4 - %ptradd86 = getelementptr inbounds i8, ptr %x, i64 4 - %81 = load i32, ptr %x, align 4 - %82 = load i32, ptr %ptradd86, align 4 - call void (ptr, ...) @printf(ptr @.str.14, i32 %81, i32 %82) + store i64 0, ptr %.anon66, align 8 + br label %loop.cond67 + +loop.cond67: ; preds = %loop.body69, %loop.exit65 + %62 = load i64, ptr %.anon66, align 8 + %gt68 = icmp ugt i64 5, %62 + br i1 %gt68, label %loop.body69, label %loop.exit74 + +loop.body69: ; preds = %loop.cond67 + %63 = load i64, ptr %.anon66, align 8 + store i64 %63, ptr %i70, align 8 + %64 = load i64, ptr %.anon66, align 8 + %ptroffset72 = getelementptr inbounds [4 x i8], ptr %sretparam, i64 %64 + %65 = load i32, ptr %ptroffset72, align 4 + store i32 %65, ptr %y71, align 4 + %66 = load i64, ptr %i70, align 8 + %67 = load i32, ptr %y71, align 4 + call void (ptr, ...) @printf(ptr @.str.12, i64 %66, i32 %67) + %68 = load i64, ptr %.anon66, align 8 + %addnuw73 = add nuw i64 %68, 1 + store i64 %addnuw73, ptr %.anon66, align 8 + br label %loop.cond67 + +loop.exit74: ; preds = %loop.cond67 + %ptradd75 = getelementptr inbounds i8, ptr %x, i64 4 + %69 = load i32, ptr %x, align 4 + %70 = load i32, ptr %ptradd75, align 4 + call void (ptr, ...) @printf(ptr @.str.13, i32 %69, i32 %70) + %ptradd77 = getelementptr inbounds i8, ptr %x, i64 4 + store ptr %ptradd77, ptr %y76, align 8 + %71 = load ptr, ptr %y76, align 8 + %72 = load i32, ptr %71, align 4 + %add78 = add i32 %72, 1 + store i32 %add78, ptr %71, align 4 + %ptradd79 = getelementptr inbounds i8, ptr %x, i64 4 + %73 = load i32, ptr %x, align 4 + %74 = load i32, ptr %ptradd79, align 4 + call void (ptr, ...) @printf(ptr @.str.14, i32 %73, i32 %74) ret void } diff --git a/test/test_suite/statements/foreach_custom.c3t b/test/test_suite/statements/foreach_custom.c3t index 62eb9ea03..c8935ddac 100644 --- a/test/test_suite/statements/foreach_custom.c3t +++ b/test/test_suite/statements/foreach_custom.c3t @@ -39,7 +39,6 @@ entry: %i = alloca [3 x i32], align 4 %x = alloca %Foo, align 8 %.anon = alloca i64, align 8 - %.anon1 = alloca i64, align 8 %f = alloca i32, align 4 %index = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %i, ptr align 4 @.__const, i32 12, i1 false) @@ -48,32 +47,30 @@ entry: store %"int[]" %1, ptr %x, align 8 %ptradd = getelementptr inbounds i8, ptr %x, i64 8 %2 = load i64, ptr %ptradd, align 8 - store i64 %2, ptr %.anon, align 8 - store i64 0, ptr %.anon1, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %entry - %3 = load i64, ptr %.anon1, align 8 - %4 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %3, %4 + %3 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %3, %2 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %5 = load i64, ptr %.anon1, align 8 - store i64 %5, ptr %index, align 8 - %6 = load ptr, ptr %x, align 8 - %7 = load i64, ptr %index, align 8 - %ptroffset = getelementptr inbounds [4 x i8], ptr %6, i64 %7 - %8 = load i32, ptr %ptroffset, align 4 - store i32 %8, ptr %f, align 4 - %9 = load i32, ptr %f, align 4 - %10 = call i32 (ptr, ...) @printf(ptr @.str, i32 %9) - br label %loop.body2 + %4 = load i64, ptr %.anon, align 8 + store i64 %4, ptr %index, align 8 + %5 = load ptr, ptr %x, align 8 + %6 = load i64, ptr %index, align 8 + %ptroffset = getelementptr inbounds [4 x i8], ptr %5, i64 %6 + %7 = load i32, ptr %ptroffset, align 4 + store i32 %7, ptr %f, align 4 + %8 = load i32, ptr %f, align 4 + %9 = call i32 (ptr, ...) @printf(ptr @.str, i32 %8) + br label %loop.body1 -loop.body2: ; preds = %loop.body +loop.body1: ; preds = %loop.body br label %loop.exit -loop.exit: ; preds = %loop.body2, %loop.cond +loop.exit: ; preds = %loop.body1, %loop.cond ret void } diff --git a/test/test_suite/statements/foreach_custom_macro.c3t b/test/test_suite/statements/foreach_custom_macro.c3t index 827a8e69a..9d1086bf8 100644 --- a/test/test_suite/statements/foreach_custom_macro.c3t +++ b/test/test_suite/statements/foreach_custom_macro.c3t @@ -45,7 +45,6 @@ entry: %i = alloca [3 x i32], align 4 %x = alloca %Foo, align 8 %.anon = alloca i64, align 8 - %.anon1 = alloca i64, align 8 %f = alloca i32, align 4 %index = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %i, ptr align 4 @.__const, i32 12, i1 false) @@ -54,32 +53,30 @@ entry: store %"int[]" %1, ptr %x, align 8 %ptradd = getelementptr inbounds i8, ptr %x, i64 8 %2 = load i64, ptr %ptradd, align 8 - store i64 %2, ptr %.anon, align 8 - store i64 0, ptr %.anon1, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %entry - %3 = load i64, ptr %.anon1, align 8 - %4 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %3, %4 + %3 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %3, %2 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %5 = load i64, ptr %.anon1, align 8 - store i64 %5, ptr %index, align 8 - %6 = load ptr, ptr %x, align 8 - %7 = load i64, ptr %index, align 8 - %ptroffset = getelementptr inbounds [4 x i8], ptr %6, i64 %7 - %8 = load i32, ptr %ptroffset, align 4 - store i32 %8, ptr %f, align 4 - %9 = load i32, ptr %f, align 4 - %10 = call i32 (ptr, ...) @printf(ptr @.str, i32 %9) - br label %loop.body2 + %4 = load i64, ptr %.anon, align 8 + store i64 %4, ptr %index, align 8 + %5 = load ptr, ptr %x, align 8 + %6 = load i64, ptr %index, align 8 + %ptroffset = getelementptr inbounds [4 x i8], ptr %5, i64 %6 + %7 = load i32, ptr %ptroffset, align 4 + store i32 %7, ptr %f, align 4 + %8 = load i32, ptr %f, align 4 + %9 = call i32 (ptr, ...) @printf(ptr @.str, i32 %8) + br label %loop.body1 -loop.body2: ; preds = %loop.body +loop.body1: ; preds = %loop.body br label %loop.exit -loop.exit: ; preds = %loop.body2, %loop.cond +loop.exit: ; preds = %loop.body1, %loop.cond ret void } diff --git a/test/test_suite/statements/foreach_distinct_iterable.c3t b/test/test_suite/statements/foreach_distinct_iterable.c3t index 8cad8f6be..c69667fdb 100644 --- a/test/test_suite/statements/foreach_distinct_iterable.c3t +++ b/test/test_suite/statements/foreach_distinct_iterable.c3t @@ -23,14 +23,10 @@ fn int main() { /* #expect: test.ll -et i64 %2 -} - define i32 @main() #0 { entry: %x = alloca %"char[]", align 8 %.anon = alloca i64, align 8 - %.anon1 = alloca i64, align 8 %y = alloca i8, align 1 %z = alloca i32, align 4 store %"char[]" { ptr @.str, i64 5 }, ptr %x, align 8 @@ -38,29 +34,27 @@ entry: %ptradd = getelementptr inbounds i8, ptr %x, i64 8 %hi = load i64, ptr %ptradd, align 8 %0 = call i64 @test.TypeA.len(ptr %lo, i64 %hi) - store i64 %0, ptr %.anon, align 8 - store i64 0, ptr %.anon1, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %loop.body, %entry - %1 = load i64, ptr %.anon1, align 8 - %2 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %1, %2 + %1 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %1, %0 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %lo2 = load ptr, ptr %x, align 8 - %ptradd3 = getelementptr inbounds i8, ptr %x, i64 8 - %hi4 = load i64, ptr %ptradd3, align 8 - %3 = load i64, ptr %.anon1, align 8 - %4 = call i8 @test.TypeA.get(ptr %lo2, i64 %hi4, i64 %3) - store i8 %4, ptr %y, align 1 - %5 = load i8, ptr %y, align 1 - %zext = zext i8 %5 to i32 + %lo1 = load ptr, ptr %x, align 8 + %ptradd2 = getelementptr inbounds i8, ptr %x, i64 8 + %hi3 = load i64, ptr %ptradd2, align 8 + %2 = load i64, ptr %.anon, align 8 + %3 = call i8 @test.TypeA.get(ptr %lo1, i64 %hi3, i64 %2) + store i8 %3, ptr %y, align 1 + %4 = load i8, ptr %y, align 1 + %zext = zext i8 %4 to i32 store i32 %zext, ptr %z, align 4 - %6 = load i64, ptr %.anon1, align 8 - %addnuw = add nuw i64 %6, 1 - store i64 %addnuw, ptr %.anon1, align 8 + %5 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %5, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond diff --git a/test/test_suite/statements/foreach_more_implementations.c3t b/test/test_suite/statements/foreach_more_implementations.c3t index e494abe3b..88959c480 100644 --- a/test/test_suite/statements/foreach_more_implementations.c3t +++ b/test/test_suite/statements/foreach_more_implementations.c3t @@ -44,89 +44,83 @@ define void @test.main() #0 { entry: %x = alloca [2 x i32], align 4 %v = alloca %Vector, align 8 - %.anon = alloca i64, align 8 %vector = alloca %Vector, align 8 - %.anon1 = alloca i64, align 8 + %.anon = alloca i64, align 8 %ref = alloca ptr, align 8 %element = alloca i64, align 8 %varargslots = alloca [1 x %any], align 16 %retparam = alloca i64, align 8 + %vector2 = alloca %Vector, align 8 %.anon3 = alloca i64, align 8 - %vector4 = alloca %Vector, align 8 - %.anon5 = alloca i64, align 8 %i = alloca i32, align 4 - %element9 = alloca i64, align 8 - %varargslots12 = alloca [1 x %any], align 16 - %retparam13 = alloca i64, align 8 + %element7 = alloca i64, align 8 + %varargslots10 = alloca [1 x %any], align 16 + %retparam11 = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 8, i1 false) store i64 2, ptr %v, align 8 %ptradd = getelementptr inbounds i8, ptr %v, i64 8 store ptr %x, ptr %ptradd, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %vector, ptr align 8 %v, i32 16, i1 false) %0 = load i64, ptr %vector, align 8 - store i64 %0, ptr %.anon, align 8 - store i64 0, ptr %.anon1, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond loop.cond: ; preds = %loop.body, %entry - %1 = load i64, ptr %.anon1, align 8 - %2 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %1, %2 + %1 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %1, %0 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %3 = load i64, ptr %.anon1, align 8 - store i64 %3, ptr %element, align 8 - %ptradd2 = getelementptr inbounds i8, ptr %v, i64 8 - %4 = load ptr, ptr %ptradd2, align 8 - %5 = load i64, ptr %element, align 8 - %ptroffset = getelementptr inbounds [4 x i8], ptr %4, i64 %5 + %2 = load i64, ptr %.anon, align 8 + store i64 %2, ptr %element, align 8 + %ptradd1 = getelementptr inbounds i8, ptr %v, i64 8 + %3 = load ptr, ptr %ptradd1, align 8 + %4 = load i64, ptr %element, align 8 + %ptroffset = getelementptr inbounds [4 x i8], ptr %3, i64 %4 store ptr %ptroffset, ptr %ref, align 8 - %6 = load ptr, ptr %ref, align 8 - %7 = insertvalue %any undef, ptr %6, 0 - %8 = insertvalue %any %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %8, ptr %varargslots, align 16 - %9 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 3, ptr %varargslots, i64 1) - %10 = load ptr, ptr %ref, align 8 - %11 = load i32, ptr %10, align 4 - %add = add i32 %11, 2 - store i32 %add, ptr %10, align 4 - %12 = load i64, ptr %.anon1, align 8 - %addnuw = add nuw i64 %12, 1 - store i64 %addnuw, ptr %.anon1, align 8 + %5 = load ptr, ptr %ref, align 8 + %6 = insertvalue %any undef, ptr %5, 0 + %7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %7, ptr %varargslots, align 16 + %8 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 3, ptr %varargslots, i64 1) + %9 = load ptr, ptr %ref, align 8 + %10 = load i32, ptr %9, align 4 + %add = add i32 %10, 2 + store i32 %add, ptr %9, align 4 + %11 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %11, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %vector4, ptr align 8 %v, i32 16, i1 false) - %13 = load i64, ptr %vector4, align 8 - store i64 %13, ptr %.anon3, align 8 - store i64 0, ptr %.anon5, align 8 - br label %loop.cond6 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %vector2, ptr align 8 %v, i32 16, i1 false) + %12 = load i64, ptr %vector2, align 8 + store i64 0, ptr %.anon3, align 8 + br label %loop.cond4 -loop.cond6: ; preds = %loop.body8, %loop.exit - %14 = load i64, ptr %.anon5, align 8 - %15 = load i64, ptr %.anon3, align 8 - %lt7 = icmp ult i64 %14, %15 - br i1 %lt7, label %loop.body8, label %loop.exit15 +loop.cond4: ; preds = %loop.body6, %loop.exit + %13 = load i64, ptr %.anon3, align 8 + %lt5 = icmp ult i64 %13, %12 + br i1 %lt5, label %loop.body6, label %loop.exit13 -loop.body8: ; preds = %loop.cond6 - %16 = load i64, ptr %.anon5, align 8 - store i64 %16, ptr %element9, align 8 - %ptradd10 = getelementptr inbounds i8, ptr %v, i64 8 - %17 = load ptr, ptr %ptradd10, align 8 - %18 = load i64, ptr %element9, align 8 - %ptroffset11 = getelementptr inbounds [4 x i8], ptr %17, i64 %18 - %19 = load i32, ptr %ptroffset11, align 4 - store i32 %19, ptr %i, align 4 - %20 = insertvalue %any undef, ptr %i, 0 - %21 = insertvalue %any %20, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %21, ptr %varargslots12, align 16 - %22 = call i64 @std.io.printf(ptr %retparam13, ptr @.str.1, i64 3, ptr %varargslots12, i64 1) - %23 = load i64, ptr %.anon5, align 8 - %addnuw14 = add nuw i64 %23, 1 - store i64 %addnuw14, ptr %.anon5, align 8 - br label %loop.cond6 +loop.body6: ; preds = %loop.cond4 + %14 = load i64, ptr %.anon3, align 8 + store i64 %14, ptr %element7, align 8 + %ptradd8 = getelementptr inbounds i8, ptr %v, i64 8 + %15 = load ptr, ptr %ptradd8, align 8 + %16 = load i64, ptr %element7, align 8 + %ptroffset9 = getelementptr inbounds [4 x i8], ptr %15, i64 %16 + %17 = load i32, ptr %ptroffset9, align 4 + store i32 %17, ptr %i, align 4 + %18 = insertvalue %any undef, ptr %i, 0 + %19 = insertvalue %any %18, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %19, ptr %varargslots10, align 16 + %20 = call i64 @std.io.printf(ptr %retparam11, ptr @.str.1, i64 3, ptr %varargslots10, i64 1) + %21 = load i64, ptr %.anon3, align 8 + %addnuw12 = add nuw i64 %21, 1 + store i64 %addnuw12, ptr %.anon3, align 8 + br label %loop.cond4 -loop.exit15: ; preds = %loop.cond6 +loop.exit13: ; preds = %loop.cond4 ret void } \ No newline at end of file diff --git a/test/test_suite/switch/switch_in_defer_macro.c3t b/test/test_suite/switch/switch_in_defer_macro.c3t index 34ba741c5..2c6ccf638 100644 --- a/test/test_suite/switch/switch_in_defer_macro.c3t +++ b/test/test_suite/switch/switch_in_defer_macro.c3t @@ -750,89 +750,86 @@ define i64 @lexer_test.lex_uint() #0 { entry: %tcases = alloca %"UintTest[]", align 8 %.anon = alloca i64, align 8 - %.anon1 = alloca i64, align 8 %tc = alloca %UintTest, align 8 %br = alloca %ByteReader, align 8 %lex = alloca %Lexer, align 8 %error_var = alloca i64, align 8 %taddr = alloca %any, align 8 %kind = alloca i8, align 1 - %error_var8 = alloca i64, align 8 + %error_var7 = alloca i64, align 8 %retparam = alloca i8, align 1 store %"UintTest[]" zeroinitializer, ptr %tcases, align 8 %ptradd = getelementptr inbounds i8, ptr %tcases, i64 8 %0 = load i64, ptr %ptradd, align 8 - store i64 %0, ptr %.anon, align 8 - store i64 0, ptr %.anon1, align 8 + store i64 0, ptr %.anon, align 8 br label %loop.cond -loop.cond: ; preds = %noerr_block13, %entry - %1 = load i64, ptr %.anon1, align 8 - %2 = load i64, ptr %.anon, align 8 - %lt = icmp ult i64 %1, %2 +loop.cond: ; preds = %noerr_block12, %entry + %1 = load i64, ptr %.anon, align 8 + %lt = icmp ult i64 %1, %0 br i1 %lt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %3 = load ptr, ptr %tcases, align 8 - %4 = load i64, ptr %.anon1, align 8 - %ptroffset = getelementptr inbounds [24 x i8], ptr %3, i64 %4 + %2 = load ptr, ptr %tcases, align 8 + %3 = load i64, ptr %.anon, align 8 + %ptroffset = getelementptr inbounds [24 x i8], ptr %2, i64 %3 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %tc, ptr align 8 %ptroffset, i32 24, i1 false) call void @llvm.memset.p0.i64(ptr align 8 %br, i8 0, i64 24, i1 false) call void @llvm.memset.p0.i64(ptr align 8 %lex, i8 0, i64 128, i1 false) %lo = load ptr, ptr %tc, align 8 - %ptradd2 = getelementptr inbounds i8, ptr %tc, i64 8 - %hi = load i64, ptr %ptradd2, align 8 - %5 = call ptr @std.io.ByteReader.init(ptr %br, ptr %lo, i64 %hi) - %6 = insertvalue %any undef, ptr %5, 0 - %7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.std.io.ByteReader" to i64), 1 - store %any %7, ptr %taddr, align 8 - %lo3 = load i64, ptr %taddr, align 8 - %ptradd4 = getelementptr inbounds i8, ptr %taddr, i64 8 - %hi5 = load ptr, ptr %ptradd4, align 8 - %lo6 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi7 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %8 = call i64 @"lexer$lexer_test.Token$lexer_test.Comment$.Lexer.init"(ptr %lex, i64 %lo3, ptr %hi5, ptr @lexer_test.is_ident_char, i64 %lo6, ptr %hi7) - %not_err = icmp eq i64 %8, 0 - %9 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %9, label %after_check, label %assign_optional + %ptradd1 = getelementptr inbounds i8, ptr %tc, i64 8 + %hi = load i64, ptr %ptradd1, align 8 + %4 = call ptr @std.io.ByteReader.init(ptr %br, ptr %lo, i64 %hi) + %5 = insertvalue %any undef, ptr %4, 0 + %6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.std.io.ByteReader" to i64), 1 + store %any %6, ptr %taddr, align 8 + %lo2 = load i64, ptr %taddr, align 8 + %ptradd3 = getelementptr inbounds i8, ptr %taddr, i64 8 + %hi4 = load ptr, ptr %ptradd3, align 8 + %lo5 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 + %hi6 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 + %7 = call i64 @"lexer$lexer_test.Token$lexer_test.Comment$.Lexer.init"(ptr %lex, i64 %lo2, ptr %hi4, ptr @lexer_test.is_ident_char, i64 %lo5, ptr %hi6) + %not_err = icmp eq i64 %7, 0 + %8 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %8, label %after_check, label %assign_optional assign_optional: ; preds = %loop.body - store i64 %8, ptr %error_var, align 8 + store i64 %7, ptr %error_var, align 8 br label %guard_block after_check: ; preds = %loop.body br label %noerr_block guard_block: ; preds = %assign_optional - %10 = load i64, ptr %error_var, align 8 - ret i64 %10 + %9 = load i64, ptr %error_var, align 8 + ret i64 %9 noerr_block: ; preds = %after_check - %11 = call i64 @"lexer$lexer_test.Token$lexer_test.Comment$.Lexer.next"(ptr %retparam, ptr %lex) - %not_err9 = icmp eq i64 %11, 0 - %12 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true) - br i1 %12, label %after_check11, label %assign_optional10 - -assign_optional10: ; preds = %noerr_block - store i64 %11, ptr %error_var8, align 8 - br label %guard_block12 - -after_check11: ; preds = %noerr_block - br label %noerr_block13 - -guard_block12: ; preds = %assign_optional10 - %13 = load i64, ptr %error_var8, align 8 - ret i64 %13 - -noerr_block13: ; preds = %after_check11 - %14 = load i8, ptr %retparam, align 1 - store i8 %14, ptr %kind, align 1 - %15 = load i8, ptr %kind, align 1 - %eq = icmp eq i8 %15, 1 + %10 = call i64 @"lexer$lexer_test.Token$lexer_test.Comment$.Lexer.next"(ptr %retparam, ptr %lex) + %not_err8 = icmp eq i64 %10, 0 + %11 = call i1 @llvm.expect.i1(i1 %not_err8, i1 true) + br i1 %11, label %after_check10, label %assign_optional9 + +assign_optional9: ; preds = %noerr_block + store i64 %10, ptr %error_var7, align 8 + br label %guard_block11 + +after_check10: ; preds = %noerr_block + br label %noerr_block12 + +guard_block11: ; preds = %assign_optional9 + %12 = load i64, ptr %error_var7, align 8 + ret i64 %12 + +noerr_block12: ; preds = %after_check10 + %13 = load i8, ptr %retparam, align 1 + store i8 %13, ptr %kind, align 1 + %14 = load i8, ptr %kind, align 1 + %eq = icmp eq i8 %14, 1 call void @llvm.assume(i1 %eq) - %16 = load i64, ptr %.anon1, align 8 - %addnuw = add nuw i64 %16, 1 - store i64 %addnuw, ptr %.anon1, align 8 + %15 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %15, 1 + store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond