From 5a2fe4c9d977bc35ac367d6b35e2073ebfc6af46 Mon Sep 17 00:00:00 2001 From: Christoffer Lerno Date: Tue, 18 Jul 2023 22:28:43 +0200 Subject: [PATCH] Fix to macro codegen. --- src/compiler/llvm_codegen.c | 2 + src/compiler/llvm_codegen_expr.c | 14 +- src/compiler/llvm_codegen_internal.h | 2 + src/compiler/llvm_codegen_stmt.c | 3 +- test/test_suite/assert/assertf.c3t | 12 +- test/test_suite/assert/unreachable.c3t | 10 +- test/test_suite/bitstruct/bitstruct_be.c3t | 217 +++--- .../compile_time/ct_builtin_time_date.c3t | 85 +-- test/test_suite/compile_time/ct_memberof.c3t | 387 +++++------ .../compile_time/untyped_conversions.c3t | 30 +- .../enumerations/enum_conversions.c3t | 222 +++--- test/test_suite/errors/error_regression_2.c3t | 636 +++++++++--------- .../errors/general_error_regression.c3t | 24 +- test/test_suite/errors/multiple_catch.c3t | 42 +- test/test_suite/errors/or_and_rethrow.c3t | 99 +-- test/test_suite/from_docs/examples_defer.c3t | 126 ++-- .../from_docs/examples_forswitch.c3t | 280 +++----- test/test_suite/functions/splat.c3t | 16 +- test/test_suite/functions/splat_aarch64.c3t | 32 +- test/test_suite/functions/splat_mingw.c3t | 24 +- test/test_suite/functions/test_regression.c3t | 82 +-- .../functions/test_regression_mingw.c3t | 65 +- .../initializer_lists/subarrays.c3t | 105 ++- .../macros/macro_failable_return_rethrow.c3t | 10 +- .../methods/enum_distinct_err_methods.c3t | 26 +- 25 files changed, 1161 insertions(+), 1390 deletions(-) diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c index 4c821775d..41af5f668 100644 --- a/src/compiler/llvm_codegen.c +++ b/src/compiler/llvm_codegen.c @@ -9,6 +9,8 @@ #include #include +const char *varargslots_name = "varargslots"; +const char *temp_name = "#temp#"; typedef struct LLVMOpaquePassBuilderOptions *LLVMPassBuilderOptionsRef; LLVMErrorRef LLVMRunPasses(LLVMModuleRef M, const char *Passes, LLVMTargetMachineRef TM, diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c index 0145406b5..78e38f4e3 100644 --- a/src/compiler/llvm_codegen_expr.c +++ b/src/compiler/llvm_codegen_expr.c @@ -5037,8 +5037,12 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef *args, unsigned *arg_count_ // No, then we can replace the instructions with the values. LLVMValueRef first_val = LLVMGetOperand(prev, 1); LLVMValueRef second_val = LLVMGetOperand(val, 1); - LLVMInstructionEraseFromParent(val); - LLVMInstructionEraseFromParent(prev); + const char *name = LLVMGetValueName(val); + if (name && strncmp(name, temp_name, 6) == 0) + { + LLVMInstructionEraseFromParent(val); + LLVMInstructionEraseFromParent(prev); + } args[(*arg_count_ref)++] = first_val; args[(*arg_count_ref)++] = second_val; return; @@ -5169,7 +5173,7 @@ void llvm_emit_vararg_parameter(GenContext *c, BEValue *value, Type *vararg_type Type *array = type_get_array(pointee_type, elements); LLVMTypeRef llvm_array_type = llvm_get_type(c, array); AlignSize alignment = type_alloca_alignment(array); - LLVMValueRef array_ref = llvm_emit_alloca(c, llvm_array_type, alignment, "varargslots"); + LLVMValueRef array_ref = llvm_emit_alloca(c, llvm_array_type, alignment, varargslots_name); foreach(Expr*, varargs) { llvm_emit_expr(c, &temp_value, val); @@ -5183,6 +5187,7 @@ void llvm_emit_vararg_parameter(GenContext *c, BEValue *value, Type *vararg_type llvm_store_to_ptr_aligned(c, slot, &temp_value, store_alignment); } llvm_value_aggregate_two(c, value, vararg_type, array_ref, llvm_const_int(c, type_usz, elements)); + LLVMSetValueName2(value->value, temp_name, 6); } @@ -5940,12 +5945,13 @@ static inline void llvm_emit_macro_block(GenContext *c, BEValue *be_value, Expr Expr *init_expr = val->var.init_expr; BEValue value; llvm_emit_expr(c, &value, init_expr); - if (type_is_abi_aggregate(value.type) || llvm_value_is_addr(&value) || val->var.is_written || val->var.is_addr) + if (llvm_value_is_addr(&value) || val->var.is_written || val->var.is_addr) { llvm_emit_and_set_decl_alloca(c, val); llvm_store_decl(c, val, &value); continue; } + val->is_value = true; val->backend_value = value.value; FOREACH_END(); diff --git a/src/compiler/llvm_codegen_internal.h b/src/compiler/llvm_codegen_internal.h index d4a790be9..a12d98a43 100644 --- a/src/compiler/llvm_codegen_internal.h +++ b/src/compiler/llvm_codegen_internal.h @@ -16,6 +16,8 @@ #define SLICE_MAX_UNROLL 4 +extern const char *varargslots_name; +extern const char *temp_name; typedef enum { BE_VALUE, diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c index 73d31c9ed..66ba3bbf3 100644 --- a/src/compiler/llvm_codegen_stmt.c +++ b/src/compiler/llvm_codegen_stmt.c @@ -1341,7 +1341,7 @@ void llvm_emit_panic(GenContext *c, const char *message, SourceSpan loc, const c Type *any_array = type_get_array(type_any, elements); LLVMTypeRef llvm_array_type = llvm_get_type(c, any_array); AlignSize alignment = type_alloca_alignment(any_array); - LLVMValueRef array_ref = llvm_emit_alloca(c, llvm_array_type, alignment, "varargslots"); + LLVMValueRef array_ref = llvm_emit_alloca(c, llvm_array_type, alignment, varargslots_name); VECEACH(varargs, i) { AlignSize store_alignment; @@ -1355,6 +1355,7 @@ void llvm_emit_panic(GenContext *c, const char *message, SourceSpan loc, const c } BEValue value; llvm_value_aggregate_two(c, &value, any_subarray, array_ref, llvm_const_int(c, type_usz, elements)); + LLVMSetValueName2(value.value, temp_name, 6); llvm_emit_parameter(c, actual_args, &count, abi_args[4], &value, any_subarray); diff --git a/test/test_suite/assert/assertf.c3t b/test/test_suite/assert/assertf.c3t index ae1b91263..50e257336 100644 --- a/test/test_suite/assert/assertf.c3t +++ b/test/test_suite/assert/assertf.c3t @@ -44,17 +44,17 @@ assert_fail: ; preds = %loop.body %8 = getelementptr inbounds [2 x %any], ptr %varargslots, i64 0, i64 1 store %any %6, ptr %8, align 16 %9 = insertvalue %"any[]" undef, ptr %varargslots, 0 - %10 = insertvalue %"any[]" %9, i64 2, 1 - store %"any[]" %10, ptr %indirectarg, align 8 + %"#temp#" = insertvalue %"any[]" %9, i64 2, 1 + store %"any[]" %"#temp#", ptr %indirectarg, align 8 call void @std.core.builtin.panicf(ptr @.panic_msg, i64 10, ptr @.file, i64 10, ptr @.func, i64 4, i32 7, ptr byval(%"any[]") align 8 %indirectarg) br label %assert_ok assert_ok: ; preds = %assert_fail, %loop.body - %11 = load i64, ptr %i, align 8 - %neq1 = icmp ne i64 2, %11 + %10 = load i64, ptr %i, align 8 + %neq1 = icmp ne i64 2, %10 call void @llvm.assume(i1 %neq1) - %12 = load i64, ptr %i, align 8 - %add = add i64 %12, 1 + %11 = load i64, ptr %i, align 8 + %add = add i64 %11, 1 store i64 %add, ptr %i, align 8 br label %loop.cond diff --git a/test/test_suite/assert/unreachable.c3t b/test/test_suite/assert/unreachable.c3t index 43dff795f..7e2485304 100644 --- a/test/test_suite/assert/unreachable.c3t +++ b/test/test_suite/assert/unreachable.c3t @@ -17,22 +17,18 @@ fn void test() define void @unreachable.test() #0 { entry: %x = alloca i32, align 4 - %string = alloca %"char[]", align 8 %indirectarg = alloca %"any[]", align 8 %0 = call i32 @unreachable.foo() store i32 %0, ptr %x, align 4 %1 = load i32, ptr %x, align 4 %gt = icmp sgt i32 %1, 0 br i1 %gt, label %if.then, label %if.exit + if.then: ; preds = %entry ret void + if.exit: ; preds = %entry - store %"char[]" { ptr @.str, i64 30 }, ptr %string, align 8 - %2 = getelementptr inbounds %"char[]", ptr %string, i32 0, i32 0 - %lo = load ptr, ptr %2, align 8 - %3 = getelementptr inbounds %"char[]", ptr %string, i32 0, i32 1 - %hi = load i64, ptr %3, align 8 store %"any[]" zeroinitializer, ptr %indirectarg, align 8 - call void @std.core.builtin.panicf(ptr %lo, i64 %hi, ptr @.str.1, i64 14, ptr @.str.2, i64 4, i32 10, ptr byval(%"any[]") align 8 %indirectarg) + call void @std.core.builtin.panicf(ptr @.str, i64 30, ptr @.str.1, i64 14, ptr @.str.2, i64 4, i32 10, ptr byval(%"any[]") align 8 %indirectarg) unreachable } \ No newline at end of file diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t index a18f7705a..ee003ced1 100644 --- a/test/test_suite/bitstruct/bitstruct_be.c3t +++ b/test/test_suite/bitstruct/bitstruct_be.c3t @@ -89,132 +89,117 @@ loop.body: ; preds = %loop.cond br label %loop.cond loop.exit: ; preds = %loop.cond - store %"char[]" zeroinitializer, ptr %x4, align 8 %22 = call ptr @std.io.stdout() store ptr %22, ptr %result, align 8 %23 = load ptr, ptr %result, align 8 - %24 = getelementptr inbounds %"char[]", ptr %x4, i32 0, i32 0 - %lo = load ptr, ptr %24, align 8 - %25 = getelementptr inbounds %"char[]", ptr %x4, i32 0, i32 1 - %hi = load i64, ptr %25, align 8 - %26 = call i64 @std.io.File.printn(ptr %retparam5, ptr %23, ptr %lo, i64 %hi) - %27 = load ptr, ptr %z, align 8 - store ptr %27, ptr %.anon6, align 8 - store i64 0, ptr %.anon7, align 8 - br label %loop.cond8 + %24 = call i64 @std.io.File.printn(ptr %retparam4, ptr %23, ptr null, i64 0) + %25 = load ptr, ptr %z, align 8 + store ptr %25, ptr %.anon5, align 8 + store i64 0, ptr %.anon6, align 8 + br label %loop.cond7 -loop.cond8: ; preds = %loop.body10, %loop.exit - %28 = load i64, ptr %.anon7, align 8 - %gt9 = icmp ugt i64 4, %28 - br i1 %gt9, label %loop.body10, label %loop.exit15 +loop.cond7: ; preds = %loop.body9, %loop.exit + %26 = load i64, ptr %.anon6, align 8 + %gt8 = icmp ugt i64 4, %26 + br i1 %gt8, label %loop.body9, label %loop.exit14 -loop.body10: ; preds = %loop.cond8 - %29 = load ptr, ptr %.anon6, align 8 - %30 = load i64, ptr %.anon7, align 8 - %31 = getelementptr inbounds [4 x i8], ptr %29, i64 0, i64 %30 - %32 = load i8, ptr %31, align 1 - store i8 %32, ptr %d11, align 1 - %33 = insertvalue %any undef, ptr %d11, 0 - %34 = insertvalue %any %33, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %35 = getelementptr inbounds [1 x %any], ptr %varargslots13, i64 0, i64 0 - store %any %34, ptr %35, align 16 - %36 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.2, i64 3, ptr %varargslots13, i64 1) - %37 = load i64, ptr %.anon7, align 8 - %add14 = add i64 %37, 1 - store i64 %add14, ptr %.anon7, align 8 - br label %loop.cond8 +loop.body9: ; preds = %loop.cond7 + %27 = load ptr, ptr %.anon5, align 8 + %28 = load i64, ptr %.anon6, align 8 + %29 = getelementptr inbounds [4 x i8], ptr %27, i64 0, i64 %28 + %30 = load i8, ptr %29, align 1 + store i8 %30, ptr %d10, align 1 + %31 = insertvalue %any undef, ptr %d10, 0 + %32 = insertvalue %any %31, i64 ptrtoint (ptr @"$ct.char" to i64), 1 + %33 = getelementptr inbounds [1 x %any], ptr %varargslots12, i64 0, i64 0 + store %any %32, ptr %33, align 16 + %34 = call i64 @std.io.printf(ptr %retparam11, ptr @.str.2, i64 3, ptr %varargslots12, i64 1) + %35 = load i64, ptr %.anon6, align 8 + %add13 = add i64 %35, 1 + store i64 %add13, ptr %.anon6, align 8 + br label %loop.cond7 -loop.exit15: ; preds = %loop.cond8 - store %"char[]" zeroinitializer, ptr %x16, align 8 - %38 = call ptr @std.io.stdout() - store ptr %38, ptr %result18, align 8 - %39 = load ptr, ptr %result18, align 8 - %40 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0 - %lo19 = load ptr, ptr %40, align 8 - %41 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1 - %hi20 = load i64, ptr %41, align 8 - %42 = call i64 @std.io.File.printn(ptr %retparam17, ptr %39, ptr %lo19, i64 %hi20) - %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 %taddr23, align 2 - %46 = insertvalue %any undef, ptr %taddr23, 0 - %47 = insertvalue %any %46, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 - %48 = getelementptr inbounds [1 x %any], ptr %varargslots22, i64 0, i64 0 - store %any %47, ptr %48, align 16 - %49 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.3, i64 10, ptr %varargslots22, i64 1) - %50 = load i32, ptr %abc, align 4 - %51 = call i32 @llvm.bswap.i32(i32 %50) - %52 = and i32 %51, -65536 - %53 = or i32 %52, 4660 - %54 = call i32 @llvm.bswap.i32(i32 %53) - store i32 %54, ptr %abc, align 4 - %55 = load i32, ptr %abc, align 4 - %56 = call i32 @llvm.bswap.i32(i32 %55) - %57 = and i32 %56, 65535 - %58 = or i32 %57, 1450704896 - %59 = call i32 @llvm.bswap.i32(i32 %58) - store i32 %59, ptr %abc, align 4 - %60 = load i32, ptr %abc, align 4 - %61 = call i32 @llvm.bswap.i32(i32 %60) - %62 = and i32 65535, %61 - %trunc26 = trunc i32 %62 to i16 - store i16 %trunc26, ptr %taddr27, align 2 - %63 = insertvalue %any undef, ptr %taddr27, 0 - %64 = insertvalue %any %63, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 - %65 = getelementptr inbounds [1 x %any], ptr %varargslots25, i64 0, i64 0 - store %any %64, ptr %65, align 16 - %66 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.4, i64 12, ptr %varargslots25, i64 1) - %67 = load ptr, ptr %z, align 8 - store ptr %67, ptr %.anon28, align 8 - store i64 0, ptr %.anon29, align 8 - br label %loop.cond30 +loop.exit14: ; preds = %loop.cond7 + %36 = call ptr @std.io.stdout() + store ptr %36, ptr %result16, align 8 + %37 = load ptr, ptr %result16, align 8 + %38 = call i64 @std.io.File.printn(ptr %retparam15, ptr %37, ptr null, i64 0) + %39 = load i32, ptr %abc, align 4 + %40 = call i32 @llvm.bswap.i32(i32 %39) + %41 = and i32 65535, %40 + %trunc = trunc i32 %41 to i16 + store i16 %trunc, ptr %taddr19, align 2 + %42 = insertvalue %any undef, ptr %taddr19, 0 + %43 = insertvalue %any %42, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 + %44 = getelementptr inbounds [1 x %any], ptr %varargslots18, i64 0, i64 0 + store %any %43, ptr %44, align 16 + %45 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.3, i64 10, ptr %varargslots18, i64 1) + %46 = load i32, ptr %abc, align 4 + %47 = call i32 @llvm.bswap.i32(i32 %46) + %48 = and i32 %47, -65536 + %49 = or i32 %48, 4660 + %50 = call i32 @llvm.bswap.i32(i32 %49) + store i32 %50, ptr %abc, align 4 + %51 = load i32, ptr %abc, align 4 + %52 = call i32 @llvm.bswap.i32(i32 %51) + %53 = and i32 %52, 65535 + %54 = or i32 %53, 1450704896 + %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 65535, %57 + %trunc22 = trunc i32 %58 to i16 + store i16 %trunc22, ptr %taddr23, align 2 + %59 = insertvalue %any undef, ptr %taddr23, 0 + %60 = insertvalue %any %59, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 + %61 = getelementptr inbounds [1 x %any], ptr %varargslots21, i64 0, i64 0 + store %any %60, ptr %61, align 16 + %62 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.4, i64 12, ptr %varargslots21, i64 1) + %63 = load ptr, ptr %z, align 8 + store ptr %63, ptr %.anon24, align 8 + store i64 0, ptr %.anon25, align 8 + br label %loop.cond26 -loop.cond30: ; preds = %loop.body32, %loop.exit15 - %68 = load i64, ptr %.anon29, align 8 - %gt31 = icmp ugt i64 4, %68 - br i1 %gt31, label %loop.body32, label %loop.exit37 +loop.cond26: ; preds = %loop.body28, %loop.exit14 + %64 = load i64, ptr %.anon25, align 8 + %gt27 = icmp ugt i64 4, %64 + br i1 %gt27, label %loop.body28, label %loop.exit33 -loop.body32: ; preds = %loop.cond30 - %69 = load ptr, ptr %.anon28, align 8 - %70 = load i64, ptr %.anon29, align 8 - %71 = getelementptr inbounds [4 x i8], ptr %69, i64 0, i64 %70 - %72 = load i8, ptr %71, align 1 - store i8 %72, ptr %d33, align 1 - %73 = insertvalue %any undef, ptr %d33, 0 - %74 = insertvalue %any %73, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %75 = getelementptr inbounds [1 x %any], ptr %varargslots35, i64 0, i64 0 - store %any %74, ptr %75, align 16 - %76 = call i64 @std.io.printf(ptr %retparam34, ptr @.str.5, i64 3, ptr %varargslots35, i64 1) - %77 = load i64, ptr %.anon29, align 8 - %add36 = add i64 %77, 1 - store i64 %add36, ptr %.anon29, align 8 - br label %loop.cond30 +loop.body28: ; preds = %loop.cond26 + %65 = load ptr, ptr %.anon24, align 8 + %66 = load i64, ptr %.anon25, align 8 + %67 = getelementptr inbounds [4 x i8], ptr %65, i64 0, i64 %66 + %68 = load i8, ptr %67, align 1 + store i8 %68, ptr %d29, align 1 + %69 = insertvalue %any undef, ptr %d29, 0 + %70 = insertvalue %any %69, i64 ptrtoint (ptr @"$ct.char" to i64), 1 + %71 = getelementptr inbounds [1 x %any], ptr %varargslots31, i64 0, i64 0 + store %any %70, ptr %71, align 16 + %72 = call i64 @std.io.printf(ptr %retparam30, ptr @.str.5, i64 3, ptr %varargslots31, i64 1) + %73 = load i64, ptr %.anon25, align 8 + %add32 = add i64 %73, 1 + store i64 %add32, ptr %.anon25, align 8 + br label %loop.cond26 -loop.exit37: ; preds = %loop.cond30 - store %"char[]" zeroinitializer, ptr %x38, align 8 - %78 = call ptr @std.io.stdout() - store ptr %78, ptr %result40, align 8 - %79 = load ptr, ptr %result40, align 8 - %80 = getelementptr inbounds %"char[]", ptr %x38, i32 0, i32 0 - %lo41 = load ptr, ptr %80, align 8 - %81 = getelementptr inbounds %"char[]", ptr %x38, i32 0, i32 1 - %hi42 = load i64, ptr %81, align 8 - %82 = call i64 @std.io.File.printn(ptr %retparam39, ptr %79, ptr %lo41, i64 %hi42) +loop.exit33: ; preds = %loop.cond26 + %74 = call ptr @std.io.stdout() + store ptr %74, ptr %result35, align 8 + %75 = load ptr, ptr %result35, align 8 + %76 = call i64 @std.io.File.printn(ptr %retparam34, ptr %75, ptr null, i64 0) store i32 0, ptr %y, align 4 - %83 = load i32, ptr %y, align 4 + %77 = load i32, ptr %y, align 4 store i32 123, ptr %y, align 4 - %84 = insertvalue %any undef, ptr %y, 0 - %85 = insertvalue %any %84, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %86 = getelementptr inbounds [2 x %any], ptr %varargslots44, i64 0, i64 0 - store %any %85, ptr %86, align 16 - %87 = load i32, ptr %y, align 4 - store i32 %87, ptr %taddr45, align 4 - %88 = insertvalue %any undef, ptr %taddr45, 0 - %89 = insertvalue %any %88, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %90 = getelementptr inbounds [2 x %any], ptr %varargslots44, i64 0, i64 1 - store %any %89, ptr %90, align 16 - %91 = call i64 @std.io.printf(ptr %retparam43, ptr @.str.6, i64 18, ptr %varargslots44, i64 2) + %78 = insertvalue %any undef, ptr %y, 0 + %79 = insertvalue %any %78, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %80 = getelementptr inbounds [2 x %any], ptr %varargslots37, i64 0, i64 0 + store %any %79, ptr %80, align 16 + %81 = load i32, ptr %y, align 4 + store i32 %81, ptr %taddr38, align 4 + %82 = insertvalue %any undef, ptr %taddr38, 0 + %83 = insertvalue %any %82, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %84 = getelementptr inbounds [2 x %any], ptr %varargslots37, i64 0, i64 1 + store %any %83, ptr %84, align 16 + %85 = call i64 @std.io.printf(ptr %retparam36, ptr @.str.6, i64 18, ptr %varargslots37, i64 2) ret void } \ No newline at end of file diff --git a/test/test_suite/compile_time/ct_builtin_time_date.c3t b/test/test_suite/compile_time/ct_builtin_time_date.c3t index 9bd5d7c19..6d918526c 100644 --- a/test/test_suite/compile_time/ct_builtin_time_date.c3t +++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t @@ -31,24 +31,20 @@ entry: %retparam = alloca i64, align 8 %varargslots = alloca [1 x %any], align 16 %taddr = alloca i32, align 4 - %x = alloca %"char[]", align 8 %retparam1 = alloca i64, align 8 %result = alloca %File, align 8 - %x2 = alloca %"char[]", align 8 - %retparam3 = alloca i64, align 8 - %result4 = alloca %File, align 8 + %retparam2 = alloca i64, align 8 + %result3 = alloca %File, align 8 + %retparam4 = alloca i64, align 8 + %varargslots5 = alloca [1 x %any], align 16 + %taddr6 = alloca i64, align 8 %retparam7 = alloca i64, align 8 %varargslots8 = alloca [1 x %any], align 16 %taddr9 = alloca i64, align 8 %retparam10 = alloca i64, align 8 - %varargslots11 = alloca [1 x %any], align 16 - %taddr12 = alloca i64, align 8 - %x13 = alloca %"char[]", align 8 - %retparam14 = alloca i64, align 8 - %result15 = alloca %File, align 8 - %x18 = alloca %"char[]", align 8 - %retparam19 = alloca i64, align 8 - %result20 = alloca %File, align 8 + %result11 = alloca %File, align 8 + %retparam12 = alloca i64, align 8 + %result13 = alloca %File, align 8 store i32 %0, ptr %taddr, align 4 %1 = insertvalue %any undef, ptr %taddr, 0 %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1 @@ -57,61 +53,44 @@ entry: %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) %gt = icmp sgt i32 %0, 0 br i1 %gt, label %if.then, label %if.exit + if.then: ; preds = %entry %sub = sub i32 %0, 1 call void @test.test(i32 %sub) br label %if.exit + if.exit: ; preds = %if.then, %entry - store %"char[]" { ptr @.str.1, i64 8 }, ptr %x, align 8 %5 = call ptr @std.io.stdout() store ptr %5, ptr %result, align 8 %6 = load ptr, ptr %result, align 8 - %7 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %7, align 8 - %8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %8, align 8 - %9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr %lo, i64 %hi) - store %"char[]" { ptr @.str.2, i64 10 }, ptr %x2, align 8 - %10 = call ptr @std.io.stdout() - store ptr %10, ptr %result4, align 8 - %11 = load ptr, ptr %result4, align 8 - %12 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0 - %lo5 = load ptr, ptr %12, align 8 - %13 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1 - %hi6 = load i64, ptr %13, align 8 - %14 = call i64 @std.io.File.printn(ptr %retparam3, ptr %11, ptr %lo5, i64 %hi6) - store i64 14, ptr %taddr9, align 8 + %7 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr @.str.1, i64 8) + %8 = call ptr @std.io.stdout() + store ptr %8, ptr %result3, align 8 + %9 = load ptr, ptr %result3, align 8 + %10 = call i64 @std.io.File.printn(ptr %retparam2, ptr %9, ptr @.str.2, i64 10) + store i64 14, ptr %taddr6, align 8 + %11 = insertvalue %any undef, ptr %taddr6, 0 + %12 = insertvalue %any %11, i64 ptrtoint (ptr @"$ct.long" to i64), 1 + %13 = getelementptr inbounds [1 x %any], ptr %varargslots5, i64 0, i64 0 + store %any %12, ptr %13, align 16 + %14 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.3, i64 2, ptr %varargslots5, i64 1) + store i64 6, ptr %taddr9, align 8 %15 = insertvalue %any undef, ptr %taddr9, 0 %16 = insertvalue %any %15, i64 ptrtoint (ptr @"$ct.long" to i64), 1 %17 = getelementptr inbounds [1 x %any], ptr %varargslots8, i64 0, i64 0 store %any %16, ptr %17, align 16 - %18 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1) - store i64 6, ptr %taddr12, align 8 - %19 = insertvalue %any undef, ptr %taddr12, 0 - %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %21 = getelementptr inbounds [1 x %any], ptr %varargslots11, i64 0, i64 0 - store %any %20, ptr %21, align 16 - %22 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.4, i64 2, ptr %varargslots11, i64 1) - store %"char[]" { ptr @.str.5, i64 23 }, ptr %x13, align 8 - %23 = call ptr @std.io.stdout() - store ptr %23, ptr %result15, align 8 - %24 = load ptr, ptr %result15, align 8 - %25 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 0 - %lo16 = load ptr, ptr %25, align 8 - %26 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 1 - %hi17 = load i64, ptr %26, align 8 - %27 = call i64 @std.io.File.printn(ptr %retparam14, ptr %24, ptr %lo16, i64 %hi17) - store %"char[]" { ptr @.str.6, i64 4 }, ptr %x18, align 8 - %28 = call ptr @std.io.stdout() - store ptr %28, ptr %result20, align 8 - %29 = load ptr, ptr %result20, align 8 - %30 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0 - %lo21 = load ptr, ptr %30, align 8 - %31 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1 - %hi22 = load i64, ptr %31, align 8 - %32 = call i64 @std.io.File.printn(ptr %retparam19, ptr %29, ptr %lo21, i64 %hi22) + %18 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.4, i64 2, ptr %varargslots8, i64 1) + %19 = call ptr @std.io.stdout() + store ptr %19, ptr %result11, align 8 + %20 = load ptr, ptr %result11, align 8 + %21 = call i64 @std.io.File.printn(ptr %retparam10, ptr %20, ptr @.str.5, i64 23) + %22 = call ptr @std.io.stdout() + store ptr %22, ptr %result13, align 8 + %23 = load ptr, ptr %result13, align 8 + %24 = call i64 @std.io.File.printn(ptr %retparam12, ptr %23, ptr @.str.6, i64 4) ret void } + ; Function Attrs: nounwind define void @test.main() #0 { entry: diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t index 3d252bcbf..9039c2c00 100644 --- a/test/test_suite/compile_time/ct_memberof.c3t +++ b/test/test_suite/compile_time/ct_memberof.c3t @@ -117,269 +117,228 @@ entry: ; Function Attrs: nounwind define void @test.test(i32 %0) #0 { entry: - %x = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 - %x1 = alloca %"char[]", align 8 - %retparam2 = alloca i64, align 8 - %result3 = alloca %File, align 8 - %x6 = alloca %"char[]", align 8 + %retparam1 = alloca i64, align 8 + %result2 = alloca %File, align 8 + %retparam3 = alloca i64, align 8 + %result4 = alloca %File, align 8 + %retparam5 = alloca i64, align 8 + %result6 = alloca %File, align 8 %retparam7 = alloca i64, align 8 %result8 = alloca %File, align 8 - %x11 = alloca %"char[]", align 8 - %retparam12 = alloca i64, align 8 - %result13 = alloca %File, align 8 - %x16 = alloca %"char[]", align 8 - %retparam17 = alloca i64, align 8 - %result18 = alloca %File, align 8 - %x21 = alloca %"char[]", align 8 - %retparam22 = alloca i64, align 8 - %result23 = alloca %File, align 8 - %x26 = alloca %"char[]", align 8 - %retparam27 = alloca i64, align 8 - %result28 = alloca %File, align 8 - %retparam31 = alloca i64, align 8 + %retparam9 = alloca i64, align 8 + %result10 = alloca %File, align 8 + %retparam11 = alloca i64, align 8 + %result12 = alloca %File, align 8 + %retparam13 = alloca i64, align 8 %varargslots = alloca [1 x %any], align 16 %taddr = alloca %"char[]", align 8 - %retparam32 = alloca i64, align 8 - %varargslots33 = alloca [2 x %any], align 16 - %taddr34 = alloca %"char[]", align 8 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [2 x %any], align 16 + %taddr16 = alloca %"char[]", align 8 + %taddr17 = alloca %"char[]", align 8 + %retparam18 = alloca i64, align 8 + %varargslots19 = alloca [2 x %any], align 16 + %taddr20 = alloca %"char[]", align 8 + %taddr21 = alloca %"char[]", align 8 + %retparam22 = alloca i64, align 8 + %varargslots23 = alloca [2 x %any], align 16 + %taddr24 = alloca %"char[]", align 8 + %taddr25 = alloca %"char[]", align 8 + %retparam26 = alloca i64, align 8 + %varargslots27 = alloca [2 x %any], align 16 + %taddr28 = alloca %"char[]", align 8 + %taddr29 = alloca %"char[]", align 8 + %retparam30 = alloca i64, align 8 + %varargslots31 = alloca [1 x %any], align 16 + %taddr32 = alloca %"char[]", align 8 + %retparam33 = alloca i64, align 8 + %varargslots34 = alloca [2 x %any], align 16 %taddr35 = alloca %"char[]", align 8 - %retparam36 = alloca i64, align 8 - %varargslots37 = alloca [2 x %any], align 16 - %taddr38 = alloca %"char[]", align 8 + %taddr36 = alloca %"char[]", align 8 + %retparam37 = alloca i64, align 8 + %varargslots38 = alloca [2 x %any], align 16 %taddr39 = alloca %"char[]", align 8 - %retparam40 = alloca i64, align 8 - %varargslots41 = alloca [2 x %any], align 16 - %taddr42 = alloca %"char[]", align 8 + %taddr40 = alloca %"char[]", align 8 + %retparam41 = alloca i64, align 8 + %varargslots42 = alloca [2 x %any], align 16 %taddr43 = alloca %"char[]", align 8 - %retparam44 = alloca i64, align 8 - %varargslots45 = alloca [2 x %any], align 16 - %taddr46 = alloca %"char[]", align 8 + %taddr44 = alloca %"char[]", align 8 + %retparam45 = alloca i64, align 8 + %varargslots46 = alloca [2 x %any], align 16 %taddr47 = alloca %"char[]", align 8 - %retparam48 = alloca i64, align 8 - %varargslots49 = alloca [1 x %any], align 16 - %taddr50 = alloca %"char[]", align 8 - %retparam51 = alloca i64, align 8 - %varargslots52 = alloca [2 x %any], align 16 - %taddr53 = alloca %"char[]", align 8 + %taddr48 = alloca %"char[]", align 8 + %retparam49 = alloca i64, align 8 + %varargslots50 = alloca [1 x %any], align 16 + %taddr51 = alloca %"char[]", align 8 + %retparam52 = alloca i64, align 8 + %varargslots53 = alloca [2 x %any], align 16 %taddr54 = alloca %"char[]", align 8 - %retparam55 = alloca i64, align 8 - %varargslots56 = alloca [2 x %any], align 16 - %taddr57 = alloca %"char[]", align 8 + %taddr55 = alloca %"char[]", align 8 + %retparam56 = alloca i64, align 8 + %varargslots57 = alloca [2 x %any], align 16 %taddr58 = alloca %"char[]", align 8 - %retparam59 = alloca i64, align 8 - %varargslots60 = alloca [2 x %any], align 16 - %taddr61 = alloca %"char[]", align 8 - %taddr62 = alloca %"char[]", align 8 - %retparam63 = alloca i64, align 8 - %varargslots64 = alloca [2 x %any], align 16 - %taddr65 = alloca %"char[]", align 8 - %taddr66 = alloca %"char[]", align 8 - %retparam67 = alloca i64, align 8 - %varargslots68 = alloca [1 x %any], align 16 - %taddr69 = alloca %"char[]", align 8 - %retparam70 = alloca i64, align 8 - %varargslots71 = alloca [2 x %any], align 16 - %taddr72 = alloca %"char[]", align 8 - %taddr73 = alloca %"char[]", align 8 - %retparam74 = alloca i64, align 8 - %varargslots75 = alloca [2 x %any], align 16 - %taddr76 = alloca %"char[]", align 8 - %taddr77 = alloca %"char[]", align 8 - store %"char[]" { ptr @.str, i64 3 }, ptr %x, align 8 + %taddr59 = alloca %"char[]", align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 %2 = load ptr, ptr %result, align 8 - %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi) - store %"char[]" { ptr @.str.10, i64 3 }, ptr %x1, align 8 - %6 = call ptr @std.io.stdout() - store ptr %6, ptr %result3, align 8 - %7 = load ptr, ptr %result3, align 8 - %8 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0 - %lo4 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1 - %hi5 = load i64, ptr %9, align 8 - %10 = call i64 @std.io.File.printn(ptr %retparam2, ptr %7, ptr %lo4, i64 %hi5) - store %"char[]" { ptr @.str.11, i64 6 }, ptr %x6, align 8 - %11 = call ptr @std.io.stdout() - store ptr %11, ptr %result8, align 8 - %12 = load ptr, ptr %result8, align 8 - %13 = getelementptr inbounds %"char[]", ptr %x6, i32 0, i32 0 - %lo9 = load ptr, ptr %13, align 8 - %14 = getelementptr inbounds %"char[]", ptr %x6, i32 0, i32 1 - %hi10 = load i64, ptr %14, align 8 - %15 = call i64 @std.io.File.printn(ptr %retparam7, ptr %12, ptr %lo9, i64 %hi10) - store %"char[]" { ptr @.str.12, i64 6 }, ptr %x11, align 8 + %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr @.str, i64 3) + %4 = call ptr @std.io.stdout() + store ptr %4, ptr %result2, align 8 + %5 = load ptr, ptr %result2, align 8 + %6 = call i64 @std.io.File.printn(ptr %retparam1, ptr %5, ptr @.str.10, i64 3) + %7 = call ptr @std.io.stdout() + store ptr %7, ptr %result4, align 8 + %8 = load ptr, ptr %result4, align 8 + %9 = call i64 @std.io.File.printn(ptr %retparam3, ptr %8, ptr @.str.11, i64 6) + %10 = call ptr @std.io.stdout() + store ptr %10, ptr %result6, align 8 + %11 = load ptr, ptr %result6, align 8 + %12 = call i64 @std.io.File.printn(ptr %retparam5, ptr %11, ptr @.str.12, i64 6) + %13 = call ptr @std.io.stdout() + store ptr %13, ptr %result8, align 8 + %14 = load ptr, ptr %result8, align 8 + %15 = call i64 @std.io.File.printn(ptr %retparam7, ptr %14, ptr @.str.13, i64 5) %16 = call ptr @std.io.stdout() - store ptr %16, ptr %result13, align 8 - %17 = load ptr, ptr %result13, align 8 - %18 = getelementptr inbounds %"char[]", ptr %x11, i32 0, i32 0 - %lo14 = load ptr, ptr %18, align 8 - %19 = getelementptr inbounds %"char[]", ptr %x11, i32 0, i32 1 - %hi15 = load i64, ptr %19, align 8 - %20 = call i64 @std.io.File.printn(ptr %retparam12, ptr %17, ptr %lo14, i64 %hi15) - store %"char[]" { ptr @.str.13, i64 5 }, ptr %x16, align 8 - %21 = call ptr @std.io.stdout() - store ptr %21, ptr %result18, align 8 - %22 = load ptr, ptr %result18, align 8 - %23 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0 - %lo19 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1 - %hi20 = load i64, ptr %24, align 8 - %25 = call i64 @std.io.File.printn(ptr %retparam17, ptr %22, ptr %lo19, i64 %hi20) - store %"char[]" { ptr @.str.14, i64 4 }, ptr %x21, align 8 - %26 = call ptr @std.io.stdout() - store ptr %26, ptr %result23, align 8 - %27 = load ptr, ptr %result23, align 8 - %28 = getelementptr inbounds %"char[]", ptr %x21, i32 0, i32 0 - %lo24 = load ptr, ptr %28, align 8 - %29 = getelementptr inbounds %"char[]", ptr %x21, i32 0, i32 1 - %hi25 = load i64, ptr %29, align 8 - %30 = call i64 @std.io.File.printn(ptr %retparam22, ptr %27, ptr %lo24, i64 %hi25) - store %"char[]" { ptr @.str.15, i64 3 }, ptr %x26, align 8 - %31 = call ptr @std.io.stdout() - store ptr %31, ptr %result28, align 8 - %32 = load ptr, ptr %result28, align 8 - %33 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 0 - %lo29 = load ptr, ptr %33, align 8 - %34 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 1 - %hi30 = load i64, ptr %34, align 8 - %35 = call i64 @std.io.File.printn(ptr %retparam27, ptr %32, ptr %lo29, i64 %hi30) + store ptr %16, ptr %result10, align 8 + %17 = load ptr, ptr %result10, align 8 + %18 = call i64 @std.io.File.printn(ptr %retparam9, ptr %17, ptr @.str.14, i64 4) + %19 = call ptr @std.io.stdout() + store ptr %19, ptr %result12, align 8 + %20 = load ptr, ptr %result12, align 8 + %21 = call i64 @std.io.File.printn(ptr %retparam11, ptr %20, ptr @.str.15, i64 3) store %"char[]" { ptr @.str.17, i64 3 }, ptr %taddr, align 8 - %36 = insertvalue %any undef, ptr %taddr, 0 + %22 = insertvalue %any undef, ptr %taddr, 0 + %23 = insertvalue %any %22, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %24 = getelementptr inbounds [1 x %any], ptr %varargslots, i64 0, i64 0 + store %any %23, ptr %24, align 16 + %25 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.16, i64 8, ptr %varargslots, i64 1) + store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr16, align 8 + %26 = insertvalue %any undef, ptr %taddr16, 0 + %27 = insertvalue %any %26, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %28 = getelementptr inbounds [2 x %any], ptr %varargslots15, i64 0, i64 0 + store %any %27, ptr %28, align 16 + store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr17, align 8 + %29 = insertvalue %any undef, ptr %taddr17, 0 + %30 = insertvalue %any %29, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %31 = getelementptr inbounds [2 x %any], ptr %varargslots15, i64 0, i64 1 + store %any %30, ptr %31, align 16 + %32 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.18, i64 6, ptr %varargslots15, i64 2) + store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr20, align 8 + %33 = insertvalue %any undef, ptr %taddr20, 0 + %34 = insertvalue %any %33, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %35 = getelementptr inbounds [2 x %any], ptr %varargslots19, i64 0, i64 0 + store %any %34, ptr %35, align 16 + store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr21, align 8 + %36 = insertvalue %any undef, ptr %taddr21, 0 %37 = insertvalue %any %36, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %38 = getelementptr inbounds [1 x %any], ptr %varargslots, i64 0, i64 0 + %38 = getelementptr inbounds [2 x %any], ptr %varargslots19, i64 0, i64 1 store %any %37, ptr %38, align 16 - %39 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.16, i64 8, ptr %varargslots, i64 1) - store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr34, align 8 - %40 = insertvalue %any undef, ptr %taddr34, 0 + %39 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.21, i64 6, ptr %varargslots19, i64 2) + store %"char[]" zeroinitializer, ptr %taddr24, align 8 + %40 = insertvalue %any undef, ptr %taddr24, 0 %41 = insertvalue %any %40, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %42 = getelementptr inbounds [2 x %any], ptr %varargslots33, i64 0, i64 0 + %42 = getelementptr inbounds [2 x %any], ptr %varargslots23, i64 0, i64 0 store %any %41, ptr %42, align 16 - store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr35, align 8 - %43 = insertvalue %any undef, ptr %taddr35, 0 + store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr25, align 8 + %43 = insertvalue %any undef, ptr %taddr25, 0 %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %45 = getelementptr inbounds [2 x %any], ptr %varargslots33, i64 0, i64 1 + %45 = getelementptr inbounds [2 x %any], ptr %varargslots23, i64 0, i64 1 store %any %44, ptr %45, align 16 - %46 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.18, i64 6, ptr %varargslots33, i64 2) - store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr38, align 8 - %47 = insertvalue %any undef, ptr %taddr38, 0 + %46 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.24, i64 6, ptr %varargslots23, i64 2) + store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr28, align 8 + %47 = insertvalue %any undef, ptr %taddr28, 0 %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %49 = getelementptr inbounds [2 x %any], ptr %varargslots37, i64 0, i64 0 + %49 = getelementptr inbounds [2 x %any], ptr %varargslots27, i64 0, i64 0 store %any %48, ptr %49, align 16 - store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr39, align 8 - %50 = insertvalue %any undef, ptr %taddr39, 0 + store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr29, align 8 + %50 = insertvalue %any undef, ptr %taddr29, 0 %51 = insertvalue %any %50, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %52 = getelementptr inbounds [2 x %any], ptr %varargslots37, i64 0, i64 1 + %52 = getelementptr inbounds [2 x %any], ptr %varargslots27, i64 0, i64 1 store %any %51, ptr %52, align 16 - %53 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.21, i64 6, ptr %varargslots37, i64 2) - store %"char[]" zeroinitializer, ptr %taddr42, align 8 - %54 = insertvalue %any undef, ptr %taddr42, 0 + %53 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.26, i64 6, ptr %varargslots27, i64 2) + store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr32, align 8 + %54 = insertvalue %any undef, ptr %taddr32, 0 %55 = insertvalue %any %54, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %56 = getelementptr inbounds [2 x %any], ptr %varargslots41, i64 0, i64 0 + %56 = getelementptr inbounds [1 x %any], ptr %varargslots31, i64 0, i64 0 store %any %55, ptr %56, align 16 - store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr43, align 8 - %57 = insertvalue %any undef, ptr %taddr43, 0 - %58 = insertvalue %any %57, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %59 = getelementptr inbounds [2 x %any], ptr %varargslots41, i64 0, i64 1 - store %any %58, ptr %59, align 16 - %60 = call i64 @std.io.printfn(ptr %retparam40, ptr @.str.24, i64 6, ptr %varargslots41, i64 2) - store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr46, align 8 - %61 = insertvalue %any undef, ptr %taddr46, 0 + %57 = call i64 @std.io.printfn(ptr %retparam30, ptr @.str.29, i64 8, ptr %varargslots31, i64 1) + store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr35, align 8 + %58 = insertvalue %any undef, ptr %taddr35, 0 + %59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %60 = getelementptr inbounds [2 x %any], ptr %varargslots34, i64 0, i64 0 + store %any %59, ptr %60, align 16 + store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr36, align 8 + %61 = insertvalue %any undef, ptr %taddr36, 0 %62 = insertvalue %any %61, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %63 = getelementptr inbounds [2 x %any], ptr %varargslots45, i64 0, i64 0 + %63 = getelementptr inbounds [2 x %any], ptr %varargslots34, i64 0, i64 1 store %any %62, ptr %63, align 16 - store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr47, align 8 - %64 = insertvalue %any undef, ptr %taddr47, 0 - %65 = insertvalue %any %64, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %66 = getelementptr inbounds [2 x %any], ptr %varargslots45, i64 0, i64 1 - store %any %65, ptr %66, align 16 - %67 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.26, i64 6, ptr %varargslots45, i64 2) - store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr50, align 8 - %68 = insertvalue %any undef, ptr %taddr50, 0 + %64 = call i64 @std.io.printfn(ptr %retparam33, ptr @.str.31, i64 6, ptr %varargslots34, i64 2) + store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr39, align 8 + %65 = insertvalue %any undef, ptr %taddr39, 0 + %66 = insertvalue %any %65, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %67 = getelementptr inbounds [2 x %any], ptr %varargslots38, i64 0, i64 0 + store %any %66, ptr %67, align 16 + store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr40, align 8 + %68 = insertvalue %any undef, ptr %taddr40, 0 %69 = insertvalue %any %68, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %70 = getelementptr inbounds [1 x %any], ptr %varargslots49, i64 0, i64 0 + %70 = getelementptr inbounds [2 x %any], ptr %varargslots38, i64 0, i64 1 store %any %69, ptr %70, align 16 - %71 = call i64 @std.io.printfn(ptr %retparam48, ptr @.str.29, i64 8, ptr %varargslots49, i64 1) - store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr53, align 8 - %72 = insertvalue %any undef, ptr %taddr53, 0 + %71 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.34, i64 6, ptr %varargslots38, i64 2) + store %"char[]" zeroinitializer, ptr %taddr43, align 8 + %72 = insertvalue %any undef, ptr %taddr43, 0 %73 = insertvalue %any %72, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %74 = getelementptr inbounds [2 x %any], ptr %varargslots52, i64 0, i64 0 + %74 = getelementptr inbounds [2 x %any], ptr %varargslots42, i64 0, i64 0 store %any %73, ptr %74, align 16 - store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr54, align 8 - %75 = insertvalue %any undef, ptr %taddr54, 0 + store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr44, align 8 + %75 = insertvalue %any undef, ptr %taddr44, 0 %76 = insertvalue %any %75, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %77 = getelementptr inbounds [2 x %any], ptr %varargslots52, i64 0, i64 1 + %77 = getelementptr inbounds [2 x %any], ptr %varargslots42, i64 0, i64 1 store %any %76, ptr %77, align 16 - %78 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.31, i64 6, ptr %varargslots52, i64 2) - store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr57, align 8 - %79 = insertvalue %any undef, ptr %taddr57, 0 + %78 = call i64 @std.io.printfn(ptr %retparam41, ptr @.str.37, i64 6, ptr %varargslots42, i64 2) + store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr47, align 8 + %79 = insertvalue %any undef, ptr %taddr47, 0 %80 = insertvalue %any %79, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %81 = getelementptr inbounds [2 x %any], ptr %varargslots56, i64 0, i64 0 + %81 = getelementptr inbounds [2 x %any], ptr %varargslots46, i64 0, i64 0 store %any %80, ptr %81, align 16 - store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr58, align 8 - %82 = insertvalue %any undef, ptr %taddr58, 0 + store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr48, align 8 + %82 = insertvalue %any undef, ptr %taddr48, 0 %83 = insertvalue %any %82, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %84 = getelementptr inbounds [2 x %any], ptr %varargslots56, i64 0, i64 1 + %84 = getelementptr inbounds [2 x %any], ptr %varargslots46, i64 0, i64 1 store %any %83, ptr %84, align 16 - %85 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.34, i64 6, ptr %varargslots56, i64 2) - store %"char[]" zeroinitializer, ptr %taddr61, align 8 - %86 = insertvalue %any undef, ptr %taddr61, 0 + %85 = call i64 @std.io.printfn(ptr %retparam45, ptr @.str.39, i64 6, ptr %varargslots46, i64 2) + store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr51, align 8 + %86 = insertvalue %any undef, ptr %taddr51, 0 %87 = insertvalue %any %86, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %88 = getelementptr inbounds [2 x %any], ptr %varargslots60, i64 0, i64 0 + %88 = getelementptr inbounds [1 x %any], ptr %varargslots50, i64 0, i64 0 store %any %87, ptr %88, align 16 - store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr62, align 8 - %89 = insertvalue %any undef, ptr %taddr62, 0 - %90 = insertvalue %any %89, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %91 = getelementptr inbounds [2 x %any], ptr %varargslots60, i64 0, i64 1 - store %any %90, ptr %91, align 16 - %92 = call i64 @std.io.printfn(ptr %retparam59, ptr @.str.37, i64 6, ptr %varargslots60, i64 2) - store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr65, align 8 - %93 = insertvalue %any undef, ptr %taddr65, 0 + %89 = call i64 @std.io.printfn(ptr %retparam49, ptr @.str.42, i64 8, ptr %varargslots50, i64 1) + store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr54, align 8 + %90 = insertvalue %any undef, ptr %taddr54, 0 + %91 = insertvalue %any %90, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %92 = getelementptr inbounds [2 x %any], ptr %varargslots53, i64 0, i64 0 + store %any %91, ptr %92, align 16 + store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr55, align 8 + %93 = insertvalue %any undef, ptr %taddr55, 0 %94 = insertvalue %any %93, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %95 = getelementptr inbounds [2 x %any], ptr %varargslots64, i64 0, i64 0 + %95 = getelementptr inbounds [2 x %any], ptr %varargslots53, i64 0, i64 1 store %any %94, ptr %95, align 16 - store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr66, align 8 - %96 = insertvalue %any undef, ptr %taddr66, 0 - %97 = insertvalue %any %96, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %98 = getelementptr inbounds [2 x %any], ptr %varargslots64, i64 0, i64 1 - store %any %97, ptr %98, align 16 - %99 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.39, i64 6, ptr %varargslots64, i64 2) - store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr69, align 8 - %100 = insertvalue %any undef, ptr %taddr69, 0 + %96 = call i64 @std.io.printfn(ptr %retparam52, ptr @.str.44, i64 6, ptr %varargslots53, i64 2) + store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr58, align 8 + %97 = insertvalue %any undef, ptr %taddr58, 0 + %98 = insertvalue %any %97, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %99 = getelementptr inbounds [2 x %any], ptr %varargslots57, i64 0, i64 0 + store %any %98, ptr %99, align 16 + store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr59, align 8 + %100 = insertvalue %any undef, ptr %taddr59, 0 %101 = insertvalue %any %100, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %102 = getelementptr inbounds [1 x %any], ptr %varargslots68, i64 0, i64 0 + %102 = getelementptr inbounds [2 x %any], ptr %varargslots57, i64 0, i64 1 store %any %101, ptr %102, align 16 - %103 = call i64 @std.io.printfn(ptr %retparam67, ptr @.str.42, i64 8, ptr %varargslots68, i64 1) - store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr72, align 8 - %104 = insertvalue %any undef, ptr %taddr72, 0 - %105 = insertvalue %any %104, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %106 = getelementptr inbounds [2 x %any], ptr %varargslots71, i64 0, i64 0 - store %any %105, ptr %106, align 16 - store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr73, align 8 - %107 = insertvalue %any undef, ptr %taddr73, 0 - %108 = insertvalue %any %107, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %109 = getelementptr inbounds [2 x %any], ptr %varargslots71, i64 0, i64 1 - store %any %108, ptr %109, align 16 - %110 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.44, i64 6, ptr %varargslots71, i64 2) - store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr76, align 8 - %111 = insertvalue %any undef, ptr %taddr76, 0 - %112 = insertvalue %any %111, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %113 = getelementptr inbounds [2 x %any], ptr %varargslots75, i64 0, i64 0 - store %any %112, ptr %113, align 16 - store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr77, align 8 - %114 = insertvalue %any undef, ptr %taddr77, 0 - %115 = insertvalue %any %114, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %116 = getelementptr inbounds [2 x %any], ptr %varargslots75, i64 0, i64 1 - store %any %115, ptr %116, align 16 - %117 = call i64 @std.io.printfn(ptr %retparam74, ptr @.str.47, i64 6, ptr %varargslots75, i64 2) + %103 = call i64 @std.io.printfn(ptr %retparam56, ptr @.str.47, i64 6, ptr %varargslots57, i64 2) ret void } + ; Function Attrs: nounwind define void @test.main() #0 { entry: diff --git a/test/test_suite/compile_time/untyped_conversions.c3t b/test/test_suite/compile_time/untyped_conversions.c3t index da306bb2d..0e123111c 100644 --- a/test/test_suite/compile_time/untyped_conversions.c3t +++ b/test/test_suite/compile_time/untyped_conversions.c3t @@ -122,20 +122,24 @@ entry: store i32 3, ptr %18, align 4 %19 = getelementptr inbounds [2 x i32], ptr %literal1, i64 0, i64 1 store i32 4, ptr %19, align 4 + %20 = insertvalue %"int[]" undef, ptr %literal1, 0 + %21 = insertvalue %"int[]" %20, i64 2, 1 store <2 x i32> , ptr %taddr, align 8 - %20 = load double, ptr %taddr, align 8 - call void @test.test(i64 %17, ptr %literal1, i64 2, double %20) - %21 = getelementptr inbounds [2 x i32], ptr %literal2, i64 0, i64 0 - store i32 2, ptr %21, align 4 - %22 = getelementptr inbounds [2 x i32], ptr %literal2, i64 0, i64 1 - store i32 7, ptr %22, align 4 - %23 = load i64, ptr %literal2, align 4 - %24 = getelementptr inbounds [2 x i32], ptr %literal3, i64 0, i64 0 - store i32 2, ptr %24, align 4 - %25 = getelementptr inbounds [2 x i32], ptr %literal3, i64 0, i64 1 - store i32 7, ptr %25, align 4 + %22 = load double, ptr %taddr, align 8 + call void @test.test(i64 %17, ptr %literal1, i64 2, double %22) + %23 = getelementptr inbounds [2 x i32], ptr %literal2, i64 0, i64 0 + store i32 2, ptr %23, align 4 + %24 = getelementptr inbounds [2 x i32], ptr %literal2, i64 0, i64 1 + store i32 7, ptr %24, align 4 + %25 = load i64, ptr %literal2, align 4 + %26 = getelementptr inbounds [2 x i32], ptr %literal3, i64 0, i64 0 + store i32 2, ptr %26, align 4 + %27 = getelementptr inbounds [2 x i32], ptr %literal3, i64 0, i64 1 + store i32 7, ptr %27, align 4 + %28 = insertvalue %"int[]" undef, ptr %literal3, 0 + %29 = insertvalue %"int[]" %28, i64 2, 1 store <2 x i32> , ptr %taddr4, align 8 - %26 = load double, ptr %taddr4, align 8 - call void @test.test(i64 %23, ptr %literal3, i64 2, double %26) + %30 = load double, ptr %taddr4, align 8 + call void @test.test(i64 %25, ptr %literal3, i64 2, double %30) ret void } diff --git a/test/test_suite/enumerations/enum_conversions.c3t b/test/test_suite/enumerations/enum_conversions.c3t index 35cffb020..8995c7d15 100644 --- a/test/test_suite/enumerations/enum_conversions.c3t +++ b/test/test_suite/enumerations/enum_conversions.c3t @@ -27,6 +27,7 @@ entry: %0 = load i32, ptr %a, align 4 %lt = icmp slt i32 %0, 0 br i1 %lt, label %panic, label %checkok + panic: ; preds = %entry store i32 %0, ptr %taddr, align 4 %1 = insertvalue %any undef, ptr %taddr, 0 @@ -34,122 +35,137 @@ panic: ; preds = %entry %3 = getelementptr inbounds [1 x %any], ptr %varargslots, i64 0, i64 0 store %any %2, ptr %3, align 16 %4 = insertvalue %"any[]" undef, ptr %varargslots, 0 - %5 = insertvalue %"any[]" %4, i64 1, 1 - store %"any[]" %5, ptr %indirectarg, align 8 + %"#temp#" = insertvalue %"any[]" %4, i64 1, 1 + store %"any[]" %"#temp#", ptr %indirectarg, align 8 call void @std.core.builtin.panicf(ptr @.panic_msg, i64 7, ptr @.file, i64 19, ptr @.func, i64 4, i32 7, ptr byval(%"any[]") align 8 %indirectarg) br label %checkok + checkok: ; preds = %panic, %entry %ge = icmp sge i32 %0, 1 - br i1 %ge, label %panic1, label %checkok5 + br i1 %ge, label %panic1, label %checkok6 + panic1: ; preds = %checkok store i32 %0, ptr %taddr2, align 4 - %6 = insertvalue %any undef, ptr %taddr2, 0 - %7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %8 = getelementptr inbounds [1 x %any], ptr %varargslots3, i64 0, i64 0 - store %any %7, ptr %8, align 16 - %9 = insertvalue %"any[]" undef, ptr %varargslots3, 0 - %10 = insertvalue %"any[]" %9, i64 1, 1 - store %"any[]" %10, ptr %indirectarg4, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg.1, i64 87, ptr @.file, i64 19, ptr @.func, i64 4, i32 7, ptr byval(%"any[]") align 8 %indirectarg4) - br label %checkok5 -checkok5: ; preds = %panic1, %checkok + %5 = insertvalue %any undef, ptr %taddr2, 0 + %6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %7 = getelementptr inbounds [1 x %any], ptr %varargslots3, i64 0, i64 0 + store %any %6, ptr %7, align 16 + %8 = insertvalue %"any[]" undef, ptr %varargslots3, 0 + %"#temp#4" = insertvalue %"any[]" %8, i64 1, 1 + store %"any[]" %"#temp#4", ptr %indirectarg5, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg.1, i64 87, ptr @.file, i64 19, ptr @.func, i64 4, i32 7, ptr byval(%"any[]") align 8 %indirectarg5) + br label %checkok6 + +checkok6: ; preds = %panic1, %checkok %trunc = trunc i32 %0 to i8 store i8 %trunc, ptr %x, align 1 store i64 0, ptr %z, align 8 - %11 = load i64, ptr %z, align 8 - %lt6 = icmp slt i64 %11, 0 - br i1 %lt6, label %panic7, label %checkok11 -panic7: ; preds = %checkok5 - store i64 %11, ptr %taddr8, align 8 - %12 = insertvalue %any undef, ptr %taddr8, 0 - %13 = insertvalue %any %12, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %14 = getelementptr inbounds [1 x %any], ptr %varargslots9, i64 0, i64 0 - store %any %13, ptr %14, align 16 - %15 = insertvalue %"any[]" undef, ptr %varargslots9, 0 - %16 = insertvalue %"any[]" %15, i64 1, 1 - store %"any[]" %16, ptr %indirectarg10, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg.2, i64 8, ptr @.file, i64 19, ptr @.func, i64 4, i32 9, ptr byval(%"any[]") align 8 %indirectarg10) - br label %checkok11 -checkok11: ; preds = %panic7, %checkok5 - %ge12 = icmp sge i64 %11, 1 - br i1 %ge12, label %panic13, label %checkok17 -panic13: ; preds = %checkok11 - store i64 %11, ptr %taddr14, align 8 - %17 = insertvalue %any undef, ptr %taddr14, 0 - %18 = insertvalue %any %17, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %19 = getelementptr inbounds [1 x %any], ptr %varargslots15, i64 0, i64 0 - store %any %18, ptr %19, align 16 - %20 = insertvalue %"any[]" undef, ptr %varargslots15, 0 - %21 = insertvalue %"any[]" %20, i64 1, 1 - store %"any[]" %21, ptr %indirectarg16, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg.1, i64 87, ptr @.file, i64 19, ptr @.func, i64 4, i32 9, ptr byval(%"any[]") align 8 %indirectarg16) - br label %checkok17 -checkok17: ; preds = %panic13, %checkok11 - %trunc18 = trunc i64 %11 to i8 - store i8 %trunc18, ptr %y, align 1 + %9 = load i64, ptr %z, align 8 + %lt7 = icmp slt i64 %9, 0 + br i1 %lt7, label %panic8, label %checkok13 + +panic8: ; preds = %checkok6 + store i64 %9, ptr %taddr9, align 8 + %10 = insertvalue %any undef, ptr %taddr9, 0 + %11 = insertvalue %any %10, i64 ptrtoint (ptr @"$ct.long" to i64), 1 + %12 = getelementptr inbounds [1 x %any], ptr %varargslots10, i64 0, i64 0 + store %any %11, ptr %12, align 16 + %13 = insertvalue %"any[]" undef, ptr %varargslots10, 0 + %"#temp#11" = insertvalue %"any[]" %13, i64 1, 1 + store %"any[]" %"#temp#11", ptr %indirectarg12, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg.2, i64 8, ptr @.file, i64 19, ptr @.func, i64 4, i32 9, ptr byval(%"any[]") align 8 %indirectarg12) + br label %checkok13 + +checkok13: ; preds = %panic8, %checkok6 + %ge14 = icmp sge i64 %9, 1 + br i1 %ge14, label %panic15, label %checkok20 + +panic15: ; preds = %checkok13 + store i64 %9, ptr %taddr16, align 8 + %14 = insertvalue %any undef, ptr %taddr16, 0 + %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.long" to i64), 1 + %16 = getelementptr inbounds [1 x %any], ptr %varargslots17, i64 0, i64 0 + store %any %15, ptr %16, align 16 + %17 = insertvalue %"any[]" undef, ptr %varargslots17, 0 + %"#temp#18" = insertvalue %"any[]" %17, i64 1, 1 + store %"any[]" %"#temp#18", ptr %indirectarg19, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg.1, i64 87, ptr @.file, i64 19, ptr @.func, i64 4, i32 9, ptr byval(%"any[]") align 8 %indirectarg19) + br label %checkok20 + +checkok20: ; preds = %panic15, %checkok13 + %trunc21 = trunc i64 %9 to i8 + store i8 %trunc21, ptr %y, align 1 store i32 256, ptr %a, align 4 - %22 = load i32, ptr %a, align 4 - %lt19 = icmp slt i32 %22, 0 - br i1 %lt19, label %panic20, label %checkok24 -panic20: ; preds = %checkok17 - store i32 %22, ptr %taddr21, align 4 - %23 = insertvalue %any undef, ptr %taddr21, 0 + %18 = load i32, ptr %a, align 4 + %lt22 = icmp slt i32 %18, 0 + br i1 %lt22, label %panic23, label %checkok28 + +panic23: ; preds = %checkok20 + store i32 %18, ptr %taddr24, align 4 + %19 = insertvalue %any undef, ptr %taddr24, 0 + %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %21 = getelementptr inbounds [1 x %any], ptr %varargslots25, i64 0, i64 0 + store %any %20, ptr %21, align 16 + %22 = insertvalue %"any[]" undef, ptr %varargslots25, 0 + %"#temp#26" = insertvalue %"any[]" %22, i64 1, 1 + store %"any[]" %"#temp#26", ptr %indirectarg27, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg.3, i64 62, ptr @.file, i64 19, ptr @.func, i64 4, i32 11, ptr byval(%"any[]") align 8 %indirectarg27) + br label %checkok28 + +checkok28: ; preds = %panic23, %checkok20 + %ge29 = icmp sge i32 %18, 1 + br i1 %ge29, label %panic30, label %checkok35 + +panic30: ; preds = %checkok28 + store i32 %18, ptr %taddr31, align 4 + %23 = insertvalue %any undef, ptr %taddr31, 0 %24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %25 = getelementptr inbounds [1 x %any], ptr %varargslots22, i64 0, i64 0 + %25 = getelementptr inbounds [1 x %any], ptr %varargslots32, i64 0, i64 0 store %any %24, ptr %25, align 16 - %26 = insertvalue %"any[]" undef, ptr %varargslots22, 0 - %27 = insertvalue %"any[]" %26, i64 1, 1 - store %"any[]" %27, ptr %indirectarg23, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg.3, i64 62, ptr @.file, i64 19, ptr @.func, i64 4, i32 11, ptr byval(%"any[]") align 8 %indirectarg23) - br label %checkok24 -checkok24: ; preds = %panic20, %checkok17 - %ge25 = icmp sge i32 %22, 1 - br i1 %ge25, label %panic26, label %checkok30 -panic26: ; preds = %checkok24 - store i32 %22, ptr %taddr27, align 4 - %28 = insertvalue %any undef, ptr %taddr27, 0 - %29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %30 = getelementptr inbounds [1 x %any], ptr %varargslots28, i64 0, i64 0 - store %any %29, ptr %30, align 16 - %31 = insertvalue %"any[]" undef, ptr %varargslots28, 0 - %32 = insertvalue %"any[]" %31, i64 1, 1 - store %"any[]" %32, ptr %indirectarg29, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg.1, i64 87, ptr @.file, i64 19, ptr @.func, i64 4, i32 11, ptr byval(%"any[]") align 8 %indirectarg29) - br label %checkok30 -checkok30: ; preds = %panic26, %checkok24 - %trunc31 = trunc i32 %22 to i8 - store i8 %trunc31, ptr %y, align 1 + %26 = insertvalue %"any[]" undef, ptr %varargslots32, 0 + %"#temp#33" = insertvalue %"any[]" %26, i64 1, 1 + store %"any[]" %"#temp#33", ptr %indirectarg34, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg.1, i64 87, ptr @.file, i64 19, ptr @.func, i64 4, i32 11, ptr byval(%"any[]") align 8 %indirectarg34) + br label %checkok35 + +checkok35: ; preds = %panic30, %checkok28 + %trunc36 = trunc i32 %18 to i8 + store i8 %trunc36, ptr %y, align 1 store i32 -1, ptr %a, align 4 - %33 = load i32, ptr %a, align 4 - %lt32 = icmp slt i32 %33, 0 - br i1 %lt32, label %panic33, label %checkok37 -panic33: ; preds = %checkok30 - store i32 %33, ptr %taddr34, align 4 - %34 = insertvalue %any undef, ptr %taddr34, 0 - %35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %36 = getelementptr inbounds [1 x %any], ptr %varargslots35, i64 0, i64 0 - store %any %35, ptr %36, align 16 - %37 = insertvalue %"any[]" undef, ptr %varargslots35, 0 - %38 = insertvalue %"any[]" %37, i64 1, 1 - store %"any[]" %38, ptr %indirectarg36, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg.3, i64 62, ptr @.file, i64 19, ptr @.func, i64 4, i32 13, ptr byval(%"any[]") align 8 %indirectarg36) - br label %checkok37 -checkok37: ; preds = %panic33, %checkok30 - %ge38 = icmp sge i32 %33, 1 - br i1 %ge38, label %panic39, label %checkok43 -panic39: ; preds = %checkok37 - store i32 %33, ptr %taddr40, align 4 - %39 = insertvalue %any undef, ptr %taddr40, 0 - %40 = insertvalue %any %39, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %41 = getelementptr inbounds [1 x %any], ptr %varargslots41, i64 0, i64 0 - store %any %40, ptr %41, align 16 - %42 = insertvalue %"any[]" undef, ptr %varargslots41, 0 - %43 = insertvalue %"any[]" %42, i64 1, 1 - store %"any[]" %43, ptr %indirectarg42, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg.1, i64 87, ptr @.file, i64 19, ptr @.func, i64 4, i32 13, ptr byval(%"any[]") align 8 %indirectarg42) + %27 = load i32, ptr %a, align 4 + %lt37 = icmp slt i32 %27, 0 + br i1 %lt37, label %panic38, label %checkok43 + +panic38: ; preds = %checkok35 + store i32 %27, ptr %taddr39, align 4 + %28 = insertvalue %any undef, ptr %taddr39, 0 + %29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %30 = getelementptr inbounds [1 x %any], ptr %varargslots40, i64 0, i64 0 + store %any %29, ptr %30, align 16 + %31 = insertvalue %"any[]" undef, ptr %varargslots40, 0 + %"#temp#41" = insertvalue %"any[]" %31, i64 1, 1 + store %"any[]" %"#temp#41", ptr %indirectarg42, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg.3, i64 62, ptr @.file, i64 19, ptr @.func, i64 4, i32 13, ptr byval(%"any[]") align 8 %indirectarg42) br label %checkok43 -checkok43: ; preds = %panic39, %checkok37 - %trunc44 = trunc i32 %33 to i8 - store i8 %trunc44, ptr %y, align 1 + +checkok43: ; preds = %panic38, %checkok35 + %ge44 = icmp sge i32 %27, 1 + br i1 %ge44, label %panic45, label %checkok50 + +panic45: ; preds = %checkok43 + store i32 %27, ptr %taddr46, align 4 + %32 = insertvalue %any undef, ptr %taddr46, 0 + %33 = insertvalue %any %32, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %34 = getelementptr inbounds [1 x %any], ptr %varargslots47, i64 0, i64 0 + store %any %33, ptr %34, align 16 + %35 = insertvalue %"any[]" undef, ptr %varargslots47, 0 + %"#temp#48" = insertvalue %"any[]" %35, i64 1, 1 + store %"any[]" %"#temp#48", ptr %indirectarg49, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg.1, i64 87, ptr @.file, i64 19, ptr @.func, i64 4, i32 13, ptr byval(%"any[]") align 8 %indirectarg49) + br label %checkok50 + +checkok50: ; preds = %panic45, %checkok43 + %trunc51 = trunc i32 %27 to i8 + store i8 %trunc51, ptr %y, align 1 ret void } diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t index 70356c8e5..4ec58b136 100644 --- a/test/test_suite/errors/error_regression_2.c3t +++ b/test/test_suite/errors/error_regression_2.c3t @@ -291,48 +291,48 @@ entry: %allocator33 = alloca ptr, align 8 %retparam35 = alloca ptr, align 8 %varargslots40 = alloca [1 x %any], align 16 - %indirectarg41 = alloca %"any[]", align 8 - %value48 = alloca %Head, align 8 - %temp49 = alloca ptr, align 8 - %using50 = alloca ptr, align 8 - %error_var51 = alloca i64, align 8 - %using52 = alloca ptr, align 8 - %allocator54 = alloca ptr, align 8 - %retparam56 = alloca ptr, align 8 - %varargslots61 = alloca [1 x %any], align 16 - %indirectarg62 = alloca %"any[]", align 8 + %indirectarg42 = alloca %"any[]", align 8 + %value49 = alloca %Head, align 8 + %temp50 = alloca ptr, align 8 + %using51 = alloca ptr, align 8 + %error_var52 = alloca i64, align 8 + %using53 = alloca ptr, align 8 + %allocator55 = alloca ptr, align 8 + %retparam57 = alloca ptr, align 8 + %varargslots62 = alloca [1 x %any], align 16 + %indirectarg64 = alloca %"any[]", align 8 %len = alloca i32, align 4 %str = alloca ptr, align 8 - %using70 = alloca ptr, align 8 - %error_var71 = alloca i64, align 8 %using72 = alloca ptr, align 8 - %allocator73 = alloca ptr, align 8 - %retparam75 = alloca ptr, align 8 - %varargslots80 = alloca [1 x %any], align 16 - %indirectarg81 = alloca %"any[]", align 8 - %reterr89 = alloca i64, align 8 - %literal90 = alloca %Doc, align 8 - %error_var91 = alloca i64, align 8 - %literal92 = alloca %Head, align 8 - %error_var93 = alloca i64, align 8 - %value96 = alloca %"char[]", align 8 - %temp97 = alloca ptr, align 8 - %using98 = alloca ptr, align 8 - %error_var99 = alloca i64, align 8 - %using100 = alloca ptr, align 8 - %allocator102 = alloca ptr, align 8 - %retparam104 = alloca ptr, align 8 - %varargslots109 = alloca [1 x %any], align 16 - %indirectarg110 = alloca %"any[]", align 8 - %value117 = alloca %Head, align 8 - %temp118 = alloca ptr, align 8 - %using119 = alloca ptr, align 8 - %error_var120 = alloca i64, align 8 - %using121 = alloca ptr, align 8 - %allocator123 = alloca ptr, align 8 - %retparam125 = alloca ptr, align 8 - %varargslots130 = alloca [1 x %any], align 16 - %indirectarg131 = alloca %"any[]", align 8 + %error_var73 = alloca i64, align 8 + %using74 = alloca ptr, align 8 + %allocator75 = alloca ptr, align 8 + %retparam77 = alloca ptr, align 8 + %varargslots82 = alloca [1 x %any], align 16 + %indirectarg84 = alloca %"any[]", align 8 + %reterr92 = alloca i64, align 8 + %literal93 = alloca %Doc, align 8 + %error_var94 = alloca i64, align 8 + %literal95 = alloca %Head, align 8 + %error_var96 = alloca i64, align 8 + %value99 = alloca %"char[]", align 8 + %temp100 = alloca ptr, align 8 + %using101 = alloca ptr, align 8 + %error_var102 = alloca i64, align 8 + %using103 = alloca ptr, align 8 + %allocator105 = alloca ptr, align 8 + %retparam107 = alloca ptr, align 8 + %varargslots112 = alloca [1 x %any], align 16 + %indirectarg114 = alloca %"any[]", align 8 + %value121 = alloca %Head, align 8 + %temp122 = alloca ptr, align 8 + %using123 = alloca ptr, align 8 + %error_var124 = alloca i64, align 8 + %using125 = alloca ptr, align 8 + %allocator127 = alloca ptr, align 8 + %retparam129 = alloca ptr, align 8 + %varargslots134 = alloca [1 x %any], align 16 + %indirectarg136 = alloca %"any[]", align 8 store ptr %1, ptr %url, align 8 %ptroffset = getelementptr inbounds i64, ptr %url, i64 1 store i64 %2, ptr %ptroffset, align 8 @@ -405,15 +405,15 @@ panic_block: ; preds = %assign_optional %30 = getelementptr inbounds [1 x %any], ptr %varargslots, i64 0, i64 0 store %any %29, ptr %30, align 16 %31 = insertvalue %"any[]" undef, ptr %varargslots, 0 - %32 = insertvalue %"any[]" %31, i64 1, 1 - store %"any[]" %32, ptr %indirectarg, align 8 + %"#temp#" = insertvalue %"any[]" %31, i64 1, 1 + store %"any[]" %"#temp#", ptr %indirectarg, align 8 call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg) unreachable noerr_block: ; preds = %after_check store ptr %27, ptr %temp, align 8 - %33 = load ptr, ptr %temp, align 8 - %not = icmp eq ptr %33, null + %32 = load ptr, ptr %temp, align 8 + %not = icmp eq ptr %32, null br i1 %not, label %if.then15, label %if.exit16 if.then15: ; preds = %noerr_block @@ -421,343 +421,343 @@ if.then15: ; preds = %noerr_block br label %guard_block if.exit16: ; preds = %noerr_block - %34 = load ptr, ptr %temp, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %34, ptr align 8 %value, i32 8, i1 false) + %33 = load ptr, ptr %temp, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %33, ptr align 8 %value, i32 8, i1 false) br label %noerr_block17 guard_block: ; preds = %if.then15 - %35 = load i64, ptr %error_var, align 8 - ret i64 %35 + %34 = load i64, ptr %error_var, align 8 + ret i64 %34 noerr_block17: ; preds = %if.exit16 - %36 = load ptr, ptr %temp, align 8 - store ptr %36, ptr %16, align 8 + %35 = load ptr, ptr %temp, align 8 + store ptr %35, ptr %16, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal9, i32 8, i1 false) ret i64 0 if.exit18: ; preds = %if.exit4 - %37 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 - %lo19 = load ptr, ptr %37, align 8 - %38 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 - %hi20 = load i64, ptr %38, align 8 - %39 = call i8 @test.contains(ptr %lo19, i64 %hi20, ptr @.str.5, i64 11) - %40 = trunc i8 %39 to i1 - br i1 %40, label %if.then21, label %if.exit69 + %36 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %lo19 = load ptr, ptr %36, align 8 + %37 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %hi20 = load i64, ptr %37, align 8 + %38 = call i8 @test.contains(ptr %lo19, i64 %hi20, ptr @.str.5, i64 11) + %39 = trunc i8 %38 to i1 + br i1 %39, label %if.then21, label %if.exit71 if.then21: ; preds = %if.exit18 - %41 = getelementptr inbounds %Doc, ptr %literal23, i32 0, i32 0 + %40 = getelementptr inbounds %Doc, ptr %literal23, i32 0, i32 0 store ptr null, ptr %literal25, align 8 - %42 = getelementptr inbounds %Head, ptr %literal25, i32 0, i32 0 + %41 = getelementptr inbounds %Head, ptr %literal25, i32 0, i32 0 store %"char[]" zeroinitializer, ptr %value27, align 8 - %43 = load ptr, ptr @std.core.mem.thread_allocator, align 8 - store ptr %43, ptr %using29, align 8 - %44 = load ptr, ptr %using29, align 8 - store ptr %44, ptr %using31, align 8 - %45 = load ptr, ptr %using31, align 8 - store ptr %45, ptr %allocator33, align 8 - %46 = load ptr, ptr %allocator33, align 8 - %47 = getelementptr inbounds %Allocator, ptr %46, i32 0, i32 0 - %48 = load ptr, ptr %47, align 8 - %49 = load ptr, ptr %allocator33, align 8 - %50 = call i64 %48(ptr %retparam35, ptr %49, i64 16, i64 0, i64 0, ptr null, i32 0) - %not_err36 = icmp eq i64 %50, 0 - %51 = call i1 @llvm.expect.i1(i1 %not_err36, i1 true) - br i1 %51, label %after_check38, label %assign_optional37 + %42 = load ptr, ptr @std.core.mem.thread_allocator, align 8 + store ptr %42, ptr %using29, align 8 + %43 = load ptr, ptr %using29, align 8 + store ptr %43, ptr %using31, align 8 + %44 = load ptr, ptr %using31, align 8 + store ptr %44, ptr %allocator33, align 8 + %45 = load ptr, ptr %allocator33, align 8 + %46 = getelementptr inbounds %Allocator, ptr %45, i32 0, i32 0 + %47 = load ptr, ptr %46, align 8 + %48 = load ptr, ptr %allocator33, align 8 + %49 = call i64 %47(ptr %retparam35, ptr %48, i64 16, i64 0, i64 0, ptr null, i32 0) + %not_err36 = icmp eq i64 %49, 0 + %50 = call i1 @llvm.expect.i1(i1 %not_err36, i1 true) + br i1 %50, label %after_check38, label %assign_optional37 assign_optional37: ; preds = %if.then21 - store i64 %50, ptr %error_var30, align 8 + store i64 %49, ptr %error_var30, align 8 br label %panic_block39 after_check38: ; preds = %if.then21 - %52 = load ptr, ptr %retparam35, align 8 - br label %noerr_block42 + %51 = load ptr, ptr %retparam35, align 8 + br label %noerr_block43 panic_block39: ; preds = %assign_optional37 - %53 = insertvalue %any undef, ptr %error_var30, 0 - %54 = insertvalue %any %53, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %55 = getelementptr inbounds [1 x %any], ptr %varargslots40, i64 0, i64 0 - store %any %54, ptr %55, align 16 - %56 = insertvalue %"any[]" undef, ptr %varargslots40, 0 - %57 = insertvalue %"any[]" %56, i64 1, 1 - store %"any[]" %57, ptr %indirectarg41, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg41) + %52 = insertvalue %any undef, ptr %error_var30, 0 + %53 = insertvalue %any %52, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 + %54 = getelementptr inbounds [1 x %any], ptr %varargslots40, i64 0, i64 0 + store %any %53, ptr %54, align 16 + %55 = insertvalue %"any[]" undef, ptr %varargslots40, 0 + %"#temp#41" = insertvalue %"any[]" %55, i64 1, 1 + store %"any[]" %"#temp#41", ptr %indirectarg42, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg42) unreachable -noerr_block42: ; preds = %after_check38 - store ptr %52, ptr %temp28, align 8 - %58 = load ptr, ptr %temp28, align 8 - %not43 = icmp eq ptr %58, null - br i1 %not43, label %if.then44, label %if.exit45 +noerr_block43: ; preds = %after_check38 + store ptr %51, ptr %temp28, align 8 + %56 = load ptr, ptr %temp28, align 8 + %not44 = icmp eq ptr %56, null + br i1 %not44, label %if.then45, label %if.exit46 -if.then44: ; preds = %noerr_block42 +if.then45: ; preds = %noerr_block43 store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var26, align 8 - br label %guard_block46 + br label %guard_block47 -if.exit45: ; preds = %noerr_block42 +if.exit46: ; preds = %noerr_block43 + %57 = load ptr, ptr %temp28, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %57, ptr align 8 %value27, i32 16, i1 false) + br label %noerr_block48 + +guard_block47: ; preds = %if.then45 + %58 = load i64, ptr %error_var26, align 8 + ret i64 %58 + +noerr_block48: ; preds = %if.exit46 %59 = load ptr, ptr %temp28, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %59, ptr align 8 %value27, i32 16, i1 false) - br label %noerr_block47 + store ptr %59, ptr %41, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value49, ptr align 8 %literal25, i32 8, i1 false) + %60 = load ptr, ptr @std.core.mem.thread_allocator, align 8 + store ptr %60, ptr %using51, align 8 + %61 = load ptr, ptr %using51, align 8 + store ptr %61, ptr %using53, align 8 + %62 = load ptr, ptr %using53, align 8 + store ptr %62, ptr %allocator55, align 8 + %63 = load ptr, ptr %allocator55, align 8 + %64 = getelementptr inbounds %Allocator, ptr %63, i32 0, i32 0 + %65 = load ptr, ptr %64, align 8 + %66 = load ptr, ptr %allocator55, align 8 + %67 = call i64 %65(ptr %retparam57, ptr %66, i64 8, i64 0, i64 0, ptr null, i32 0) + %not_err58 = icmp eq i64 %67, 0 + %68 = call i1 @llvm.expect.i1(i1 %not_err58, i1 true) + br i1 %68, label %after_check60, label %assign_optional59 -guard_block46: ; preds = %if.then44 - %60 = load i64, ptr %error_var26, align 8 - ret i64 %60 +assign_optional59: ; preds = %noerr_block48 + store i64 %67, ptr %error_var52, align 8 + br label %panic_block61 -noerr_block47: ; preds = %if.exit45 - %61 = load ptr, ptr %temp28, align 8 - store ptr %61, ptr %42, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value48, ptr align 8 %literal25, i32 8, i1 false) - %62 = load ptr, ptr @std.core.mem.thread_allocator, align 8 - store ptr %62, ptr %using50, align 8 - %63 = load ptr, ptr %using50, align 8 - store ptr %63, ptr %using52, align 8 - %64 = load ptr, ptr %using52, align 8 - store ptr %64, ptr %allocator54, align 8 - %65 = load ptr, ptr %allocator54, align 8 - %66 = getelementptr inbounds %Allocator, ptr %65, i32 0, i32 0 - %67 = load ptr, ptr %66, align 8 - %68 = load ptr, ptr %allocator54, align 8 - %69 = call i64 %67(ptr %retparam56, ptr %68, i64 8, i64 0, i64 0, ptr null, i32 0) - %not_err57 = icmp eq i64 %69, 0 - %70 = call i1 @llvm.expect.i1(i1 %not_err57, i1 true) - br i1 %70, label %after_check59, label %assign_optional58 +after_check60: ; preds = %noerr_block48 + %69 = load ptr, ptr %retparam57, align 8 + br label %noerr_block65 -assign_optional58: ; preds = %noerr_block47 - store i64 %69, ptr %error_var51, align 8 - br label %panic_block60 - -after_check59: ; preds = %noerr_block47 - %71 = load ptr, ptr %retparam56, align 8 - br label %noerr_block63 - -panic_block60: ; preds = %assign_optional58 - %72 = insertvalue %any undef, ptr %error_var51, 0 - %73 = insertvalue %any %72, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %74 = getelementptr inbounds [1 x %any], ptr %varargslots61, i64 0, i64 0 - store %any %73, ptr %74, align 16 - %75 = insertvalue %"any[]" undef, ptr %varargslots61, 0 - %76 = insertvalue %"any[]" %75, i64 1, 1 - store %"any[]" %76, ptr %indirectarg62, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg62) +panic_block61: ; preds = %assign_optional59 + %70 = insertvalue %any undef, ptr %error_var52, 0 + %71 = insertvalue %any %70, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 + %72 = getelementptr inbounds [1 x %any], ptr %varargslots62, i64 0, i64 0 + store %any %71, ptr %72, align 16 + %73 = insertvalue %"any[]" undef, ptr %varargslots62, 0 + %"#temp#63" = insertvalue %"any[]" %73, i64 1, 1 + store %"any[]" %"#temp#63", ptr %indirectarg64, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg64) unreachable -noerr_block63: ; preds = %after_check59 - store ptr %71, ptr %temp49, align 8 - %77 = load ptr, ptr %temp49, align 8 - %not64 = icmp eq ptr %77, null - br i1 %not64, label %if.then65, label %if.exit66 +noerr_block65: ; preds = %after_check60 + store ptr %69, ptr %temp50, align 8 + %74 = load ptr, ptr %temp50, align 8 + %not66 = icmp eq ptr %74, null + br i1 %not66, label %if.then67, label %if.exit68 -if.then65: ; preds = %noerr_block63 +if.then67: ; preds = %noerr_block65 store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var24, align 8 - br label %guard_block67 + br label %guard_block69 -if.exit66: ; preds = %noerr_block63 - %78 = load ptr, ptr %temp49, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %78, ptr align 8 %value48, i32 8, i1 false) - br label %noerr_block68 +if.exit68: ; preds = %noerr_block65 + %75 = load ptr, ptr %temp50, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %75, ptr align 8 %value49, i32 8, i1 false) + br label %noerr_block70 -guard_block67: ; preds = %if.then65 - %79 = load i64, ptr %error_var24, align 8 - ret i64 %79 +guard_block69: ; preds = %if.then67 + %76 = load i64, ptr %error_var24, align 8 + ret i64 %76 -noerr_block68: ; preds = %if.exit66 - %80 = load ptr, ptr %temp49, align 8 - store ptr %80, ptr %41, align 8 +noerr_block70: ; preds = %if.exit68 + %77 = load ptr, ptr %temp50, align 8 + store ptr %77, ptr %40, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal23, i32 8, i1 false) ret i64 0 -if.exit69: ; preds = %if.exit18 - %81 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 - %82 = load i64, ptr %81, align 8 - %trunc = trunc i64 %82 to i32 - %83 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 - %84 = load ptr, ptr %83, align 8 - %85 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.6, i32 %trunc, ptr %84) - store i32 %85, ptr %len, align 4 - %86 = load ptr, ptr @std.core.mem.thread_allocator, align 8 - store ptr %86, ptr %using70, align 8 - %87 = load ptr, ptr %using70, align 8 - store ptr %87, ptr %using72, align 8 - %88 = load i32, ptr %len, align 4 - %add = add i32 %88, 1 - %89 = load ptr, ptr %using72, align 8 - store ptr %89, ptr %allocator73, align 8 +if.exit71: ; preds = %if.exit18 + %78 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %79 = load i64, ptr %78, align 8 + %trunc = trunc i64 %79 to i32 + %80 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %81 = load ptr, ptr %80, align 8 + %82 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.6, i32 %trunc, ptr %81) + store i32 %82, ptr %len, align 4 + %83 = load ptr, ptr @std.core.mem.thread_allocator, align 8 + store ptr %83, ptr %using72, align 8 + %84 = load ptr, ptr %using72, align 8 + store ptr %84, ptr %using74, align 8 + %85 = load i32, ptr %len, align 4 + %add = add i32 %85, 1 + %86 = load ptr, ptr %using74, align 8 + store ptr %86, ptr %allocator75, align 8 %sext = sext i32 %add to i64 - %add74 = add i64 %sext, 0 - %90 = load ptr, ptr %allocator73, align 8 - %91 = getelementptr inbounds %Allocator, ptr %90, i32 0, i32 0 - %92 = load ptr, ptr %91, align 8 - %93 = load ptr, ptr %allocator73, align 8 - %94 = call i64 %92(ptr %retparam75, ptr %93, i64 %add74, i64 0, i64 0, ptr null, i32 0) - %not_err76 = icmp eq i64 %94, 0 - %95 = call i1 @llvm.expect.i1(i1 %not_err76, i1 true) - br i1 %95, label %after_check78, label %assign_optional77 + %add76 = add i64 %sext, 0 + %87 = load ptr, ptr %allocator75, align 8 + %88 = getelementptr inbounds %Allocator, ptr %87, i32 0, i32 0 + %89 = load ptr, ptr %88, align 8 + %90 = load ptr, ptr %allocator75, align 8 + %91 = call i64 %89(ptr %retparam77, ptr %90, i64 %add76, i64 0, i64 0, ptr null, i32 0) + %not_err78 = icmp eq i64 %91, 0 + %92 = call i1 @llvm.expect.i1(i1 %not_err78, i1 true) + br i1 %92, label %after_check80, label %assign_optional79 -assign_optional77: ; preds = %if.exit69 - store i64 %94, ptr %error_var71, align 8 - br label %panic_block79 +assign_optional79: ; preds = %if.exit71 + store i64 %91, ptr %error_var73, align 8 + br label %panic_block81 -after_check78: ; preds = %if.exit69 - %96 = load ptr, ptr %retparam75, align 8 - br label %noerr_block82 +after_check80: ; preds = %if.exit71 + %93 = load ptr, ptr %retparam77, align 8 + br label %noerr_block85 -panic_block79: ; preds = %assign_optional77 - %97 = insertvalue %any undef, ptr %error_var71, 0 - %98 = insertvalue %any %97, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %99 = getelementptr inbounds [1 x %any], ptr %varargslots80, i64 0, i64 0 - store %any %98, ptr %99, align 16 - %100 = insertvalue %"any[]" undef, ptr %varargslots80, 0 - %101 = insertvalue %"any[]" %100, i64 1, 1 - store %"any[]" %101, ptr %indirectarg81, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg81) +panic_block81: ; preds = %assign_optional79 + %94 = insertvalue %any undef, ptr %error_var73, 0 + %95 = insertvalue %any %94, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 + %96 = getelementptr inbounds [1 x %any], ptr %varargslots82, i64 0, i64 0 + store %any %95, ptr %96, align 16 + %97 = insertvalue %"any[]" undef, ptr %varargslots82, 0 + %"#temp#83" = insertvalue %"any[]" %97, i64 1, 1 + store %"any[]" %"#temp#83", ptr %indirectarg84, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg84) unreachable -noerr_block82: ; preds = %after_check78 - store ptr %96, ptr %str, align 8 - %102 = load ptr, ptr %str, align 8 - %not83 = icmp eq ptr %102, null - br i1 %not83, label %if.then84, label %if.exit85 +noerr_block85: ; preds = %after_check80 + store ptr %93, ptr %str, align 8 + %98 = load ptr, ptr %str, align 8 + %not86 = icmp eq ptr %98, null + br i1 %not86, label %if.then87, label %if.exit88 -if.then84: ; preds = %noerr_block82 +if.then87: ; preds = %noerr_block85 ret i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64) -if.exit85: ; preds = %noerr_block82 - %103 = load ptr, ptr %str, align 8 - %104 = load i32, ptr %len, align 4 - %sext86 = sext i32 %104 to i64 - %add87 = add i64 %sext86, 1 - %105 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 - %106 = load i64, ptr %105, align 8 - %trunc88 = trunc i64 %106 to i32 - %107 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 - %108 = load ptr, ptr %107, align 8 - %109 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %103, i64 %add87, ptr @.str.7, i32 %trunc88, ptr %108) - %110 = getelementptr inbounds %Doc, ptr %literal90, i32 0, i32 0 - store ptr null, ptr %literal92, align 8 - %111 = getelementptr inbounds %Head, ptr %literal92, i32 0, i32 0 - %112 = load ptr, ptr %str, align 8 - %113 = load i32, ptr %len, align 4 - %sub = sub i32 %113, 1 - %sext94 = sext i32 %sub to i64 - %114 = add i64 %sext94, 1 - %size = sub i64 %114, 0 - %ptroffset95 = getelementptr inbounds i8, ptr %112, i64 0 - %115 = insertvalue %"char[]" undef, ptr %ptroffset95, 0 - %116 = insertvalue %"char[]" %115, i64 %size, 1 - store %"char[]" %116, ptr %value96, align 8 - %117 = load ptr, ptr @std.core.mem.thread_allocator, align 8 - store ptr %117, ptr %using98, align 8 - %118 = load ptr, ptr %using98, align 8 - store ptr %118, ptr %using100, align 8 - %119 = load ptr, ptr %using100, align 8 - store ptr %119, ptr %allocator102, align 8 - %120 = load ptr, ptr %allocator102, align 8 - %121 = getelementptr inbounds %Allocator, ptr %120, i32 0, i32 0 - %122 = load ptr, ptr %121, align 8 - %123 = load ptr, ptr %allocator102, align 8 - %124 = call i64 %122(ptr %retparam104, ptr %123, i64 16, i64 0, i64 0, ptr null, i32 0) - %not_err105 = icmp eq i64 %124, 0 - %125 = call i1 @llvm.expect.i1(i1 %not_err105, i1 true) - br i1 %125, label %after_check107, label %assign_optional106 +if.exit88: ; preds = %noerr_block85 + %99 = load ptr, ptr %str, align 8 + %100 = load i32, ptr %len, align 4 + %sext89 = sext i32 %100 to i64 + %add90 = add i64 %sext89, 1 + %101 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %102 = load i64, ptr %101, align 8 + %trunc91 = trunc i64 %102 to i32 + %103 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %104 = load ptr, ptr %103, align 8 + %105 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %99, i64 %add90, ptr @.str.7, i32 %trunc91, ptr %104) + %106 = getelementptr inbounds %Doc, ptr %literal93, i32 0, i32 0 + store ptr null, ptr %literal95, align 8 + %107 = getelementptr inbounds %Head, ptr %literal95, i32 0, i32 0 + %108 = load ptr, ptr %str, align 8 + %109 = load i32, ptr %len, align 4 + %sub = sub i32 %109, 1 + %sext97 = sext i32 %sub to i64 + %110 = add i64 %sext97, 1 + %size = sub i64 %110, 0 + %ptroffset98 = getelementptr inbounds i8, ptr %108, i64 0 + %111 = insertvalue %"char[]" undef, ptr %ptroffset98, 0 + %112 = insertvalue %"char[]" %111, i64 %size, 1 + store %"char[]" %112, ptr %value99, align 8 + %113 = load ptr, ptr @std.core.mem.thread_allocator, align 8 + store ptr %113, ptr %using101, align 8 + %114 = load ptr, ptr %using101, align 8 + store ptr %114, ptr %using103, align 8 + %115 = load ptr, ptr %using103, align 8 + store ptr %115, ptr %allocator105, align 8 + %116 = load ptr, ptr %allocator105, align 8 + %117 = getelementptr inbounds %Allocator, ptr %116, i32 0, i32 0 + %118 = load ptr, ptr %117, align 8 + %119 = load ptr, ptr %allocator105, align 8 + %120 = call i64 %118(ptr %retparam107, ptr %119, i64 16, i64 0, i64 0, ptr null, i32 0) + %not_err108 = icmp eq i64 %120, 0 + %121 = call i1 @llvm.expect.i1(i1 %not_err108, i1 true) + br i1 %121, label %after_check110, label %assign_optional109 -assign_optional106: ; preds = %if.exit85 - store i64 %124, ptr %error_var99, align 8 - br label %panic_block108 +assign_optional109: ; preds = %if.exit88 + store i64 %120, ptr %error_var102, align 8 + br label %panic_block111 -after_check107: ; preds = %if.exit85 - %126 = load ptr, ptr %retparam104, align 8 - br label %noerr_block111 +after_check110: ; preds = %if.exit88 + %122 = load ptr, ptr %retparam107, align 8 + br label %noerr_block115 -panic_block108: ; preds = %assign_optional106 - %127 = insertvalue %any undef, ptr %error_var99, 0 - %128 = insertvalue %any %127, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %129 = getelementptr inbounds [1 x %any], ptr %varargslots109, i64 0, i64 0 - store %any %128, ptr %129, align 16 - %130 = insertvalue %"any[]" undef, ptr %varargslots109, 0 - %131 = insertvalue %"any[]" %130, i64 1, 1 - store %"any[]" %131, ptr %indirectarg110, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg110) +panic_block111: ; preds = %assign_optional109 + %123 = insertvalue %any undef, ptr %error_var102, 0 + %124 = insertvalue %any %123, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 + %125 = getelementptr inbounds [1 x %any], ptr %varargslots112, i64 0, i64 0 + store %any %124, ptr %125, align 16 + %126 = insertvalue %"any[]" undef, ptr %varargslots112, 0 + %"#temp#113" = insertvalue %"any[]" %126, i64 1, 1 + store %"any[]" %"#temp#113", ptr %indirectarg114, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg114) unreachable -noerr_block111: ; preds = %after_check107 - store ptr %126, ptr %temp97, align 8 - %132 = load ptr, ptr %temp97, align 8 - %not112 = icmp eq ptr %132, null - br i1 %not112, label %if.then113, label %if.exit114 +noerr_block115: ; preds = %after_check110 + store ptr %122, ptr %temp100, align 8 + %127 = load ptr, ptr %temp100, align 8 + %not116 = icmp eq ptr %127, null + br i1 %not116, label %if.then117, label %if.exit118 -if.then113: ; preds = %noerr_block111 - store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var93, align 8 - br label %guard_block115 +if.then117: ; preds = %noerr_block115 + store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var96, align 8 + br label %guard_block119 -if.exit114: ; preds = %noerr_block111 - %133 = load ptr, ptr %temp97, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %133, ptr align 8 %value96, i32 16, i1 false) - br label %noerr_block116 +if.exit118: ; preds = %noerr_block115 + %128 = load ptr, ptr %temp100, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %128, ptr align 8 %value99, i32 16, i1 false) + br label %noerr_block120 -guard_block115: ; preds = %if.then113 - %134 = load i64, ptr %error_var93, align 8 - ret i64 %134 +guard_block119: ; preds = %if.then117 + %129 = load i64, ptr %error_var96, align 8 + ret i64 %129 -noerr_block116: ; preds = %if.exit114 - %135 = load ptr, ptr %temp97, align 8 - store ptr %135, ptr %111, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value117, ptr align 8 %literal92, i32 8, i1 false) - %136 = load ptr, ptr @std.core.mem.thread_allocator, align 8 - store ptr %136, ptr %using119, align 8 - %137 = load ptr, ptr %using119, align 8 - store ptr %137, ptr %using121, align 8 - %138 = load ptr, ptr %using121, align 8 - store ptr %138, ptr %allocator123, align 8 - %139 = load ptr, ptr %allocator123, align 8 - %140 = getelementptr inbounds %Allocator, ptr %139, i32 0, i32 0 - %141 = load ptr, ptr %140, align 8 - %142 = load ptr, ptr %allocator123, align 8 - %143 = call i64 %141(ptr %retparam125, ptr %142, i64 8, i64 0, i64 0, ptr null, i32 0) - %not_err126 = icmp eq i64 %143, 0 - %144 = call i1 @llvm.expect.i1(i1 %not_err126, i1 true) - br i1 %144, label %after_check128, label %assign_optional127 +noerr_block120: ; preds = %if.exit118 + %130 = load ptr, ptr %temp100, align 8 + store ptr %130, ptr %107, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value121, ptr align 8 %literal95, i32 8, i1 false) + %131 = load ptr, ptr @std.core.mem.thread_allocator, align 8 + store ptr %131, ptr %using123, align 8 + %132 = load ptr, ptr %using123, align 8 + store ptr %132, ptr %using125, align 8 + %133 = load ptr, ptr %using125, align 8 + store ptr %133, ptr %allocator127, align 8 + %134 = load ptr, ptr %allocator127, align 8 + %135 = getelementptr inbounds %Allocator, ptr %134, i32 0, i32 0 + %136 = load ptr, ptr %135, align 8 + %137 = load ptr, ptr %allocator127, align 8 + %138 = call i64 %136(ptr %retparam129, ptr %137, i64 8, i64 0, i64 0, ptr null, i32 0) + %not_err130 = icmp eq i64 %138, 0 + %139 = call i1 @llvm.expect.i1(i1 %not_err130, i1 true) + br i1 %139, label %after_check132, label %assign_optional131 -assign_optional127: ; preds = %noerr_block116 - store i64 %143, ptr %error_var120, align 8 - br label %panic_block129 +assign_optional131: ; preds = %noerr_block120 + store i64 %138, ptr %error_var124, align 8 + br label %panic_block133 -after_check128: ; preds = %noerr_block116 - %145 = load ptr, ptr %retparam125, align 8 - br label %noerr_block132 - -panic_block129: ; preds = %assign_optional127 - %146 = insertvalue %any undef, ptr %error_var120, 0 - %147 = insertvalue %any %146, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %148 = getelementptr inbounds [1 x %any], ptr %varargslots130, i64 0, i64 0 - store %any %147, ptr %148, align 16 - %149 = insertvalue %"any[]" undef, ptr %varargslots130, 0 - %150 = insertvalue %"any[]" %149, i64 1, 1 - store %"any[]" %150, ptr %indirectarg131, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg131) - unreachable - -noerr_block132: ; preds = %after_check128 - store ptr %145, ptr %temp118, align 8 - %151 = load ptr, ptr %temp118, align 8 - %not133 = icmp eq ptr %151, null - br i1 %not133, label %if.then134, label %if.exit135 - -if.then134: ; preds = %noerr_block132 - store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var91, align 8 - br label %guard_block136 - -if.exit135: ; preds = %noerr_block132 - %152 = load ptr, ptr %temp118, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %152, ptr align 8 %value117, i32 8, i1 false) +after_check132: ; preds = %noerr_block120 + %140 = load ptr, ptr %retparam129, align 8 br label %noerr_block137 -guard_block136: ; preds = %if.then134 - %153 = load i64, ptr %error_var91, align 8 - ret i64 %153 +panic_block133: ; preds = %assign_optional131 + %141 = insertvalue %any undef, ptr %error_var124, 0 + %142 = insertvalue %any %141, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 + %143 = getelementptr inbounds [1 x %any], ptr %varargslots134, i64 0, i64 0 + store %any %142, ptr %143, align 16 + %144 = insertvalue %"any[]" undef, ptr %varargslots134, 0 + %"#temp#135" = insertvalue %"any[]" %144, i64 1, 1 + store %"any[]" %"#temp#135", ptr %indirectarg136, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 204, ptr byval(%"any[]") align 8 %indirectarg136) + unreachable -noerr_block137: ; preds = %if.exit135 - %154 = load ptr, ptr %temp118, align 8 - store ptr %154, ptr %110, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal90, i32 8, i1 false) +noerr_block137: ; preds = %after_check132 + store ptr %140, ptr %temp122, align 8 + %145 = load ptr, ptr %temp122, align 8 + %not138 = icmp eq ptr %145, null + br i1 %not138, label %if.then139, label %if.exit140 + +if.then139: ; preds = %noerr_block137 + store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var94, align 8 + br label %guard_block141 + +if.exit140: ; preds = %noerr_block137 + %146 = load ptr, ptr %temp122, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %146, ptr align 8 %value121, i32 8, i1 false) + br label %noerr_block142 + +guard_block141: ; preds = %if.then139 + %147 = load i64, ptr %error_var94, align 8 + ret i64 %147 + +noerr_block142: ; preds = %if.exit140 + %148 = load ptr, ptr %temp122, align 8 + store ptr %148, ptr %106, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal93, i32 8, i1 false) ret i64 0 } diff --git a/test/test_suite/errors/general_error_regression.c3t b/test/test_suite/errors/general_error_regression.c3t index d1afe0e48..3f76f98aa 100644 --- a/test/test_suite/errors/general_error_regression.c3t +++ b/test/test_suite/errors/general_error_regression.c3t @@ -74,54 +74,36 @@ fn void main() define void @foo.Foo.hello(ptr %0) #0 { entry: - %x = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 - store %"char[]" { ptr @.str.12, i64 14 }, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 %2 = load ptr, ptr %result, align 8 - %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi) + %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr @.str.12, i64 14) ret void } ; Function Attrs: nounwind define void @foo.Bar.hello(ptr %0) #0 { entry: - %x = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 - store %"char[]" { ptr @.str.13, i64 14 }, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 %2 = load ptr, ptr %result, align 8 - %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi) + %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr @.str.13, i64 14) ret void } ; Function Attrs: nounwind define void @foo.MyEnum.hello(ptr %0) #0 { entry: - %x = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 - store %"char[]" { ptr @.str.14, i64 17 }, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 %2 = load ptr, ptr %result, align 8 - %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi) + %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr @.str.14, i64 17) ret void } diff --git a/test/test_suite/errors/multiple_catch.c3t b/test/test_suite/errors/multiple_catch.c3t index eb3b9c761..518c2302e 100644 --- a/test/test_suite/errors/multiple_catch.c3t +++ b/test/test_suite/errors/multiple_catch.c3t @@ -54,7 +54,6 @@ entry: %varargslots22 = alloca [1 x %any], align 16 %temp_err = alloca i64, align 8 %retparam27 = alloca i32, align 4 - %x = alloca %"char[]", align 8 %retparam38 = alloca i64, align 8 %result = alloca %File, align 8 %err42 = alloca i64, align 8 @@ -182,41 +181,36 @@ end_block35: ; preds = %after_check34, %ass br i1 %neq36, label %if.then37, label %if.exit41 if.then37: ; preds = %end_block35 - store %"char[]" { ptr @.str.5, i64 4 }, ptr %x, align 8 %23 = call ptr @std.io.stdout() store ptr %23, ptr %result, align 8 %24 = load ptr, ptr %result, align 8 - %25 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %25, align 8 - %26 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %26, align 8 - %27 = call i64 @std.io.File.printn(ptr %retparam38, ptr %24, ptr %lo, i64 %hi) + %25 = call i64 @std.io.File.printn(ptr %retparam38, ptr %24, ptr @.str.5, i64 4) br label %if.exit41 if.exit41: ; preds = %if.then37, %end_block35 br label %testblock43 testblock43: ; preds = %if.exit41 - %28 = call i64 @demo1.hello(ptr %retparam44, i32 0) - %not_err45 = icmp eq i64 %28, 0 - %29 = call i1 @llvm.expect.i1(i1 %not_err45, i1 true) - br i1 %29, label %after_check47, label %assign_optional46 + %26 = call i64 @demo1.hello(ptr %retparam44, i32 0) + %not_err45 = icmp eq i64 %26, 0 + %27 = call i1 @llvm.expect.i1(i1 %not_err45, i1 true) + br i1 %27, label %after_check47, label %assign_optional46 assign_optional46: ; preds = %testblock43 - store i64 %28, ptr %err42, align 8 + store i64 %26, ptr %err42, align 8 br label %end_block52 after_check47: ; preds = %testblock43 br label %testblock48 testblock48: ; preds = %after_check47 - %30 = call i64 @demo1.bye() - %not_err49 = icmp eq i64 %30, 0 - %31 = call i1 @llvm.expect.i1(i1 %not_err49, i1 true) - br i1 %31, label %after_check51, label %assign_optional50 + %28 = call i64 @demo1.bye() + %not_err49 = icmp eq i64 %28, 0 + %29 = call i1 @llvm.expect.i1(i1 %not_err49, i1 true) + br i1 %29, label %after_check51, label %assign_optional50 assign_optional50: ; preds = %testblock48 - store i64 %30, ptr %err42, align 8 + store i64 %28, ptr %err42, align 8 br label %end_block52 after_check51: ; preds = %testblock48 @@ -224,16 +218,16 @@ after_check51: ; preds = %testblock48 br label %end_block52 end_block52: ; preds = %after_check51, %assign_optional50, %assign_optional46 - %32 = load i64, ptr %err42, align 8 - %neq53 = icmp ne i64 %32, 0 + %30 = load i64, ptr %err42, align 8 + %neq53 = icmp ne i64 %30, 0 br i1 %neq53, label %if.then54, label %if.exit59 if.then54: ; preds = %end_block52 - %33 = insertvalue %any undef, ptr %err42, 0 - %34 = insertvalue %any %33, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %35 = getelementptr inbounds [1 x %any], ptr %varargslots56, i64 0, i64 0 - store %any %34, ptr %35, align 16 - %36 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.6, i64 8, ptr %varargslots56, i64 1) + %31 = insertvalue %any undef, ptr %err42, 0 + %32 = insertvalue %any %31, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 + %33 = getelementptr inbounds [1 x %any], ptr %varargslots56, i64 0, i64 0 + store %any %32, ptr %33, align 16 + %34 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.6, i64 8, ptr %varargslots56, i64 1) br label %if.exit59 if.exit59: ; preds = %if.then54, %end_block52 diff --git a/test/test_suite/errors/or_and_rethrow.c3t b/test/test_suite/errors/or_and_rethrow.c3t index 909513725..ba596e1fe 100644 --- a/test/test_suite/errors/or_and_rethrow.c3t +++ b/test/test_suite/errors/or_and_rethrow.c3t @@ -46,20 +46,16 @@ entry: %taddr = alloca i32, align 4 %error_var = alloca i64, align 8 %blockret = alloca i32, align 4 - %x = alloca %"char[]", align 8 %retparam1 = alloca i64, align 8 %result = alloca %File, align 8 - %x2 = alloca %"char[]", align 8 - %retparam3 = alloca i64, align 8 - %result4 = alloca %File, align 8 - %error_var7 = alloca i64, align 8 - %blockret8 = alloca i32, align 4 - %x12 = alloca %"char[]", align 8 - %retparam13 = alloca i64, align 8 - %result14 = alloca %File, align 8 - %x18 = alloca %"char[]", align 8 - %retparam19 = alloca i64, align 8 - %result20 = alloca %File, align 8 + %retparam2 = alloca i64, align 8 + %result3 = alloca %File, align 8 + %error_var4 = alloca i64, align 8 + %blockret5 = alloca i32, align 4 + %retparam9 = alloca i64, align 8 + %result10 = alloca %File, align 8 + %retparam12 = alloca i64, align 8 + %result13 = alloca %File, align 8 store i32 %0, ptr %taddr, align 4 %1 = insertvalue %any undef, ptr %taddr, 0 %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1 @@ -85,48 +81,33 @@ or.phi: ; preds = %entry br label %if.then if.then: ; preds = %or.phi - store %"char[]" { ptr @.str.2, i64 3 }, ptr %x, align 8 %6 = call ptr @std.io.stdout() store ptr %6, ptr %result, align 8 %7 = load ptr, ptr %result, align 8 - %8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %9, align 8 - %10 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %lo, i64 %hi) + %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr @.str.2, i64 3) br label %if.exit if.exit: ; preds = %if.then - store %"char[]" { ptr @.str.3, i64 9 }, ptr %x2, align 8 - %11 = call ptr @std.io.stdout() - store ptr %11, ptr %result4, align 8 - %12 = load ptr, ptr %result4, align 8 - %13 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0 - %lo5 = load ptr, ptr %13, align 8 - %14 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1 - %hi6 = load i64, ptr %14, align 8 - %15 = call i64 @std.io.File.printn(ptr %retparam3, ptr %12, ptr %lo5, i64 %hi6) - store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var7, align 8 - br label %opt_block_cleanup9 + %9 = call ptr @std.io.stdout() + store ptr %9, ptr %result3, align 8 + %10 = load ptr, ptr %result3, align 8 + %11 = call i64 @std.io.File.printn(ptr %retparam2, ptr %10, ptr @.str.3, i64 9) + store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var4, align 8 + br label %opt_block_cleanup6 -opt_block_cleanup9: ; preds = %if.exit +opt_block_cleanup6: ; preds = %if.exit call void @foo.blurb() - br label %guard_block10 + br label %guard_block7 -guard_block10: ; preds = %opt_block_cleanup9 - %16 = load i64, ptr %error_var7, align 8 - ret i64 %16 +guard_block7: ; preds = %opt_block_cleanup6 + %12 = load i64, ptr %error_var4, align 8 + ret i64 %12 -if.exit17: ; No predecessors! - store %"char[]" { ptr @.str.5, i64 7 }, ptr %x18, align 8 - %17 = call ptr @std.io.stdout() - store ptr %17, ptr %result20, align 8 - %18 = load ptr, ptr %result20, align 8 - %19 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0 - %lo21 = load ptr, ptr %19, align 8 - %20 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1 - %hi22 = load i64, ptr %20, align 8 - %21 = call i64 @std.io.File.printn(ptr %retparam19, ptr %18, ptr %lo21, i64 %hi22) +if.exit11: ; No predecessors! + %13 = call ptr @std.io.stdout() + store ptr %13, ptr %result13, align 8 + %14 = load ptr, ptr %result13, align 8 + %15 = call i64 @std.io.File.printn(ptr %retparam12, ptr %14, ptr @.str.5, i64 7) ret i64 0 } @@ -138,14 +119,12 @@ entry: %taddr = alloca i32, align 4 %error_var = alloca i64, align 8 %blockret = alloca i32, align 4 - %x = alloca %"char[]", align 8 %retparam1 = alloca i64, align 8 %result = alloca %File, align 8 %error_var2 = alloca i64, align 8 %blockret3 = alloca i32, align 4 - %x7 = alloca %"char[]", align 8 - %retparam8 = alloca i64, align 8 - %result9 = alloca %File, align 8 + %retparam7 = alloca i64, align 8 + %result8 = alloca %File, align 8 store i32 %0, ptr %taddr, align 4 %1 = insertvalue %any undef, ptr %taddr, 0 %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1 @@ -171,15 +150,10 @@ and.phi: ; preds = %entry br label %if.exit if.exit: ; preds = %and.phi - store %"char[]" { ptr @.str.7, i64 9 }, ptr %x, align 8 %6 = call ptr @std.io.stdout() store ptr %6, ptr %result, align 8 %7 = load ptr, ptr %result, align 8 - %8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %9, align 8 - %10 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %lo, i64 %hi) + %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr @.str.7, i64 9) store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var2, align 8 br label %opt_block_cleanup4 @@ -188,19 +162,14 @@ opt_block_cleanup4: ; preds = %if.exit br label %guard_block5 guard_block5: ; preds = %opt_block_cleanup4 - %11 = load i64, ptr %error_var2, align 8 - ret i64 %11 + %9 = load i64, ptr %error_var2, align 8 + ret i64 %9 if.exit6: ; No predecessors! - store %"char[]" { ptr @.str.8, i64 7 }, ptr %x7, align 8 - %12 = call ptr @std.io.stdout() - store ptr %12, ptr %result9, align 8 - %13 = load ptr, ptr %result9, align 8 - %14 = getelementptr inbounds %"char[]", ptr %x7, i32 0, i32 0 - %lo10 = load ptr, ptr %14, align 8 - %15 = getelementptr inbounds %"char[]", ptr %x7, i32 0, i32 1 - %hi11 = load i64, ptr %15, align 8 - %16 = call i64 @std.io.File.printn(ptr %retparam8, ptr %13, ptr %lo10, i64 %hi11) + %10 = call ptr @std.io.stdout() + store ptr %10, ptr %result8, align 8 + %11 = load ptr, ptr %result8, align 8 + %12 = call i64 @std.io.File.printn(ptr %retparam7, ptr %11, ptr @.str.8, i64 7) ret i64 0 } diff --git a/test/test_suite/from_docs/examples_defer.c3t b/test/test_suite/from_docs/examples_defer.c3t index 9e737b0b2..6b6b3a542 100644 --- a/test/test_suite/from_docs/examples_defer.c3t +++ b/test/test_suite/from_docs/examples_defer.c3t @@ -27,103 +27,53 @@ define void @defer1.test(i32 %0) #0 { entry: %eq = icmp eq i32 %0, 1 br i1 %eq, label %if.then, label %if.exit - if.then: ; preds = %entry - store %"char[]" { ptr @.str, i64 1 }, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 %2 = load ptr, ptr %result, align 8 - %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = call i64 @std.io.File.print(ptr %retparam, ptr %2, ptr %lo, i64 %hi) - store %"char[]" zeroinitializer, ptr %x1, align 8 - %6 = call ptr @std.io.stdout() - store ptr %6, ptr %result3, align 8 - %7 = load ptr, ptr %result3, align 8 - %8 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0 - %lo4 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1 - %hi5 = load i64, ptr %9, align 8 - %10 = call i64 @std.io.File.printn(ptr %retparam2, ptr %7, ptr %lo4, i64 %hi5) + %3 = call i64 @std.io.File.print(ptr %retparam, ptr %2, ptr @.str, i64 1) + %4 = call ptr @std.io.stdout() + store ptr %4, ptr %result2, align 8 + %5 = load ptr, ptr %result2, align 8 + %6 = call i64 @std.io.File.printn(ptr %retparam1, ptr %5, ptr null, i64 0) ret void - if.exit: ; preds = %entry - %eq6 = icmp eq i32 %0, 0 - br i1 %eq6, label %if.then7, label %if.exit23 - -if.then7: ; preds = %if.exit - store %"char[]" { ptr @.str.1, i64 1 }, ptr %x8, align 8 - %11 = call ptr @std.io.stdout() - store ptr %11, ptr %result10, align 8 - %12 = load ptr, ptr %result10, align 8 - %13 = getelementptr inbounds %"char[]", ptr %x8, i32 0, i32 0 - %lo11 = load ptr, ptr %13, align 8 - %14 = getelementptr inbounds %"char[]", ptr %x8, i32 0, i32 1 - %hi12 = load i64, ptr %14, align 8 - %15 = call i64 @std.io.File.print(ptr %retparam9, ptr %12, ptr %lo11, i64 %hi12) - store %"char[]" { ptr @.str.2, i64 1 }, ptr %x13, align 8 - %16 = call ptr @std.io.stdout() - store ptr %16, ptr %result15, align 8 - %17 = load ptr, ptr %result15, align 8 - %18 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 0 - %lo16 = load ptr, ptr %18, align 8 - %19 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 1 - %hi17 = load i64, ptr %19, align 8 - %20 = call i64 @std.io.File.print(ptr %retparam14, ptr %17, ptr %lo16, i64 %hi17) - store %"char[]" zeroinitializer, ptr %x18, align 8 - %21 = call ptr @std.io.stdout() - store ptr %21, ptr %result20, align 8 - %22 = load ptr, ptr %result20, align 8 - %23 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0 - %lo21 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1 - %hi22 = load i64, ptr %24, align 8 - %25 = call i64 @std.io.File.printn(ptr %retparam19, ptr %22, ptr %lo21, i64 %hi22) + %eq3 = icmp eq i32 %0, 0 + br i1 %eq3, label %if.then4, label %if.exit11 +if.then4: ; preds = %if.exit + %7 = call ptr @std.io.stdout() + store ptr %7, ptr %result6, align 8 + %8 = load ptr, ptr %result6, align 8 + %9 = call i64 @std.io.File.print(ptr %retparam5, ptr %8, ptr @.str.1, i64 1) + %10 = call ptr @std.io.stdout() + store ptr %10, ptr %result8, align 8 + %11 = load ptr, ptr %result8, align 8 + %12 = call i64 @std.io.File.print(ptr %retparam7, ptr %11, ptr @.str.2, i64 1) + %13 = call ptr @std.io.stdout() + store ptr %13, ptr %result10, align 8 + %14 = load ptr, ptr %result10, align 8 + %15 = call i64 @std.io.File.printn(ptr %retparam9, ptr %14, ptr null, i64 0) ret void - -if.exit23: ; preds = %if.exit - store %"char[]" { ptr @.str.3, i64 1 }, ptr %x24, align 8 - %26 = call ptr @std.io.stdout() - store ptr %26, ptr %result26, align 8 - %27 = load ptr, ptr %result26, align 8 - %28 = getelementptr inbounds %"char[]", ptr %x24, i32 0, i32 0 - %lo27 = load ptr, ptr %28, align 8 - %29 = getelementptr inbounds %"char[]", ptr %x24, i32 0, i32 1 - %hi28 = load i64, ptr %29, align 8 - %30 = call i64 @std.io.File.print(ptr %retparam25, ptr %27, ptr %lo27, i64 %hi28) - store %"char[]" { ptr @.str.4, i64 1 }, ptr %x29, align 8 - %31 = call ptr @std.io.stdout() - store ptr %31, ptr %result31, align 8 - %32 = load ptr, ptr %result31, align 8 - %33 = getelementptr inbounds %"char[]", ptr %x29, i32 0, i32 0 - %lo32 = load ptr, ptr %33, align 8 - %34 = getelementptr inbounds %"char[]", ptr %x29, i32 0, i32 1 - %hi33 = load i64, ptr %34, align 8 - %35 = call i64 @std.io.File.print(ptr %retparam30, ptr %32, ptr %lo32, i64 %hi33) - store %"char[]" { ptr @.str.5, i64 1 }, ptr %x34, align 8 - %36 = call ptr @std.io.stdout() - store ptr %36, ptr %result36, align 8 - %37 = load ptr, ptr %result36, align 8 - %38 = getelementptr inbounds %"char[]", ptr %x34, i32 0, i32 0 - %lo37 = load ptr, ptr %38, align 8 - %39 = getelementptr inbounds %"char[]", ptr %x34, i32 0, i32 1 - %hi38 = load i64, ptr %39, align 8 - %40 = call i64 @std.io.File.print(ptr %retparam35, ptr %37, ptr %lo37, i64 %hi38) - store %"char[]" zeroinitializer, ptr %x39, align 8 - %41 = call ptr @std.io.stdout() - store ptr %41, ptr %result41, align 8 - %42 = load ptr, ptr %result41, align 8 - %43 = getelementptr inbounds %"char[]", ptr %x39, i32 0, i32 0 - %lo42 = load ptr, ptr %43, align 8 - %44 = getelementptr inbounds %"char[]", ptr %x39, i32 0, i32 1 - %hi43 = load i64, ptr %44, align 8 - %45 = call i64 @std.io.File.printn(ptr %retparam40, ptr %42, ptr %lo42, i64 %hi43) +if.exit11: ; preds = %if.exit + %16 = call ptr @std.io.stdout() + store ptr %16, ptr %result13, align 8 + %17 = load ptr, ptr %result13, align 8 + %18 = call i64 @std.io.File.print(ptr %retparam12, ptr %17, ptr @.str.3, i64 1) + %19 = call ptr @std.io.stdout() + store ptr %19, ptr %result15, align 8 + %20 = load ptr, ptr %result15, align 8 + %21 = call i64 @std.io.File.print(ptr %retparam14, ptr %20, ptr @.str.4, i64 1) + %22 = call ptr @std.io.stdout() + store ptr %22, ptr %result17, align 8 + %23 = load ptr, ptr %result17, align 8 + %24 = call i64 @std.io.File.print(ptr %retparam16, ptr %23, ptr @.str.5, i64 1) + %25 = call ptr @std.io.stdout() + store ptr %25, ptr %result19, align 8 + %26 = load ptr, ptr %result19, align 8 + %27 = call i64 @std.io.File.printn(ptr %retparam18, ptr %26, ptr null, i64 0) ret void } - - +; Function Attrs: nounwind define void @defer1.main() #0 { entry: call void @defer1.test(i32 1) diff --git a/test/test_suite/from_docs/examples_forswitch.c3t b/test/test_suite/from_docs/examples_forswitch.c3t index 67c01a0e7..195e75381 100644 --- a/test/test_suite/from_docs/examples_forswitch.c3t +++ b/test/test_suite/from_docs/examples_forswitch.c3t @@ -94,12 +94,10 @@ entry: %i = alloca i32, align 4 store i32 0, ptr %i, align 4 br label %loop.cond - loop.cond: ; preds = %loop.body, %entry %0 = load i32, ptr %i, align 4 %lt = icmp slt i32 %0, 10 br i1 %lt, label %loop.body, label %loop.exit - loop.body: ; preds = %loop.cond %1 = load i32, ptr %i, align 4 %2 = call i32 (ptr, ...) @printf(ptr @.str, i32 %1) @@ -107,50 +105,39 @@ loop.body: ; preds = %loop.cond %add = add i32 %3, 1 store i32 %add, ptr %i, align 4 br label %loop.cond - loop.exit: ; preds = %loop.cond %4 = load ptr, ptr @std.core.builtin.panic, align 8 call void %4(ptr @.panic_msg, i64 19, ptr @.file, i64 21, ptr @.func, i64 11, i32 14) unreachable } - ; Function Attrs: nounwind define void @examples.demo_enum(i32 %0) #0 { entry: %switch = alloca i32, align 4 - %x = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 - %x2 = alloca %"char[]", align 8 - %retparam3 = alloca i64, align 8 - %result4 = alloca %File, align 8 - %switch7 = alloca i32, align 4 - %x10 = alloca %"char[]", align 8 - %retparam11 = alloca i64, align 8 - %result12 = alloca %File, align 8 - %x16 = alloca %"char[]", align 8 + %retparam2 = alloca i64, align 8 + %result3 = alloca %File, align 8 + %switch4 = alloca i32, align 4 + %retparam7 = alloca i64, align 8 + %result8 = alloca %File, align 8 + %retparam10 = alloca i64, align 8 + %result11 = alloca %File, align 8 + %switch13 = alloca i32, align 4 %retparam17 = alloca i64, align 8 %result18 = alloca %File, align 8 - %switch22 = alloca i32, align 4 - %x26 = alloca %"char[]", align 8 - %retparam27 = alloca i64, align 8 - %result28 = alloca %File, align 8 - %switch33 = alloca i32, align 4 - %switch37 = alloca i32, align 4 + %switch21 = alloca i32, align 4 + %switch25 = alloca i32, align 4 %a = alloca i32, align 4 - %x40 = alloca %"char[]", align 8 - %retparam41 = alloca i64, align 8 - %result42 = alloca %File, align 8 - %a46 = alloca i32, align 4 - %x47 = alloca %"char[]", align 8 - %retparam48 = alloca i64, align 8 - %result49 = alloca %File, align 8 - %x53 = alloca %"char[]", align 8 - %retparam54 = alloca i64, align 8 - %result55 = alloca %File, align 8 + %retparam28 = alloca i64, align 8 + %result29 = alloca %File, align 8 + %a31 = alloca i32, align 4 + %retparam32 = alloca i64, align 8 + %result33 = alloca %File, align 8 + %retparam35 = alloca i64, align 8 + %result36 = alloca %File, align 8 store i32 %0, ptr %switch, align 4 br label %switch.entry - switch.entry: ; preds = %entry %1 = load i32, ptr %switch, align 4 switch i32 %1, label %switch.exit [ @@ -158,165 +145,104 @@ switch.entry: ; preds = %entry i32 1, label %switch.case i32 2, label %switch.case1 ] - switch.case: ; preds = %switch.entry, %switch.entry - store %"char[]" { ptr @.str.1, i64 8 }, ptr %x, align 8 %2 = call ptr @std.io.stdout() store ptr %2, ptr %result, align 8 %3 = load ptr, ptr %result, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %4, align 8 - %5 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %5, align 8 - %6 = call i64 @std.io.File.printn(ptr %retparam, ptr %3, ptr %lo, i64 %hi) + %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %3, ptr @.str.1, i64 8) br label %switch.exit - switch.case1: ; preds = %switch.entry - store %"char[]" { ptr @.str.2, i64 4 }, ptr %x2, align 8 - %7 = call ptr @std.io.stdout() - store ptr %7, ptr %result4, align 8 - %8 = load ptr, ptr %result4, align 8 - %9 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0 - %lo5 = load ptr, ptr %9, align 8 - %10 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1 - %hi6 = load i64, ptr %10, align 8 - %11 = call i64 @std.io.File.printn(ptr %retparam3, ptr %8, ptr %lo5, i64 %hi6) + %5 = call ptr @std.io.stdout() + store ptr %5, ptr %result3, align 8 + %6 = load ptr, ptr %result3, align 8 + %7 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr @.str.2, i64 4) br label %switch.exit - switch.exit: ; preds = %switch.case1, %switch.case, %switch.entry - store i32 %0, ptr %switch7, align 4 - br label %switch.entry8 - -switch.entry8: ; preds = %switch.exit - %12 = load i32, ptr %switch7, align 4 - switch i32 %12, label %switch.exit21 [ - i32 0, label %switch.case9 - i32 1, label %switch.case9 - i32 2, label %switch.case15 + store i32 %0, ptr %switch4, align 4 + br label %switch.entry5 +switch.entry5: ; preds = %switch.exit + %8 = load i32, ptr %switch4, align 4 + switch i32 %8, label %switch.exit12 [ + i32 0, label %switch.case6 + i32 1, label %switch.case6 + i32 2, label %switch.case9 ] - -switch.case9: ; preds = %switch.entry8, %switch.entry8 - store %"char[]" { ptr @.str.3, i64 8 }, ptr %x10, align 8 - %13 = call ptr @std.io.stdout() - store ptr %13, ptr %result12, align 8 - %14 = load ptr, ptr %result12, align 8 - %15 = getelementptr inbounds %"char[]", ptr %x10, i32 0, i32 0 - %lo13 = load ptr, ptr %15, align 8 - %16 = getelementptr inbounds %"char[]", ptr %x10, i32 0, i32 1 - %hi14 = load i64, ptr %16, align 8 - %17 = call i64 @std.io.File.printn(ptr %retparam11, ptr %14, ptr %lo13, i64 %hi14) - br label %switch.exit21 - -switch.case15: ; preds = %switch.entry8 - store %"char[]" { ptr @.str.4, i64 4 }, ptr %x16, align 8 - %18 = call ptr @std.io.stdout() - store ptr %18, ptr %result18, align 8 - %19 = load ptr, ptr %result18, align 8 - %20 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0 - %lo19 = load ptr, ptr %20, align 8 - %21 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1 - %hi20 = load i64, ptr %21, align 8 - %22 = call i64 @std.io.File.printn(ptr %retparam17, ptr %19, ptr %lo19, i64 %hi20) - br label %switch.exit21 - -switch.exit21: ; preds = %switch.case15, %switch.case9, %switch.entry8 - store i32 %0, ptr %switch22, align 4 - br label %switch.entry23 - -switch.entry23: ; preds = %switch.exit21 - %23 = load i32, ptr %switch22, align 4 - switch i32 %23, label %switch.exit32 [ - i32 0, label %switch.case24 - i32 1, label %switch.case25 - i32 2, label %switch.case31 +switch.case6: ; preds = %switch.entry5, %switch.entry5 + %9 = call ptr @std.io.stdout() + store ptr %9, ptr %result8, align 8 + %10 = load ptr, ptr %result8, align 8 + %11 = call i64 @std.io.File.printn(ptr %retparam7, ptr %10, ptr @.str.3, i64 8) + br label %switch.exit12 +switch.case9: ; preds = %switch.entry5 + %12 = call ptr @std.io.stdout() + store ptr %12, ptr %result11, align 8 + %13 = load ptr, ptr %result11, align 8 + %14 = call i64 @std.io.File.printn(ptr %retparam10, ptr %13, ptr @.str.4, i64 4) + br label %switch.exit12 +switch.exit12: ; preds = %switch.case9, %switch.case6, %switch.entry5 + store i32 %0, ptr %switch13, align 4 + br label %switch.entry14 +switch.entry14: ; preds = %switch.exit12 + %15 = load i32, ptr %switch13, align 4 + switch i32 %15, label %switch.exit20 [ + i32 0, label %switch.case15 + i32 1, label %switch.case16 + i32 2, label %switch.case19 ] - -switch.case24: ; preds = %switch.entry23 - br label %switch.exit32 - -switch.case25: ; preds = %switch.entry23 - store %"char[]" { ptr @.str.5, i64 6 }, ptr %x26, align 8 - %24 = call ptr @std.io.stdout() - store ptr %24, ptr %result28, align 8 - %25 = load ptr, ptr %result28, align 8 - %26 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 0 - %lo29 = load ptr, ptr %26, align 8 - %27 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 1 - %hi30 = load i64, ptr %27, align 8 - %28 = call i64 @std.io.File.printn(ptr %retparam27, ptr %25, ptr %lo29, i64 %hi30) - br label %switch.exit32 - -switch.case31: ; preds = %switch.entry23 - br label %switch.exit32 - -switch.exit32: ; preds = %switch.case31, %switch.case25, %switch.case24, %switch.entry23 - store i32 %0, ptr %switch33, align 4 - br label %switch.entry34 - -switch.entry34: ; preds = %switch.exit32 - %29 = load i32, ptr %switch33, align 4 - switch i32 %29, label %switch.default [ - i32 0, label %switch.case35 - i32 1, label %switch.case35 - i32 2, label %switch.case35 +switch.case15: ; preds = %switch.entry14 + br label %switch.exit20 +switch.case16: ; preds = %switch.entry14 + %16 = call ptr @std.io.stdout() + store ptr %16, ptr %result18, align 8 + %17 = load ptr, ptr %result18, align 8 + %18 = call i64 @std.io.File.printn(ptr %retparam17, ptr %17, ptr @.str.5, i64 6) + br label %switch.exit20 +switch.case19: ; preds = %switch.entry14 + br label %switch.exit20 +switch.exit20: ; preds = %switch.case19, %switch.case16, %switch.case15, %switch.entry14 + store i32 %0, ptr %switch21, align 4 + br label %switch.entry22 +switch.entry22: ; preds = %switch.exit20 + %19 = load i32, ptr %switch21, align 4 + switch i32 %19, label %switch.default [ + i32 0, label %switch.case23 + i32 1, label %switch.case23 + i32 2, label %switch.case23 ] - -switch.case35: ; preds = %switch.entry34, %switch.entry34, %switch.entry34 - br label %switch.exit36 - -switch.default: ; preds = %switch.entry34 - br label %switch.exit36 - -switch.exit36: ; preds = %switch.default, %switch.case35 - store i32 %0, ptr %switch37, align 4 - br label %switch.entry38 - -switch.entry38: ; preds = %switch.exit36 - %30 = load i32, ptr %switch37, align 4 - switch i32 %30, label %switch.exit58 [ - i32 0, label %switch.case39 - i32 1, label %switch.case45 - i32 2, label %switch.case52 +switch.case23: ; preds = %switch.entry22, %switch.entry22, %switch.entry22 + br label %switch.exit24 +switch.default: ; preds = %switch.entry22 + br label %switch.exit24 +switch.exit24: ; preds = %switch.default, %switch.case23 + store i32 %0, ptr %switch25, align 4 + br label %switch.entry26 +switch.entry26: ; preds = %switch.exit24 + %20 = load i32, ptr %switch25, align 4 + switch i32 %20, label %switch.exit37 [ + i32 0, label %switch.case27 + i32 1, label %switch.case30 + i32 2, label %switch.case34 ] - -switch.case39: ; preds = %switch.entry38 +switch.case27: ; preds = %switch.entry26 store i32 1, ptr %a, align 4 - store %"char[]" { ptr @.str.6, i64 1 }, ptr %x40, align 8 - %31 = call ptr @std.io.stdout() - store ptr %31, ptr %result42, align 8 - %32 = load ptr, ptr %result42, align 8 - %33 = getelementptr inbounds %"char[]", ptr %x40, i32 0, i32 0 - %lo43 = load ptr, ptr %33, align 8 - %34 = getelementptr inbounds %"char[]", ptr %x40, i32 0, i32 1 - %hi44 = load i64, ptr %34, align 8 - %35 = call i64 @std.io.File.printn(ptr %retparam41, ptr %32, ptr %lo43, i64 %hi44) - br label %switch.case45 - -switch.case45: ; preds = %switch.entry38, %switch.case39 - store i32 2, ptr %a46, align 4 - store %"char[]" { ptr @.str.7, i64 1 }, ptr %x47, align 8 - %36 = call ptr @std.io.stdout() - store ptr %36, ptr %result49, align 8 - %37 = load ptr, ptr %result49, align 8 - %38 = getelementptr inbounds %"char[]", ptr %x47, i32 0, i32 0 - %lo50 = load ptr, ptr %38, align 8 - %39 = getelementptr inbounds %"char[]", ptr %x47, i32 0, i32 1 - %hi51 = load i64, ptr %39, align 8 - %40 = call i64 @std.io.File.printn(ptr %retparam48, ptr %37, ptr %lo50, i64 %hi51) - br label %switch.case52 - -switch.case52: ; preds = %switch.entry38, %switch.case45 - store %"char[]" { ptr @.str.8, i64 1 }, ptr %x53, align 8 - %41 = call ptr @std.io.stdout() - store ptr %41, ptr %result55, align 8 - %42 = load ptr, ptr %result55, align 8 - %43 = getelementptr inbounds %"char[]", ptr %x53, i32 0, i32 0 - %lo56 = load ptr, ptr %43, align 8 - %44 = getelementptr inbounds %"char[]", ptr %x53, i32 0, i32 1 - %hi57 = load i64, ptr %44, align 8 - %45 = call i64 @std.io.File.printn(ptr %retparam54, ptr %42, ptr %lo56, i64 %hi57) - br label %switch.exit58 - -switch.exit58: ; preds = %switch.case52, %switch.entry38 + %21 = call ptr @std.io.stdout() + store ptr %21, ptr %result29, align 8 + %22 = load ptr, ptr %result29, align 8 + %23 = call i64 @std.io.File.printn(ptr %retparam28, ptr %22, ptr @.str.6, i64 1) + br label %switch.case30 +switch.case30: ; preds = %switch.entry26, %switch.case27 + store i32 2, ptr %a31, align 4 + %24 = call ptr @std.io.stdout() + store ptr %24, ptr %result33, align 8 + %25 = load ptr, ptr %result33, align 8 + %26 = call i64 @std.io.File.printn(ptr %retparam32, ptr %25, ptr @.str.7, i64 1) + br label %switch.case34 +switch.case34: ; preds = %switch.entry26, %switch.case30 + %27 = call ptr @std.io.stdout() + store ptr %27, ptr %result36, align 8 + %28 = load ptr, ptr %result36, align 8 + %29 = call i64 @std.io.File.printn(ptr %retparam35, ptr %28, ptr @.str.8, i64 1) + br label %switch.exit37 +switch.exit37: ; preds = %switch.case34, %switch.entry26 ret void } \ No newline at end of file diff --git a/test/test_suite/functions/splat.c3t b/test/test_suite/functions/splat.c3t index de3dae794..a55252650 100644 --- a/test/test_suite/functions/splat.c3t +++ b/test/test_suite/functions/splat.c3t @@ -32,12 +32,14 @@ declare i32 @sum_us(ptr, i64) #0 %4 = insertvalue %"int[]" undef, ptr %x, 0 %5 = insertvalue %"int[]" %4, i64 3, 1 store %"int[]" %5, ptr %z, align 8 - %6 = call i32 @sum_us(ptr %x, i64 3) - %7 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 0 - %lo = load ptr, ptr %7, align 8 - %8 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 1 - %hi = load i64, ptr %8, align 8 - %9 = call i32 @sum_us(ptr %lo, i64 %hi) - %10 = call i32 @sum_us(ptr null, i64 0) + %6 = insertvalue %"int[]" undef, ptr %x, 0 + %7 = insertvalue %"int[]" %6, i64 3, 1 + %8 = call i32 @sum_us(ptr %x, i64 3) + %9 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 0 + %lo = load ptr, ptr %9, align 8 + %10 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 1 + %hi = load i64, ptr %10, align 8 + %11 = call i32 @sum_us(ptr %lo, i64 %hi) + %12 = call i32 @sum_us(ptr null, i64 0) ret void } \ No newline at end of file diff --git a/test/test_suite/functions/splat_aarch64.c3t b/test/test_suite/functions/splat_aarch64.c3t index 3a3a1dd4c..6ea49b0b2 100644 --- a/test/test_suite/functions/splat_aarch64.c3t +++ b/test/test_suite/functions/splat_aarch64.c3t @@ -35,23 +35,23 @@ entry: %2 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 2 store i32 3, ptr %2, align 4 %3 = insertvalue %"int[]" undef, ptr %varargslots, 0 - %4 = insertvalue %"int[]" %3, i64 3, 1 - store %"int[]" %4, ptr %taddr, align 8 - %5 = load [2 x i64], ptr %taddr, align 8 - %6 = call i32 @sum_us([2 x i64] %5) + %"#temp#" = insertvalue %"int[]" %3, i64 3, 1 + store %"int[]" %"#temp#", ptr %taddr, align 8 + %4 = load [2 x i64], ptr %taddr, align 8 + %5 = call i32 @sum_us([2 x i64] %4) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 12, i1 false) - %7 = insertvalue %"int[]" undef, ptr %x, 0 - %8 = insertvalue %"int[]" %7, i64 3, 1 - store %"int[]" %8, ptr %z, align 8 - %9 = insertvalue %"int[]" undef, ptr %x, 0 - %10 = insertvalue %"int[]" %9, i64 3, 1 - store %"int[]" %10, ptr %taddr1, align 8 - %11 = load [2 x i64], ptr %taddr1, align 8 - %12 = call i32 @sum_us([2 x i64] %11) - %13 = load [2 x i64], ptr %z, align 8 - %14 = call i32 @sum_us([2 x i64] %13) + %6 = insertvalue %"int[]" undef, ptr %x, 0 + %7 = insertvalue %"int[]" %6, i64 3, 1 + store %"int[]" %7, ptr %z, align 8 + %8 = insertvalue %"int[]" undef, ptr %x, 0 + %9 = insertvalue %"int[]" %8, i64 3, 1 + store %"int[]" %9, ptr %taddr1, align 8 + %10 = load [2 x i64], ptr %taddr1, align 8 + %11 = call i32 @sum_us([2 x i64] %10) + %12 = load [2 x i64], ptr %z, align 8 + %13 = call i32 @sum_us([2 x i64] %12) store %"int[]" zeroinitializer, ptr %taddr2, align 8 - %15 = load [2 x i64], ptr %taddr2, align 8 - %16 = call i32 @sum_us([2 x i64] %15) + %14 = load [2 x i64], ptr %taddr2, align 8 + %15 = call i32 @sum_us([2 x i64] %14) ret void } diff --git a/test/test_suite/functions/splat_mingw.c3t b/test/test_suite/functions/splat_mingw.c3t index 787c098cf..f88171bcc 100644 --- a/test/test_suite/functions/splat_mingw.c3t +++ b/test/test_suite/functions/splat_mingw.c3t @@ -33,19 +33,19 @@ entry: %2 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 2 store i32 3, ptr %2, align 4 %3 = insertvalue %"int[]" undef, ptr %varargslots, 0 - %4 = insertvalue %"int[]" %3, i64 3, 1 - store %"int[]" %4, ptr %indirectarg, align 8 - %5 = call i32 @sum_us(ptr align 8 %indirectarg) + %"#temp#" = insertvalue %"int[]" %3, i64 3, 1 + store %"int[]" %"#temp#", ptr %indirectarg, align 8 + %4 = call i32 @sum_us(ptr align 8 %indirectarg) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 12, i1 false) - %6 = insertvalue %"int[]" undef, ptr %x, 0 - %7 = insertvalue %"int[]" %6, i64 3, 1 - store %"int[]" %7, ptr %z, align 8 - %8 = insertvalue %"int[]" undef, ptr %x, 0 - %9 = insertvalue %"int[]" %8, i64 3, 1 - store %"int[]" %9, ptr %indirectarg1, align 8 - %10 = call i32 @sum_us(ptr align 8 %indirectarg1) + %5 = insertvalue %"int[]" undef, ptr %x, 0 + %6 = insertvalue %"int[]" %5, i64 3, 1 + store %"int[]" %6, ptr %z, align 8 + %7 = insertvalue %"int[]" undef, ptr %x, 0 + %8 = insertvalue %"int[]" %7, i64 3, 1 + store %"int[]" %8, ptr %indirectarg1, align 8 + %9 = call i32 @sum_us(ptr align 8 %indirectarg1) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg2, ptr align 8 %z, i32 16, i1 false) - %11 = call i32 @sum_us(ptr align 8 %indirectarg2) + %10 = call i32 @sum_us(ptr align 8 %indirectarg2) store %"int[]" zeroinitializer, ptr %indirectarg3, align 8 - %12 = call i32 @sum_us(ptr align 8 %indirectarg3) + %11 = call i32 @sum_us(ptr align 8 %indirectarg3) ret void diff --git a/test/test_suite/functions/test_regression.c3t b/test/test_suite/functions/test_regression.c3t index ff815d154..1e6f324a6 100644 --- a/test/test_suite/functions/test_regression.c3t +++ b/test/test_suite/functions/test_regression.c3t @@ -355,12 +355,14 @@ if.exit: ; preds = %entry %11 = add i64 %sub, 1 %size = sub i64 %11, 1 %ptroffset2 = getelementptr inbounds i32, ptr %9, i64 1 - %12 = call i32 @test.sum_us(ptr %ptroffset2, i64 %size) - %add = add i32 %7, %12 + %12 = insertvalue %"int[]" undef, ptr %ptroffset2, 0 + %13 = insertvalue %"int[]" %12, i64 %size, 1 + %14 = call i32 @test.sum_us(ptr %ptroffset2, i64 %size) + %add = add i32 %7, %14 %add3 = add i32 %4, %add store i32 %add3, ptr %sum, align 4 - %13 = load i32, ptr %sum, align 4 - ret i32 %13 + %15 = load i32, ptr %sum, align 4 + ret i32 %15 } ; Function Attrs: nounwind @@ -470,7 +472,7 @@ loop.exit: ; preds = %loop.cond loop.cond2: ; preds = %loop.body5, %loop.exit %12 = load i32, ptr %i1, align 4 - %13 = call i64 @"std.collections.list$int$.List.len"(ptr %array) + %13 = call i64 @"std.collections.list$int$.List.len"(ptr %array) #3 %trunc3 = trunc i64 %13 to i32 %lt4 = icmp slt i32 %12, %trunc3 br i1 %lt4, label %loop.body5, label %loop.exit8 @@ -479,7 +481,7 @@ loop.body5: ; preds = %loop.cond2 %14 = load i32, ptr %i1, align 4 %15 = load i32, ptr %i1, align 4 %sext6 = sext i32 %15 to i64 - %16 = call i32 @"std.collections.list$int$.List.get"(ptr %array, i64 %sext6) + %16 = call i32 @"std.collections.list$int$.List.get"(ptr %array, i64 %sext6) #3 %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %14, i32 %16) %18 = load i32, ptr %i1, align 4 %add7 = add i32 %18, 1 @@ -508,40 +510,44 @@ loop.exit8: ; preds = %loop.cond2 store i32 3, ptr %fro, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 16 %x, ptr align 16 @.__const.12, i32 16, i1 false) %31 = load i32, ptr %fro, align 4 - %32 = call i32 @test.sum_us(ptr %x, i64 4) - %33 = call i32 (ptr, ...) @printf(ptr @.str.13, i32 %32) - %add9 = add i32 %31, %33 + %32 = insertvalue %"int[]" undef, ptr %x, 0 + %33 = insertvalue %"int[]" %32, i64 4, 1 + %34 = call i32 @test.sum_us(ptr %x, i64 4) + %35 = call i32 (ptr, ...) @printf(ptr @.str.13, i32 %34) + %add9 = add i32 %31, %35 store i32 %add9, ptr %fro, align 4 - %34 = load i32, ptr %fro, align 4 - %35 = call i32 (ptr, ...) @printf(ptr @.str.14, i32 %34) - %36 = insertvalue %"int[]" undef, ptr %x, 0 - %37 = insertvalue %"int[]" %36, i64 4, 1 - store %"int[]" %37, ptr %z, align 8 + %36 = load i32, ptr %fro, align 4 + %37 = call i32 (ptr, ...) @printf(ptr @.str.14, i32 %36) + %38 = insertvalue %"int[]" undef, ptr %x, 0 + %39 = insertvalue %"int[]" %38, i64 4, 1 + store %"int[]" %39, ptr %z, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %de, ptr align 4 @.__const.15, i32 12, i1 false) - %38 = call i32 @test.sum_us(ptr %x, i64 4) - %39 = call i32 (ptr, ...) @printf(ptr @.str.16, i32 %38) - %40 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 0 - %lo = load ptr, ptr %40, align 8 - %41 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 1 - %hi = load i64, ptr %41, align 8 - %42 = call i32 @test.sum_us(ptr %lo, i64 %hi) - %43 = call i32 (ptr, ...) @printf(ptr @.str.17, i32 %42) - %44 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 0 - store i32 1, ptr %44, align 4 - %45 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 1 - store i32 2, ptr %45, align 4 - %46 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 2 - store i32 4, ptr %46, align 4 - %47 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 3 - store i32 5, ptr %47, align 4 - %48 = call i32 @test.sum_us(ptr %varargslots, i64 4) - %49 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %48) - %50 = getelementptr inbounds [1 x i32], ptr %varargslots10, i64 0, i64 0 - store i32 1, ptr %50, align 4 - %51 = call i32 @test.sum_us(ptr %varargslots10, i64 1) - %52 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %51) - %53 = call i32 @test.sum_us(ptr null, i64 0) - %54 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %53) + %40 = insertvalue %"int[]" undef, ptr %x, 0 + %41 = insertvalue %"int[]" %40, i64 4, 1 + %42 = call i32 @test.sum_us(ptr %x, i64 4) + %43 = call i32 (ptr, ...) @printf(ptr @.str.16, i32 %42) + %44 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 0 + %lo = load ptr, ptr %44, align 8 + %45 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 1 + %hi = load i64, ptr %45, align 8 + %46 = call i32 @test.sum_us(ptr %lo, i64 %hi) + %47 = call i32 (ptr, ...) @printf(ptr @.str.17, i32 %46) + %48 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 0 + store i32 1, ptr %48, align 4 + %49 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 1 + store i32 2, ptr %49, align 4 + %50 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 2 + store i32 4, ptr %50, align 4 + %51 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 3 + store i32 5, ptr %51, align 4 + %52 = call i32 @test.sum_us(ptr %varargslots, i64 4) + %53 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %52) + %54 = getelementptr inbounds [1 x i32], ptr %varargslots10, i64 0, i64 0 + store i32 1, ptr %54, align 4 + %55 = call i32 @test.sum_us(ptr %varargslots10, i64 1) + %56 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %55) + %57 = call i32 @test.sum_us(ptr null, i64 0) + %58 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %57) store ptr null, ptr %a1, align 8 store ptr null, ptr %b2, align 8 ret void diff --git a/test/test_suite/functions/test_regression_mingw.c3t b/test/test_suite/functions/test_regression_mingw.c3t index b00711e44..a292c0026 100644 --- a/test/test_suite/functions/test_regression_mingw.c3t +++ b/test/test_suite/functions/test_regression_mingw.c3t @@ -244,13 +244,21 @@ fn Type getValue(Blob blob) %LinkedList = type { ptr, i64, ptr, ptr } %List = type { i64, i64, ptr, ptr } %Foo = type { i32, i32 } + $"$ct.test.Bobo" = comdat any + $"$ct.test.Blob" = comdat any + $"$ct.test.Foor" = comdat any + $"$ct.test.Foo2" = comdat any + $"$ct.test.Foo" = comdat any + $"$ct.int" = comdat any + $"$ct.test.MyEnum" = comdat any + @"$ct.test.Bobo" = linkonce global %.introspect { i8 10, ptr null, i64 20, i64 0, i64 6, [0 x i64] zeroinitializer }, comdat, align 8 @"$ct.test.Blob" = linkonce global %.introspect { i8 10, ptr null, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, comdat, align 8 @"$ct.test.Foor" = linkonce global %.introspect { i8 11, ptr null, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, comdat, align 8 @@ -283,6 +291,7 @@ $"$ct.test.MyEnum" = comdat any @.str.20 = private unnamed_addr constant [13 x i8] c"Vararg0: %d\0A\00", align 1 @.str.21 = private unnamed_addr constant [12 x i8] c"Foo is: %d\0A\00", align 1 @.str.22 = private unnamed_addr constant [9 x i8] c"Mutating\00", align 1 + ; Function Attrs: nounwind define void @test.Foo2.printme(ptr %0) #0 { entry: @@ -291,6 +300,7 @@ entry: %3 = call i32 (ptr, ...) @printf(ptr @.str.21, i32 %2) ret void } + ; Function Attrs: nounwind define i32 @test.Foo2.mutate(ptr %0) #0 { entry: @@ -301,14 +311,17 @@ entry: store i32 %add, ptr %2, align 4 ret i32 %add } + ; Function Attrs: nounwind declare i32 @printf(ptr, ...) #0 + ; Function Attrs: nounwind define void @test.helloWorld() #0 { entry: %0 = call i32 (ptr, ...) @printf(ptr @.str) ret void } + ; Function Attrs: nounwind define i32 @test.test_static() #0 { entry: @@ -320,6 +333,7 @@ entry: %3 = load i32, ptr @test_static.x, align 4 ret i32 %3 } + ; Function Attrs: nounwind define i32 @test.helo(double %0, ptr align 4 %1) #0 { entry: @@ -332,6 +346,7 @@ entry: %2 = call i32 @test.helo(double 1.000000e+00, ptr align 4 %indirectarg) ret i32 1 } + ; Function Attrs: nounwind define i32 @test.test1(i32 %0, i32 %1) #0 { entry: @@ -343,12 +358,15 @@ entry: store i32 %3, ptr %a, align 4 %gt = icmp sgt i32 %1, 128 br i1 %gt, label %if.then, label %if.exit + if.then: ; preds = %entry ret i32 -1 + if.exit: ; preds = %entry %4 = load i32, ptr %a, align 4 ret i32 %4 } + ; Function Attrs: nounwind define i32 @test.sum_us(ptr align 8 %0) #0 { entry: @@ -359,8 +377,10 @@ entry: %2 = load i64, ptr %1, align 8 %eq = icmp eq i64 0, %2 br i1 %eq, label %if.then, label %if.exit + if.then: ; preds = %entry ret i32 0 + if.exit: ; preds = %entry %3 = load i32, ptr %sum, align 4 %4 = getelementptr inbounds %"int[]", ptr %0, i32 0, i32 0 @@ -384,6 +404,7 @@ if.exit: ; preds = %entry %14 = load i32, ptr %sum, align 4 ret i32 %14 } + ; Function Attrs: nounwind define i32 @test.sumd(ptr align 8 %0) #0 { entry: @@ -392,6 +413,7 @@ entry: store i32 0, ptr %sum, align 4 store i32 0, ptr %i, align 4 br label %loop.cond + loop.cond: ; preds = %loop.body, %entry %1 = load i32, ptr %i, align 4 %sext = sext i32 %1 to i64 @@ -401,6 +423,7 @@ loop.cond: ; preds = %loop.body, %entry %check = icmp slt i64 %3, 0 %siui-lt = or i1 %check, %lt br i1 %siui-lt, label %loop.body, label %loop.exit + loop.body: ; preds = %loop.cond %4 = load i32, ptr %sum, align 4 %5 = getelementptr inbounds %"int[]", ptr %0, i32 0, i32 0 @@ -415,10 +438,12 @@ loop.body: ; preds = %loop.cond %add2 = add i32 %9, 1 store i32 %add2, ptr %i, align 4 br label %loop.cond + loop.exit: ; preds = %loop.cond %10 = load i32, ptr %sum, align 4 ret i32 %10 } + ; Function Attrs: nounwind define void @test.main() #0 { entry: @@ -440,8 +465,8 @@ entry: %varargslots = alloca [4 x i32], align 16 %indirectarg12 = alloca %"int[]", align 8 %varargslots13 = alloca [1 x i32], align 4 - %indirectarg14 = alloca %"int[]", align 8 %indirectarg15 = alloca %"int[]", align 8 + %indirectarg16 = alloca %"int[]", align 8 %a1 = alloca ptr, align 8 %b2 = alloca ptr, align 8 %0 = call i32 @test.test_static() @@ -454,12 +479,14 @@ entry: call void @"std.collections.linkedlist$int$.LinkedList.push"(ptr %list, i32 30) store i32 0, ptr %i, align 4 br label %loop.cond + loop.cond: ; preds = %loop.body, %entry %3 = load i32, ptr %i, align 4 %4 = call i64 @"std.collections.linkedlist$int$.LinkedList.len"(ptr %list) #3 %trunc = trunc i64 %4 to i32 %lt = icmp slt i32 %3, %trunc br i1 %lt, label %loop.body, label %loop.exit + loop.body: ; preds = %loop.cond %5 = load i32, ptr %i, align 4 %6 = load i32, ptr %i, align 4 @@ -470,6 +497,7 @@ loop.body: ; preds = %loop.cond %add = add i32 %9, 1 store i32 %add, ptr %i, align 4 br label %loop.cond + loop.exit: ; preds = %loop.cond call void @"std.collections.linkedlist$int$.LinkedList.free"(ptr %list) %10 = call i32 (ptr, ...) @printf(ptr @.str.3, i32 3) @@ -483,22 +511,25 @@ loop.exit: ; preds = %loop.cond call void @"std.collections.list$int$.List.insert_at"(ptr %array, i64 2, i32 300) store i32 0, ptr %i1, align 4 br label %loop.cond2 + loop.cond2: ; preds = %loop.body5, %loop.exit %12 = load i32, ptr %i1, align 4 - %13 = call i64 @"std.collections.list$int$.List.len"(ptr %array) + %13 = call i64 @"std.collections.list$int$.List.len"(ptr %array) #3 %trunc3 = trunc i64 %13 to i32 %lt4 = icmp slt i32 %12, %trunc3 br i1 %lt4, label %loop.body5, label %loop.exit8 + loop.body5: ; preds = %loop.cond2 %14 = load i32, ptr %i1, align 4 %15 = load i32, ptr %i1, align 4 %sext6 = sext i32 %15 to i64 - %16 = call i32 @"std.collections.list$int$.List.get"(ptr %array, i64 %sext6) + %16 = call i32 @"std.collections.list$int$.List.get"(ptr %array, i64 %sext6) #3 %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %14, i32 %16) %18 = load i32, ptr %i1, align 4 %add7 = add i32 %18, 1 store i32 %add7, ptr %i1, align 4 br label %loop.cond2 + loop.exit8: ; preds = %loop.cond2 call void @"std.collections.list$int$.List.free"(ptr %array) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const.6, i32 4, i1 false) @@ -551,20 +582,20 @@ loop.exit8: ; preds = %loop.cond2 %49 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 3 store i32 5, ptr %49, align 4 %50 = insertvalue %"int[]" undef, ptr %varargslots, 0 - %51 = insertvalue %"int[]" %50, i64 4, 1 - store %"int[]" %51, ptr %indirectarg12, align 8 - %52 = call i32 @test.sum_us(ptr align 8 %indirectarg12) - %53 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %52) - %54 = getelementptr inbounds [1 x i32], ptr %varargslots13, i64 0, i64 0 - store i32 1, ptr %54, align 4 - %55 = insertvalue %"int[]" undef, ptr %varargslots13, 0 - %56 = insertvalue %"int[]" %55, i64 1, 1 - store %"int[]" %56, ptr %indirectarg14, align 8 - %57 = call i32 @test.sum_us(ptr align 8 %indirectarg14) - %58 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %57) - store %"int[]" zeroinitializer, ptr %indirectarg15, align 8 - %59 = call i32 @test.sum_us(ptr align 8 %indirectarg15) - %60 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %59) + %"#temp#" = insertvalue %"int[]" %50, i64 4, 1 + store %"int[]" %"#temp#", ptr %indirectarg12, align 8 + %51 = call i32 @test.sum_us(ptr align 8 %indirectarg12) + %52 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %51) + %53 = getelementptr inbounds [1 x i32], ptr %varargslots13, i64 0, i64 0 + store i32 1, ptr %53, align 4 + %54 = insertvalue %"int[]" undef, ptr %varargslots13, 0 + %"#temp#14" = insertvalue %"int[]" %54, i64 1, 1 + store %"int[]" %"#temp#14", ptr %indirectarg15, align 8 + %55 = call i32 @test.sum_us(ptr align 8 %indirectarg15) + %56 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %55) + store %"int[]" zeroinitializer, ptr %indirectarg16, align 8 + %57 = call i32 @test.sum_us(ptr align 8 %indirectarg16) + %58 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %57) store ptr null, ptr %a1, align 8 store ptr null, ptr %b2, align 8 ret void diff --git a/test/test_suite/initializer_lists/subarrays.c3t b/test/test_suite/initializer_lists/subarrays.c3t index 9865ccbd6..eeb466843 100644 --- a/test/test_suite/initializer_lists/subarrays.c3t +++ b/test/test_suite/initializer_lists/subarrays.c3t @@ -48,7 +48,6 @@ fn int main() %Bar = type { i32, i32 } %"Bar[]" = type { ptr, i64 } %"int[]" = type { ptr, i64 } -%"char[]" = type { ptr, i64 } %File = type { ptr } %Baz = type { double } @@ -76,16 +75,14 @@ entry: %literal = alloca [3 x i32], align 4 %y = alloca ptr, align 8 %literal2 = alloca [3 x i32], align 4 - %x3 = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 %ffe = alloca %Baz, align 8 %azz = alloca [1 x i32], align 4 %xy = alloca i8, align 1 - %literal7 = alloca [3 x i32], align 4 - %x9 = alloca %"char[]", align 8 - %retparam10 = alloca i64, align 8 - %result11 = alloca %File, align 8 + %literal6 = alloca [3 x i32], align 4 + %retparam8 = alloca i64, align 8 + %result9 = alloca %File, align 8 %b = alloca %Bar, align 4 %z = alloca %Baz, align 8 %sub = alloca %"int[]", align 8 @@ -115,68 +112,58 @@ entry: %12 = getelementptr inbounds [3 x i32], ptr %literal2, i64 0, i64 2 store i32 567, ptr %12, align 4 store ptr %literal2, ptr %y, align 8 - store %"char[]" { ptr @.str.5, i64 6 }, ptr %x3, align 8 %13 = call ptr @std.io.stdout() store ptr %13, ptr %result, align 8 %14 = load ptr, ptr %result, align 8 - %15 = getelementptr inbounds %"char[]", ptr %x3, i32 0, i32 0 - %lo = load ptr, ptr %15, align 8 - %16 = getelementptr inbounds %"char[]", ptr %x3, i32 0, i32 1 - %hi = load i64, ptr %16, align 8 - %17 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr %lo, i64 %hi) - %18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1 - %19 = load i64, ptr %18, align 8 - %trunc = trunc i64 %19 to i32 - %20 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0 - %21 = load ptr, ptr %20, align 8 - %ptroffset4 = getelementptr inbounds i32, ptr %21, i64 1 - %22 = load i32, ptr %ptroffset4, align 4 - %23 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %trunc, i32 %22) - %24 = load ptr, ptr %y, align 8 - %ptroffset5 = getelementptr inbounds i32, ptr %24, i64 1 - %25 = load i32, ptr %ptroffset5, align 4 - %26 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %25) - %27 = load ptr, ptr @subarrays.fofeo, align 8 - %ptroffset6 = getelementptr inbounds i32, ptr %27, i64 1 - %28 = load i32, ptr %ptroffset6, align 4 - %29 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %28) + %15 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr @.str.5, i64 6) + %16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1 + %17 = load i64, ptr %16, align 8 + %trunc = trunc i64 %17 to i32 + %18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0 + %19 = load ptr, ptr %18, align 8 + %ptroffset3 = getelementptr inbounds i32, ptr %19, i64 1 + %20 = load i32, ptr %ptroffset3, align 4 + %21 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %trunc, i32 %20) + %22 = load ptr, ptr %y, align 8 + %ptroffset4 = getelementptr inbounds i32, ptr %22, i64 1 + %23 = load i32, ptr %ptroffset4, align 4 + %24 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %23) + %25 = load ptr, ptr @subarrays.fofeo, align 8 + %ptroffset5 = getelementptr inbounds i32, ptr %25, i64 1 + %26 = load i32, ptr %ptroffset5, align 4 + %27 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %26) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const, i32 8, i1 false) - %30 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0 - store i32 0, ptr %30, align 4 - %31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0 - store i32 1, ptr %31, align 4 - %32 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1 - store i32 2, ptr %32, align 4 - %33 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2 - store i32 3, ptr %33, align 4 - %34 = insertvalue %"int[]" undef, ptr %literal7, 0 - %35 = insertvalue %"int[]" %34, i64 3, 1 - %36 = extractvalue %"int[]" %35, 1 - %not = icmp eq i64 %36, 0 - %37 = zext i1 %not to i8 - store i8 %37, ptr %xy, align 1 - %38 = load i8, ptr %xy, align 1 - %39 = trunc i8 %38 to i1 - %not8 = xor i1 %39, true - br i1 %not8, label %if.then, label %if.exit + %28 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0 + store i32 0, ptr %28, align 4 + %29 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 0 + store i32 1, ptr %29, align 4 + %30 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 1 + store i32 2, ptr %30, align 4 + %31 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 2 + store i32 3, ptr %31, align 4 + %32 = insertvalue %"int[]" undef, ptr %literal6, 0 + %33 = insertvalue %"int[]" %32, i64 3, 1 + %34 = extractvalue %"int[]" %33, 1 + %not = icmp eq i64 %34, 0 + %35 = zext i1 %not to i8 + store i8 %35, ptr %xy, align 1 + %36 = load i8, ptr %xy, align 1 + %37 = trunc i8 %36 to i1 + %not7 = xor i1 %37, true + br i1 %not7, label %if.then, label %if.exit if.then: ; preds = %entry - store %"char[]" { ptr @.str.9, i64 2 }, ptr %x9, align 8 - %40 = call ptr @std.io.stdout() - store ptr %40, ptr %result11, align 8 - %41 = load ptr, ptr %result11, align 8 - %42 = getelementptr inbounds %"char[]", ptr %x9, i32 0, i32 0 - %lo12 = load ptr, ptr %42, align 8 - %43 = getelementptr inbounds %"char[]", ptr %x9, i32 0, i32 1 - %hi13 = load i64, ptr %43, align 8 - %44 = call i64 @std.io.File.printn(ptr %retparam10, ptr %41, ptr %lo12, i64 %hi13) + %38 = call ptr @std.io.stdout() + store ptr %38, ptr %result9, align 8 + %39 = load ptr, ptr %result9, align 8 + %40 = call i64 @std.io.File.printn(ptr %retparam8, ptr %39, ptr @.str.9, i64 2) br label %if.exit if.exit: ; preds = %if.then, %entry - %45 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0 - store i32 0, ptr %45, align 4 - %46 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1 - store i32 0, ptr %46, align 4 + %41 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0 + store i32 0, ptr %41, align 4 + %42 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1 + store i32 0, ptr %42, align 4 call void @llvm.memset.p0.i64(ptr align 8 %z, i8 0, i64 8, i1 false) store %"int[]" zeroinitializer, ptr %sub, align 8 store %"Bar[]" zeroinitializer, ptr %foo, align 8 diff --git a/test/test_suite/macros/macro_failable_return_rethrow.c3t b/test/test_suite/macros/macro_failable_return_rethrow.c3t index f08613b4b..61267e4ac 100644 --- a/test/test_suite/macros/macro_failable_return_rethrow.c3t +++ b/test/test_suite/macros/macro_failable_return_rethrow.c3t @@ -27,33 +27,27 @@ entry: %not_err = icmp eq i64 %0, 0 %1 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) br i1 %1, label %after_check, label %assign_optional - assign_optional: ; preds = %entry store i64 %0, ptr %error_var1, align 8 br label %guard_block - after_check: ; preds = %entry br label %noerr_block - guard_block: ; preds = %assign_optional %2 = load i64, ptr %error_var1, align 8 store i64 %2, ptr %error_var, align 8 br label %panic_block - noerr_block: ; preds = %after_check br label %noerr_block2 - panic_block: ; preds = %guard_block %3 = insertvalue %any undef, ptr %error_var, 0 %4 = insertvalue %any %3, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 %5 = getelementptr inbounds [1 x %any], ptr %varargslots, i64 0, i64 0 store %any %4, ptr %5, align 16 %6 = insertvalue %"any[]" undef, ptr %varargslots, 0 - %7 = insertvalue %"any[]" %6, i64 1, 1 - store %"any[]" %7, ptr %indirectarg, align 8 + %"#temp#" = insertvalue %"any[]" %6, i64 1, 1 + store %"any[]" %"#temp#", ptr %indirectarg, align 8 call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 32, ptr @.func, i64 4, i32 13, ptr byval(%"any[]") align 8 %indirectarg) unreachable - noerr_block2: ; preds = %noerr_block ret void } \ No newline at end of file diff --git a/test/test_suite/methods/enum_distinct_err_methods.c3t b/test/test_suite/methods/enum_distinct_err_methods.c3t index cb4350936..2afb7ac8f 100644 --- a/test/test_suite/methods/enum_distinct_err_methods.c3t +++ b/test/test_suite/methods/enum_distinct_err_methods.c3t @@ -46,55 +46,35 @@ fn int main() define void @foo.Foo.hello(ptr %0) #0 { entry: - %x = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 - store %"char[]" { ptr @.str, i64 14 }, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 %2 = load ptr, ptr %result, align 8 - %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi) + %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr @.str, i64 14) ret void } define void @foo.Bar.hello(ptr %0) #0 { entry: - %x = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 - store %"char[]" { ptr @.str.1, i64 14 }, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 %2 = load ptr, ptr %result, align 8 - %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi) + %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr @.str.1, i64 14) ret void } - define void @foo.MyEnum.hello(ptr %0) #0 { entry: - %x = alloca %"char[]", align 8 %retparam = alloca i64, align 8 %result = alloca %File, align 8 - store %"char[]" { ptr @.str.2, i64 17 }, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 %2 = load ptr, ptr %result, align 8 - %3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi) + %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr @.str.2, i64 17) ret void } - define i32 @main() #0 { entry: %f = alloca i64, align 8