From a9c28cce6d4ce7d4c69913f618ad33a9126797fb Mon Sep 17 00:00:00 2001 From: Christoffer Lerno Date: Tue, 10 Oct 2023 11:30:30 +0200 Subject: [PATCH] Default protocols. Closes #1039 --- src/compiler/compiler_internal.h | 2 + src/compiler/enums.h | 1 + src/compiler/llvm_codegen.c | 2 +- src/compiler/llvm_codegen_expr.c | 461 +++++++++------- src/compiler/llvm_codegen_internal.h | 1 - src/compiler/sema_decls.c | 122 +++-- src/compiler/sema_expr.c | 1 + src/compiler/sema_liveness.c | 10 +- src/compiler/sema_name_resolution.c | 30 +- src/compiler/symtab.c | 1 + test/test_suite/abi/darwin64_avx.c3t | 6 +- test/test_suite/abi/darwin64_avx512.c3t | 6 +- .../abi/riscv32-ilp32-ilp32f-ilp32d-abi-1.c3t | 6 +- .../abi/riscv32-ilp32-ilp32f-ilp32d-abi-2.c3t | 6 +- .../abi/riscv32-ilp32-ilp32f-ilp32d-abi-3.c3t | 100 ++-- test/test_suite/assert/assertf.c3t | 4 +- .../bitstruct/bitstruct_anon_in_struct_ok.c3t | 64 +-- test/test_suite/bitstruct/bitstruct_be.c3t | 40 +- .../bitstruct/bitstruct_initializer.c3t | 282 +++++----- test/test_suite/bitstruct/bitstruct_ops.c3t | 206 +++---- .../bitstruct/embedded_bitstruct.c3t | 32 +- test/test_suite/clang/2002-04.c3t | 22 +- .../compile_time_access_subscript.c3t | 2 +- .../compile_time/ct_builtin_time_date.c3t | 30 +- test/test_suite/compile_time/ct_funcptr.c3t | 2 +- test/test_suite/compile_time/ct_memberof.c3t | 514 +++++++++++------- .../compile_time/typeof_example.c3t | 8 +- .../compile_time/untyped_conversions.c3t | 23 +- .../concurrency/atomic_load_store.c3t | 2 +- .../concurrency/atomic_load_store_debug.c3t | 2 +- .../dynamic/dynamic_with_default.c3t | 106 ++++ test/test_suite/dynamic/inherit.c3t | 4 +- .../dynamic/overlapping_function.c3t | 4 +- .../enumerations/enum_associated_value.c3t | 26 +- .../enum_associated_values_other.c3t | 2 +- .../enumerations/enum_conversions.c3t | 32 +- .../enumerations/enum_reflect_associated.c3t | 30 +- test/test_suite/errors/error_introspect.c3t | 24 +- test/test_suite/errors/error_regression_2.c3t | 78 +-- test/test_suite/errors/multiple_catch.c3t | 18 +- .../errors/optional_chained_init.c3t | 150 ++--- .../errors/optional_with_optional.c3t | 290 +++++----- test/test_suite/errors/or_and_rethrow.c3t | 4 +- test/test_suite/errors/printing_errors.c3t | 76 +-- .../errors/try_with_chained_unwrap.c3t | 12 +- test/test_suite/expressions/addr_compiles.c3t | 28 +- .../test_suite/expressions/pointer_access.c3t | 40 +- .../func_ptr_conversions_and_names.c3t | 100 ++-- test/test_suite/functions/splat_aarch64.c3t | 4 +- test/test_suite/functions/splat_mingw.c3t | 4 +- test/test_suite/functions/test_regression.c3t | 16 +- .../functions/test_regression_mingw.c3t | 24 +- test/test_suite/generic/enum_set_test.c3t | 58 +- .../generic/generic_lambda_complex.c3t | 22 +- test/test_suite/generic/generic_num.c3t | 2 +- test/test_suite/generic/generic_over_fn.c3t | 24 +- test/test_suite/initializer_lists/fasta.c3t | 28 +- test/test_suite/initializer_lists/statics.c3t | 12 +- test/test_suite/lambda/lambda_in_macro.c3t | 26 +- test/test_suite/literals/bin_literal.c3t | 28 +- .../macros/macro_failable_return_rethrow.c3t | 4 +- .../test_suite/macros/macro_typed_varargs.c3t | 10 +- .../macros/macro_untyped_varargs_2.c3t | 108 ++-- test/test_suite/macros/macro_vasplat.c3t | 112 ++-- test/test_suite/macros/userland_bitcast.c3t | 8 +- .../pointers/array_pointer_decay.c3t | 18 +- .../slices/slice_to_slice_assign.c3t | 36 +- .../slices/slice_to_slice_vector_assign.c3t | 36 +- .../statements/custom_foreach_with_ref.c3t | 44 +- test/test_suite/statements/fallthough_do.c3t | 18 +- test/test_suite/statements/foreach_common.c3t | 16 +- .../foreach_more_implementations.c3t | 10 +- .../statements/foreach_r_common.c3t | 16 +- test/test_suite/statements/simple_do.c3t | 6 +- test/test_suite/stdlib/map.c3t | 134 ++--- 75 files changed, 2089 insertions(+), 1747 deletions(-) create mode 100644 test/test_suite/dynamic/dynamic_with_default.c3t diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h index 5ddfebfa2..34989314e 100644 --- a/src/compiler/compiler_internal.h +++ b/src/compiler/compiler_internal.h @@ -563,11 +563,13 @@ typedef struct bool attr_finalizer : 1; bool attr_protocol_method : 1; bool attr_dynamic : 1; + bool attr_default : 1; bool is_lambda : 1; union { uint32_t priority; DeclId protocol_method; + DeclId default_method; Decl **generated_lambda; Decl **lambda_ct_parameters; }; diff --git a/src/compiler/enums.h b/src/compiler/enums.h index 0fad9916a..8085f897d 100644 --- a/src/compiler/enums.h +++ b/src/compiler/enums.h @@ -776,6 +776,7 @@ typedef enum ATTRIBUTE_BIGENDIAN, ATTRIBUTE_BUILTIN, ATTRIBUTE_CALLCONV, + ATTRIBUTE_DEFAULT, ATTRIBUTE_DEPRECATED, ATTRIBUTE_DYNAMIC, ATTRIBUTE_EXPORT, diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c index 2e5bf887c..91837a789 100644 --- a/src/compiler/llvm_codegen.c +++ b/src/compiler/llvm_codegen.c @@ -10,7 +10,7 @@ #include const char *varargslots_name = "varargslots"; -const char *temp_name = "#temp#"; +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 a3d49998e..59c42dc06 100644 --- a/src/compiler/llvm_codegen_expr.c +++ b/src/compiler/llvm_codegen_expr.c @@ -5209,30 +5209,7 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef *args, unsigned *arg_count_ } } -static void llvm_emit_splatted_variadic_arg(GenContext *c, Expr *expr, Type *vararg_type, BEValue *subarray) -{ - BEValue value; - llvm_emit_expr(c, &value, expr); - Type *type = expr->type->canonical; - switch (type->type_kind) - { - case TYPE_ARRAY: - llvm_value_addr(c, &value); - llvm_value_bitcast(c, &value, type->array.base); - llvm_value_aggregate_two(c, subarray, vararg_type, value.value, llvm_const_int(c, type_usz, type->array.len)); - return; - case TYPE_POINTER: - // Load the pointer - llvm_value_rvalue(c, &value); - llvm_value_aggregate_two(c, subarray, vararg_type, value.value, llvm_const_int(c, type_usz, type->pointer->array.len)); - return; - case TYPE_SUBARRAY: - *subarray = value; - return; - default: - UNREACHABLE - } -} + void llvm_add_abi_call_attributes(GenContext *c, LLVMValueRef call_value, int count, ABIArgInfo **infos) { @@ -5267,47 +5244,6 @@ void llvm_add_abi_call_attributes(GenContext *c, LLVMValueRef call_value, int co } -void llvm_emit_vararg_parameter(GenContext *c, BEValue *value, Type *vararg_type, ABIArgInfo *abi_info, Expr **varargs, Expr *vararg_splat) -{ - REMINDER("All varargs should be called with non-alias!"); - - // 9a. Special case, empty argument - if (!vararg_splat && !varargs) - { - // Just set the size to zero. - llvm_value_set(value, llvm_get_zero(c, vararg_type), vararg_type); - return; - } - if (vararg_splat) - { - // 9b. We splat the last type which is either a slice, an array or a dynamic array. - llvm_emit_splatted_variadic_arg(c, vararg_splat, vararg_type, value); - return; - } - BEValue temp_value; - // 9b. Otherwise, we also need to allocate memory for the arguments: - Type *pointee_type = vararg_type->array.base; - unsigned elements = vec_size(varargs); - 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_name); - foreach(Expr*, varargs) - { - llvm_emit_expr(c, &temp_value, val); - AlignSize store_alignment; - LLVMValueRef slot = llvm_emit_array_gep_raw(c, - array_ref, - llvm_array_type, - foreach_index, - alignment, - &store_alignment); - 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); -} - void llvm_emit_raw_call(GenContext *c, BEValue *result_value, FunctionPrototype *prototype, LLVMTypeRef func_type, LLVMValueRef func, LLVMValueRef *args, unsigned arg_count, int inline_flag, LLVMValueRef error_var, bool sret_return, BEValue *synthetic_return_param) { @@ -5630,115 +5566,30 @@ static LLVMValueRef llvm_emit_dynamic_search(GenContext *c, LLVMValueRef type_id return phi; } -static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr, BEValue *target) +/** + * We assume all optionals are already folded for the arguments. + */ +INLINE void llvm_emit_call_invocation(GenContext *c, BEValue *result_value, + BEValue *target, + SourceSpan span, + FunctionPrototype *prototype, + Expr **args, + BEValue *values, + int inline_flag, + LLVMValueRef func, + LLVMTypeRef func_type, + Expr **varargs) { - if (expr->call_expr.is_builtin) - { - llvm_emit_builtin_call(c, result_value, expr); - return; - } - - llvm_emit_update_stack_row(c, expr->span.row); - - LLVMTypeRef func_type; - LLVMValueRef func; - BEValue temp_value; - - bool always_inline = false; - - FunctionPrototype *prototype; - Expr **args = expr->call_expr.arguments; - - BEValue arg0_pointer = { .value = NULL }; - - // 1. Dynamic dispatch. - if (expr->call_expr.is_dynamic_dispatch) - { - assert(vec_size(args)); - Expr *any_val = args[0]; - assert(any_val->expr_kind == EXPR_CAST); - any_val = exprptr(any_val->cast_expr.expr)->unary_expr.expr; - BEValue result; - llvm_emit_expr(c, &result, any_val); - BEValue typeid = result; - llvm_emit_type_from_any(c, &typeid); - llvm_value_rvalue(c, &typeid); - llvm_emit_any_pointer(c, &result, &arg0_pointer); - LLVMValueRef introspect = LLVMBuildIntToPtr(c->builder, typeid.value, c->ptr_type, ""); - - LLVMBasicBlockRef missing_function = llvm_basic_block_new(c, "missing_function"); - LLVMBasicBlockRef match = llvm_basic_block_new(c, "match"); - - AlignSize align; - Decl *dyn_fn = declptr(expr->call_expr.func_ref); - func = llvm_emit_dynamic_search(c, introspect, llvm_get_ref(c, dyn_fn)); - LLVMValueRef cmp = LLVMBuildICmp(c->builder, LLVMIntEQ, func, LLVMConstNull(c->ptr_type), ""); - llvm_emit_cond_br_raw(c, cmp, missing_function, match); - llvm_emit_block(c, missing_function); - scratch_buffer_clear(); - scratch_buffer_printf("No method '%s' could be found on target", dyn_fn->name); - llvm_emit_panic(c, scratch_buffer_to_string(), expr->span, NULL, NULL); - llvm_emit_unreachable(c); - llvm_emit_block(c, match); - - prototype = type_get_resolved_prototype(dyn_fn->type); - func_type = llvm_get_type(c, dyn_fn->type); - } - else if (!expr->call_expr.is_func_ref) - { - // Call through a pointer. - Expr *function = exprptr(expr->call_expr.function); - - // 1a. Find the pointee type for the function pointer: - Type *type = function->type->canonical->pointer; - - // 1b. Find the type signature using the underlying pointer. - prototype = type_get_resolved_prototype(type); - - // 1c. Evaluate the pointer expression. - BEValue func_value; - llvm_emit_expr(c, &func_value, function); - - // 1d. Load it as a value - func = llvm_load_value_store(c, &func_value); - - // 1e. Calculate the function type - func_type = llvm_get_type(c, type); - } - else - { - // 2a. Get the function declaration - - Decl *function_decl = declptr(expr->call_expr.func_ref); - always_inline = function_decl->func_decl.attr_inline; - - // 2b. Set signature, function and function type - prototype = type_get_resolved_prototype(function_decl->type); - func = llvm_get_ref(c, function_decl); - assert(func); - func_type = llvm_get_type(c, function_decl->type); - } LLVMValueRef arg_values[512]; unsigned arg_count = 0; Type **params = prototype->param_types; ABIArgInfo **abi_args = prototype->abi_args; unsigned param_count = vec_size(params); - Expr **varargs = NULL; - Expr *vararg_splat = NULL; - if (expr->call_expr.splat_vararg) - { - vararg_splat = expr->call_expr.splat; - } - else - { - varargs = expr->call_expr.varargs; - } FunctionPrototype copy; if (prototype->raw_variadic) { - if (varargs || vararg_splat) + if (varargs) { - assert(!vararg_splat); copy = *prototype; copy.varargs = NULL; @@ -5787,9 +5638,9 @@ static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr break; } llvm_value_set_address(result_value, - llvm_emit_alloca(c, llvm_get_type(c, call_return_type), alignment, "sretparam"), - call_return_type, - alignment); + llvm_emit_alloca(c, llvm_get_type(c, call_return_type), alignment, "sretparam"), + call_return_type, + alignment); // 6c. Add the pointer to the list of arguments. arg_values[arg_count++] = result_value->value; @@ -5821,67 +5672,174 @@ static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr llvm_value_set_address_abi_aligned(&synthetic_return_param, synthetic_return_param.value, actual_return_type); } + BEValue temp_value; // 8. Add all other arguments. for (unsigned i = 0; i < param_count; i++) { // 8a. Evaluate the expression. - Expr *arg_expr = args[i]; Type *param = params[i]; ABIArgInfo *info = abi_args[i]; - if (arg_expr) - { - if (i == 0 && arg0_pointer.value) - { - temp_value = arg0_pointer; - } - else - { - llvm_emit_expr(c, &temp_value, arg_expr); - } - } - else - { - llvm_emit_vararg_parameter(c, &temp_value, param, info, varargs, vararg_splat); - } - // 8b. Emit the parameter according to ABI rules. - llvm_emit_parameter(c, arg_values, &arg_count, info, &temp_value, param); + BEValue value_copy = values[i]; + llvm_emit_parameter(c, arg_values, &arg_count, info, &value_copy, param); } // 9. Typed varargs if (prototype->raw_variadic) { + unsigned vararg_count = vec_size(varargs); if (prototype->abi_varargs) { // 9. Emit varargs. unsigned index = 0; ABIArgInfo **abi_varargs = prototype->abi_varargs; - foreach(Expr*, varargs) + for (unsigned i = 0; i < vararg_count; i++) { - llvm_emit_expr(c, &temp_value, val); ABIArgInfo *info = abi_varargs[index]; - llvm_emit_parameter(c, arg_values, &arg_count, info, &temp_value, prototype->varargs[index]); + BEValue value_copy = values[i + param_count]; + llvm_emit_parameter(c, arg_values, &arg_count, info, &value_copy, prototype->varargs[index]); index++; } } else { // 9. Emit varargs. - foreach(Expr*, varargs) + for (unsigned i = 0; i < vararg_count; i++) { - llvm_emit_expr(c, &temp_value, val); REMINDER("Varargs should be expanded correctly"); - arg_values[arg_count++] = llvm_load_value_store(c, &temp_value); + arg_values[arg_count++] = llvm_load_value_store(c, &values[i + param_count]); } } } // 10. Create the actual call (remember to emit a loc, because we might have shifted loc emitting the params) - EMIT_LOC(c, expr); + if (c->debug.builder) llvm_emit_debug_location(c, span); + + llvm_emit_raw_call(c, result_value, prototype, func_type, func, arg_values, arg_count, inline_flag, error_var, sret_return, &synthetic_return_param); + + // Emit the current stack into the thread local or things will get messed up. + llvm_emit_pop_stacktrace(c, NULL); + + // 17i. The simple case here is where there is a normal return. + // In this case be_value already holds the result +} + +INLINE void llvm_emit_varargs_expr(GenContext *c, BEValue *value_ref, Expr **varargs, Type *param) +{ + BEValue inner_temp; + // 9b. Otherwise, we also need to allocate memory for the arguments: + Type *pointee_type = param->array.base; + unsigned elements = vec_size(varargs); + 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_name); + foreach(Expr*, varargs) + { + llvm_emit_expr(c, &inner_temp, val); + llvm_value_fold_optional(c, &inner_temp); + AlignSize store_alignment; + LLVMValueRef slot = llvm_emit_array_gep_raw(c, + array_ref, + llvm_array_type, + foreach_index, + alignment, + &store_alignment); + llvm_store_to_ptr_aligned(c, slot, &inner_temp, store_alignment); + } + llvm_value_aggregate_two(c, value_ref, param, array_ref, llvm_const_int(c, type_usz, elements)); + LLVMSetValueName2(value_ref->value, temp_name, 6); +} + +INLINE void llvm_emit_vasplat_expr(GenContext *c, BEValue *value_ref, Expr *vasplat, Type *param) +{ + llvm_emit_expr(c, value_ref, vasplat); + llvm_value_fold_optional(c, value_ref); + Type *type = value_ref->type; + switch (type->type_kind) + { + case TYPE_ARRAY: + llvm_value_addr(c, value_ref); + llvm_value_bitcast(c, value_ref, type->array.base); + llvm_value_aggregate_two(c, value_ref, param, value_ref->value, llvm_const_int(c, type_usz, type->array.len)); + return; + case TYPE_POINTER: + // Load the pointer + llvm_value_rvalue(c, value_ref); + llvm_value_aggregate_two(c, value_ref, param, value_ref->value, llvm_const_int(c, type_usz, type->pointer->array.len)); + return; + case TYPE_SUBARRAY: + return; + default: + UNREACHABLE + } + +} +static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr, BEValue *target) +{ + if (expr->call_expr.is_builtin) + { + llvm_emit_builtin_call(c, result_value, expr); + return; + } + + llvm_emit_update_stack_row(c, expr->span.row); + + LLVMTypeRef func_type; + LLVMValueRef func; + + BEValue values[256]; + Expr **args = expr->call_expr.arguments; + unsigned arg_count = vec_size(args); + bool always_inline = false; + FunctionPrototype *prototype; + + // 1. Dynamic dispatch. + if (expr->call_expr.is_dynamic_dispatch) + { + assert(arg_count); + Expr *any_val = args[0]; + assert(any_val->expr_kind == EXPR_CAST); + args[0] = exprptr(any_val->cast_expr.expr)->unary_expr.expr; + } + + if (!expr->call_expr.is_func_ref) + { + // Call through a pointer. + Expr *function = exprptr(expr->call_expr.function); + + // 1a. Find the pointee type for the function pointer: + Type *type = function->type->canonical->pointer; + + // 1b. Find the type signature using the underlying pointer. + prototype = type_get_resolved_prototype(type); + + // 1c. Evaluate the pointer expression. + BEValue func_value; + llvm_emit_expr(c, &func_value, function); + + // 1d. Load it as a value + func = llvm_load_value_store(c, &func_value); + + // 1e. Calculate the function type + func_type = llvm_get_type(c, type); + } + else + { + // 2a. Get the function declaration + Decl *function_decl = declptr(expr->call_expr.func_ref); + always_inline = function_decl->func_decl.attr_inline; + + // 2b. Set signature, function and function type + prototype = type_get_resolved_prototype(function_decl->type); + func = llvm_get_ref(c, function_decl); + assert(func); + func_type = llvm_get_type(c, function_decl->type); + } int inline_flag = 0; if (expr->call_expr.attr_force_noinline) { @@ -5891,14 +5849,121 @@ static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr { inline_flag = expr->call_expr.attr_force_inline || always_inline ? 1 : 0; } - llvm_emit_raw_call(c, result_value, prototype, func_type, func, arg_values, arg_count, inline_flag, error_var, sret_return, &synthetic_return_param); - // Emit the current stack into the thread local or things will get messed up. - llvm_emit_pop_stacktrace(c, NULL); + Expr *vararg_splat = NULL; + Expr **varargs = NULL; + if (expr->call_expr.splat_vararg) + { + vararg_splat = expr->call_expr.splat; + } + else + { + varargs = expr->call_expr.varargs; + } - // 17i. The simple case here is where there is a normal return. - // In this case be_value already holds the result - return; + for (unsigned i = 0; i < arg_count; i++) + { + BEValue *value_ref = &values[i]; + Expr *arg = args[i]; + if (arg) + { + llvm_emit_expr(c, value_ref, args[i]); + llvm_value_fold_optional(c, value_ref); + continue; + } + Type *param = prototype->param_types[i]; + if (vararg_splat) + { + llvm_emit_vasplat_expr(c, value_ref, vararg_splat, param); + continue; + } + if (varargs) + { + llvm_emit_varargs_expr(c, value_ref, varargs, param); + continue; + } + // Just set the size to zero. + llvm_value_set(value_ref, llvm_get_zero(c, param), param); + } + // Emit raw varargs + if (prototype->raw_variadic && varargs) + { + FOREACH_BEGIN_IDX(i, Expr *vararg, varargs) + BEValue *value_ref = &values[arg_count + i]; + llvm_emit_expr(c, value_ref, vararg); + llvm_value_fold_optional(c, value_ref); + FOREACH_END(); + } + + // 1. Dynamic dispatch. + if (expr->call_expr.is_dynamic_dispatch) + { + assert(arg_count); + BEValue result = values[0]; + BEValue typeid = result; + llvm_emit_type_from_any(c, &typeid); + llvm_value_rvalue(c, &typeid); + llvm_emit_any_pointer(c, &result, &result); + LLVMValueRef introspect = LLVMBuildIntToPtr(c->builder, typeid.value, c->ptr_type, ""); + + LLVMBasicBlockRef missing_function = llvm_basic_block_new(c, "missing_function"); + LLVMBasicBlockRef match = llvm_basic_block_new(c, "match"); + + AlignSize align; + Decl *dyn_fn = declptr(expr->call_expr.func_ref); + prototype = type_get_resolved_prototype(dyn_fn->type); + func_type = llvm_get_type(c, dyn_fn->type); + func = llvm_emit_dynamic_search(c, introspect, llvm_get_ref(c, dyn_fn)); + LLVMValueRef cmp = LLVMBuildICmp(c->builder, LLVMIntEQ, func, LLVMConstNull(c->ptr_type), ""); + llvm_emit_cond_br_raw(c, cmp, missing_function, match); + llvm_emit_block(c, missing_function); + Decl *default_method = declptrzero(dyn_fn->func_decl.protocol_method); + if (default_method) + { + LLVMBasicBlockRef after = llvm_basic_block_new(c, "after_call"); + FunctionPrototype *default_prototype = type_get_resolved_prototype(default_method->type); + BEValue default_res; + llvm_emit_call_invocation(c, &default_res, target, expr->span, default_prototype, args, values, inline_flag, + llvm_get_ref(c, default_method), + llvm_get_type(c, default_method->type), + varargs); + LLVMValueRef default_val = llvm_load_value(c, &default_res); + LLVMBasicBlockRef default_block = c->current_block; + llvm_emit_br(c, after); + llvm_emit_block(c, match); + prototype = type_get_resolved_prototype(dyn_fn->type); + func_type = llvm_get_type(c, dyn_fn->type); + BEValue normal_res; + values[0] = result; + llvm_emit_call_invocation(c, &normal_res, target, expr->span, prototype, args, values, inline_flag, func, func_type, + varargs); + LLVMValueRef normal_val = llvm_load_value(c, &normal_res); + LLVMBasicBlockRef normal_block = c->current_block; + llvm_emit_br(c, after); + llvm_emit_block(c, after); + if (normal_val) + { + LLVMValueRef phi = LLVMBuildPhi(c->builder, LLVMTypeOf(normal_val), "result"); + llvm_set_phi(phi, default_val, default_block, normal_val, normal_block); + llvm_value_set(result_value, phi, default_res.type); + } + else + { + *result_value = (BEValue) { .value = NULL }; + } + return; + } + scratch_buffer_clear(); + scratch_buffer_printf("No method '%s' could be found on target", dyn_fn->name); + llvm_emit_panic(c, scratch_buffer_to_string(), expr->span, NULL, NULL); + llvm_emit_unreachable(c); + llvm_emit_block(c, match); + values[0] = result; + + } + + llvm_emit_call_invocation(c, result_value, target, expr->span, prototype, args, values, inline_flag, func, func_type, + varargs); } diff --git a/src/compiler/llvm_codegen_internal.h b/src/compiler/llvm_codegen_internal.h index edbfde1b5..a48c79e40 100644 --- a/src/compiler/llvm_codegen_internal.h +++ b/src/compiler/llvm_codegen_internal.h @@ -490,7 +490,6 @@ LLVMValueRef llvm_emit_coerce(GenContext *c, LLVMTypeRef coerced, BEValue *value static inline LLVMCallConv llvm_call_convention_from_call(CallABI abi); void llvm_emit_raw_call(GenContext *c, BEValue *result_value, FunctionPrototype *prototype, LLVMTypeRef func_type, LLVMValueRef func, LLVMValueRef *args, unsigned arg_count, int inline_flag, LLVMValueRef error_var, bool sret_return, BEValue *synthetic_return_param); void llvm_emit_parameter(GenContext *c, LLVMValueRef *args, unsigned *arg_count_ref, ABIArgInfo *info, BEValue *be_value, Type *type); -void llvm_emit_vararg_parameter(GenContext *c, BEValue *value, Type *vararg_type, ABIArgInfo *abi_info, Expr **varargs, Expr *vararg_splat); // -- Dynamic protocol -- LLVMValueRef llvm_get_selector(GenContext *c, const char *name); diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c index 6ca0bc9b4..b660ba357 100644 --- a/src/compiler/sema_decls.c +++ b/src/compiler/sema_decls.c @@ -765,7 +765,6 @@ static bool sema_analyse_protocol(SemaContext *context, Decl *decl, bool *erase_ return false; } } - vec_add(decl->methods, method); if (!method->extname) { scratch_buffer_clear(); @@ -1640,7 +1639,7 @@ static inline bool unit_add_method_like(CompilationUnit *unit, Type *parent_type Decl *ambiguous = NULL; Decl *private = NULL; method = sema_resolve_method(unit, parent, name, &ambiguous, &private); - if (method) + if (method && !method->func_decl.attr_protocol_method) { SEMA_ERROR(method_like, "This %s is already defined for '%s'.", method_name_by_decl(method_like), parent_type->name); @@ -1731,6 +1730,51 @@ static inline Decl *sema_find_protocol_for_method(SemaContext *context, Type *pa if (!sema_analyse_decl(context, first_protocol)) return poisoned_decl; return first_match; } +static inline bool sema_compare_method_with_protocol(SemaContext *context, Decl *decl, Decl *implemented_method) +{ + Signature protocol_sig = implemented_method->func_decl.signature; + Signature this_sig = decl->func_decl.signature; + Type *any_rtype = typeget(protocol_sig.rtype); + Type *this_rtype = typeget(this_sig.rtype); + if (any_rtype->canonical != this_rtype->canonical) + { + SEMA_ERROR(type_infoptr(this_sig.rtype), "The prototype method has a return type %s, but this function returns %s, they need to match.", + type_quoted_error_string(any_rtype), type_quoted_error_string(this_rtype)); + SEMA_NOTE(type_infoptr(protocol_sig.rtype), "The interface definition is here."); + return false; + } + Decl **any_params = protocol_sig.params; + Decl **this_params = this_sig.params; + unsigned any_param_count = vec_size(any_params); + unsigned this_param_count = vec_size(this_params); + if (any_param_count != this_param_count) + { + if (any_param_count > this_param_count) + { + SEMA_ERROR(decl, "This function is missing parameters, %d parameters were expected.", any_param_count); + SEMA_NOTE(any_params[this_param_count], "Compare with the interface definition."); + return false; + } + else + { + SEMA_ERROR(this_params[any_param_count], "This function has too many parameters (%d).", this_param_count); + SEMA_NOTE(decl, "Compare with the interface, which has only %d parameter%s.", + any_param_count, any_param_count == 1 ? "" : "s"); + } + return false; + } + FOREACH_BEGIN_IDX(i, Decl *param, this_params) + if (i == 0) continue; + if (param->type->canonical != any_params[i]->type->canonical) + { + SEMA_ERROR(vartype(param), "The prototype argument has type %s, but in this function it has type %s. Please make them match.", + type_quoted_error_string(any_params[i]->type), type_quoted_error_string(param->type)); + SEMA_NOTE(vartype(any_params[i]), "The interface definition is here."); + return false; + } + FOREACH_END(); + return true; +} static inline bool sema_analyse_method(SemaContext *context, Decl *decl) { @@ -1748,61 +1792,45 @@ static inline bool sema_analyse_method(SemaContext *context, Decl *decl) TypeInfo *parent_type = type_infoptr(decl->func_decl.type_parent); if (!sema_resolve_type_info(context, parent_type, RESOLVE_TYPE_FUNC_METHOD)) return false; Type *par_type = parent_type->type->canonical; + if (!sema_resolve_type_decl(context, par_type)) return false; Decl **params = decl->func_decl.signature.params; bool is_dynamic = decl->func_decl.attr_dynamic; if (!vec_size(params)) RETURN_SEMA_ERROR(decl, "A method must start with an argument of the type " "it is a method of, e.g. 'fn Foo.test(Foo* foo)'."); if (!sema_is_valid_method_param(context, params[0], par_type, is_dynamic)) return false; + if (decl->func_decl.attr_default) + { + if (par_type->type_kind != TYPE_PROTOCOL) + { + RETURN_SEMA_ERROR(decl, "Only protocols may have @default methods."); + } + Decl *implemented_method = sema_protocol_method_by_name(par_type->decl, decl->name); + if (!implemented_method) + { + RETURN_SEMA_ERROR(decl, "No matching protocol method could be found for the '%s' method.", decl->name); + } + if (!implemented_method->func_decl.attr_optional) + { + SEMA_ERROR(decl, "Only @optional protocol methods may have @default implementations.", decl->name); + SEMA_NOTE(implemented_method, "The definition of the protocol method is here."); + return false; + } + if (!sema_compare_method_with_protocol(context, decl, implemented_method)) return false; + implemented_method->func_decl.default_method = declid(decl); + decl->func_decl.protocol_method = declid(implemented_method); + } if (is_dynamic) { - if (!sema_resolve_type_decl(context, par_type)) return false; + if (par_type->type_kind == TYPE_PROTOCOL) + { + RETURN_SEMA_ERROR(decl, "Protocols may not implement @dynamic methods."); + } Decl *implemented_method = sema_find_protocol_for_method(context, par_type, decl); if (!decl_ok(implemented_method)) return false; if (implemented_method) { - Signature protocol_sig = implemented_method->func_decl.signature; - Signature this_sig = decl->func_decl.signature; - Type *any_rtype = typeget(protocol_sig.rtype); - Type *this_rtype = typeget(this_sig.rtype); - if (any_rtype->canonical != this_rtype->canonical) - { - SEMA_ERROR(type_infoptr(this_sig.rtype), "The prototype method has a return type %s, but this function returns %s, they need to match.", - type_quoted_error_string(any_rtype), type_quoted_error_string(this_rtype)); - SEMA_NOTE(type_infoptr(protocol_sig.rtype), "The interface definition is here."); - return false; - } - Decl **any_params = protocol_sig.params; - Decl **this_params = this_sig.params; - unsigned any_param_count = vec_size(any_params); - unsigned this_param_count = vec_size(this_params); - if (any_param_count != this_param_count) - { - if (any_param_count > this_param_count) - { - SEMA_ERROR(decl, "This function is missing parameters, %d parameters were expected.", any_param_count); - SEMA_NOTE(any_params[this_param_count], "Compare with the interface definition."); - return false; - } - else - { - SEMA_ERROR(this_params[any_param_count], "This function has too many parameters (%d).", this_param_count); - SEMA_NOTE(decl, "Compare with the interface, which has only %d parameter%s.", - any_param_count, any_param_count == 1 ? "" : "s"); - } - return false; - } - FOREACH_BEGIN_IDX(i, Decl *param, this_params) - if (i == 0) continue; - if (param->type->canonical != any_params[i]->type->canonical) - { - SEMA_ERROR(vartype(param), "The prototype argument has type %s, but in this function it has type %s. Please make them match.", - type_quoted_error_string(any_params[i]->type), type_quoted_error_string(param->type)); - SEMA_NOTE(vartype(any_params[i]), "The interface definition is here."); - return false; - } - FOREACH_END(); - + if (!sema_compare_method_with_protocol(context, decl, implemented_method)) return false; decl->func_decl.protocol_method = declid(implemented_method); } else @@ -1911,6 +1939,7 @@ static bool sema_analyse_attribute(SemaContext *context, Decl *decl, Attr *attr, [ATTRIBUTE_BIGENDIAN] = ATTR_BITSTRUCT, [ATTRIBUTE_BUILTIN] = ATTR_MACRO | ATTR_FUNC | ATTR_GLOBAL | ATTR_CONST, [ATTRIBUTE_CALLCONV] = ATTR_FUNC | ATTR_PROTOCOL_METHOD, + [ATTRIBUTE_DEFAULT] = ATTR_FUNC | ATTR_MACRO, [ATTRIBUTE_DEPRECATED] = USER_DEFINED_TYPES | CALLABLE_TYPE | ATTR_CONST | ATTR_GLOBAL | ATTR_MEMBER | ATTR_BITSTRUCT_MEMBER, [ATTRIBUTE_DYNAMIC] = ATTR_FUNC, [ATTRIBUTE_EXPORT] = ATTR_FUNC | ATTR_GLOBAL | ATTR_CONST | EXPORTED_USER_DEFINED_TYPES, @@ -2183,6 +2212,9 @@ static bool sema_analyse_attribute(SemaContext *context, Decl *decl, Attr *attr, case ATTRIBUTE_OVERLAP: decl->bitstruct.overlap = true; break; + case ATTRIBUTE_DEFAULT: + decl->func_decl.attr_default = true; + break; case ATTRIBUTE_DYNAMIC: decl->func_decl.attr_dynamic = true; break; diff --git a/src/compiler/sema_expr.c b/src/compiler/sema_expr.c index 735b543de..85c46485e 100644 --- a/src/compiler/sema_expr.c +++ b/src/compiler/sema_expr.c @@ -1716,6 +1716,7 @@ static inline Type *context_unify_returns(SemaContext *context) // 5. No match -> error. if (!max) { + assert(return_stmt); SEMA_ERROR(return_stmt, "Cannot find a common parent type of %s and %s", type_quoted_error_string(rtype), type_quoted_error_string(common_type)); Ast *prev = context->returns[i - 1]; diff --git a/src/compiler/sema_liveness.c b/src/compiler/sema_liveness.c index d5be4196d..849737aa1 100644 --- a/src/compiler/sema_liveness.c +++ b/src/compiler/sema_liveness.c @@ -17,6 +17,7 @@ RETRY: type = type->canonical; switch (type->type_kind) { + case TYPE_PROPTR: case TYPE_POINTER: type = type->pointer; goto RETRY; @@ -534,8 +535,11 @@ INLINE void sema_trace_decl_dynamic_methods(Decl *decl) for (unsigned i = 0; i < method_count; i++) { Decl *method = methods[i]; - if (method->decl_kind == DECL_MACRO || !method->func_decl.attr_dynamic) continue; - sema_trace_decl_liveness(method); + if (method->decl_kind == DECL_MACRO) continue; + if (method->func_decl.attr_dynamic || method->func_decl.attr_default) + { + sema_trace_decl_liveness(method); + } } } static void sema_trace_func_liveness(Signature *sig) @@ -569,13 +573,13 @@ RETRY: case DECL_FAULT: case DECL_STRUCT: case DECL_UNION: + case DECL_PROTOCOL: sema_trace_decl_dynamic_methods(decl); return; case DECL_POISONED: case DECL_ATTRIBUTE: case DECL_ENUM_CONSTANT: case DECL_FAULTVALUE: - case DECL_PROTOCOL: return; case DECL_CT_ASSERT: case DECL_CT_ECHO: diff --git a/src/compiler/sema_name_resolution.c b/src/compiler/sema_name_resolution.c index d9bf3bb12..29e118c64 100644 --- a/src/compiler/sema_name_resolution.c +++ b/src/compiler/sema_name_resolution.c @@ -87,6 +87,17 @@ static void add_members_to_decl_stack(Decl *decl) sema_decl_stack_push(members[i]); } } + if (decl->decl_kind == DECL_PROTOCOL) + { + FOREACH_BEGIN(TypeInfo *parent_protocol, decl->protocols) + FOREACH_BEGIN(Decl *protocol, parent_protocol->type->decl->protocol_methods) + sema_decl_stack_push(protocol); + FOREACH_END(); + FOREACH_END(); + FOREACH_BEGIN(Decl *protocol, decl->protocol_methods) + sema_decl_stack_push(protocol); + FOREACH_END(); + } if (decl_is_struct_type(decl) || decl->decl_kind == DECL_BITSTRUCT) { Decl **members = decl->strukt.members; @@ -650,15 +661,20 @@ Decl *sema_resolve_method_in_module(Module *module, Type *actual_type, const cha Decl *sema_resolve_method(CompilationUnit *unit, Decl *type, const char *method_name, Decl **ambiguous_ref, Decl **private_ref) { - // 1. Look at the previously defined ones. - VECEACH(type->methods, i) + // Protocol, prefer protocol methods. + if (type->decl_kind == DECL_PROTOCOL) { - Decl *func = type->methods[i]; - if (method_name == func->name) - { - return func; - } + FOREACH_BEGIN(Decl *method, type->protocol_methods) + if (method_name == method->name) return method; + FOREACH_END(); } + // Look through natively defined methods. + FOREACH_BEGIN(Decl *method, type->methods) + if (method_name == method->name) + { + return method; + } + FOREACH_END(); return sema_resolve_type_method(unit, type->type, method_name, ambiguous_ref, private_ref); } diff --git a/src/compiler/symtab.c b/src/compiler/symtab.c index 97b69a4f5..5d086520d 100644 --- a/src/compiler/symtab.c +++ b/src/compiler/symtab.c @@ -323,6 +323,7 @@ void symtab_init(uint32_t capacity) attribute_list[ATTRIBUTE_BIGENDIAN] = KW_DEF("@bigendian"); attribute_list[ATTRIBUTE_BUILTIN] = KW_DEF("@builtin"); attribute_list[ATTRIBUTE_CALLCONV] = KW_DEF("@callconv"); + attribute_list[ATTRIBUTE_DEFAULT] = KW_DEF("@default"); attribute_list[ATTRIBUTE_DEPRECATED] = KW_DEF("@deprecated"); attribute_list[ATTRIBUTE_DYNAMIC] = KW_DEF("@dynamic"); attribute_list[ATTRIBUTE_EXPORT] = KW_DEF("@export"); diff --git a/test/test_suite/abi/darwin64_avx.c3t b/test/test_suite/abi/darwin64_avx.c3t index 008edc4ba..776cd3a5f 100644 --- a/test/test_suite/abi/darwin64_avx.c3t +++ b/test/test_suite/abi/darwin64_avx.c3t @@ -180,8 +180,8 @@ declare void @test52_helper(i32, ...) #0 define void @test.test52() #0 { entry: %literal = alloca %Complex, align 8 - %0 = load <8 x float>, ptr @test.x52, align 32 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false) + %0 = load <8 x float>, ptr @test.x52, align 32 %1 = getelementptr inbounds %Complex, ptr %literal, i32 0, i32 0 %lo = load double, ptr %1, align 8 %2 = getelementptr inbounds %Complex, ptr %literal, i32 0, i32 1 @@ -196,17 +196,17 @@ define void @test.test54() #0 { entry: %literal = alloca %Complex, align 8 %literal1 = alloca %Complex, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const.6, i32 16, i1 false) %0 = load <8 x float>, ptr @test.x54, align 32 %1 = load <8 x float>, ptr @test.x54, align 32 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const.6, i32 16, i1 false) %2 = getelementptr inbounds %Complex, ptr %literal, i32 0, i32 0 %lo = load double, ptr %2, align 8 %3 = getelementptr inbounds %Complex, ptr %literal, i32 0, i32 1 %hi = load double, ptr %3, align 8 call void (<8 x float>, ...) @test54_helper(<8 x float> %0, <8 x float> %1, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double %lo, double %hi) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal1, ptr align 8 @.__const.7, i32 16, i1 false) %4 = load <8 x float>, ptr @test.x54, align 32 %5 = load <8 x float>, ptr @test.x54, align 32 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal1, ptr align 8 @.__const.7, i32 16, i1 false) call void (<8 x float>, ...) @test54_helper(<8 x float> %4, <8 x float> %5, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, ptr byval(%Complex) align 8 %literal1) ret void } diff --git a/test/test_suite/abi/darwin64_avx512.c3t b/test/test_suite/abi/darwin64_avx512.c3t index a43bc3d27..5e7b2fe13 100644 --- a/test/test_suite/abi/darwin64_avx512.c3t +++ b/test/test_suite/abi/darwin64_avx512.c3t @@ -101,8 +101,8 @@ declare void @f62_helper(i32, ...) #0 define void @test.f62() #0 { entry: %literal = alloca %Complex, align 8 - %0 = load <16 x float>, ptr @test.x62, align 64 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false) + %0 = load <16 x float>, ptr @test.x62, align 64 %1 = getelementptr inbounds %Complex, ptr %literal, i32 0, i32 0 %lo = load double, ptr %1, align 8 %2 = getelementptr inbounds %Complex, ptr %literal, i32 0, i32 1 @@ -119,17 +119,17 @@ define void @test.f64() #0 { entry: %literal = alloca %Complex, align 8 %literal1 = alloca %Complex, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const.4, i32 16, i1 false) %0 = load <16 x float>, ptr @test.x64, align 64 %1 = load <16 x float>, ptr @test.x64, align 64 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const.4, i32 16, i1 false) %2 = getelementptr inbounds %Complex, ptr %literal, i32 0, i32 0 %lo = load double, ptr %2, align 8 %3 = getelementptr inbounds %Complex, ptr %literal, i32 0, i32 1 %hi = load double, ptr %3, align 8 call void (<16 x float>, ...) @f64_helper(<16 x float> %0, <16 x float> %1, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double %lo, double %hi) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal1, ptr align 8 @.__const.5, i32 16, i1 false) %4 = load <16 x float>, ptr @test.x64, align 64 %5 = load <16 x float>, ptr @test.x64, align 64 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal1, ptr align 8 @.__const.5, i32 16, i1 false) call void (<16 x float>, ...) @f64_helper(<16 x float> %4, <16 x float> %5, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, ptr byval(%Complex) align 8 %literal1) ret void } diff --git a/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-1.c3t b/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-1.c3t index b29bf49e1..0568cae51 100644 --- a/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-1.c3t +++ b/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-1.c3t @@ -487,12 +487,12 @@ entry: %literal3 = alloca %Large, align 4 %indirectarg = alloca %Large, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 1 %literal, ptr align 1 @.__const.4, i32 4, i1 false) - %0 = load i32, ptr %literal, align 1 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal1, ptr align 4 @.__const.5, i32 8, i1 false) - %1 = load [2 x i32], ptr %literal1, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal2, ptr align 8 @.__const.6, i32 8, i1 false) - %2 = load i64, ptr %literal2, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal3, ptr align 4 @.__const.7, i32 16, i1 false) + %0 = load i32, ptr %literal, align 1 + %1 = load [2 x i32], ptr %literal1, align 4 + %2 = load i64, ptr %literal2, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %indirectarg, ptr align 4 %literal3, i32 16, i1 false) %3 = call i32 (i32, ...) @f_va_callee(i32 1, i32 2, i32 3, double 4.000000e+00, double 5.000000e+00, i32 %0, [2 x i32] %1, i64 %2, ptr align 4 %indirectarg) ret void diff --git a/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-2.c3t b/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-2.c3t index a7fcf14a6..c7b153ac3 100644 --- a/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-2.c3t +++ b/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-2.c3t @@ -513,12 +513,12 @@ entry: %literal3 = alloca %Large, align 4 %indirectarg = alloca %Large, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 1 %literal, ptr align 1 @.__const.4, i32 4, i1 false) - %0 = load i32, ptr %literal, align 1 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal1, ptr align 4 @.__const.5, i32 8, i1 false) - %1 = load [2 x i32], ptr %literal1, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal2, ptr align 8 @.__const.6, i32 8, i1 false) - %2 = load i64, ptr %literal2, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal3, ptr align 4 @.__const.7, i32 16, i1 false) + %0 = load i32, ptr %literal, align 1 + %1 = load [2 x i32], ptr %literal1, align 4 + %2 = load i64, ptr %literal2, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %indirectarg, ptr align 4 %literal3, i32 16, i1 false) %3 = call i32 (i32, ...) @f_va_callee(i32 1, i32 2, i32 3, double 4.000000e+00, double 5.000000e+00, i32 %0, [2 x i32] %1, i64 %2, ptr align 4 %indirectarg) ret void diff --git a/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-3.c3t b/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-3.c3t index 58e454cfe..71428354e 100644 --- a/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-3.c3t +++ b/test/test_suite/abi/riscv32-ilp32-ilp32f-ilp32d-abi-3.c3t @@ -184,52 +184,54 @@ define void @test.f_void() #0 { entry: ret void } -; Function Attrs: nounwind + define zeroext i8 @test.f_scalar_0(i8 zeroext %0) #0 { entry: ret i8 %0 } -; Function Attrs: nounwind + define signext i8 @test.f_scalar_1(i8 signext %0) #0 { entry: ret i8 %0 } -; Function Attrs: nounwind + define zeroext i8 @test.f_scalar_2(i8 zeroext %0) #0 { entry: ret i8 %0 } -; Function Attrs: nounwind + define i32 @test.f_scalar_3(i32 %0) #0 { entry: ret i32 %0 } -; Function Attrs: nounwind + define i64 @test.f_scalar_4(i64 %0) #0 { entry: ret i64 %0 } -; Function Attrs: nounwind + define i128 @test.f_scalar_5(i128 %0) #0 { entry: ret i128 %0 } -; Function Attrs: nounwind + define float @test.f_fp_scalar_1(float %0) #0 { entry: ret float %0 } -; Function Attrs: nounwind + define double @test.f_fp_scalar_2(double %0) #0 { entry: ret double %0 } -; Function Attrs: nounwind + + define fp128 @test.f_fp_scalar_3(fp128 %0) #0 { entry: ret fp128 %0 } -; Function Attrs: nounwind + + define void @test.f_agg_tiny(i32 %0) #0 { entry: %x = alloca %Tiny, align 1 @@ -248,7 +250,8 @@ entry: store i8 %add1, ptr %5, align 1 ret void } -; Function Attrs: nounwind + + define i32 @test.f_agg_tiny_ret() #0 { entry: %literal = alloca %Tiny, align 1 @@ -256,7 +259,8 @@ entry: %0 = load i32, ptr %literal, align 1 ret i32 %0 } -; Function Attrs: nounwind + + define void @test.f_vec_tiny_v4i8(i32 %0) #0 { entry: %x = alloca <4 x i8>, align 4 @@ -273,7 +277,8 @@ entry: store <4 x i8> %elemset1, ptr %x, align 4 ret void } -; Function Attrs: nounwind + + define i32 @test.f_vec_tiny_v4i8_ret() #0 { entry: %taddr = alloca <4 x i8>, align 4 @@ -281,7 +286,8 @@ entry: %0 = load i32, ptr %taddr, align 4 ret i32 %0 } -; Function Attrs: nounwind + + define void @test.f_vec_tiny_v1i32(i32 %0) #0 { entry: %x = alloca <1 x i32>, align 4 @@ -291,7 +297,8 @@ entry: store <1 x i32> %elemset, ptr %x, align 4 ret void } -; Function Attrs: nounwind + + define i32 @test.f_vec_tiny_v1i32_ret() #0 { entry: %taddr = alloca <1 x i32>, align 4 @@ -299,7 +306,8 @@ entry: %0 = load i32, ptr %taddr, align 4 ret i32 %0 } -; Function Attrs: nounwind + + define void @test.f_agg_small([2 x i32] %0) #0 { entry: %x = alloca %Small, align 4 @@ -316,7 +324,8 @@ entry: store ptr %7, ptr %6, align 4 ret void } -; Function Attrs: nounwind + + define [2 x i32] @test.f_agg_small_ret() #0 { entry: %literal = alloca %Small, align 4 @@ -324,7 +333,8 @@ entry: %0 = load [2 x i32], ptr %literal, align 4 ret [2 x i32] %0 } -; Function Attrs: nounwind + + define void @test.f_vec_small_v8i8(i64 %0) #0 { entry: %x = alloca <8 x i8>, align 8 @@ -336,7 +346,8 @@ entry: store <8 x i8> %elemset, ptr %x, align 8 ret void } -; Function Attrs: nounwind + + define i64 @test.f_vec_small_v8i8_ret() #0 { entry: %taddr = alloca <8 x i8>, align 8 @@ -344,7 +355,8 @@ entry: %0 = load i64, ptr %taddr, align 8 ret i64 %0 } -; Function Attrs: nounwind + + define void @test.f_vec_small_v1i64(i64 %0) #0 { entry: %x = alloca <1 x i64>, align 8 @@ -354,7 +366,8 @@ entry: store <1 x i64> %elemset, ptr %x, align 8 ret void } -; Function Attrs: nounwind + + define i64 @test.f_vec_small_v1i64_ret() #0 { entry: %taddr = alloca <1 x i64>, align 8 @@ -362,7 +375,8 @@ entry: %0 = load i64, ptr %taddr, align 8 ret i64 %0 } -; Function Attrs: nounwind + + define void @test.f_agg_small_aligned(i64 %0) #0 { entry: %x = alloca %Small_aligned, align 8 @@ -375,7 +389,8 @@ entry: store i64 %add, ptr %1, align 8 ret void } -; Function Attrs: nounwind + + define i64 @test.f_agg_small_aligned_ret(i64 %0) #0 { entry: %x = alloca %Small_aligned, align 8 @@ -385,7 +400,8 @@ entry: %1 = load i64, ptr %literal, align 8 ret i64 %1 } -; Function Attrs: nounwind + + define void @test.f_agg_large(ptr align 4 %0) #0 { entry: %1 = getelementptr inbounds %Large, ptr %0, i32 0, i32 0 @@ -400,7 +416,8 @@ entry: store i32 %add1, ptr %1, align 4 ret void } -; Function Attrs: nounwind + + define void @test.f_agg_large_ret(ptr noalias sret(%Large) align 4 %0, i32 %1, i8 signext %2) #0 { entry: %literal = alloca %Large, align 4 @@ -408,7 +425,8 @@ entry: call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %literal, i32 16, i1 false) ret void } -; Function Attrs: nounwind + + define void @test.f_vec_large_v16i8(ptr align 16 %0) #0 { entry: %1 = load <16 x i8>, ptr %0, align 16 @@ -418,13 +436,15 @@ entry: store <16 x i8> %elemset, ptr %0, align 16 ret void } -; Function Attrs: nounwind + + define void @test.f_vec_large_v16i8_ret(ptr noalias sret(<16 x i8>) align 16 %0) #0 { entry: store <16 x i8> , ptr %0, align 16 ret void } -; Function Attrs: nounwind + + define i32 @test.f_scalar_stack_1(i32 %0, [2 x i32] %1, i64 %2, ptr align 4 %3, i8 zeroext %4, i8 signext %5, i8 %6, i8 %7) #0 { entry: %a = alloca %Tiny, align 1 @@ -438,7 +458,8 @@ entry: %add = add i32 %zext, %sext ret i32 %add } -; Function Attrs: nounwind + + define void @test.f_scalar_stack_2(ptr noalias sret(%Large) align 4 %0, i32 %1, i64 %2, i64 %3, fp128 %4, i8 zeroext %5, i8 %6, i8 %7) #0 { entry: %literal = alloca %Large, align 4 @@ -456,17 +477,20 @@ entry: call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %literal, i32 16, i1 false) ret void } -; Function Attrs: nounwind + + define fp128 @test.f_scalar_stack_4(i32 %0, i64 %1, i64 %2, fp128 %3, i8 zeroext %4, i8 %5, i8 %6) #0 { entry: ret fp128 %3 } -; Function Attrs: nounwind + + define void @test.f_scalar_stack_5(double %0, i64 %1, double %2, i64 %3, i32 %4, i64 %5, float %6, double %7, fp128 %8) #0 { entry: ret void } -; Function Attrs: nounwind + + define void @test.f_agg_stack(double %0, i64 %1, double %2, i64 %3, i32 %4, [2 x i32] %5, i64 %6, ptr align 4 %7) #0 { entry: %e = alloca %Tiny, align 1 @@ -477,9 +501,11 @@ entry: store i64 %6, ptr %g, align 8 ret void } -; Function Attrs: nounwind + + declare i32 @f_va_callee(i32, ...) #0 -; Function Attrs: nounwind + + define void @test.f_va_caller() #0 { entry: %literal = alloca %Tiny, align 1 @@ -488,12 +514,12 @@ entry: %literal3 = alloca %Large, align 4 %indirectarg = alloca %Large, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 1 %literal, ptr align 1 @.__const.4, i32 4, i1 false) - %0 = load i32, ptr %literal, align 1 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal1, ptr align 4 @.__const.5, i32 8, i1 false) - %1 = load [2 x i32], ptr %literal1, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal2, ptr align 8 @.__const.6, i32 8, i1 false) - %2 = load i64, ptr %literal2, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal3, ptr align 4 @.__const.7, i32 16, i1 false) + %0 = load i32, ptr %literal, align 1 + %1 = load [2 x i32], ptr %literal1, align 4 + %2 = load i64, ptr %literal2, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %indirectarg, ptr align 4 %literal3, i32 16, i1 false) %3 = call i32 (i32, ...) @f_va_callee(i32 1, i32 2, i32 3, double 4.000000e+00, double 5.000000e+00, i32 %0, [2 x i32] %1, i64 %2, ptr align 4 %indirectarg) ret void diff --git a/test/test_suite/assert/assertf.c3t b/test/test_suite/assert/assertf.c3t index 736c76c52..76eb5aa67 100644 --- a/test/test_suite/assert/assertf.c3t +++ b/test/test_suite/assert/assertf.c3t @@ -41,8 +41,8 @@ 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 - %"#temp#" = insertvalue %"any*[]" %9, i64 2, 1 - store %"any*[]" %"#temp#", 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) unreachable assert_ok: ; preds = %loop.body diff --git a/test/test_suite/bitstruct/bitstruct_anon_in_struct_ok.c3t b/test/test_suite/bitstruct/bitstruct_anon_in_struct_ok.c3t index 495897e4d..a92e74cc8 100644 --- a/test/test_suite/bitstruct/bitstruct_anon_in_struct_ok.c3t +++ b/test/test_suite/bitstruct/bitstruct_anon_in_struct_ok.c3t @@ -31,17 +31,17 @@ fn void main() { define void @foo.main() #0 { entry: %test = alloca %Test, align 2 - %retparam = alloca i64, align 8 %varargslots = alloca [3 x %"any*"], align 16 %taddr = alloca i8, align 1 %taddr2 = alloca i8, align 1 %taddr3 = alloca i16, align 2 - %retparam4 = alloca i64, align 8 - %varargslots5 = alloca [4 x %"any*"], align 16 - %taddr8 = alloca i8, align 1 - %taddr11 = alloca i8, align 1 - %taddr14 = alloca i8, align 1 - %taddr17 = alloca i8, align 1 + %retparam = alloca i64, align 8 + %varargslots4 = alloca [4 x %"any*"], align 16 + %taddr7 = alloca i8, align 1 + %taddr10 = alloca i8, align 1 + %taddr13 = alloca i8, align 1 + %taddr16 = alloca i8, align 1 + %retparam17 = alloca i64, align 8 %0 = getelementptr inbounds %Test, ptr %test, i32 0, i32 0 store i16 0, ptr %0, align 2 %1 = getelementptr inbounds %Test, ptr %test, i32 0, i32 1 @@ -78,45 +78,45 @@ entry: %21 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 3) %22 = getelementptr inbounds %Test, ptr %test, i32 0, i32 1 %23 = load i16, ptr %22, align 2 - %lshrl6 = lshr i16 %23, 7 - %24 = and i16 1, %lshrl6 - %trunc7 = trunc i16 %24 to i8 - store i8 %trunc7, ptr %taddr8, align 1 - %25 = insertvalue %"any*" undef, ptr %taddr8, 0 + %lshrl5 = lshr i16 %23, 7 + %24 = and i16 1, %lshrl5 + %trunc6 = trunc i16 %24 to i8 + store i8 %trunc6, ptr %taddr7, align 1 + %25 = insertvalue %"any*" undef, ptr %taddr7, 0 %26 = insertvalue %"any*" %25, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %27 = getelementptr inbounds [4 x %"any*"], ptr %varargslots5, i64 0, i64 0 + %27 = getelementptr inbounds [4 x %"any*"], ptr %varargslots4, i64 0, i64 0 store %"any*" %26, ptr %27, align 16 %28 = getelementptr inbounds %Test, ptr %test, i32 0, i32 1 %29 = load i16, ptr %28, align 2 - %lshrl9 = lshr i16 %29, 6 - %30 = and i16 1, %lshrl9 - %trunc10 = trunc i16 %30 to i8 - store i8 %trunc10, ptr %taddr11, align 1 - %31 = insertvalue %"any*" undef, ptr %taddr11, 0 + %lshrl8 = lshr i16 %29, 6 + %30 = and i16 1, %lshrl8 + %trunc9 = trunc i16 %30 to i8 + store i8 %trunc9, ptr %taddr10, align 1 + %31 = insertvalue %"any*" undef, ptr %taddr10, 0 %32 = insertvalue %"any*" %31, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %33 = getelementptr inbounds [4 x %"any*"], ptr %varargslots5, i64 0, i64 1 + %33 = getelementptr inbounds [4 x %"any*"], ptr %varargslots4, i64 0, i64 1 store %"any*" %32, ptr %33, align 16 %34 = getelementptr inbounds %Test, ptr %test, i32 0, i32 1 %35 = load i16, ptr %34, align 2 - %lshrl12 = lshr i16 %35, 5 - %36 = and i16 1, %lshrl12 - %trunc13 = trunc i16 %36 to i8 - store i8 %trunc13, ptr %taddr14, align 1 - %37 = insertvalue %"any*" undef, ptr %taddr14, 0 + %lshrl11 = lshr i16 %35, 5 + %36 = and i16 1, %lshrl11 + %trunc12 = trunc i16 %36 to i8 + store i8 %trunc12, ptr %taddr13, align 1 + %37 = insertvalue %"any*" undef, ptr %taddr13, 0 %38 = insertvalue %"any*" %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %39 = getelementptr inbounds [4 x %"any*"], ptr %varargslots5, i64 0, i64 2 + %39 = getelementptr inbounds [4 x %"any*"], ptr %varargslots4, i64 0, i64 2 store %"any*" %38, ptr %39, align 16 %40 = getelementptr inbounds %Test, ptr %test, i32 0, i32 1 %41 = load i16, ptr %40, align 2 - %lshrl15 = lshr i16 %41, 4 - %42 = and i16 1, %lshrl15 - %trunc16 = trunc i16 %42 to i8 - store i8 %trunc16, ptr %taddr17, align 1 - %43 = insertvalue %"any*" undef, ptr %taddr17, 0 + %lshrl14 = lshr i16 %41, 4 + %42 = and i16 1, %lshrl14 + %trunc15 = trunc i16 %42 to i8 + store i8 %trunc15, ptr %taddr16, align 1 + %43 = insertvalue %"any*" undef, ptr %taddr16, 0 %44 = insertvalue %"any*" %43, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %45 = getelementptr inbounds [4 x %"any*"], ptr %varargslots5, i64 0, i64 3 + %45 = getelementptr inbounds [4 x %"any*"], ptr %varargslots4, i64 0, i64 3 store %"any*" %44, ptr %45, align 16 - %46 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.1, i64 12, ptr %varargslots5, i64 4) + %46 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.1, i64 12, ptr %varargslots4, i64 4) ret void } diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t index c8d16f614..8ee0d4298 100644 --- a/test/test_suite/bitstruct/bitstruct_be.c3t +++ b/test/test_suite/bitstruct/bitstruct_be.c3t @@ -80,9 +80,9 @@ loop.body: ; preds = %loop.cond store i8 %16, ptr %d, align 1 %17 = insertvalue %"any*" undef, ptr %d, 0 %18 = insertvalue %"any*" %17, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %19 = getelementptr inbounds [1 x %"any*"], ptr %varargslots3, i64 0, i64 0 + %19 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0 store %"any*" %18, ptr %19, align 16 - %20 = call i64 @std.io.printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, i64 1) + %20 = call i64 @std.io.printf(ptr %retparam3, ptr @.str.1, i64 3, ptr %varargslots2, i64 1) %21 = load i64, ptr %.anon1, align 8 %add = add i64 %21, 1 store i64 %add, ptr %.anon1, align 8 @@ -163,9 +163,9 @@ loop.body23: ; preds = %loop.cond21 store i8 %36, ptr %d24, align 1 %37 = insertvalue %"any*" undef, ptr %d24, 0 %38 = insertvalue %"any*" %37, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %39 = getelementptr inbounds [1 x %"any*"], ptr %varargslots26, i64 0, i64 0 + %39 = getelementptr inbounds [1 x %"any*"], ptr %varargslots25, i64 0, i64 0 store %"any*" %38, ptr %39, align 16 - %40 = call i64 @std.io.printf(ptr %retparam25, ptr @.str.2, i64 3, ptr %varargslots26, i64 1) + %40 = call i64 @std.io.printf(ptr %retparam26, ptr @.str.2, i64 3, ptr %varargslots25, i64 1) %41 = load i64, ptr %.anon20, align 8 %add29 = add i64 %41, 1 store i64 %add29, ptr %.anon20, align 8 @@ -232,12 +232,12 @@ voiderr53: ; preds = %noerr_block51, %gua %52 = call i32 @llvm.bswap.i32(i32 %51) %53 = and i32 65535, %52 %trunc = trunc i32 %53 to i16 - store i16 %trunc, ptr %taddr56, align 2 - %54 = insertvalue %"any*" undef, ptr %taddr56, 0 + store i16 %trunc, ptr %taddr55, align 2 + %54 = insertvalue %"any*" undef, ptr %taddr55, 0 %55 = insertvalue %"any*" %54, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 - %56 = getelementptr inbounds [1 x %"any*"], ptr %varargslots55, i64 0, i64 0 + %56 = getelementptr inbounds [1 x %"any*"], ptr %varargslots54, i64 0, i64 0 store %"any*" %55, ptr %56, align 16 - %57 = call i64 @std.io.printfn(ptr %retparam54, ptr @.str.3, i64 10, ptr %varargslots55, i64 1) + %57 = call i64 @std.io.printfn(ptr %retparam56, ptr @.str.3, i64 10, ptr %varargslots54, i64 1) %58 = load i32, ptr %abc, align 4 %59 = call i32 @llvm.bswap.i32(i32 %58) %60 = and i32 %59, -65536 @@ -253,13 +253,13 @@ voiderr53: ; preds = %noerr_block51, %gua %68 = load i32, ptr %abc, align 4 %69 = call i32 @llvm.bswap.i32(i32 %68) %70 = and i32 65535, %69 - %trunc61 = trunc i32 %70 to i16 - store i16 %trunc61, ptr %taddr62, align 2 - %71 = insertvalue %"any*" undef, ptr %taddr62, 0 + %trunc60 = trunc i32 %70 to i16 + store i16 %trunc60, ptr %taddr61, align 2 + %71 = insertvalue %"any*" undef, ptr %taddr61, 0 %72 = insertvalue %"any*" %71, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 - %73 = getelementptr inbounds [1 x %"any*"], ptr %varargslots60, i64 0, i64 0 + %73 = getelementptr inbounds [1 x %"any*"], ptr %varargslots59, i64 0, i64 0 store %"any*" %72, ptr %73, align 16 - %74 = call i64 @std.io.printfn(ptr %retparam59, ptr @.str.4, i64 12, ptr %varargslots60, i64 1) + %74 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.4, i64 12, ptr %varargslots59, i64 1) %75 = load ptr, ptr %z, align 8 store ptr %75, ptr %.anon65, align 8 store i64 0, ptr %.anon66, align 8 @@ -278,9 +278,9 @@ loop.body69: ; preds = %loop.cond67 store i8 %80, ptr %d70, align 1 %81 = insertvalue %"any*" undef, ptr %d70, 0 %82 = insertvalue %"any*" %81, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %83 = getelementptr inbounds [1 x %"any*"], ptr %varargslots72, i64 0, i64 0 + %83 = getelementptr inbounds [1 x %"any*"], ptr %varargslots71, i64 0, i64 0 store %"any*" %82, ptr %83, align 16 - %84 = call i64 @std.io.printf(ptr %retparam71, ptr @.str.5, i64 3, ptr %varargslots72, i64 1) + %84 = call i64 @std.io.printf(ptr %retparam72, ptr @.str.5, i64 3, ptr %varargslots71, i64 1) %85 = load i64, ptr %.anon66, align 8 %add75 = add i64 %85, 1 store i64 %add75, ptr %.anon66, align 8 @@ -348,14 +348,14 @@ voiderr99: ; preds = %noerr_block97, %gua store i32 123, ptr %y, align 4 %96 = insertvalue %"any*" undef, ptr %y, 0 %97 = insertvalue %"any*" %96, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %98 = getelementptr inbounds [2 x %"any*"], ptr %varargslots101, i64 0, i64 0 + %98 = getelementptr inbounds [2 x %"any*"], ptr %varargslots100, i64 0, i64 0 store %"any*" %97, ptr %98, align 16 %99 = load i32, ptr %y, align 4 - store i32 %99, ptr %taddr102, align 4 - %100 = insertvalue %"any*" undef, ptr %taddr102, 0 + store i32 %99, ptr %taddr101, align 4 + %100 = insertvalue %"any*" undef, ptr %taddr101, 0 %101 = insertvalue %"any*" %100, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %102 = getelementptr inbounds [2 x %"any*"], ptr %varargslots101, i64 0, i64 1 + %102 = getelementptr inbounds [2 x %"any*"], ptr %varargslots100, i64 0, i64 1 store %"any*" %101, ptr %102, align 16 - %103 = call i64 @std.io.printf(ptr %retparam100, ptr @.str.6, i64 18, ptr %varargslots101, i64 2) + %103 = call i64 @std.io.printf(ptr %retparam102, ptr @.str.6, i64 18, ptr %varargslots100, i64 2) ret void } \ No newline at end of file diff --git a/test/test_suite/bitstruct/bitstruct_initializer.c3t b/test/test_suite/bitstruct/bitstruct_initializer.c3t index 550040203..e1cf52086 100644 --- a/test/test_suite/bitstruct/bitstruct_initializer.c3t +++ b/test/test_suite/bitstruct/bitstruct_initializer.c3t @@ -54,36 +54,36 @@ entry: %y = alloca %Abc, align 8 %d = alloca %Abc, align 8 %b = alloca [8 x i8], align 1 - %retparam = alloca i64, align 8 %varargslots = alloca [3 x %"any*"], align 16 %taddr = alloca i32, align 4 %taddr13 = alloca i32, align 4 %taddr16 = alloca i8, align 1 - %retparam17 = alloca i64, align 8 - %varargslots18 = alloca [3 x %"any*"], align 16 - %taddr20 = alloca i32, align 4 - %taddr23 = alloca i32, align 4 - %taddr26 = alloca i8, align 1 - %retparam27 = alloca i64, align 8 - %varargslots28 = alloca [3 x %"any*"], align 16 - %taddr36 = alloca i32, align 4 - %taddr44 = alloca i32, align 4 - %taddr46 = alloca i8, align 1 - %retparam61 = alloca i64, align 8 - %varargslots62 = alloca [3 x %"any*"], align 16 - %taddr64 = alloca i32, align 4 - %taddr67 = alloca i32, align 4 - %taddr70 = alloca i8, align 1 - %retparam71 = alloca i64, align 8 - %varargslots72 = alloca [3 x %"any*"], align 16 - %taddr74 = alloca i32, align 4 - %taddr77 = alloca i32, align 4 - %taddr80 = alloca i8, align 1 - %retparam81 = alloca i64, align 8 - %varargslots82 = alloca [3 x %"any*"], align 16 - %taddr90 = alloca i32, align 4 - %taddr98 = alloca i32, align 4 - %taddr100 = alloca i8, align 1 + %retparam = alloca i64, align 8 + %varargslots17 = alloca [3 x %"any*"], align 16 + %taddr19 = alloca i32, align 4 + %taddr22 = alloca i32, align 4 + %taddr25 = alloca i8, align 1 + %retparam26 = alloca i64, align 8 + %varargslots27 = alloca [3 x %"any*"], align 16 + %taddr35 = alloca i32, align 4 + %taddr43 = alloca i32, align 4 + %taddr45 = alloca i8, align 1 + %retparam46 = alloca i64, align 8 + %varargslots61 = alloca [3 x %"any*"], align 16 + %taddr63 = alloca i32, align 4 + %taddr66 = alloca i32, align 4 + %taddr69 = alloca i8, align 1 + %retparam70 = alloca i64, align 8 + %varargslots71 = alloca [3 x %"any*"], align 16 + %taddr73 = alloca i32, align 4 + %taddr76 = alloca i32, align 4 + %taddr79 = alloca i8, align 1 + %retparam80 = alloca i64, align 8 + %varargslots81 = alloca [3 x %"any*"], align 16 + %taddr89 = alloca i32, align 4 + %taddr97 = alloca i32, align 4 + %taddr99 = alloca i8, align 1 + %retparam100 = alloca i64, align 8 store i64 0, ptr %x, align 8 %zext = zext i32 %0 to i64 %1 = and i64 %zext, 4294967295 @@ -183,91 +183,91 @@ entry: %47 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 %48 = load i64, ptr %47, align 8 %49 = and i64 4294967295, %48 - %trunc19 = trunc i64 %49 to i32 - store i32 %trunc19, ptr %taddr20, align 4 - %50 = insertvalue %"any*" undef, ptr %taddr20, 0 + %trunc18 = trunc i64 %49 to i32 + store i32 %trunc18, ptr %taddr19, align 4 + %50 = insertvalue %"any*" undef, ptr %taddr19, 0 %51 = insertvalue %"any*" %50, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %52 = getelementptr inbounds [3 x %"any*"], ptr %varargslots18, i64 0, i64 0 + %52 = getelementptr inbounds [3 x %"any*"], ptr %varargslots17, i64 0, i64 0 store %"any*" %51, ptr %52, align 16 %53 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 %54 = load i64, ptr %53, align 8 - %lshrl21 = lshr i64 %54, 32 - %55 = and i64 2147483647, %lshrl21 - %trunc22 = trunc i64 %55 to i32 - store i32 %trunc22, ptr %taddr23, align 4 - %56 = insertvalue %"any*" undef, ptr %taddr23, 0 + %lshrl20 = lshr i64 %54, 32 + %55 = and i64 2147483647, %lshrl20 + %trunc21 = trunc i64 %55 to i32 + store i32 %trunc21, ptr %taddr22, align 4 + %56 = insertvalue %"any*" undef, ptr %taddr22, 0 %57 = insertvalue %"any*" %56, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %58 = getelementptr inbounds [3 x %"any*"], ptr %varargslots18, i64 0, i64 1 + %58 = getelementptr inbounds [3 x %"any*"], ptr %varargslots17, i64 0, i64 1 store %"any*" %57, ptr %58, align 16 %59 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 %60 = load i64, ptr %59, align 8 - %lshrl24 = lshr i64 %60, 63 - %61 = and i64 1, %lshrl24 - %trunc25 = trunc i64 %61 to i8 - store i8 %trunc25, ptr %taddr26, align 1 - %62 = insertvalue %"any*" undef, ptr %taddr26, 0 + %lshrl23 = lshr i64 %60, 63 + %61 = and i64 1, %lshrl23 + %trunc24 = trunc i64 %61 to i8 + store i8 %trunc24, ptr %taddr25, align 1 + %62 = insertvalue %"any*" undef, ptr %taddr25, 0 %63 = insertvalue %"any*" %62, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %64 = getelementptr inbounds [3 x %"any*"], ptr %varargslots18, i64 0, i64 2 + %64 = getelementptr inbounds [3 x %"any*"], ptr %varargslots17, i64 0, i64 2 store %"any*" %63, ptr %64, align 16 - %65 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.2, i64 8, ptr %varargslots18, i64 3) + %65 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.2, i64 8, ptr %varargslots17, i64 3) %66 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 %67 = load i8, ptr %66, align 1 - %zext29 = zext i8 %67 to i32 + %zext28 = zext i8 %67 to i32 %68 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 %69 = load i8, ptr %68, align 1 - %zext30 = zext i8 %69 to i32 - %shl31 = shl i32 %zext30, 8 - %70 = or i32 %shl31, %zext29 + %zext29 = zext i8 %69 to i32 + %shl30 = shl i32 %zext29, 8 + %70 = or i32 %shl30, %zext28 %71 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 %72 = load i8, ptr %71, align 1 - %zext32 = zext i8 %72 to i32 - %shl33 = shl i32 %zext32, 16 - %73 = or i32 %shl33, %70 + %zext31 = zext i8 %72 to i32 + %shl32 = shl i32 %zext31, 16 + %73 = or i32 %shl32, %70 %74 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 %75 = load i8, ptr %74, align 1 - %zext34 = zext i8 %75 to i32 - %shl35 = shl i32 %zext34, 24 - %76 = or i32 %shl35, %73 - store i32 %76, ptr %taddr36, align 4 - %77 = insertvalue %"any*" undef, ptr %taddr36, 0 + %zext33 = zext i8 %75 to i32 + %shl34 = shl i32 %zext33, 24 + %76 = or i32 %shl34, %73 + store i32 %76, ptr %taddr35, align 4 + %77 = insertvalue %"any*" undef, ptr %taddr35, 0 %78 = insertvalue %"any*" %77, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %79 = getelementptr inbounds [3 x %"any*"], ptr %varargslots28, i64 0, i64 0 + %79 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 0 store %"any*" %78, ptr %79, align 16 %80 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 %81 = load i8, ptr %80, align 1 - %zext37 = zext i8 %81 to i32 + %zext36 = zext i8 %81 to i32 %82 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 %83 = load i8, ptr %82, align 1 - %zext38 = zext i8 %83 to i32 - %shl39 = shl i32 %zext38, 8 - %84 = or i32 %shl39, %zext37 + %zext37 = zext i8 %83 to i32 + %shl38 = shl i32 %zext37, 8 + %84 = or i32 %shl38, %zext36 %85 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 %86 = load i8, ptr %85, align 1 - %zext40 = zext i8 %86 to i32 - %shl41 = shl i32 %zext40, 16 - %87 = or i32 %shl41, %84 + %zext39 = zext i8 %86 to i32 + %shl40 = shl i32 %zext39, 16 + %87 = or i32 %shl40, %84 %88 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 %89 = load i8, ptr %88, align 1 - %zext42 = zext i8 %89 to i32 - %shl43 = shl i32 %zext42, 24 - %90 = or i32 %shl43, %87 + %zext41 = zext i8 %89 to i32 + %shl42 = shl i32 %zext41, 24 + %90 = or i32 %shl42, %87 %91 = and i32 2147483647, %90 - store i32 %91, ptr %taddr44, align 4 - %92 = insertvalue %"any*" undef, ptr %taddr44, 0 + store i32 %91, ptr %taddr43, align 4 + %92 = insertvalue %"any*" undef, ptr %taddr43, 0 %93 = insertvalue %"any*" %92, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %94 = getelementptr inbounds [3 x %"any*"], ptr %varargslots28, i64 0, i64 1 + %94 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 1 store %"any*" %93, ptr %94, align 16 %95 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 %96 = load i8, ptr %95, align 1 - %lshrl45 = lshr i8 %96, 7 - %97 = trunc i8 %lshrl45 to i1 + %lshrl44 = lshr i8 %96, 7 + %97 = trunc i8 %lshrl44 to i1 %98 = zext i1 %97 to i8 - store i8 %98, ptr %taddr46, align 1 - %99 = insertvalue %"any*" undef, ptr %taddr46, 0 + store i8 %98, ptr %taddr45, align 1 + %99 = insertvalue %"any*" undef, ptr %taddr45, 0 %100 = insertvalue %"any*" %99, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %101 = getelementptr inbounds [3 x %"any*"], ptr %varargslots28, i64 0, i64 2 + %101 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 2 store %"any*" %100, ptr %101, align 16 - %102 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.3, i64 8, ptr %varargslots28, i64 3) + %102 = call i64 @std.io.printfn(ptr %retparam46, ptr @.str.3, i64 8, ptr %varargslots27, i64 3) %add = add i32 %0, 1 %zext47 = zext i32 %add to i64 %103 = and i64 %zext47, 4294967295 @@ -336,119 +336,119 @@ entry: store i8 %133, ptr %130, align 1 %134 = load i64, ptr %x, align 8 %135 = and i64 4294967295, %134 - %trunc63 = trunc i64 %135 to i32 - store i32 %trunc63, ptr %taddr64, align 4 - %136 = insertvalue %"any*" undef, ptr %taddr64, 0 + %trunc62 = trunc i64 %135 to i32 + store i32 %trunc62, ptr %taddr63, align 4 + %136 = insertvalue %"any*" undef, ptr %taddr63, 0 %137 = insertvalue %"any*" %136, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %138 = getelementptr inbounds [3 x %"any*"], ptr %varargslots62, i64 0, i64 0 + %138 = getelementptr inbounds [3 x %"any*"], ptr %varargslots61, i64 0, i64 0 store %"any*" %137, ptr %138, align 16 %139 = load i64, ptr %x, align 8 - %lshrl65 = lshr i64 %139, 32 - %140 = and i64 2147483647, %lshrl65 - %trunc66 = trunc i64 %140 to i32 - store i32 %trunc66, ptr %taddr67, align 4 - %141 = insertvalue %"any*" undef, ptr %taddr67, 0 + %lshrl64 = lshr i64 %139, 32 + %140 = and i64 2147483647, %lshrl64 + %trunc65 = trunc i64 %140 to i32 + store i32 %trunc65, ptr %taddr66, align 4 + %141 = insertvalue %"any*" undef, ptr %taddr66, 0 %142 = insertvalue %"any*" %141, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %143 = getelementptr inbounds [3 x %"any*"], ptr %varargslots62, i64 0, i64 1 + %143 = getelementptr inbounds [3 x %"any*"], ptr %varargslots61, i64 0, i64 1 store %"any*" %142, ptr %143, align 16 %144 = load i64, ptr %x, align 8 - %lshrl68 = lshr i64 %144, 63 - %145 = and i64 1, %lshrl68 - %trunc69 = trunc i64 %145 to i8 - store i8 %trunc69, ptr %taddr70, align 1 - %146 = insertvalue %"any*" undef, ptr %taddr70, 0 + %lshrl67 = lshr i64 %144, 63 + %145 = and i64 1, %lshrl67 + %trunc68 = trunc i64 %145 to i8 + store i8 %trunc68, ptr %taddr69, align 1 + %146 = insertvalue %"any*" undef, ptr %taddr69, 0 %147 = insertvalue %"any*" %146, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %148 = getelementptr inbounds [3 x %"any*"], ptr %varargslots62, i64 0, i64 2 + %148 = getelementptr inbounds [3 x %"any*"], ptr %varargslots61, i64 0, i64 2 store %"any*" %147, ptr %148, align 16 - %149 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.4, i64 8, ptr %varargslots62, i64 3) + %149 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.4, i64 8, ptr %varargslots61, i64 3) %150 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 %151 = load i64, ptr %150, align 8 %152 = and i64 4294967295, %151 - %trunc73 = trunc i64 %152 to i32 - store i32 %trunc73, ptr %taddr74, align 4 - %153 = insertvalue %"any*" undef, ptr %taddr74, 0 + %trunc72 = trunc i64 %152 to i32 + store i32 %trunc72, ptr %taddr73, align 4 + %153 = insertvalue %"any*" undef, ptr %taddr73, 0 %154 = insertvalue %"any*" %153, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %155 = getelementptr inbounds [3 x %"any*"], ptr %varargslots72, i64 0, i64 0 + %155 = getelementptr inbounds [3 x %"any*"], ptr %varargslots71, i64 0, i64 0 store %"any*" %154, ptr %155, align 16 %156 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 %157 = load i64, ptr %156, align 8 - %lshrl75 = lshr i64 %157, 32 - %158 = and i64 2147483647, %lshrl75 - %trunc76 = trunc i64 %158 to i32 - store i32 %trunc76, ptr %taddr77, align 4 - %159 = insertvalue %"any*" undef, ptr %taddr77, 0 + %lshrl74 = lshr i64 %157, 32 + %158 = and i64 2147483647, %lshrl74 + %trunc75 = trunc i64 %158 to i32 + store i32 %trunc75, ptr %taddr76, align 4 + %159 = insertvalue %"any*" undef, ptr %taddr76, 0 %160 = insertvalue %"any*" %159, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %161 = getelementptr inbounds [3 x %"any*"], ptr %varargslots72, i64 0, i64 1 + %161 = getelementptr inbounds [3 x %"any*"], ptr %varargslots71, i64 0, i64 1 store %"any*" %160, ptr %161, align 16 %162 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 %163 = load i64, ptr %162, align 8 - %lshrl78 = lshr i64 %163, 63 - %164 = and i64 1, %lshrl78 - %trunc79 = trunc i64 %164 to i8 - store i8 %trunc79, ptr %taddr80, align 1 - %165 = insertvalue %"any*" undef, ptr %taddr80, 0 + %lshrl77 = lshr i64 %163, 63 + %164 = and i64 1, %lshrl77 + %trunc78 = trunc i64 %164 to i8 + store i8 %trunc78, ptr %taddr79, align 1 + %165 = insertvalue %"any*" undef, ptr %taddr79, 0 %166 = insertvalue %"any*" %165, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %167 = getelementptr inbounds [3 x %"any*"], ptr %varargslots72, i64 0, i64 2 + %167 = getelementptr inbounds [3 x %"any*"], ptr %varargslots71, i64 0, i64 2 store %"any*" %166, ptr %167, align 16 - %168 = call i64 @std.io.printfn(ptr %retparam71, ptr @.str.5, i64 8, ptr %varargslots72, i64 3) + %168 = call i64 @std.io.printfn(ptr %retparam80, ptr @.str.5, i64 8, ptr %varargslots71, i64 3) %169 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 %170 = load i8, ptr %169, align 1 - %zext83 = zext i8 %170 to i32 + %zext82 = zext i8 %170 to i32 %171 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 %172 = load i8, ptr %171, align 1 - %zext84 = zext i8 %172 to i32 - %shl85 = shl i32 %zext84, 8 - %173 = or i32 %shl85, %zext83 + %zext83 = zext i8 %172 to i32 + %shl84 = shl i32 %zext83, 8 + %173 = or i32 %shl84, %zext82 %174 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 %175 = load i8, ptr %174, align 1 - %zext86 = zext i8 %175 to i32 - %shl87 = shl i32 %zext86, 16 - %176 = or i32 %shl87, %173 + %zext85 = zext i8 %175 to i32 + %shl86 = shl i32 %zext85, 16 + %176 = or i32 %shl86, %173 %177 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 %178 = load i8, ptr %177, align 1 - %zext88 = zext i8 %178 to i32 - %shl89 = shl i32 %zext88, 24 - %179 = or i32 %shl89, %176 - store i32 %179, ptr %taddr90, align 4 - %180 = insertvalue %"any*" undef, ptr %taddr90, 0 + %zext87 = zext i8 %178 to i32 + %shl88 = shl i32 %zext87, 24 + %179 = or i32 %shl88, %176 + store i32 %179, ptr %taddr89, align 4 + %180 = insertvalue %"any*" undef, ptr %taddr89, 0 %181 = insertvalue %"any*" %180, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %182 = getelementptr inbounds [3 x %"any*"], ptr %varargslots82, i64 0, i64 0 + %182 = getelementptr inbounds [3 x %"any*"], ptr %varargslots81, i64 0, i64 0 store %"any*" %181, ptr %182, align 16 %183 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 %184 = load i8, ptr %183, align 1 - %zext91 = zext i8 %184 to i32 + %zext90 = zext i8 %184 to i32 %185 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 %186 = load i8, ptr %185, align 1 - %zext92 = zext i8 %186 to i32 - %shl93 = shl i32 %zext92, 8 - %187 = or i32 %shl93, %zext91 + %zext91 = zext i8 %186 to i32 + %shl92 = shl i32 %zext91, 8 + %187 = or i32 %shl92, %zext90 %188 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 %189 = load i8, ptr %188, align 1 - %zext94 = zext i8 %189 to i32 - %shl95 = shl i32 %zext94, 16 - %190 = or i32 %shl95, %187 + %zext93 = zext i8 %189 to i32 + %shl94 = shl i32 %zext93, 16 + %190 = or i32 %shl94, %187 %191 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 %192 = load i8, ptr %191, align 1 - %zext96 = zext i8 %192 to i32 - %shl97 = shl i32 %zext96, 24 - %193 = or i32 %shl97, %190 + %zext95 = zext i8 %192 to i32 + %shl96 = shl i32 %zext95, 24 + %193 = or i32 %shl96, %190 %194 = and i32 2147483647, %193 - store i32 %194, ptr %taddr98, align 4 - %195 = insertvalue %"any*" undef, ptr %taddr98, 0 + store i32 %194, ptr %taddr97, align 4 + %195 = insertvalue %"any*" undef, ptr %taddr97, 0 %196 = insertvalue %"any*" %195, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %197 = getelementptr inbounds [3 x %"any*"], ptr %varargslots82, i64 0, i64 1 + %197 = getelementptr inbounds [3 x %"any*"], ptr %varargslots81, i64 0, i64 1 store %"any*" %196, ptr %197, align 16 %198 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 %199 = load i8, ptr %198, align 1 - %lshrl99 = lshr i8 %199, 7 - %200 = trunc i8 %lshrl99 to i1 + %lshrl98 = lshr i8 %199, 7 + %200 = trunc i8 %lshrl98 to i1 %201 = zext i1 %200 to i8 - store i8 %201, ptr %taddr100, align 1 - %202 = insertvalue %"any*" undef, ptr %taddr100, 0 + store i8 %201, ptr %taddr99, align 1 + %202 = insertvalue %"any*" undef, ptr %taddr99, 0 %203 = insertvalue %"any*" %202, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %204 = getelementptr inbounds [3 x %"any*"], ptr %varargslots82, i64 0, i64 2 + %204 = getelementptr inbounds [3 x %"any*"], ptr %varargslots81, i64 0, i64 2 store %"any*" %203, ptr %204, align 16 - %205 = call i64 @std.io.printfn(ptr %retparam81, ptr @.str.6, i64 8, ptr %varargslots82, i64 3) + %205 = call i64 @std.io.printfn(ptr %retparam100, ptr @.str.6, i64 8, ptr %varargslots81, i64 3) ret void } diff --git a/test/test_suite/bitstruct/bitstruct_ops.c3t b/test/test_suite/bitstruct/bitstruct_ops.c3t index 33f666f84..a9219e9bc 100644 --- a/test/test_suite/bitstruct/bitstruct_ops.c3t +++ b/test/test_suite/bitstruct/bitstruct_ops.c3t @@ -47,46 +47,46 @@ entry: %f1 = alloca i32, align 4 %f2 = alloca i32, align 4 %f3 = alloca i32, align 4 - %retparam = alloca i64, align 8 %varargslots = alloca [2 x %"any*"], align 16 %taddr = alloca i8, align 1 %taddr2 = alloca i8, align 1 + %retparam = alloca i64, align 8 %f4 = alloca i32, align 4 - %retparam3 = alloca i64, align 8 - %varargslots4 = alloca [2 x %"any*"], align 16 - %taddr6 = alloca i8, align 1 - %taddr9 = alloca i8, align 1 + %varargslots3 = alloca [2 x %"any*"], align 16 + %taddr5 = alloca i8, align 1 + %taddr8 = alloca i8, align 1 + %retparam9 = alloca i64, align 8 %f5 = alloca i32, align 4 - %retparam10 = alloca i64, align 8 - %varargslots11 = alloca [2 x %"any*"], align 16 - %taddr13 = alloca i8, align 1 - %taddr16 = alloca i8, align 1 - %retparam18 = alloca i64, align 8 - %varargslots19 = alloca [2 x %"any*"], align 16 - %taddr21 = alloca i8, align 1 - %taddr24 = alloca i8, align 1 + %varargslots10 = alloca [2 x %"any*"], align 16 + %taddr12 = alloca i8, align 1 + %taddr15 = alloca i8, align 1 + %retparam16 = alloca i64, align 8 + %varargslots18 = alloca [2 x %"any*"], align 16 + %taddr20 = alloca i8, align 1 + %taddr23 = alloca i8, align 1 + %retparam24 = alloca i64, align 8 %b1 = alloca [13 x i8], align 1 %b2 = alloca [13 x i8], align 1 %b3 = alloca [13 x i8], align 1 %0 = alloca i104, align 1 - %retparam26 = alloca i64, align 8 - %varargslots27 = alloca [3 x %"any*"], align 16 - %taddr28 = alloca i8, align 1 - %taddr30 = alloca i8, align 1 - %taddr32 = alloca i8, align 1 + %varargslots26 = alloca [3 x %"any*"], align 16 + %taddr27 = alloca i8, align 1 + %taddr29 = alloca i8, align 1 + %taddr31 = alloca i8, align 1 + %retparam32 = alloca i64, align 8 %1 = alloca i104, align 1 - %retparam34 = alloca i64, align 8 - %varargslots35 = alloca [3 x %"any*"], align 16 - %taddr36 = alloca i8, align 1 - %taddr38 = alloca i8, align 1 - %taddr40 = alloca i8, align 1 + %varargslots34 = alloca [3 x %"any*"], align 16 + %taddr35 = alloca i8, align 1 + %taddr37 = alloca i8, align 1 + %taddr39 = alloca i8, align 1 + %retparam40 = alloca i64, align 8 %taddr41 = alloca [13 x i8], align 1 %2 = alloca i104, align 1 - %retparam43 = alloca i64, align 8 - %varargslots44 = alloca [3 x %"any*"], align 16 - %taddr45 = alloca i8, align 1 - %taddr47 = alloca i8, align 1 - %taddr49 = alloca i8, align 1 + %varargslots43 = alloca [3 x %"any*"], align 16 + %taddr44 = alloca i8, align 1 + %taddr46 = alloca i8, align 1 + %taddr48 = alloca i8, align 1 + %retparam49 = alloca i64, align 8 store i32 3, ptr %f1, align 4 store i32 1, ptr %f2, align 4 %3 = load i32, ptr %f1, align 4 @@ -120,63 +120,63 @@ entry: store i32 %xor, ptr %f4, align 4 %19 = load i32, ptr %f4, align 4 %20 = and i32 1, %19 - %trunc5 = trunc i32 %20 to i8 - store i8 %trunc5, ptr %taddr6, align 1 - %21 = insertvalue %"any*" undef, ptr %taddr6, 0 + %trunc4 = trunc i32 %20 to i8 + store i8 %trunc4, ptr %taddr5, align 1 + %21 = insertvalue %"any*" undef, ptr %taddr5, 0 %22 = insertvalue %"any*" %21, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %23 = getelementptr inbounds [2 x %"any*"], ptr %varargslots4, i64 0, i64 0 + %23 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 0 store %"any*" %22, ptr %23, align 16 %24 = load i32, ptr %f4, align 4 - %lshrl7 = lshr i32 %24, 1 - %25 = and i32 1, %lshrl7 - %trunc8 = trunc i32 %25 to i8 - store i8 %trunc8, ptr %taddr9, align 1 - %26 = insertvalue %"any*" undef, ptr %taddr9, 0 + %lshrl6 = lshr i32 %24, 1 + %25 = and i32 1, %lshrl6 + %trunc7 = trunc i32 %25 to i8 + store i8 %trunc7, ptr %taddr8, align 1 + %26 = insertvalue %"any*" undef, ptr %taddr8, 0 %27 = insertvalue %"any*" %26, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %28 = getelementptr inbounds [2 x %"any*"], ptr %varargslots4, i64 0, i64 1 + %28 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 1 store %"any*" %27, ptr %28, align 16 - %29 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.1, i64 5, ptr %varargslots4, i64 2) + %29 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.1, i64 5, ptr %varargslots3, i64 2) store i32 3, ptr %f5, align 4 %30 = load i32, ptr %f5, align 4 %31 = and i32 1, %30 - %trunc12 = trunc i32 %31 to i8 - store i8 %trunc12, ptr %taddr13, align 1 - %32 = insertvalue %"any*" undef, ptr %taddr13, 0 + %trunc11 = trunc i32 %31 to i8 + store i8 %trunc11, ptr %taddr12, align 1 + %32 = insertvalue %"any*" undef, ptr %taddr12, 0 %33 = insertvalue %"any*" %32, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots11, i64 0, i64 0 + %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots10, i64 0, i64 0 store %"any*" %33, ptr %34, align 16 %35 = load i32, ptr %f5, align 4 - %lshrl14 = lshr i32 %35, 1 - %36 = and i32 1, %lshrl14 - %trunc15 = trunc i32 %36 to i8 - store i8 %trunc15, ptr %taddr16, align 1 - %37 = insertvalue %"any*" undef, ptr %taddr16, 0 + %lshrl13 = lshr i32 %35, 1 + %36 = and i32 1, %lshrl13 + %trunc14 = trunc i32 %36 to i8 + store i8 %trunc14, ptr %taddr15, align 1 + %37 = insertvalue %"any*" undef, ptr %taddr15, 0 %38 = insertvalue %"any*" %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %39 = getelementptr inbounds [2 x %"any*"], ptr %varargslots11, i64 0, i64 1 + %39 = getelementptr inbounds [2 x %"any*"], ptr %varargslots10, i64 0, i64 1 store %"any*" %38, ptr %39, align 16 - %40 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.2, i64 5, ptr %varargslots11, i64 2) + %40 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.2, i64 5, ptr %varargslots10, i64 2) %41 = load i32, ptr %f5, align 4 %42 = load i32, ptr %f2, align 4 %and17 = and i32 %41, %42 store i32 %and17, ptr %f5, align 4 %43 = load i32, ptr %f5, align 4 %44 = and i32 1, %43 - %trunc20 = trunc i32 %44 to i8 - store i8 %trunc20, ptr %taddr21, align 1 - %45 = insertvalue %"any*" undef, ptr %taddr21, 0 + %trunc19 = trunc i32 %44 to i8 + store i8 %trunc19, ptr %taddr20, align 1 + %45 = insertvalue %"any*" undef, ptr %taddr20, 0 %46 = insertvalue %"any*" %45, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %47 = getelementptr inbounds [2 x %"any*"], ptr %varargslots19, i64 0, i64 0 + %47 = getelementptr inbounds [2 x %"any*"], ptr %varargslots18, i64 0, i64 0 store %"any*" %46, ptr %47, align 16 %48 = load i32, ptr %f5, align 4 - %lshrl22 = lshr i32 %48, 1 - %49 = and i32 1, %lshrl22 - %trunc23 = trunc i32 %49 to i8 - store i8 %trunc23, ptr %taddr24, align 1 - %50 = insertvalue %"any*" undef, ptr %taddr24, 0 + %lshrl21 = lshr i32 %48, 1 + %49 = and i32 1, %lshrl21 + %trunc22 = trunc i32 %49 to i8 + store i8 %trunc22, ptr %taddr23, align 1 + %50 = insertvalue %"any*" undef, ptr %taddr23, 0 %51 = insertvalue %"any*" %50, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %52 = getelementptr inbounds [2 x %"any*"], ptr %varargslots19, i64 0, i64 1 + %52 = getelementptr inbounds [2 x %"any*"], ptr %varargslots18, i64 0, i64 1 store %"any*" %51, ptr %52, align 16 - %53 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.3, i64 5, ptr %varargslots19, i64 2) + %53 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.3, i64 5, ptr %varargslots18, i64 2) store [13 x i8] c"\03\00\00\02\00\00\00\00\00\00\00\00\00", ptr %b1, align 1 store [13 x i8] c"\01\00\00\00\00\00\00\00\00\00\00\00\00", ptr %b2, align 1 %54 = load i104, ptr %b1, align 1 @@ -188,32 +188,32 @@ entry: %57 = load i8, ptr %56, align 1 %58 = trunc i8 %57 to i1 %59 = zext i1 %58 to i8 - store i8 %59, ptr %taddr28, align 1 - %60 = insertvalue %"any*" undef, ptr %taddr28, 0 + store i8 %59, ptr %taddr27, align 1 + %60 = insertvalue %"any*" undef, ptr %taddr27, 0 %61 = insertvalue %"any*" %60, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %62 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 0 + %62 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, i64 0, i64 0 store %"any*" %61, ptr %62, align 16 %63 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0 %64 = load i8, ptr %63, align 1 - %lshrl29 = lshr i8 %64, 1 - %65 = trunc i8 %lshrl29 to i1 + %lshrl28 = lshr i8 %64, 1 + %65 = trunc i8 %lshrl28 to i1 %66 = zext i1 %65 to i8 - store i8 %66, ptr %taddr30, align 1 - %67 = insertvalue %"any*" undef, ptr %taddr30, 0 + store i8 %66, ptr %taddr29, align 1 + %67 = insertvalue %"any*" undef, ptr %taddr29, 0 %68 = insertvalue %"any*" %67, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %69 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 1 + %69 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, i64 0, i64 1 store %"any*" %68, ptr %69, align 16 %70 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3 %71 = load i8, ptr %70, align 1 - %lshrl31 = lshr i8 %71, 1 - %72 = trunc i8 %lshrl31 to i1 + %lshrl30 = lshr i8 %71, 1 + %72 = trunc i8 %lshrl30 to i1 %73 = zext i1 %72 to i8 - store i8 %73, ptr %taddr32, align 1 - %74 = insertvalue %"any*" undef, ptr %taddr32, 0 + store i8 %73, ptr %taddr31, align 1 + %74 = insertvalue %"any*" undef, ptr %taddr31, 0 %75 = insertvalue %"any*" %74, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %76 = getelementptr inbounds [3 x %"any*"], ptr %varargslots27, i64 0, i64 2 + %76 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, i64 0, i64 2 store %"any*" %75, ptr %76, align 16 - %77 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.4, i64 8, ptr %varargslots27, i64 3) + %77 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.4, i64 8, ptr %varargslots26, i64 3) %78 = load i104, ptr %b3, align 1 %bnot33 = xor i104 %78, -1 store i104 %bnot33, ptr %1, align 8 @@ -222,32 +222,32 @@ entry: %80 = load i8, ptr %79, align 1 %81 = trunc i8 %80 to i1 %82 = zext i1 %81 to i8 - store i8 %82, ptr %taddr36, align 1 - %83 = insertvalue %"any*" undef, ptr %taddr36, 0 + store i8 %82, ptr %taddr35, align 1 + %83 = insertvalue %"any*" undef, ptr %taddr35, 0 %84 = insertvalue %"any*" %83, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %85 = getelementptr inbounds [3 x %"any*"], ptr %varargslots35, i64 0, i64 0 + %85 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, i64 0, i64 0 store %"any*" %84, ptr %85, align 16 %86 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0 %87 = load i8, ptr %86, align 1 - %lshrl37 = lshr i8 %87, 1 - %88 = trunc i8 %lshrl37 to i1 + %lshrl36 = lshr i8 %87, 1 + %88 = trunc i8 %lshrl36 to i1 %89 = zext i1 %88 to i8 - store i8 %89, ptr %taddr38, align 1 - %90 = insertvalue %"any*" undef, ptr %taddr38, 0 + store i8 %89, ptr %taddr37, align 1 + %90 = insertvalue %"any*" undef, ptr %taddr37, 0 %91 = insertvalue %"any*" %90, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %92 = getelementptr inbounds [3 x %"any*"], ptr %varargslots35, i64 0, i64 1 + %92 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, i64 0, i64 1 store %"any*" %91, ptr %92, align 16 %93 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3 %94 = load i8, ptr %93, align 1 - %lshrl39 = lshr i8 %94, 1 - %95 = trunc i8 %lshrl39 to i1 + %lshrl38 = lshr i8 %94, 1 + %95 = trunc i8 %lshrl38 to i1 %96 = zext i1 %95 to i8 - store i8 %96, ptr %taddr40, align 1 - %97 = insertvalue %"any*" undef, ptr %taddr40, 0 + store i8 %96, ptr %taddr39, align 1 + %97 = insertvalue %"any*" undef, ptr %taddr39, 0 %98 = insertvalue %"any*" %97, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %99 = getelementptr inbounds [3 x %"any*"], ptr %varargslots35, i64 0, i64 2 + %99 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, i64 0, i64 2 store %"any*" %98, ptr %99, align 16 - %100 = call i64 @std.io.printfn(ptr %retparam34, ptr @.str.5, i64 8, ptr %varargslots35, i64 3) + %100 = call i64 @std.io.printfn(ptr %retparam40, ptr @.str.5, i64 8, ptr %varargslots34, i64 3) store [13 x i8] c"\03\00\00\00\00\00\00\00\00\00\00\00\00", ptr %taddr41, align 1 %101 = load i104, ptr %b3, align 1 %102 = load i104, ptr %taddr41, align 1 @@ -258,31 +258,31 @@ entry: %104 = load i8, ptr %103, align 1 %105 = trunc i8 %104 to i1 %106 = zext i1 %105 to i8 - store i8 %106, ptr %taddr45, align 1 - %107 = insertvalue %"any*" undef, ptr %taddr45, 0 + store i8 %106, ptr %taddr44, align 1 + %107 = insertvalue %"any*" undef, ptr %taddr44, 0 %108 = insertvalue %"any*" %107, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %109 = getelementptr inbounds [3 x %"any*"], ptr %varargslots44, i64 0, i64 0 + %109 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, i64 0, i64 0 store %"any*" %108, ptr %109, align 16 %110 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0 %111 = load i8, ptr %110, align 1 - %lshrl46 = lshr i8 %111, 1 - %112 = trunc i8 %lshrl46 to i1 + %lshrl45 = lshr i8 %111, 1 + %112 = trunc i8 %lshrl45 to i1 %113 = zext i1 %112 to i8 - store i8 %113, ptr %taddr47, align 1 - %114 = insertvalue %"any*" undef, ptr %taddr47, 0 + store i8 %113, ptr %taddr46, align 1 + %114 = insertvalue %"any*" undef, ptr %taddr46, 0 %115 = insertvalue %"any*" %114, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %116 = getelementptr inbounds [3 x %"any*"], ptr %varargslots44, i64 0, i64 1 + %116 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, i64 0, i64 1 store %"any*" %115, ptr %116, align 16 %117 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3 %118 = load i8, ptr %117, align 1 - %lshrl48 = lshr i8 %118, 1 - %119 = trunc i8 %lshrl48 to i1 + %lshrl47 = lshr i8 %118, 1 + %119 = trunc i8 %lshrl47 to i1 %120 = zext i1 %119 to i8 - store i8 %120, ptr %taddr49, align 1 - %121 = insertvalue %"any*" undef, ptr %taddr49, 0 + store i8 %120, ptr %taddr48, align 1 + %121 = insertvalue %"any*" undef, ptr %taddr48, 0 %122 = insertvalue %"any*" %121, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %123 = getelementptr inbounds [3 x %"any*"], ptr %varargslots44, i64 0, i64 2 + %123 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, i64 0, i64 2 store %"any*" %122, ptr %123, align 16 - %124 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.6, i64 8, ptr %varargslots44, i64 3) + %124 = call i64 @std.io.printfn(ptr %retparam49, ptr @.str.6, i64 8, ptr %varargslots43, i64 3) ret void } diff --git a/test/test_suite/bitstruct/embedded_bitstruct.c3t b/test/test_suite/bitstruct/embedded_bitstruct.c3t index 300b8403f..b68ba7a55 100644 --- a/test/test_suite/bitstruct/embedded_bitstruct.c3t +++ b/test/test_suite/bitstruct/embedded_bitstruct.c3t @@ -53,26 +53,26 @@ entry: %0 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1 %1 = getelementptr inbounds %.anon, ptr %0, i32 0, i32 0 %2 = getelementptr inbounds %.anon.0, ptr %1, i32 0, i32 0 - %3 = load i32, ptr %2, align 4 - %4 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 2 - %5 = load i32, ptr %4, align 4 - %shl = shl i32 %5, 21 + %3 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 2 + %4 = load i32, ptr %3, align 4 + %shl = shl i32 %4, 21 %ashr = ashr i32 %shl, 23 - call void (ptr, ...) @printf(ptr @.str, i32 %3, i32 %ashr) + %5 = load i32, ptr %2, align 4 + call void (ptr, ...) @printf(ptr @.str, i32 %5, i32 %ashr) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %f, ptr align 4 @.__const.10, i32 16, i1 false) %6 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 %7 = getelementptr inbounds %.anon.1, ptr %6, i32 0, i32 0 %8 = getelementptr inbounds %.anon.2, ptr %7, i32 0, i32 0 - %9 = load i32, ptr %8, align 4 - %10 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 - %11 = getelementptr inbounds %.anon.1, ptr %10, i32 0, i32 1 - %12 = getelementptr inbounds %.anon.3, ptr %11, i32 0, i32 0 - %13 = load i32, ptr %12, align 4 - %14 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 - %15 = getelementptr inbounds %.anon.1, ptr %14, i32 0, i32 2 - %16 = load i32, ptr %15, align 4 - %17 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 1 - %18 = load i32, ptr %17, align 4 - call void (ptr, ...) @printf(ptr @.str.11, i32 %9, i32 %13, i32 %16, i32 %18) + %9 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 + %10 = getelementptr inbounds %.anon.1, ptr %9, i32 0, i32 1 + %11 = getelementptr inbounds %.anon.3, ptr %10, i32 0, i32 0 + %12 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 + %13 = getelementptr inbounds %.anon.1, ptr %12, i32 0, i32 2 + %14 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 1 + %15 = load i32, ptr %8, align 4 + %16 = load i32, ptr %11, align 4 + %17 = load i32, ptr %13, align 4 + %18 = load i32, ptr %14, align 4 + call void (ptr, ...) @printf(ptr @.str.11, i32 %15, i32 %16, i32 %17, i32 %18) ret void } diff --git a/test/test_suite/clang/2002-04.c3t b/test/test_suite/clang/2002-04.c3t index 59ae0e500..261ab71a4 100644 --- a/test/test_suite/clang/2002-04.c3t +++ b/test/test_suite/clang/2002-04.c3t @@ -144,17 +144,17 @@ entry: %indirectarg = alloca %FooSt, align 8 %indirectarg1 = alloca %FooSt, align 8 %1 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 0 - %2 = load i8, ptr %1, align 4 - %3 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 1 - %4 = load i16, ptr %3, align 2 - %5 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 2 - %6 = load i8, ptr %5, align 4 - %7 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 3 - %8 = load i32, ptr %7, align 4 - %9 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 4 - %10 = load i16, ptr %9, align 4 - %sext = sext i16 %10 to i32 - %11 = call i32 @testE(i8 zeroext %2, i16 signext %4, i8 zeroext %6, i32 %8, i32 %sext, float 0x3FB99999A0000000) + %2 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 1 + %3 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 2 + %4 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 3 + %5 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 4 + %6 = load i16, ptr %5, align 4 + %sext = sext i16 %6 to i32 + %7 = load i8, ptr %1, align 4 + %8 = load i16, ptr %2, align 2 + %9 = load i8, ptr %3, align 4 + %10 = load i32, ptr %4, align 4 + %11 = call i32 @testE(i8 zeroext %7, i16 signext %8, i8 zeroext %9, i32 %10, i32 %sext, float 0x3FB99999A0000000) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 4 %0, i32 20, i1 false) %12 = call i32 @testF(ptr byval(%FooSt) align 8 %indirectarg, float 0x3FB99999A0000000) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg1, ptr align 4 %0, i32 20, i1 false) diff --git a/test/test_suite/compile_time/compile_time_access_subscript.c3t b/test/test_suite/compile_time/compile_time_access_subscript.c3t index 6e89db8f7..31ecdc31c 100644 --- a/test/test_suite/compile_time/compile_time_access_subscript.c3t +++ b/test/test_suite/compile_time/compile_time_access_subscript.c3t @@ -55,9 +55,9 @@ fn void main() %z8 = alloca %Abc, align 4 %z9 = alloca [2 x i32], align 4 %z10 = alloca %"int[]", align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %literal = alloca %Abc, align 4 + %retparam = alloca i64, align 8 store i32 0, ptr %z, align 4 %0 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 0 store float 0.000000e+00, ptr %0, align 4 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 ad800d0f3..7e719df18 100644 --- a/test/test_suite/compile_time/ct_builtin_time_date.c3t +++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t @@ -28,9 +28,9 @@ fn void main() define void @test.test(i32 %0) #0 { entry: - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i32, align 4 + %retparam = alloca i64, align 8 %len = alloca i64, align 8 %error_var = alloca i64, align 8 %retparam2 = alloca i64, align 8 @@ -41,12 +41,12 @@ entry: %retparam18 = alloca i64, align 8 %error_var24 = alloca i64, align 8 %error_var30 = alloca i64, align 8 - %retparam38 = alloca i64, align 8 - %varargslots39 = alloca [1 x %"any*"], align 16 - %taddr40 = alloca i64, align 8 - %retparam43 = alloca i64, align 8 - %varargslots44 = alloca [1 x %"any*"], align 16 - %taddr45 = alloca i64, align 8 + %varargslots38 = alloca [1 x %"any*"], align 16 + %taddr39 = alloca i64, align 8 + %retparam40 = alloca i64, align 8 + %varargslots43 = alloca [1 x %"any*"], align 16 + %taddr44 = alloca i64, align 8 + %retparam45 = alloca i64, align 8 %len48 = alloca i64, align 8 %error_var49 = alloca i64, align 8 %retparam51 = alloca i64, align 8 @@ -156,18 +156,18 @@ noerr_block35: ; preds = %after_check33 %add36 = add i64 %22, 1 br label %voiderr37 voiderr37: ; preds = %noerr_block35, %guard_block34, %guard_block28, %guard_block22 - store i64 14, ptr %taddr40, align 8 - %23 = insertvalue %"any*" undef, ptr %taddr40, 0 + store i64 14, ptr %taddr39, align 8 + %23 = insertvalue %"any*" undef, ptr %taddr39, 0 %24 = insertvalue %"any*" %23, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %25 = getelementptr inbounds [1 x %"any*"], ptr %varargslots39, i64 0, i64 0 + %25 = getelementptr inbounds [1 x %"any*"], ptr %varargslots38, i64 0, i64 0 store %"any*" %24, ptr %25, align 16 - %26 = call i64 @std.io.printfn(ptr %retparam38, ptr @.str.3, i64 2, ptr %varargslots39, i64 1) - store i64 6, ptr %taddr45, align 8 - %27 = insertvalue %"any*" undef, ptr %taddr45, 0 + %26 = call i64 @std.io.printfn(ptr %retparam40, ptr @.str.3, i64 2, ptr %varargslots38, i64 1) + store i64 6, ptr %taddr44, align 8 + %27 = insertvalue %"any*" undef, ptr %taddr44, 0 %28 = insertvalue %"any*" %27, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %29 = getelementptr inbounds [1 x %"any*"], ptr %varargslots44, i64 0, i64 0 + %29 = getelementptr inbounds [1 x %"any*"], ptr %varargslots43, i64 0, i64 0 store %"any*" %28, ptr %29, align 16 - %30 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.4, i64 2, ptr %varargslots44, i64 1) + %30 = call i64 @std.io.printfn(ptr %retparam45, ptr @.str.4, i64 2, ptr %varargslots43, i64 1) %31 = call ptr @std.io.stdout() %32 = call i64 @std.io.File.write(ptr %retparam51, ptr %31, ptr @.str.5, i64 23) %not_err52 = icmp eq i64 %32, 0 diff --git a/test/test_suite/compile_time/ct_funcptr.c3t b/test/test_suite/compile_time/ct_funcptr.c3t index 46a7c5a49..314bf6283 100644 --- a/test/test_suite/compile_time/ct_funcptr.c3t +++ b/test/test_suite/compile_time/ct_funcptr.c3t @@ -19,9 +19,9 @@ fn void main() define void @test.test(i32 %0) #0 { entry: %ptr = alloca ptr, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i32, align 4 + %retparam = alloca i64, align 8 store ptr @test.test, ptr %ptr, align 8 store i32 %0, ptr %taddr, align 4 %1 = insertvalue %"any*" undef, ptr %taddr, 0 diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t index 50474955a..55b422a5d 100644 --- a/test/test_suite/compile_time/ct_memberof.c3t +++ b/test/test_suite/compile_time/ct_memberof.c3t @@ -151,67 +151,71 @@ entry: %retparam132 = alloca i64, align 8 %error_var138 = alloca i64, align 8 %error_var144 = alloca i64, align 8 - %retparam152 = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca %"char[]", align 8 - %retparam155 = alloca i64, align 8 - %varargslots156 = alloca [2 x %"any*"], align 16 + %retparam152 = alloca i64, align 8 + %varargslots155 = alloca [2 x %"any*"], align 16 + %taddr156 = alloca %"char[]", align 8 %taddr157 = alloca %"char[]", align 8 - %taddr158 = alloca %"char[]", align 8 - %retparam161 = alloca i64, align 8 - %varargslots162 = alloca [2 x %"any*"], align 16 + %retparam158 = alloca i64, align 8 + %varargslots161 = alloca [2 x %"any*"], align 16 + %taddr162 = alloca %"char[]", align 8 %taddr163 = alloca %"char[]", align 8 - %taddr164 = alloca %"char[]", align 8 - %retparam167 = alloca i64, align 8 - %varargslots168 = alloca [2 x %"any*"], align 16 + %retparam164 = alloca i64, align 8 + %varargslots167 = alloca [2 x %"any*"], align 16 + %taddr168 = alloca %"char[]", align 8 %taddr169 = alloca %"char[]", align 8 - %taddr170 = alloca %"char[]", align 8 - %retparam173 = alloca i64, align 8 - %varargslots174 = alloca [2 x %"any*"], align 16 + %retparam170 = alloca i64, align 8 + %varargslots173 = alloca [2 x %"any*"], align 16 + %taddr174 = alloca %"char[]", align 8 %taddr175 = alloca %"char[]", align 8 - %taddr176 = alloca %"char[]", align 8 - %retparam179 = alloca i64, align 8 - %varargslots180 = alloca [1 x %"any*"], align 16 - %taddr181 = alloca %"char[]", align 8 - %retparam184 = alloca i64, align 8 - %varargslots185 = alloca [2 x %"any*"], align 16 + %retparam176 = alloca i64, align 8 + %varargslots179 = alloca [1 x %"any*"], align 16 + %taddr180 = alloca %"char[]", align 8 + %retparam181 = alloca i64, align 8 + %varargslots184 = alloca [2 x %"any*"], align 16 + %taddr185 = alloca %"char[]", align 8 %taddr186 = alloca %"char[]", align 8 - %taddr187 = alloca %"char[]", align 8 - %retparam190 = alloca i64, align 8 - %varargslots191 = alloca [2 x %"any*"], align 16 + %retparam187 = alloca i64, align 8 + %varargslots190 = alloca [2 x %"any*"], align 16 + %taddr191 = alloca %"char[]", align 8 %taddr192 = alloca %"char[]", align 8 - %taddr193 = alloca %"char[]", align 8 - %retparam196 = alloca i64, align 8 - %varargslots197 = alloca [2 x %"any*"], align 16 + %retparam193 = alloca i64, align 8 + %varargslots196 = alloca [2 x %"any*"], align 16 + %taddr197 = alloca %"char[]", align 8 %taddr198 = alloca %"char[]", align 8 - %taddr199 = alloca %"char[]", align 8 - %retparam202 = alloca i64, align 8 - %varargslots203 = alloca [2 x %"any*"], align 16 + %retparam199 = alloca i64, align 8 + %varargslots202 = alloca [2 x %"any*"], align 16 + %taddr203 = alloca %"char[]", align 8 %taddr204 = alloca %"char[]", align 8 - %taddr205 = alloca %"char[]", align 8 - %retparam208 = alloca i64, align 8 - %varargslots209 = alloca [1 x %"any*"], align 16 - %taddr210 = alloca %"char[]", align 8 - %retparam213 = alloca i64, align 8 - %varargslots214 = alloca [2 x %"any*"], align 16 + %retparam205 = alloca i64, align 8 + %varargslots208 = alloca [1 x %"any*"], align 16 + %taddr209 = alloca %"char[]", align 8 + %retparam210 = alloca i64, align 8 + %varargslots213 = alloca [2 x %"any*"], align 16 + %taddr214 = alloca %"char[]", align 8 %taddr215 = alloca %"char[]", align 8 - %taddr216 = alloca %"char[]", align 8 - %retparam219 = alloca i64, align 8 - %varargslots220 = alloca [2 x %"any*"], align 16 + %retparam216 = alloca i64, align 8 + %varargslots219 = alloca [2 x %"any*"], align 16 + %taddr220 = alloca %"char[]", align 8 %taddr221 = alloca %"char[]", align 8 - %taddr222 = alloca %"char[]", align 8 + %retparam222 = alloca i64, align 8 %1 = call ptr @std.io.stdout() %2 = call i64 @std.io.File.write(ptr %retparam, ptr %1, ptr @.str, i64 3) %not_err = icmp eq i64 %2, 0 %3 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) br i1 %3, label %after_check, label %assign_optional + assign_optional: ; preds = %entry store i64 %2, ptr %error_var, align 8 br label %guard_block + after_check: ; preds = %entry br label %noerr_block + guard_block: ; preds = %assign_optional br label %voiderr + noerr_block: ; preds = %after_check %4 = load i64, ptr %retparam, align 8 store i64 %4, ptr %len, align 8 @@ -219,42 +223,55 @@ noerr_block: ; preds = %after_check %not_err3 = icmp eq i64 %5, 0 %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true) br i1 %6, label %after_check5, label %assign_optional4 + assign_optional4: ; preds = %noerr_block store i64 %5, ptr %error_var2, align 8 br label %guard_block6 + after_check5: ; preds = %noerr_block br label %noerr_block7 + guard_block6: ; preds = %assign_optional4 br label %voiderr + noerr_block7: ; preds = %after_check5 %7 = call i64 @std.io.File.flush(ptr %1) %not_err9 = icmp eq i64 %7, 0 %8 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true) br i1 %8, label %after_check11, label %assign_optional10 + assign_optional10: ; preds = %noerr_block7 store i64 %7, ptr %error_var8, align 8 br label %guard_block12 + after_check11: ; preds = %noerr_block7 br label %noerr_block13 + guard_block12: ; preds = %assign_optional10 br label %voiderr + noerr_block13: ; preds = %after_check11 %9 = load i64, ptr %len, align 8 %add = add i64 %9, 1 br label %voiderr + voiderr: ; preds = %noerr_block13, %guard_block12, %guard_block6, %guard_block %10 = call ptr @std.io.stdout() %11 = call i64 @std.io.File.write(ptr %retparam17, ptr %10, ptr @.str.10, i64 3) %not_err18 = icmp eq i64 %11, 0 %12 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true) br i1 %12, label %after_check20, label %assign_optional19 + assign_optional19: ; preds = %voiderr store i64 %11, ptr %error_var15, align 8 br label %guard_block21 + after_check20: ; preds = %voiderr br label %noerr_block22 + guard_block21: ; preds = %assign_optional19 br label %voiderr36 + noerr_block22: ; preds = %after_check20 %13 = load i64, ptr %retparam17, align 8 store i64 %13, ptr %len14, align 8 @@ -262,42 +279,55 @@ noerr_block22: ; preds = %after_check20 %not_err24 = icmp eq i64 %14, 0 %15 = call i1 @llvm.expect.i1(i1 %not_err24, i1 true) br i1 %15, label %after_check26, label %assign_optional25 + assign_optional25: ; preds = %noerr_block22 store i64 %14, ptr %error_var23, align 8 br label %guard_block27 + after_check26: ; preds = %noerr_block22 br label %noerr_block28 + guard_block27: ; preds = %assign_optional25 br label %voiderr36 + noerr_block28: ; preds = %after_check26 %16 = call i64 @std.io.File.flush(ptr %10) %not_err30 = icmp eq i64 %16, 0 %17 = call i1 @llvm.expect.i1(i1 %not_err30, i1 true) br i1 %17, label %after_check32, label %assign_optional31 + assign_optional31: ; preds = %noerr_block28 store i64 %16, ptr %error_var29, align 8 br label %guard_block33 + after_check32: ; preds = %noerr_block28 br label %noerr_block34 + guard_block33: ; preds = %assign_optional31 br label %voiderr36 + noerr_block34: ; preds = %after_check32 %18 = load i64, ptr %len14, align 8 %add35 = add i64 %18, 1 br label %voiderr36 + voiderr36: ; preds = %noerr_block34, %guard_block33, %guard_block27, %guard_block21 %19 = call ptr @std.io.stdout() %20 = call i64 @std.io.File.write(ptr %retparam40, ptr %19, ptr @.str.11, i64 6) %not_err41 = icmp eq i64 %20, 0 %21 = call i1 @llvm.expect.i1(i1 %not_err41, i1 true) br i1 %21, label %after_check43, label %assign_optional42 + assign_optional42: ; preds = %voiderr36 store i64 %20, ptr %error_var38, align 8 br label %guard_block44 + after_check43: ; preds = %voiderr36 br label %noerr_block45 + guard_block44: ; preds = %assign_optional42 br label %voiderr59 + noerr_block45: ; preds = %after_check43 %22 = load i64, ptr %retparam40, align 8 store i64 %22, ptr %len37, align 8 @@ -305,42 +335,55 @@ noerr_block45: ; preds = %after_check43 %not_err47 = icmp eq i64 %23, 0 %24 = call i1 @llvm.expect.i1(i1 %not_err47, i1 true) br i1 %24, label %after_check49, label %assign_optional48 + assign_optional48: ; preds = %noerr_block45 store i64 %23, ptr %error_var46, align 8 br label %guard_block50 + after_check49: ; preds = %noerr_block45 br label %noerr_block51 + guard_block50: ; preds = %assign_optional48 br label %voiderr59 + noerr_block51: ; preds = %after_check49 %25 = call i64 @std.io.File.flush(ptr %19) %not_err53 = icmp eq i64 %25, 0 %26 = call i1 @llvm.expect.i1(i1 %not_err53, i1 true) br i1 %26, label %after_check55, label %assign_optional54 + assign_optional54: ; preds = %noerr_block51 store i64 %25, ptr %error_var52, align 8 br label %guard_block56 + after_check55: ; preds = %noerr_block51 br label %noerr_block57 + guard_block56: ; preds = %assign_optional54 br label %voiderr59 + noerr_block57: ; preds = %after_check55 %27 = load i64, ptr %len37, align 8 %add58 = add i64 %27, 1 br label %voiderr59 + voiderr59: ; preds = %noerr_block57, %guard_block56, %guard_block50, %guard_block44 %28 = call ptr @std.io.stdout() %29 = call i64 @std.io.File.write(ptr %retparam63, ptr %28, ptr @.str.12, i64 6) %not_err64 = icmp eq i64 %29, 0 %30 = call i1 @llvm.expect.i1(i1 %not_err64, i1 true) br i1 %30, label %after_check66, label %assign_optional65 + assign_optional65: ; preds = %voiderr59 store i64 %29, ptr %error_var61, align 8 br label %guard_block67 + after_check66: ; preds = %voiderr59 br label %noerr_block68 + guard_block67: ; preds = %assign_optional65 br label %voiderr82 + noerr_block68: ; preds = %after_check66 %31 = load i64, ptr %retparam63, align 8 store i64 %31, ptr %len60, align 8 @@ -348,42 +391,55 @@ noerr_block68: ; preds = %after_check66 %not_err70 = icmp eq i64 %32, 0 %33 = call i1 @llvm.expect.i1(i1 %not_err70, i1 true) br i1 %33, label %after_check72, label %assign_optional71 + assign_optional71: ; preds = %noerr_block68 store i64 %32, ptr %error_var69, align 8 br label %guard_block73 + after_check72: ; preds = %noerr_block68 br label %noerr_block74 + guard_block73: ; preds = %assign_optional71 br label %voiderr82 + noerr_block74: ; preds = %after_check72 %34 = call i64 @std.io.File.flush(ptr %28) %not_err76 = icmp eq i64 %34, 0 %35 = call i1 @llvm.expect.i1(i1 %not_err76, i1 true) br i1 %35, label %after_check78, label %assign_optional77 + assign_optional77: ; preds = %noerr_block74 store i64 %34, ptr %error_var75, align 8 br label %guard_block79 + after_check78: ; preds = %noerr_block74 br label %noerr_block80 + guard_block79: ; preds = %assign_optional77 br label %voiderr82 + noerr_block80: ; preds = %after_check78 %36 = load i64, ptr %len60, align 8 %add81 = add i64 %36, 1 br label %voiderr82 + voiderr82: ; preds = %noerr_block80, %guard_block79, %guard_block73, %guard_block67 %37 = call ptr @std.io.stdout() - %38 = call i64 @std.io.File.write(ptr %retparam86, ptr %37, ptr @.str.13 + %38 = call i64 @std.io.File.write(ptr %retparam86, ptr %37, ptr @.str.13, i64 6) %not_err87 = icmp eq i64 %38, 0 %39 = call i1 @llvm.expect.i1(i1 %not_err87, i1 true) br i1 %39, label %after_check89, label %assign_optional88 + assign_optional88: ; preds = %voiderr82 store i64 %38, ptr %error_var84, align 8 br label %guard_block90 + after_check89: ; preds = %voiderr82 br label %noerr_block91 + guard_block90: ; preds = %assign_optional88 br label %voiderr105 + noerr_block91: ; preds = %after_check89 %40 = load i64, ptr %retparam86, align 8 store i64 %40, ptr %len83, align 8 @@ -391,42 +447,55 @@ noerr_block91: ; preds = %after_check89 %not_err93 = icmp eq i64 %41, 0 %42 = call i1 @llvm.expect.i1(i1 %not_err93, i1 true) br i1 %42, label %after_check95, label %assign_optional94 + assign_optional94: ; preds = %noerr_block91 store i64 %41, ptr %error_var92, align 8 br label %guard_block96 + after_check95: ; preds = %noerr_block91 br label %noerr_block97 + guard_block96: ; preds = %assign_optional94 br label %voiderr105 + noerr_block97: ; preds = %after_check95 %43 = call i64 @std.io.File.flush(ptr %37) %not_err99 = icmp eq i64 %43, 0 %44 = call i1 @llvm.expect.i1(i1 %not_err99, i1 true) br i1 %44, label %after_check101, label %assign_optional100 + assign_optional100: ; preds = %noerr_block97 store i64 %43, ptr %error_var98, align 8 br label %guard_block102 + after_check101: ; preds = %noerr_block97 br label %noerr_block103 + guard_block102: ; preds = %assign_optional100 br label %voiderr105 + noerr_block103: ; preds = %after_check101 %45 = load i64, ptr %len83, align 8 %add104 = add i64 %45, 1 br label %voiderr105 + voiderr105: ; preds = %noerr_block103, %guard_block102, %guard_block96, %guard_block90 %46 = call ptr @std.io.stdout() %47 = call i64 @std.io.File.write(ptr %retparam109, ptr %46, ptr @.str.14, i64 4) %not_err110 = icmp eq i64 %47, 0 %48 = call i1 @llvm.expect.i1(i1 %not_err110, i1 true) br i1 %48, label %after_check112, label %assign_optional111 + assign_optional111: ; preds = %voiderr105 store i64 %47, ptr %error_var107, align 8 br label %guard_block113 + after_check112: ; preds = %voiderr105 br label %noerr_block114 + guard_block113: ; preds = %assign_optional111 br label %voiderr128 + noerr_block114: ; preds = %after_check112 %49 = load i64, ptr %retparam109, align 8 store i64 %49, ptr %len106, align 8 @@ -434,42 +503,55 @@ noerr_block114: ; preds = %after_check112 %not_err116 = icmp eq i64 %50, 0 %51 = call i1 @llvm.expect.i1(i1 %not_err116, i1 true) br i1 %51, label %after_check118, label %assign_optional117 + assign_optional117: ; preds = %noerr_block114 store i64 %50, ptr %error_var115, align 8 br label %guard_block119 + after_check118: ; preds = %noerr_block114 br label %noerr_block120 + guard_block119: ; preds = %assign_optional117 br label %voiderr128 + noerr_block120: ; preds = %after_check118 %52 = call i64 @std.io.File.flush(ptr %46) %not_err122 = icmp eq i64 %52, 0 %53 = call i1 @llvm.expect.i1(i1 %not_err122, i1 true) br i1 %53, label %after_check124, label %assign_optional123 + assign_optional123: ; preds = %noerr_block120 store i64 %52, ptr %error_var121, align 8 br label %guard_block125 + after_check124: ; preds = %noerr_block120 br label %noerr_block126 + guard_block125: ; preds = %assign_optional123 br label %voiderr128 + noerr_block126: ; preds = %after_check124 %54 = load i64, ptr %len106, align 8 %add127 = add i64 %54, 1 br label %voiderr128 + voiderr128: ; preds = %noerr_block126, %guard_block125, %guard_block119, %guard_block113 %55 = call ptr @std.io.stdout() %56 = call i64 @std.io.File.write(ptr %retparam132, ptr %55, ptr @.str.15, i64 3) %not_err133 = icmp eq i64 %56, 0 %57 = call i1 @llvm.expect.i1(i1 %not_err133, i1 true) br i1 %57, label %after_check135, label %assign_optional134 + assign_optional134: ; preds = %voiderr128 store i64 %56, ptr %error_var130, align 8 br label %guard_block136 + after_check135: ; preds = %voiderr128 br label %noerr_block137 + guard_block136: ; preds = %assign_optional134 br label %voiderr151 + noerr_block137: ; preds = %after_check135 %58 = load i64, ptr %retparam132, align 8 store i64 %58, ptr %len129, align 8 @@ -477,29 +559,38 @@ noerr_block137: ; preds = %after_check135 %not_err139 = icmp eq i64 %59, 0 %60 = call i1 @llvm.expect.i1(i1 %not_err139, i1 true) br i1 %60, label %after_check141, label %assign_optional140 + assign_optional140: ; preds = %noerr_block137 store i64 %59, ptr %error_var138, align 8 br label %guard_block142 + after_check141: ; preds = %noerr_block137 br label %noerr_block143 + guard_block142: ; preds = %assign_optional140 br label %voiderr151 + noerr_block143: ; preds = %after_check141 %61 = call i64 @std.io.File.flush(ptr %55) %not_err145 = icmp eq i64 %61, 0 %62 = call i1 @llvm.expect.i1(i1 %not_err145, i1 true) br i1 %62, label %after_check147, label %assign_optional146 + assign_optional146: ; preds = %noerr_block143 store i64 %61, ptr %error_var144, align 8 br label %guard_block148 + after_check147: ; preds = %noerr_block143 br label %noerr_block149 + guard_block148: ; preds = %assign_optional146 br label %voiderr151 + noerr_block149: ; preds = %after_check147 %63 = load i64, ptr %len129, align 8 %add150 = add i64 %63, 1 br label %voiderr151 + voiderr151: ; preds = %noerr_block149, %guard_block148, %guard_block142, %guard_block136 store %"char[]" { ptr @.str.17, i64 3 }, ptr %taddr, align 8 %64 = insertvalue %"any*" undef, ptr %taddr, 0 @@ -507,280 +598,281 @@ voiderr151: ; preds = %noerr_block149, %gu %66 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %65, ptr %66, align 16 %67 = call i64 @std.io.printfn(ptr %retparam152, ptr @.str.16, i64 8, ptr %varargslots, i64 1) - store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr157, align 8 - %68 = insertvalue %"any*" undef, ptr %taddr157, 0 + store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr156, align 8 + %68 = insertvalue %"any*" undef, ptr %taddr156, 0 %69 = insertvalue %"any*" %68, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %70 = getelementptr inbounds [2 x %"any*"], ptr %varargslots156, i64 0, i64 0 + %70 = getelementptr inbounds [2 x %"any*"], ptr %varargslots155, i64 0, i64 0 store %"any*" %69, ptr %70, align 16 - store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr158, align 8 - %71 = insertvalue %"any*" undef, ptr %taddr158, 0 + store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr157, align 8 + %71 = insertvalue %"any*" undef, ptr %taddr157, 0 %72 = insertvalue %"any*" %71, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %73 = getelementptr inbounds [2 x %"any*"], ptr %varargslots156, i64 0, i64 1 + %73 = getelementptr inbounds [2 x %"any*"], ptr %varargslots155, i64 0, i64 1 store %"any*" %72, ptr %73, align 16 - %74 = call i64 @std.io.printfn(ptr %retparam155, ptr @.str.18, i64 6, ptr %varargslots156, i64 2) - store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr163, align 8 - %75 = insertvalue %"any*" undef, ptr %taddr163, 0 + %74 = call i64 @std.io.printfn(ptr %retparam158, ptr @.str.18, i64 6, ptr %varargslots155, i64 2) + store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr162, align 8 + %75 = insertvalue %"any*" undef, ptr %taddr162, 0 %76 = insertvalue %"any*" %75, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %77 = getelementptr inbounds [2 x %"any*"], ptr %varargslots162, i64 0, i64 0 + %77 = getelementptr inbounds [2 x %"any*"], ptr %varargslots161, i64 0, i64 0 store %"any*" %76, ptr %77, align 16 - store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr164, align 8 - %78 = insertvalue %"any*" undef, ptr %taddr164, 0 + store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr163, align 8 + %78 = insertvalue %"any*" undef, ptr %taddr163, 0 %79 = insertvalue %"any*" %78, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %80 = getelementptr inbounds [2 x %"any*"], ptr %varargslots162, i64 0, i64 1 + %80 = getelementptr inbounds [2 x %"any*"], ptr %varargslots161, i64 0, i64 1 store %"any*" %79, ptr %80, align 16 - %81 = call i64 @std.io.printfn(ptr %retparam161, ptr @.str.21, i64 6, ptr %varargslots162, i64 2) - store %"char[]" zeroinitializer, ptr %taddr169, align 8 - %82 = insertvalue %"any*" undef, ptr %taddr169, 0 + %81 = call i64 @std.io.printfn(ptr %retparam164, ptr @.str.21, i64 6, ptr %varargslots161, i64 2) + store %"char[]" zeroinitializer, ptr %taddr168, align 8 + %82 = insertvalue %"any*" undef, ptr %taddr168, 0 %83 = insertvalue %"any*" %82, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %84 = getelementptr inbounds [2 x %"any*"], ptr %varargslots168, i64 0, i64 0 + %84 = getelementptr inbounds [2 x %"any*"], ptr %varargslots167, i64 0, i64 0 store %"any*" %83, ptr %84, align 16 - store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr170, align 8 - %85 = insertvalue %"any*" undef, ptr %taddr170, 0 + store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr169, align 8 + %85 = insertvalue %"any*" undef, ptr %taddr169, 0 %86 = insertvalue %"any*" %85, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %87 = getelementptr inbounds [2 x %"any*"], ptr %varargslots168, i64 0, i64 1 + %87 = getelementptr inbounds [2 x %"any*"], ptr %varargslots167, i64 0, i64 1 store %"any*" %86, ptr %87, align 16 - %88 = call i64 @std.io.printfn(ptr %retparam167, ptr @.str.24, i64 6, ptr %varargslots168, i64 2) - store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr175, align 8 - %89 = insertvalue %"any*" undef, ptr %taddr175, 0 + %88 = call i64 @std.io.printfn(ptr %retparam170, ptr @.str.24, i64 6, ptr %varargslots167, i64 2) + store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr174, align 8 + %89 = insertvalue %"any*" undef, ptr %taddr174, 0 %90 = insertvalue %"any*" %89, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %91 = getelementptr inbounds [2 x %"any*"], ptr %varargslots174, i64 0, i64 0 + %91 = getelementptr inbounds [2 x %"any*"], ptr %varargslots173, i64 0, i64 0 store %"any*" %90, ptr %91, align 16 - store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr176, align 8 - %92 = insertvalue %"any*" undef, ptr %taddr176, 0 + store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr175, align 8 + %92 = insertvalue %"any*" undef, ptr %taddr175, 0 %93 = insertvalue %"any*" %92, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %94 = getelementptr inbounds [2 x %"any*"], ptr %varargslots174, i64 0, i64 1 + %94 = getelementptr inbounds [2 x %"any*"], ptr %varargslots173, i64 0, i64 1 store %"any*" %93, ptr %94, align 16 - %95 = call i64 @std.io.printfn(ptr %retparam173, ptr @.str.26, i64 6, ptr %varargslots174, i64 2) - store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr181, align 8 - %96 = insertvalue %"any*" undef, ptr %taddr181, 0 + %95 = call i64 @std.io.printfn(ptr %retparam176, ptr @.str.26, i64 6, ptr %varargslots173, i64 2) + store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr180, align 8 + %96 = insertvalue %"any*" undef, ptr %taddr180, 0 %97 = insertvalue %"any*" %96, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %98 = getelementptr inbounds [1 x %"any*"], ptr %varargslots180, i64 0, i64 0 + %98 = getelementptr inbounds [1 x %"any*"], ptr %varargslots179, i64 0, i64 0 store %"any*" %97, ptr %98, align 16 - %99 = call i64 @std.io.printfn(ptr %retparam179, ptr @.str.29, i64 8, ptr %varargslots180, i64 1) - store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr186, align 8 - %100 = insertvalue %"any*" undef, ptr %taddr186, 0 + %99 = call i64 @std.io.printfn(ptr %retparam181, ptr @.str.29, i64 8, ptr %varargslots179, i64 1) + store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr185, align 8 + %100 = insertvalue %"any*" undef, ptr %taddr185, 0 %101 = insertvalue %"any*" %100, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %102 = getelementptr inbounds [2 x %"any*"], ptr %varargslots185, i64 0, i64 0 + %102 = getelementptr inbounds [2 x %"any*"], ptr %varargslots184, i64 0, i64 0 store %"any*" %101, ptr %102, align 16 - store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr187, align 8 - %103 = insertvalue %"any*" undef, ptr %taddr187, 0 + store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr186, align 8 + %103 = insertvalue %"any*" undef, ptr %taddr186, 0 %104 = insertvalue %"any*" %103, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %105 = getelementptr inbounds [2 x %"any*"], ptr %varargslots185, i64 0, i64 1 + %105 = getelementptr inbounds [2 x %"any*"], ptr %varargslots184, i64 0, i64 1 store %"any*" %104, ptr %105, align 16 - %106 = call i64 @std.io.printfn(ptr %retparam184, ptr @.str.31, i64 6, ptr %varargslots185, i64 2) - store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr192, align 8 - %107 = insertvalue %"any*" undef, ptr %taddr192, 0 + %106 = call i64 @std.io.printfn(ptr %retparam187, ptr @.str.31, i64 6, ptr %varargslots184, i64 2) + store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr191, align 8 + %107 = insertvalue %"any*" undef, ptr %taddr191, 0 %108 = insertvalue %"any*" %107, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %109 = getelementptr inbounds [2 x %"any*"], ptr %varargslots191, i64 0, i64 0 + %109 = getelementptr inbounds [2 x %"any*"], ptr %varargslots190, i64 0, i64 0 store %"any*" %108, ptr %109, align 16 - store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr193, align 8 - %110 = insertvalue %"any*" undef, ptr %taddr193, 0 + store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr192, align 8 + %110 = insertvalue %"any*" undef, ptr %taddr192, 0 %111 = insertvalue %"any*" %110, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %112 = getelementptr inbounds [2 x %"any*"], ptr %varargslots191, i64 0, i64 1 + %112 = getelementptr inbounds [2 x %"any*"], ptr %varargslots190, i64 0, i64 1 store %"any*" %111, ptr %112, align 16 - %113 = call i64 @std.io.printfn(ptr %retparam190, ptr @.str.34, i64 6, ptr %varargslots191, i64 2) - store %"char[]" zeroinitializer, ptr %taddr198, align 8 - %114 = insertvalue %"any*" undef, ptr %taddr198, 0 + %113 = call i64 @std.io.printfn(ptr %retparam193, ptr @.str.34, i64 6, ptr %varargslots190, i64 2) + store %"char[]" zeroinitializer, ptr %taddr197, align 8 + %114 = insertvalue %"any*" undef, ptr %taddr197, 0 %115 = insertvalue %"any*" %114, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %116 = getelementptr inbounds [2 x %"any*"], ptr %varargslots197, i64 0, i64 0 + %116 = getelementptr inbounds [2 x %"any*"], ptr %varargslots196, i64 0, i64 0 store %"any*" %115, ptr %116, align 16 - store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr199, align 8 - %117 = insertvalue %"any*" undef, ptr %taddr199, 0 + store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr198, align 8 + %117 = insertvalue %"any*" undef, ptr %taddr198, 0 %118 = insertvalue %"any*" %117, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %119 = getelementptr inbounds [2 x %"any*"], ptr %varargslots197, i64 0, i64 1 + %119 = getelementptr inbounds [2 x %"any*"], ptr %varargslots196, i64 0, i64 1 store %"any*" %118, ptr %119, align 16 - %120 = call i64 @std.io.printfn(ptr %retparam196, ptr @.str.37, i64 6, ptr %varargslots197, i64 2) - store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr204, align 8 - %121 = insertvalue %"any*" undef, ptr %taddr204, 0 + %120 = call i64 @std.io.printfn(ptr %retparam199, ptr @.str.37, i64 6, ptr %varargslots196, i64 2) + store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr203, align 8 + %121 = insertvalue %"any*" undef, ptr %taddr203, 0 %122 = insertvalue %"any*" %121, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %123 = getelementptr inbounds [2 x %"any*"], ptr %varargslots203, i64 0, i64 0 + %123 = getelementptr inbounds [2 x %"any*"], ptr %varargslots202, i64 0, i64 0 store %"any*" %122, ptr %123, align 16 - store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr205, align 8 - %124 = insertvalue %"any*" undef, ptr %taddr205, 0 + store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr204, align 8 + %124 = insertvalue %"any*" undef, ptr %taddr204, 0 %125 = insertvalue %"any*" %124, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %126 = getelementptr inbounds [2 x %"any*"], ptr %varargslots203, i64 0, i64 1 + %126 = getelementptr inbounds [2 x %"any*"], ptr %varargslots202, i64 0, i64 1 store %"any*" %125, ptr %126, align 16 - %127 = call i64 @std.io.printfn(ptr %retparam202, ptr @.str.39, i64 6, ptr %varargslots203, i64 2) - store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr210, align 8 - %128 = insertvalue %"any*" undef, ptr %taddr210, 0 + %127 = call i64 @std.io.printfn(ptr %retparam205, ptr @.str.39, i64 6, ptr %varargslots202, i64 2) + store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr209, align 8 + %128 = insertvalue %"any*" undef, ptr %taddr209, 0 %129 = insertvalue %"any*" %128, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %130 = getelementptr inbounds [1 x %"any*"], ptr %varargslots209, i64 0, i64 0 + %130 = getelementptr inbounds [1 x %"any*"], ptr %varargslots208, i64 0, i64 0 store %"any*" %129, ptr %130, align 16 - %131 = call i64 @std.io.printfn(ptr %retparam208, ptr @.str.42, i64 8, ptr %varargslots209, i64 1) - store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr215, align 8 - %132 = insertvalue %"any*" undef, ptr %taddr215, 0 + %131 = call i64 @std.io.printfn(ptr %retparam210, ptr @.str.42, i64 8, ptr %varargslots208, i64 1) + store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr214, align 8 + %132 = insertvalue %"any*" undef, ptr %taddr214, 0 %133 = insertvalue %"any*" %132, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %134 = getelementptr inbounds [2 x %"any*"], ptr %varargslots214, i64 0, i64 0 + %134 = getelementptr inbounds [2 x %"any*"], ptr %varargslots213, i64 0, i64 0 store %"any*" %133, ptr %134, align 16 - store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr216, align 8 - %135 = insertvalue %"any*" undef, ptr %taddr216, 0 + store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr215, align 8 + %135 = insertvalue %"any*" undef, ptr %taddr215, 0 %136 = insertvalue %"any*" %135, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %137 = getelementptr inbounds [2 x %"any*"], ptr %varargslots214, i64 0, i64 1 + %137 = getelementptr inbounds [2 x %"any*"], ptr %varargslots213, i64 0, i64 1 store %"any*" %136, ptr %137, align 16 - %138 = call i64 @std.io.printfn(ptr %retparam213, ptr @.str.44, i64 6, ptr %varargslots214, i64 2) - store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr221, align 8 - %139 = insertvalue %"any*" undef, ptr %taddr221, 0 + %138 = call i64 @std.io.printfn(ptr %retparam216, ptr @.str.44, i64 6, ptr %varargslots213, i64 2) + store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr220, align 8 + %139 = insertvalue %"any*" undef, ptr %taddr220, 0 %140 = insertvalue %"any*" %139, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %141 = getelementptr inbounds [2 x %"any*"], ptr %varargslots220, i64 0, i64 0 + %141 = getelementptr inbounds [2 x %"any*"], ptr %varargslots219, i64 0, i64 0 store %"any*" %140, ptr %141, align 16 - store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr222, align 8 - %142 = insertvalue %"any*" undef, ptr %taddr222, 0 + store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr221, align 8 + %142 = insertvalue %"any*" undef, ptr %taddr221, 0 %143 = insertvalue %"any*" %142, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %144 = getelementptr inbounds [2 x %"any*"], ptr %varargslots220, i64 0, i64 1 + %144 = getelementptr inbounds [2 x %"any*"], ptr %varargslots219, i64 0, i64 1 store %"any*" %143, ptr %144, align 16 - %145 = call i64 @std.io.printfn(ptr %retparam219, ptr @.str.47, i64 6, ptr %varargslots220, i64 2) + %145 = call i64 @std.io.printfn(ptr %retparam222, ptr @.str.47, i64 6, ptr %varargslots219, i64 2) ret void } + ; Function Attrs: nounwind define void @test.main() #0 { entry: - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i64, align 8 - %retparam1 = alloca i64, align 8 - %varargslots2 = alloca [1 x %"any*"], align 16 - %taddr3 = alloca i64, align 8 - %retparam4 = alloca i64, align 8 - %varargslots5 = alloca [2 x %"any*"], align 16 + %retparam = alloca i64, align 8 + %varargslots1 = alloca [1 x %"any*"], align 16 + %taddr2 = alloca i64, align 8 + %retparam3 = alloca i64, align 8 + %varargslots4 = alloca [2 x %"any*"], align 16 + %taddr5 = alloca i64, align 8 %taddr6 = alloca i64, align 8 - %taddr7 = alloca i64, align 8 - %retparam8 = alloca i64, align 8 - %varargslots9 = alloca [2 x %"any*"], align 16 + %retparam7 = alloca i64, align 8 + %varargslots8 = alloca [2 x %"any*"], align 16 + %taddr9 = alloca i64, align 8 %taddr10 = alloca i64, align 8 - %taddr11 = alloca i64, align 8 - %retparam12 = alloca i64, align 8 - %varargslots13 = alloca [2 x %"any*"], align 16 + %retparam11 = alloca i64, align 8 + %varargslots12 = alloca [2 x %"any*"], align 16 + %taddr13 = alloca i64, align 8 %taddr14 = alloca i64, align 8 - %taddr15 = alloca i64, align 8 - %retparam16 = alloca i64, align 8 - %varargslots17 = alloca [2 x %"any*"], align 16 + %retparam15 = alloca i64, align 8 + %varargslots16 = alloca [2 x %"any*"], align 16 + %taddr17 = alloca i64, align 8 %taddr18 = alloca i64, align 8 - %taddr19 = alloca i64, align 8 - %retparam20 = alloca i64, align 8 - %varargslots21 = alloca [2 x %"any*"], align 16 + %retparam19 = alloca i64, align 8 + %varargslots20 = alloca [2 x %"any*"], align 16 + %taddr21 = alloca i64, align 8 %taddr22 = alloca i64, align 8 - %taddr23 = alloca i64, align 8 - %retparam24 = alloca i64, align 8 - %varargslots25 = alloca [2 x %"any*"], align 16 + %retparam23 = alloca i64, align 8 + %varargslots24 = alloca [2 x %"any*"], align 16 + %taddr25 = alloca i64, align 8 %taddr26 = alloca i64, align 8 - %taddr27 = alloca i64, align 8 - %retparam28 = alloca i64, align 8 - %varargslots29 = alloca [2 x %"any*"], align 16 + %retparam27 = alloca i64, align 8 + %varargslots28 = alloca [2 x %"any*"], align 16 + %taddr29 = alloca i64, align 8 %taddr30 = alloca i64, align 8 - %taddr31 = alloca i64, align 8 - %retparam32 = alloca i64, align 8 - %varargslots33 = alloca [1 x %"any*"], align 16 - %taddr34 = alloca i64, align 8 - %retparam35 = alloca i64, align 8 - %varargslots36 = alloca [2 x %"any*"], align 16 + %retparam31 = alloca i64, align 8 + %varargslots32 = alloca [1 x %"any*"], align 16 + %taddr33 = alloca i64, align 8 + %retparam34 = alloca i64, align 8 + %varargslots35 = alloca [2 x %"any*"], align 16 + %taddr36 = alloca i64, align 8 %taddr37 = alloca i64, align 8 - %taddr38 = alloca i64, align 8 + %retparam38 = alloca i64, align 8 store i64 4, ptr %taddr, align 8 %0 = insertvalue %"any*" undef, ptr %taddr, 0 %1 = insertvalue %"any*" %0, i64 ptrtoint (ptr @"$ct.long" to i64), 1 %2 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %1, ptr %2, align 16 %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.50, i64 7, ptr %varargslots, i64 1) - store i64 1, ptr %taddr3, align 8 - %4 = insertvalue %"any*" undef, ptr %taddr3, 0 + store i64 1, ptr %taddr2, align 8 + %4 = insertvalue %"any*" undef, ptr %taddr2, 0 %5 = insertvalue %"any*" %4, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %6 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0 + %6 = getelementptr inbounds [1 x %"any*"], ptr %varargslots1, i64 0, i64 0 store %"any*" %5, ptr %6, align 16 - %7 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.51, i64 7, ptr %varargslots2, i64 1) - store i64 0, ptr %taddr6, align 8 - %8 = insertvalue %"any*" undef, ptr %taddr6, 0 + %7 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.51, i64 7, ptr %varargslots1, i64 1) + store i64 0, ptr %taddr5, align 8 + %8 = insertvalue %"any*" undef, ptr %taddr5, 0 %9 = insertvalue %"any*" %8, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %10 = getelementptr inbounds [2 x %"any*"], ptr %varargslots5, i64 0, i64 0 + %10 = getelementptr inbounds [2 x %"any*"], ptr %varargslots4, i64 0, i64 0 store %"any*" %9, ptr %10, align 16 - store i64 4, ptr %taddr7, align 8 - %11 = insertvalue %"any*" undef, ptr %taddr7, 0 + store i64 4, ptr %taddr6, align 8 + %11 = insertvalue %"any*" undef, ptr %taddr6, 0 %12 = insertvalue %"any*" %11, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %13 = getelementptr inbounds [2 x %"any*"], ptr %varargslots5, i64 0, i64 1 + %13 = getelementptr inbounds [2 x %"any*"], ptr %varargslots4, i64 0, i64 1 store %"any*" %12, ptr %13, align 16 - %14 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.52, i64 8, ptr %varargslots5, i64 2) - store i64 2, ptr %taddr10, align 8 - %15 = insertvalue %"any*" undef, ptr %taddr10, 0 + %14 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.52, i64 8, ptr %varargslots4, i64 2) + store i64 2, ptr %taddr9, align 8 + %15 = insertvalue %"any*" undef, ptr %taddr9, 0 %16 = insertvalue %"any*" %15, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %17 = getelementptr inbounds [2 x %"any*"], ptr %varargslots9, i64 0, i64 0 + %17 = getelementptr inbounds [2 x %"any*"], ptr %varargslots8, i64 0, i64 0 store %"any*" %16, ptr %17, align 16 - store i64 2, ptr %taddr11, align 8 - %18 = insertvalue %"any*" undef, ptr %taddr11, 0 + store i64 2, ptr %taddr10, align 8 + %18 = insertvalue %"any*" undef, ptr %taddr10, 0 %19 = insertvalue %"any*" %18, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %20 = getelementptr inbounds [2 x %"any*"], ptr %varargslots9, i64 0, i64 1 + %20 = getelementptr inbounds [2 x %"any*"], ptr %varargslots8, i64 0, i64 1 store %"any*" %19, ptr %20, align 16 - %21 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.53, i64 8, ptr %varargslots9, i64 2) - store i64 4, ptr %taddr14, align 8 - %22 = insertvalue %"any*" undef, ptr %taddr14, 0 + %21 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.53, i64 8, ptr %varargslots8, i64 2) + store i64 4, ptr %taddr13, align 8 + %22 = insertvalue %"any*" undef, ptr %taddr13, 0 %23 = insertvalue %"any*" %22, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %24 = getelementptr inbounds [2 x %"any*"], ptr %varargslots13, i64 0, i64 0 + %24 = getelementptr inbounds [2 x %"any*"], ptr %varargslots12, i64 0, i64 0 store %"any*" %23, ptr %24, align 16 - store i64 4, ptr %taddr15, align 8 - %25 = insertvalue %"any*" undef, ptr %taddr15, 0 + store i64 4, ptr %taddr14, align 8 + %25 = insertvalue %"any*" undef, ptr %taddr14, 0 %26 = insertvalue %"any*" %25, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %27 = getelementptr inbounds [2 x %"any*"], ptr %varargslots13, i64 0, i64 1 + %27 = getelementptr inbounds [2 x %"any*"], ptr %varargslots12, i64 0, i64 1 store %"any*" %26, ptr %27, align 16 - %28 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.54, i64 8, ptr %varargslots13, i64 2) - store i64 4, ptr %taddr18, align 8 - %29 = insertvalue %"any*" undef, ptr %taddr18, 0 + %28 = call i64 @std.io.printfn(ptr %retparam15, ptr @.str.54, i64 8, ptr %varargslots12, i64 2) + store i64 4, ptr %taddr17, align 8 + %29 = insertvalue %"any*" undef, ptr %taddr17, 0 %30 = insertvalue %"any*" %29, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %31 = getelementptr inbounds [2 x %"any*"], ptr %varargslots17, i64 0, i64 0 + %31 = getelementptr inbounds [2 x %"any*"], ptr %varargslots16, i64 0, i64 0 store %"any*" %30, ptr %31, align 16 - store i64 4, ptr %taddr19, align 8 - %32 = insertvalue %"any*" undef, ptr %taddr19, 0 + store i64 4, ptr %taddr18, align 8 + %32 = insertvalue %"any*" undef, ptr %taddr18, 0 %33 = insertvalue %"any*" %32, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots17, i64 0, i64 1 + %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots16, i64 0, i64 1 store %"any*" %33, ptr %34, align 16 - %35 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.55, i64 8, ptr %varargslots17, i64 2) - store i64 4, ptr %taddr22, align 8 - %36 = insertvalue %"any*" undef, ptr %taddr22, 0 + %35 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.55, i64 8, ptr %varargslots16, i64 2) + store i64 4, ptr %taddr21, align 8 + %36 = insertvalue %"any*" undef, ptr %taddr21, 0 %37 = insertvalue %"any*" %36, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %38 = getelementptr inbounds [2 x %"any*"], ptr %varargslots21, i64 0, i64 0 + %38 = getelementptr inbounds [2 x %"any*"], ptr %varargslots20, i64 0, i64 0 store %"any*" %37, ptr %38, align 16 - store i64 4, ptr %taddr23, align 8 - %39 = insertvalue %"any*" undef, ptr %taddr23, 0 + store i64 4, ptr %taddr22, align 8 + %39 = insertvalue %"any*" undef, ptr %taddr22, 0 %40 = insertvalue %"any*" %39, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %41 = getelementptr inbounds [2 x %"any*"], ptr %varargslots21, i64 0, i64 1 + %41 = getelementptr inbounds [2 x %"any*"], ptr %varargslots20, i64 0, i64 1 store %"any*" %40, ptr %41, align 16 - %42 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.56, i64 9, ptr %varargslots21, i64 2) - store i64 5, ptr %taddr26, align 8 - %43 = insertvalue %"any*" undef, ptr %taddr26, 0 + %42 = call i64 @std.io.printfn(ptr %retparam23, ptr @.str.56, i64 9, ptr %varargslots20, i64 2) + store i64 5, ptr %taddr25, align 8 + %43 = insertvalue %"any*" undef, ptr %taddr25, 0 %44 = insertvalue %"any*" %43, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %45 = getelementptr inbounds [2 x %"any*"], ptr %varargslots25, i64 0, i64 0 + %45 = getelementptr inbounds [2 x %"any*"], ptr %varargslots24, i64 0, i64 0 store %"any*" %44, ptr %45, align 16 - store i64 1, ptr %taddr27, align 8 - %46 = insertvalue %"any*" undef, ptr %taddr27, 0 + store i64 1, ptr %taddr26, align 8 + %46 = insertvalue %"any*" undef, ptr %taddr26, 0 %47 = insertvalue %"any*" %46, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %48 = getelementptr inbounds [2 x %"any*"], ptr %varargslots25, i64 0, i64 1 + %48 = getelementptr inbounds [2 x %"any*"], ptr %varargslots24, i64 0, i64 1 store %"any*" %47, ptr %48, align 16 - %49 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.57, i64 9, ptr %varargslots25, i64 2) - store i64 8, ptr %taddr30, align 8 - %50 = insertvalue %"any*" undef, ptr %taddr30, 0 + %49 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.57, i64 9, ptr %varargslots24, i64 2) + store i64 8, ptr %taddr29, align 8 + %50 = insertvalue %"any*" undef, ptr %taddr29, 0 %51 = insertvalue %"any*" %50, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %52 = getelementptr inbounds [2 x %"any*"], ptr %varargslots29, i64 0, i64 0 + %52 = getelementptr inbounds [2 x %"any*"], ptr %varargslots28, i64 0, i64 0 store %"any*" %51, ptr %52, align 16 - store i64 4, ptr %taddr31, align 8 - %53 = insertvalue %"any*" undef, ptr %taddr31, 0 + store i64 4, ptr %taddr30, align 8 + %53 = insertvalue %"any*" undef, ptr %taddr30, 0 %54 = insertvalue %"any*" %53, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %55 = getelementptr inbounds [2 x %"any*"], ptr %varargslots29, i64 0, i64 1 + %55 = getelementptr inbounds [2 x %"any*"], ptr %varargslots28, i64 0, i64 1 store %"any*" %54, ptr %55, align 16 - %56 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.58, i64 10, ptr %varargslots29, i64 2) - store i64 4, ptr %taddr34, align 8 - %57 = insertvalue %"any*" undef, ptr %taddr34, 0 + %56 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.58, i64 10, ptr %varargslots28, i64 2) + store i64 4, ptr %taddr33, align 8 + %57 = insertvalue %"any*" undef, ptr %taddr33, 0 %58 = insertvalue %"any*" %57, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %59 = getelementptr inbounds [1 x %"any*"], ptr %varargslots33, i64 0, i64 0 + %59 = getelementptr inbounds [1 x %"any*"], ptr %varargslots32, i64 0, i64 0 store %"any*" %58, ptr %59, align 16 - %60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.59, i64 7, ptr %varargslots33, i64 1) - store i64 8, ptr %taddr37, align 8 - %61 = insertvalue %"any*" undef, ptr %taddr37, 0 + %60 = call i64 @std.io.printfn(ptr %retparam34, ptr @.str.59, i64 7, ptr %varargslots32, i64 1) + store i64 8, ptr %taddr36, align 8 + %61 = insertvalue %"any*" undef, ptr %taddr36, 0 %62 = insertvalue %"any*" %61, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %63 = getelementptr inbounds [2 x %"any*"], ptr %varargslots36, i64 0, i64 0 + %63 = getelementptr inbounds [2 x %"any*"], ptr %varargslots35, i64 0, i64 0 store %"any*" %62, ptr %63, align 16 - store i64 4, ptr %taddr38, align 8 - %64 = insertvalue %"any*" undef, ptr %taddr38, 0 + store i64 4, ptr %taddr37, align 8 + %64 = insertvalue %"any*" undef, ptr %taddr37, 0 %65 = insertvalue %"any*" %64, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %66 = getelementptr inbounds [2 x %"any*"], ptr %varargslots36, i64 0, i64 1 + %66 = getelementptr inbounds [2 x %"any*"], ptr %varargslots35, i64 0, i64 1 store %"any*" %65, ptr %66, align 16 - %67 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.60, i64 10, ptr %varargslots36, i64 2) + %67 = call i64 @std.io.printfn(ptr %retparam38, ptr @.str.60, i64 10, ptr %varargslots35, i64 2) call void @test.test(i32 10) ret void } \ No newline at end of file diff --git a/test/test_suite/compile_time/typeof_example.c3t b/test/test_suite/compile_time/typeof_example.c3t index 18fc0e602..83a555113 100644 --- a/test/test_suite/compile_time/typeof_example.c3t +++ b/test/test_suite/compile_time/typeof_example.c3t @@ -45,8 +45,8 @@ fn void main() store float %7, ptr %f2, align 4 %8 = load float, ptr %f, align 4 %fpfpext = fpext float %8 to double - %9 = load i32, ptr %i, align 4 - %10 = load float, ptr %f2, align 4 - %fpfpext4 = fpext float %10 to double - call void (ptr, ...) @printf(ptr @.str, double %fpfpext, i32 %9, double %fpfpext4) + %9 = load float, ptr %f2, align 4 + %fpfpext4 = fpext float %9 to double + %10 = load i32, ptr %i, align 4 + call void (ptr, ...) @printf(ptr @.str, double %fpfpext, i32 %10, double %fpfpext4) ret void \ No newline at end of file diff --git a/test/test_suite/compile_time/untyped_conversions.c3t b/test/test_suite/compile_time/untyped_conversions.c3t index a9d52cad2..afd8bdd39 100644 --- a/test/test_suite/compile_time/untyped_conversions.c3t +++ b/test/test_suite/compile_time/untyped_conversions.c3t @@ -28,7 +28,6 @@ fn void main() %Foo = type { i32, i32 } %"int[]" = type { ptr, i64 } %"any*" = type { ptr, i64 } - @"$ct.test.Foo" = linkonce global %.introspect { i8 10, i64 0, ptr null, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 @.str = private unnamed_addr constant [9 x i8] c"%s %s %s\00", align 1 @"$ct.a2$int" = linkonce global %.introspect { i8 15, i64 0, ptr null, i64 8, i64 ptrtoint (ptr @"$ct.int" to i64), i64 2, [0 x i64] zeroinitializer }, align 8 @@ -48,15 +47,14 @@ fn void main() @.__const.6 = private unnamed_addr constant [2 x i32] [i32 3, i32 4], align 4 @.__const.7 = private unnamed_addr constant [2 x i32] [i32 2, i32 7], align 4 @.__const.8 = private unnamed_addr constant [2 x i32] [i32 2, i32 7], align 4 - ; Function Attrs: nounwind define void @test.test(i64 %0, ptr %1, i64 %2, double %3) #0 { entry: %a = alloca [2 x i32], align 4 %b = alloca %"int[]", align 8 %c = alloca <2 x i32>, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [3 x %"any*"], align 16 + %retparam = alloca i64, align 8 store i64 %0, ptr %a, align 4 store ptr %1, ptr %b, align 8 %ptroffset = getelementptr inbounds i64, ptr %b, i64 1 @@ -77,7 +75,6 @@ entry: %13 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3) ret void } - ; Function Attrs: nounwind define void @test.main() #0 { entry: @@ -85,8 +82,8 @@ entry: %defg = alloca %Foo, align 4 %y = alloca [1 x [2 x i32]], align 4 %y2 = alloca [1 x [2 x double]], align 16 - %retparam = alloca i64, align 8 %varargslots = alloca [4 x %"any*"], align 16 + %retparam = alloca i64, align 8 %literal = alloca [2 x i32], align 4 %literal1 = alloca [2 x i32], align 4 %taddr = alloca <2 x i32>, align 8 @@ -117,20 +114,20 @@ entry: store %"any*" %12, ptr %13, align 16 %14 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.4, i64 14, ptr %varargslots, i64 4) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal, ptr align 4 @.__const.5, i32 8, i1 false) - %15 = load i64, ptr %literal, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal1, ptr align 4 @.__const.6, i32 8, i1 false) - %16 = insertvalue %"int[]" undef, ptr %literal1, 0 - %17 = insertvalue %"int[]" %16, i64 2, 1 + %15 = insertvalue %"int[]" undef, ptr %literal1, 0 + %16 = insertvalue %"int[]" %15, i64 2, 1 + %17 = load i64, ptr %literal, align 4 store <2 x i32> , ptr %taddr, align 8 %18 = load double, ptr %taddr, align 8 - call void @test.test(i64 %15, ptr %literal1, i64 2, double %18) + call void @test.test(i64 %17, ptr %literal1, i64 2, double %18) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal2, ptr align 4 @.__const.7, i32 8, i1 false) - %19 = load i64, ptr %literal2, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal3, ptr align 4 @.__const.8, i32 8, i1 false) - %20 = insertvalue %"int[]" undef, ptr %literal3, 0 - %21 = insertvalue %"int[]" %20, i64 2, 1 + %19 = insertvalue %"int[]" undef, ptr %literal3, 0 + %20 = insertvalue %"int[]" %19, i64 2, 1 + %21 = load i64, ptr %literal2, align 4 store <2 x i32> , ptr %taddr4, align 8 %22 = load double, ptr %taddr4, align 8 - call void @test.test(i64 %19, ptr %literal3, i64 2, double %22) + call void @test.test(i64 %21, ptr %literal3, i64 2, double %22) ret void } diff --git a/test/test_suite/concurrency/atomic_load_store.c3t b/test/test_suite/concurrency/atomic_load_store.c3t index bdda5ab96..25a11c826 100644 --- a/test/test_suite/concurrency/atomic_load_store.c3t +++ b/test/test_suite/concurrency/atomic_load_store.c3t @@ -25,8 +25,8 @@ entry: %a = alloca i32, align 4 %x = alloca i32, align 4 %y = alloca i32, align 4 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 store i32 111, ptr %a, align 4 %0 = load atomic i32, ptr %a seq_cst, align 4 store i32 %0, ptr %x, align 4 diff --git a/test/test_suite/concurrency/atomic_load_store_debug.c3t b/test/test_suite/concurrency/atomic_load_store_debug.c3t index 081f59368..2d84859e4 100644 --- a/test/test_suite/concurrency/atomic_load_store_debug.c3t +++ b/test/test_suite/concurrency/atomic_load_store_debug.c3t @@ -31,8 +31,8 @@ entry: %a = alloca i32, align 4 %x = alloca i32, align 4 %y = alloca i32, align 4 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 call void @llvm.dbg.declare(metadata ptr %a, metadata !9, metadata !DIExpression()), !dbg !11 store i32 111, ptr %a, align 4, !dbg !12 call void @llvm.dbg.declare(metadata ptr %x, metadata !13, metadata !DIExpression()), !dbg !14 diff --git a/test/test_suite/dynamic/dynamic_with_default.c3t b/test/test_suite/dynamic/dynamic_with_default.c3t new file mode 100644 index 000000000..8dd89c985 --- /dev/null +++ b/test/test_suite/dynamic/dynamic_with_default.c3t @@ -0,0 +1,106 @@ +// #target: macos-x64 +module test; + +protocol Abc +{ + fn int[<2>] test() @optional; + fn int bye(); +} + +fn int[<2>] Abc.test(&self) @default +{ + return { 5, 7 }; +} + +struct Hello (Abc) +{ + int y; +} + +fn int[<2>] Hello.test(&self) @dynamic { return { 5, 10 }; } +fn int Hello.bye(&self) @dynamic { return 7; } +fn void main() +{ + Hello z = { 32 }; + Abc* x = &z; + int[<2>] z2 = x.test(); + int w = x.bye(); +} +/* #expect: test.ll + +define double @test.Abc.test(i64 %0, ptr %1) #0 { +define double @test.Hello.test(ptr %0) #0 { +define i32 @test.Hello.bye(ptr %0) #0 { + +define void @test.main() #0 { +entry: + %2 = getelementptr inbounds %"any*", ptr %x, i32 0, i32 1 + %3 = load i64, ptr %2, align 8 + %4 = getelementptr inbounds %"any*", ptr %x, i32 0, i32 0 + %5 = inttoptr i64 %3 to ptr + %type = load ptr, ptr %.cachedtype, align 8 + %6 = icmp eq ptr %5, %type + br i1 %6, label %cache_hit, label %cache_miss +cache_miss: ; preds = %entry + %7 = getelementptr inbounds %.introspect, ptr %5, i32 0, i32 2 + %8 = load ptr, ptr %7, align 8 + %9 = call ptr @.dyn_search(ptr %8, ptr @"$sel.test") + store ptr %9, ptr %.inlinecache, align 8 + store ptr %5, ptr %.cachedtype, align 8 + br label %10 +cache_hit: ; preds = %entry + %cache_hit_fn = load ptr, ptr %.inlinecache, align 8 + br label %10 +10: ; preds = %cache_hit, %cache_miss + %fn_phi = phi ptr [ %cache_hit_fn, %cache_hit ], [ %9, %cache_miss ] + %11 = icmp eq ptr %fn_phi, null + br i1 %11, label %missing_function, label %match +missing_function: ; preds = %10 + %12 = getelementptr inbounds { i64, ptr }, ptr %x, i32 0, i32 0 + %lo = load i64, ptr %12, align 8 + %13 = getelementptr inbounds { i64, ptr }, ptr %x, i32 0, i32 1 + %hi = load ptr, ptr %13, align 8 + %14 = call double @test.Abc.test(i64 %lo, ptr %hi) + store double %14, ptr %result, align 8 + %15 = load <2 x i32>, ptr %result, align 8 + br label %after_call +match: ; preds = %10 + %16 = load ptr, ptr %4, align 8 + %17 = call double %fn_phi(ptr %16) + store double %17, ptr %result1, align 8 + %18 = load <2 x i32>, ptr %result1, align 8 + br label %after_call +after_call: ; preds = %match, %missing_function + %result2 = phi <2 x i32> [ %15, %missing_function ], [ %18, %match ] + store <2 x i32> %result2, ptr %z2, align 8 + %19 = getelementptr inbounds %"any*", ptr %x, i32 0, i32 1 + %20 = load i64, ptr %19, align 8 + %21 = getelementptr inbounds %"any*", ptr %x, i32 0, i32 0 + %22 = inttoptr i64 %20 to ptr + %type5 = load ptr, ptr %.cachedtype4, align 8 + %23 = icmp eq ptr %22, %type5 + br i1 %23, label %cache_hit7, label %cache_miss6 +cache_miss6: ; preds = %after_call + %24 = getelementptr inbounds %.introspect, ptr %22, i32 0, i32 2 + %25 = load ptr, ptr %24, align 8 + %26 = call ptr @.dyn_search(ptr %25, ptr @"$sel.bye") + store ptr %26, ptr %.inlinecache3, align 8 + store ptr %22, ptr %.cachedtype4, align 8 + br label %27 +cache_hit7: ; preds = %after_call + %cache_hit_fn8 = load ptr, ptr %.inlinecache3, align 8 + br label %27 +27: ; preds = %cache_hit7, %cache_miss6 + %fn_phi9 = phi ptr [ %cache_hit_fn8, %cache_hit7 ], [ %26, %cache_miss6 ] + %28 = icmp eq ptr %fn_phi9, null + br i1 %28, label %missing_function10, label %match11 +missing_function10: ; preds = %27 + %29 = load ptr, ptr @std.core.builtin.panic, align 8 + call void %29(ptr @.panic_msg, i64 40, ptr @.file, i64 23, ptr @.func, i64 4, i32 26) + unreachable +match11: ; preds = %27 + %30 = load ptr, ptr %21, align 8 + %31 = call i32 %fn_phi9(ptr %30) + store i32 %31, ptr %w, align 4 + ret void +} \ No newline at end of file diff --git a/test/test_suite/dynamic/inherit.c3t b/test/test_suite/dynamic/inherit.c3t index dea7b70c8..fabf28608 100644 --- a/test/test_suite/dynamic/inherit.c3t +++ b/test/test_suite/dynamic/inherit.c3t @@ -101,8 +101,8 @@ panic_block: ; preds = %assign_optional %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %11, ptr %12, align 16 %13 = insertvalue %"any*[]" undef, ptr %varargslots, 0 - %"#temp#" = insertvalue %"any*[]" %13, i64 1, 1 - store %"any*[]" %"#temp#", ptr %indirectarg, align 8 + %"$$temp" = insertvalue %"any*[]" %13, 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 4, i32 392, ptr byval(%"any*[]") align 8 %indirectarg) unreachable diff --git a/test/test_suite/dynamic/overlapping_function.c3t b/test/test_suite/dynamic/overlapping_function.c3t index f2eabc300..22c0f8d22 100644 --- a/test/test_suite/dynamic/overlapping_function.c3t +++ b/test/test_suite/dynamic/overlapping_function.c3t @@ -95,8 +95,8 @@ panic_block: ; preds = %assign_optional %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %11, ptr %12, align 16 %13 = insertvalue %"any*[]" undef, ptr %varargslots, 0 - %"#temp#" = insertvalue %"any*[]" %13, i64 1, 1 - store %"any*[]" %"#temp#", ptr %indirectarg, align 8 + %"$$temp" = insertvalue %"any*[]" %13, 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 4, i32 392, ptr byval(%"any*[]") align 8 %indirectarg) unreachable diff --git a/test/test_suite/enumerations/enum_associated_value.c3t b/test/test_suite/enumerations/enum_associated_value.c3t index 393edd5da..e01de3187 100644 --- a/test/test_suite/enumerations/enum_associated_value.c3t +++ b/test/test_suite/enumerations/enum_associated_value.c3t @@ -41,19 +41,19 @@ entry: %0 = load i32, ptr %f, align 4 %zext = zext i32 %0 to i64 %1 = getelementptr inbounds [2 x i32], ptr @"test.Foo$val", i64 0, i64 %zext - %2 = load i32, ptr %1, align 4 - %3 = load i32, ptr %f, align 4 - %zext1 = zext i32 %3 to i64 - %4 = getelementptr inbounds [2 x ptr], ptr @"test.Foo$testme", i64 0, i64 %zext1 - %5 = load ptr, ptr %4, align 8 + %2 = load i32, ptr %f, align 4 + %zext1 = zext i32 %2 to i64 + %3 = getelementptr inbounds [2 x ptr], ptr @"test.Foo$testme", i64 0, i64 %zext1 + %4 = load i32, ptr %g, align 4 + %zext2 = zext i32 %4 to i64 + %5 = getelementptr inbounds [2 x i32], ptr @"test.Foo$val", i64 0, i64 %zext2 %6 = load i32, ptr %g, align 4 - %zext2 = zext i32 %6 to i64 - %7 = getelementptr inbounds [2 x i32], ptr @"test.Foo$val", i64 0, i64 %zext2 - %8 = load i32, ptr %7, align 4 - %9 = load i32, ptr %g, align 4 - %zext3 = zext i32 %9 to i64 - %10 = getelementptr inbounds [2 x ptr], ptr @"test.Foo$testme", i64 0, i64 %zext3 - %11 = load ptr, ptr %10, align 8 - %12 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %2, ptr %5, i32 %8, ptr %11) + %zext3 = zext i32 %6 to i64 + %7 = getelementptr inbounds [2 x ptr], ptr @"test.Foo$testme", i64 0, i64 %zext3 + %8 = load i32, ptr %1, align 4 + %9 = load ptr, ptr %3, align 8 + %10 = load i32, ptr %5, align 4 + %11 = load ptr, ptr %7, align 8 + %12 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %8, ptr %9, i32 %10, ptr %11) ret void } diff --git a/test/test_suite/enumerations/enum_associated_values_other.c3t b/test/test_suite/enumerations/enum_associated_values_other.c3t index 32643bf66..6f092410c 100644 --- a/test/test_suite/enumerations/enum_associated_values_other.c3t +++ b/test/test_suite/enumerations/enum_associated_values_other.c3t @@ -60,8 +60,8 @@ entry: %x = alloca ptr, align 8 %a = alloca i32, align 4 %z = alloca %"char[]", align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 store ptr %0, ptr %args, align 8 %ptroffset = getelementptr inbounds i64, ptr %args, i64 1 store i64 %1, ptr %ptroffset, align 8 diff --git a/test/test_suite/enumerations/enum_conversions.c3t b/test/test_suite/enumerations/enum_conversions.c3t index 4454a118f..2362fd074 100644 --- a/test/test_suite/enumerations/enum_conversions.c3t +++ b/test/test_suite/enumerations/enum_conversions.c3t @@ -35,8 +35,8 @@ 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 - %"#temp#" = insertvalue %"any*[]" %4, i64 1, 1 - store %"any*[]" %"#temp#", 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 @@ -51,8 +51,8 @@ panic1: ; preds = %checkok %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 + %"$$temp4" = insertvalue %"any*[]" %8, i64 1, 1 + store %"any*[]" %"$$temp4", 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 @@ -71,8 +71,8 @@ panic8: ; preds = %checkok6 %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 + %"$$temp11" = insertvalue %"any*[]" %13, i64 1, 1 + store %"any*[]" %"$$temp11", 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 @@ -87,8 +87,8 @@ panic15: ; preds = %checkok13 %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 + %"$$temp18" = insertvalue %"any*[]" %17, i64 1, 1 + store %"any*[]" %"$$temp18", 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 @@ -107,8 +107,8 @@ panic23: ; preds = %checkok20 %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 + %"$$temp26" = insertvalue %"any*[]" %22, i64 1, 1 + store %"any*[]" %"$$temp26", 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 @@ -123,8 +123,8 @@ panic30: ; preds = %checkok28 %25 = getelementptr inbounds [1 x %"any*"], ptr %varargslots32, i64 0, i64 0 store %"any*" %24, ptr %25, align 16 %26 = insertvalue %"any*[]" undef, ptr %varargslots32, 0 - %"#temp#33" = insertvalue %"any*[]" %26, i64 1, 1 - store %"any*[]" %"#temp#33", ptr %indirectarg34, align 8 + %"$$temp33" = insertvalue %"any*[]" %26, i64 1, 1 + store %"any*[]" %"$$temp33", 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 @@ -143,8 +143,8 @@ panic38: ; preds = %checkok35 %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 + %"$$temp41" = insertvalue %"any*[]" %31, i64 1, 1 + store %"any*[]" %"$$temp41", 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 @@ -159,8 +159,8 @@ panic45: ; preds = %checkok43 %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 + %"$$temp48" = insertvalue %"any*[]" %35, i64 1, 1 + store %"any*[]" %"$$temp48", 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 diff --git a/test/test_suite/enumerations/enum_reflect_associated.c3t b/test/test_suite/enumerations/enum_reflect_associated.c3t index 7ce7e4ce9..d65f89ce7 100644 --- a/test/test_suite/enumerations/enum_reflect_associated.c3t +++ b/test/test_suite/enumerations/enum_reflect_associated.c3t @@ -22,32 +22,32 @@ fn int main() define i32 @main() #0 { entry: - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca %"char[]", align 8 - %retparam1 = alloca i64, align 8 - %varargslots2 = alloca [1 x %"any*"], align 16 - %taddr3 = alloca %"char[]", align 8 - %retparam4 = alloca i64, align 8 - %varargslots5 = alloca [1 x %"any*"], align 16 - %taddr6 = alloca %"char[]", align 8 + %retparam = alloca i64, align 8 + %varargslots1 = alloca [1 x %"any*"], align 16 + %taddr2 = alloca %"char[]", align 8 + %retparam3 = alloca i64, align 8 + %varargslots4 = alloca [1 x %"any*"], align 16 + %taddr5 = alloca %"char[]", align 8 + %retparam6 = alloca i64, align 8 store %"char[]" { ptr @.str.2, i64 3 }, ptr %taddr, align 8 %0 = insertvalue %"any*" undef, ptr %taddr, 0 %1 = insertvalue %"any*" %0, i64 ptrtoint (ptr @"$ct.String" to i64), 1 %2 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %1, ptr %2, align 16 %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.1, i64 2, ptr %varargslots, i64 1) - store %"char[]" { ptr @.str.4, i64 6 }, ptr %taddr3, align 8 - %4 = insertvalue %"any*" undef, ptr %taddr3, 0 + store %"char[]" { ptr @.str.4, i64 6 }, ptr %taddr2, align 8 + %4 = insertvalue %"any*" undef, ptr %taddr2, 0 %5 = insertvalue %"any*" %4, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %6 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0 + %6 = getelementptr inbounds [1 x %"any*"], ptr %varargslots1, i64 0, i64 0 store %"any*" %5, ptr %6, align 16 - %7 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.3, i64 2, ptr %varargslots2, i64 1) - store %"char[]" { ptr @.str.6, i64 6 }, ptr %taddr6, align 8 - %8 = insertvalue %"any*" undef, ptr %taddr6, 0 + %7 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.3, i64 2, ptr %varargslots1, i64 1) + store %"char[]" { ptr @.str.6, i64 6 }, ptr %taddr5, align 8 + %8 = insertvalue %"any*" undef, ptr %taddr5, 0 %9 = insertvalue %"any*" %8, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %10 = getelementptr inbounds [1 x %"any*"], ptr %varargslots5, i64 0, i64 0 + %10 = getelementptr inbounds [1 x %"any*"], ptr %varargslots4, i64 0, i64 0 store %"any*" %9, ptr %10, align 16 - %11 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.5, i64 2, ptr %varargslots5, i64 1) + %11 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.5, i64 2, ptr %varargslots4, i64 1) ret i32 0 } diff --git a/test/test_suite/errors/error_introspect.c3t b/test/test_suite/errors/error_introspect.c3t index 0ea0c8bab..80112fcaa 100644 --- a/test/test_suite/errors/error_introspect.c3t +++ b/test/test_suite/errors/error_introspect.c3t @@ -38,14 +38,14 @@ fn void main() entry: %x = alloca %"char[][]", align 8 %literal = alloca [2 x %"char[]"], align 16 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 - %retparam1 = alloca i64, align 8 - %varargslots2 = alloca [1 x %"any*"], align 16 - %literal3 = alloca [2 x i64], align 16 - %retparam4 = alloca i64, align 8 - %varargslots5 = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 + %varargslots1 = alloca [1 x %"any*"], align 16 + %literal2 = alloca [2 x i64], align 16 + %retparam3 = alloca i64, align 8 + %varargslots4 = alloca [1 x %"any*"], align 16 %taddr = alloca i64, align 8 + %retparam5 = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 16 @.__const, i32 32, i1 false) %0 = insertvalue %"char[][]" undef, ptr %literal, 0 %1 = insertvalue %"char[][]" %0, i64 2, 1 @@ -55,17 +55,17 @@ entry: %4 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %3, ptr %4, align 16 %5 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.3, i64 13, ptr %varargslots, i64 1) - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal3, ptr align 16 @.__const.5, i32 16, i1 false) - %6 = insertvalue %"any*" undef, ptr %literal3, 0 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal2, ptr align 16 @.__const.5, i32 16, i1 false) + %6 = insertvalue %"any*" undef, ptr %literal2, 0 %7 = insertvalue %"any*" %6, i64 ptrtoint (ptr @"$ct.a2$foo.Foo" to i64), 1 - %8 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0 + %8 = getelementptr inbounds [1 x %"any*"], ptr %varargslots1, i64 0, i64 0 store %"any*" %7, ptr %8, align 16 - %9 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.4, i64 14, ptr %varargslots2, i64 1) + %9 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.4, i64 14, ptr %varargslots1, i64 1) store i64 2, ptr %taddr, align 8 %10 = insertvalue %"any*" undef, ptr %taddr, 0 %11 = insertvalue %"any*" %10, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots5, i64 0, i64 0 + %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots4, i64 0, i64 0 store %"any*" %11, ptr %12, align 16 - %13 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.6, i64 16, ptr %varargslots5, i64 1) + %13 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.6, i64 16, ptr %varargslots4, i64 1) ret void } diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t index f920cda9a..cfaac48eb 100644 --- a/test/test_suite/errors/error_regression_2.c3t +++ b/test/test_suite/errors/error_regression_2.c3t @@ -174,12 +174,12 @@ cond.phi: ; preds = %cond.rhs, %cond.lhs %8 = load i64, ptr %7, align 8 %trunc = trunc i64 %8 to i32 %9 = getelementptr inbounds %"char[]", ptr %title, i32 0, i32 0 - %10 = load ptr, ptr %9, align 8 - %11 = getelementptr inbounds %Summary, ptr %0, i32 0, i32 1 - %12 = load i8, ptr %11, align 8 - %13 = trunc i8 %12 to i1 - %ternary = select i1 %13, ptr @.str.30, ptr @.str.31 - %14 = call i32 (ptr, ptr, ...) @fprintf(ptr %1, ptr @.str.29, i32 %trunc, ptr %10, ptr %ternary) + %10 = getelementptr inbounds %Summary, ptr %0, i32 0, i32 1 + %11 = load i8, ptr %10, align 8 + %12 = trunc i8 %11 to i1 + %ternary = select i1 %12, ptr @.str.30, ptr @.str.31 + %13 = load ptr, ptr %9, align 8 + %14 = call i32 (ptr, ptr, ...) @fprintf(ptr %1, ptr @.str.29, i32 %trunc, ptr %13, ptr %ternary) ret void } @@ -403,9 +403,9 @@ panic_block: ; preds = %assign_optional %28 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %27, ptr %28, align 16 %29 = insertvalue %"any*[]" undef, ptr %varargslots, 0 - %"#temp#" = insertvalue %"any*[]" %29, 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 + %"$$temp" = insertvalue %"any*[]" %29, 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 392, ptr byval(%"any*[]") align 8 %indirectarg) unreachable noerr_block: ; preds = %after_check @@ -476,9 +476,9 @@ panic_block39: ; preds = %assign_optional37 %52 = getelementptr inbounds [1 x %"any*"], ptr %varargslots40, i64 0, i64 0 store %"any*" %51, ptr %52, align 16 %53 = insertvalue %"any*[]" undef, ptr %varargslots40, 0 - %"#temp#41" = insertvalue %"any*[]" %53, 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 + %"$$temp41" = insertvalue %"any*[]" %53, i64 1, 1 + store %"any*[]" %"$$temp41", ptr %indirectarg42, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 392, ptr byval(%"any*[]") align 8 %indirectarg42) unreachable noerr_block43: ; preds = %after_check38 @@ -533,9 +533,9 @@ panic_block61: ; preds = %assign_optional59 %70 = getelementptr inbounds [1 x %"any*"], ptr %varargslots62, i64 0, i64 0 store %"any*" %69, ptr %70, align 16 %71 = insertvalue %"any*[]" undef, ptr %varargslots62, 0 - %"#temp#63" = insertvalue %"any*[]" %71, 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 + %"$$temp63" = insertvalue %"any*[]" %71, i64 1, 1 + store %"any*[]" %"$$temp63", ptr %indirectarg64, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 392, ptr byval(%"any*[]") align 8 %indirectarg64) unreachable noerr_block65: ; preds = %after_check60 @@ -604,9 +604,9 @@ panic_block81: ; preds = %assign_optional79 %94 = getelementptr inbounds [1 x %"any*"], ptr %varargslots82, i64 0, i64 0 store %"any*" %93, ptr %94, align 16 %95 = insertvalue %"any*[]" undef, ptr %varargslots82, 0 - %"#temp#83" = insertvalue %"any*[]" %95, 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 + %"$$temp83" = insertvalue %"any*[]" %95, i64 1, 1 + store %"any*[]" %"$$temp83", ptr %indirectarg84, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 392, ptr byval(%"any*[]") align 8 %indirectarg84) unreachable noerr_block85: ; preds = %after_check80 @@ -619,15 +619,15 @@ if.then87: ; preds = %noerr_block85 ret i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64) if.exit88: ; preds = %noerr_block85 - %97 = load ptr, ptr %str, align 8 - %98 = load i64, ptr %len, align 8 - %add89 = add i64 %98, 1 - %99 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 - %100 = load i64, ptr %99, align 8 - %trunc90 = trunc i64 %100 to i32 - %101 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 - %102 = load ptr, ptr %101, align 8 - %103 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %97, i64 %add89, ptr @.str.8, i32 %trunc90, ptr %102) + %97 = load i64, ptr %len, align 8 + %add89 = add i64 %97, 1 + %98 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %99 = load i64, ptr %98, align 8 + %trunc90 = trunc i64 %99 to i32 + %100 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %101 = load ptr, ptr %str, align 8 + %102 = load ptr, ptr %100, align 8 + %103 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %101, i64 %add89, ptr @.str.8, i32 %trunc90, ptr %102) %104 = getelementptr inbounds %Doc, ptr %literal92, i32 0, i32 0 store ptr null, ptr %literal94, align 8 %105 = getelementptr inbounds %Head, ptr %literal94, i32 0, i32 0 @@ -669,9 +669,9 @@ panic_block109: ; preds = %assign_optional107 %123 = getelementptr inbounds [1 x %"any*"], ptr %varargslots110, i64 0, i64 0 store %"any*" %122, ptr %123, align 16 %124 = insertvalue %"any*[]" undef, ptr %varargslots110, 0 - %"#temp#111" = insertvalue %"any*[]" %124, i64 1, 1 - store %"any*[]" %"#temp#111", ptr %indirectarg112, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func + %"$$temp111" = insertvalue %"any*[]" %124, i64 1, 1 + store %"any*[]" %"$$temp111", ptr %indirectarg112, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 392, ptr byval(%"any*[]") align 8 %indirectarg112) unreachable noerr_block113: ; preds = %after_check108 @@ -726,9 +726,9 @@ panic_block131: ; preds = %assign_optional129 %141 = getelementptr inbounds [1 x %"any*"], ptr %varargslots132, i64 0, i64 0 store %"any*" %140, ptr %141, align 16 %142 = insertvalue %"any*[]" undef, ptr %varargslots132, 0 - %"#temp#133" = insertvalue %"any*[]" %142, i64 1, 1 - store %"any*[]" %"#temp#133", ptr %indirectarg134, align 8 - call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7 + %"$$temp133" = insertvalue %"any*[]" %142, i64 1, 1 + store %"any*[]" %"$$temp133", ptr %indirectarg134, align 8 + call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 7, i32 392, ptr byval(%"any*[]") align 8 %indirectarg134) unreachable noerr_block135: ; preds = %after_check130 @@ -874,8 +874,8 @@ define i64 @test.readWhetherTitleNonEmpty(ptr %0, ptr %1, i64 %2) #0 { entry: %url = alloca %"char[]", align 8 %reterr = alloca i64, align 8 - %retparam = alloca i8, align 1 - %retparam1 = alloca %Doc, align 8 + %retparam = alloca %Doc, align 8 + %retparam1 = alloca i8, align 1 store ptr %1, ptr %url, align 8 %ptroffset = getelementptr inbounds i64, ptr %url, i64 1 store i64 %2, ptr %ptroffset, align 8 @@ -883,7 +883,7 @@ entry: %lo = load ptr, ptr %3, align 8 %4 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 %hi = load i64, ptr %4, align 8 - %5 = call i64 @test.readDoc(ptr %retparam1, ptr %lo, i64 %hi) + %5 = call i64 @test.readDoc(ptr %retparam, ptr %lo, i64 %hi) %not_err = icmp eq i64 %5, 0 %6 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) br i1 %6, label %after_check, label %assign_optional @@ -893,8 +893,8 @@ assign_optional: ; preds = %entry br label %err_retblock after_check: ; preds = %entry - %7 = load ptr, ptr %retparam1, align 8 - %8 = call i64 @test.isTitleNonEmpty(ptr %retparam, ptr %7) + %7 = load ptr, ptr %retparam, align 8 + %8 = call i64 @test.isTitleNonEmpty(ptr %retparam1, ptr %7) %not_err2 = icmp eq i64 %8, 0 %9 = call i1 @llvm.expect.i1(i1 %not_err2, i1 true) br i1 %9, label %after_check4, label %assign_optional3 @@ -904,7 +904,7 @@ assign_optional3: ; preds = %after_check br label %err_retblock after_check4: ; preds = %after_check - %10 = load i8, ptr %retparam, align 1 + %10 = load i8, ptr %retparam1, align 1 store i8 %10, ptr %0, align 1 ret i64 0 diff --git a/test/test_suite/errors/multiple_catch.c3t b/test/test_suite/errors/multiple_catch.c3t index c08233739..d16fba3d4 100644 --- a/test/test_suite/errors/multiple_catch.c3t +++ b/test/test_suite/errors/multiple_catch.c3t @@ -46,12 +46,12 @@ define void @demo1.main() #0 { entry: %err = alloca i64, align 8 %retparam = alloca i32, align 4 - %retparam5 = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam5 = alloca i64, align 8 %err8 = alloca i64, align 8 %retparam10 = alloca i32, align 4 - %retparam21 = alloca i64, align 8 - %varargslots22 = alloca [1 x %"any*"], align 16 + %varargslots21 = alloca [1 x %"any*"], align 16 + %retparam22 = alloca i64, align 8 %temp_err = alloca i64, align 8 %retparam27 = alloca i32, align 4 %len = alloca i64, align 8 @@ -61,8 +61,8 @@ entry: %error_var49 = alloca i64, align 8 %err56 = alloca i64, align 8 %retparam58 = alloca i32, align 4 - %retparam69 = alloca i64, align 8 - %varargslots70 = alloca [1 x %"any*"], align 16 + %varargslots69 = alloca [1 x %"any*"], align 16 + %retparam70 = alloca i64, align 8 br label %testblock testblock: ; preds = %entry @@ -143,9 +143,9 @@ end_block18: ; preds = %after_check17, %ass if.then20: ; preds = %end_block18 %14 = insertvalue %"any*" undef, ptr %err8, 0 %15 = insertvalue %"any*" %14, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %16 = getelementptr inbounds [1 x %"any*"], ptr %varargslots22, i64 0, i64 0 + %16 = getelementptr inbounds [1 x %"any*"], ptr %varargslots21, i64 0, i64 0 store %"any*" %15, ptr %16, align 16 - %17 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.4, i64 8, ptr %varargslots22, i64 1) + %17 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.4, i64 8, ptr %varargslots21, i64 1) br label %if.exit25 if.exit25: ; preds = %if.then20, %end_block18 @@ -280,9 +280,9 @@ end_block66: ; preds = %after_check65, %ass if.then68: ; preds = %end_block66 %37 = insertvalue %"any*" undef, ptr %err56, 0 %38 = insertvalue %"any*" %37, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %39 = getelementptr inbounds [1 x %"any*"], ptr %varargslots70, i64 0, i64 0 + %39 = getelementptr inbounds [1 x %"any*"], ptr %varargslots69, i64 0, i64 0 store %"any*" %38, ptr %39, align 16 - %40 = call i64 @std.io.printfn(ptr %retparam69, ptr @.str.6, i64 8, ptr %varargslots70, i64 1) + %40 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.6, i64 8, ptr %varargslots69, i64 1) br label %if.exit73 if.exit73: ; preds = %if.then68, %end_block66 diff --git a/test/test_suite/errors/optional_chained_init.c3t b/test/test_suite/errors/optional_chained_init.c3t index 500e97bc5..e1bfb412c 100644 --- a/test/test_suite/errors/optional_chained_init.c3t +++ b/test/test_suite/errors/optional_chained_init.c3t @@ -53,15 +53,15 @@ entry: %b = alloca i32, align 4 %b.f = alloca i64, align 8 %err = alloca i64, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 %err3 = alloca i64, align 8 - %retparam12 = alloca i64, align 8 - %varargslots13 = alloca [1 x %"any*"], align 16 - %retparam17 = alloca i64, align 8 - %varargslots18 = alloca [1 x %"any*"], align 16 - %retparam24 = alloca i64, align 8 - %varargslots25 = alloca [1 x %"any*"], align 16 + %varargslots12 = alloca [1 x %"any*"], align 16 + %retparam13 = alloca i64, align 8 + %varargslots17 = alloca [1 x %"any*"], align 16 + %retparam21 = alloca i64, align 8 + %varargslots24 = alloca [1 x %"any*"], align 16 + %retparam28 = alloca i64, align 8 store i32 1, ptr %a, align 4 store i64 0, ptr %a.f, align 8 store i64 ptrtoint (ptr @"test.Test$FOO" to i64), ptr %a.f, align 8 @@ -123,44 +123,44 @@ end_block9: ; preds = %after_check8, %assi if.then11: ; preds = %end_block9 %8 = insertvalue %"any*" undef, ptr %err3, 0 %9 = insertvalue %"any*" %8, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %10 = getelementptr inbounds [1 x %"any*"], ptr %varargslots13, i64 0, i64 0 + %10 = getelementptr inbounds [1 x %"any*"], ptr %varargslots12, i64 0, i64 0 store %"any*" %9, ptr %10, align 16 - %11 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.1, i64 13, ptr %varargslots13, i64 1) + %11 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.1, i64 13, ptr %varargslots12, i64 1) br label %if.exit16 if.exit16: ; preds = %if.then11, %end_block9 - %optval19 = load i64, ptr %a.f, align 8 - %not_err20 = icmp eq i64 %optval19, 0 - %12 = call i1 @llvm.expect.i1(i1 %not_err20, i1 true) - br i1 %12, label %after_check21, label %after_check23 + %optval18 = load i64, ptr %a.f, align 8 + %not_err19 = icmp eq i64 %optval18, 0 + %12 = call i1 @llvm.expect.i1(i1 %not_err19, i1 true) + br i1 %12, label %after_check20, label %after_check23 -after_check21: ; preds = %if.exit16 +after_check20: ; preds = %if.exit16 %13 = insertvalue %"any*" undef, ptr %a, 0 %14 = insertvalue %"any*" %13, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %15 = getelementptr inbounds [1 x %"any*"], ptr %varargslots18, i64 0, i64 0 + %15 = getelementptr inbounds [1 x %"any*"], ptr %varargslots17, i64 0, i64 0 store %"any*" %14, ptr %15, align 16 - %16 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.2, i64 9, ptr %varargslots18, i64 1) + %16 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.2, i64 9, ptr %varargslots17, i64 1) %not_err22 = icmp eq i64 %16, 0 %17 = call i1 @llvm.expect.i1(i1 %not_err22, i1 true) br i1 %17, label %after_check23, label %after_check23 -after_check23: ; preds = %if.exit16, %after_check21, %after_check21 - %optval26 = load i64, ptr %b.f, align 8 - %not_err27 = icmp eq i64 %optval26, 0 - %18 = call i1 @llvm.expect.i1(i1 %not_err27, i1 true) - br i1 %18, label %after_check28, label %after_check30 +after_check23: ; preds = %if.exit16, %after_check20, %after_check20 + %optval25 = load i64, ptr %b.f, align 8 + %not_err26 = icmp eq i64 %optval25, 0 + %18 = call i1 @llvm.expect.i1(i1 %not_err26, i1 true) + br i1 %18, label %after_check27, label %after_check30 -after_check28: ; preds = %after_check23 +after_check27: ; preds = %after_check23 %19 = insertvalue %"any*" undef, ptr %b, 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 + %21 = getelementptr inbounds [1 x %"any*"], ptr %varargslots24, i64 0, i64 0 store %"any*" %20, ptr %21, align 16 - %22 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.3, i64 9, ptr %varargslots25, i64 1) + %22 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.3, i64 9, ptr %varargslots24, i64 1) %not_err29 = icmp eq i64 %22, 0 %23 = call i1 @llvm.expect.i1(i1 %not_err29, i1 true) br i1 %23, label %after_check30, label %after_check30 -after_check30: ; preds = %after_check23, %after_check28, %after_check28 +after_check30: ; preds = %after_check23, %after_check27, %after_check27 ret void } @@ -174,15 +174,15 @@ entry: %b = alloca i32, align 4 %b.f = alloca i64, align 8 %err = alloca i64, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 %err8 = alloca i64, align 8 - %retparam17 = alloca i64, align 8 - %varargslots18 = alloca [1 x %"any*"], align 16 - %retparam22 = alloca i64, align 8 - %varargslots23 = alloca [1 x %"any*"], align 16 - %retparam29 = alloca i64, align 8 - %varargslots30 = alloca [1 x %"any*"], align 16 + %varargslots17 = alloca [1 x %"any*"], align 16 + %retparam18 = alloca i64, align 8 + %varargslots22 = alloca [1 x %"any*"], align 16 + %retparam26 = alloca i64, align 8 + %varargslots29 = alloca [1 x %"any*"], align 16 + %retparam33 = alloca i64, align 8 store i64 ptrtoint (ptr @"test.Test$FOO" to i64), ptr %x.f, align 8 store i32 1, ptr %a, align 4 store i64 0, ptr %a.f, align 8 @@ -266,44 +266,44 @@ end_block14: ; preds = %after_check13, %ass if.then16: ; preds = %end_block14 %10 = insertvalue %"any*" undef, ptr %err8, 0 %11 = insertvalue %"any*" %10, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots18, i64 0, i64 0 + %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots17, i64 0, i64 0 store %"any*" %11, ptr %12, align 16 - %13 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.5, i64 13, ptr %varargslots18, i64 1) + %13 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.5, i64 13, ptr %varargslots17, i64 1) br label %if.exit21 if.exit21: ; preds = %if.then16, %end_block14 - %optval24 = load i64, ptr %a.f, align 8 - %not_err25 = icmp eq i64 %optval24, 0 - %14 = call i1 @llvm.expect.i1(i1 %not_err25, i1 true) - br i1 %14, label %after_check26, label %after_check28 + %optval23 = load i64, ptr %a.f, align 8 + %not_err24 = icmp eq i64 %optval23, 0 + %14 = call i1 @llvm.expect.i1(i1 %not_err24, i1 true) + br i1 %14, label %after_check25, label %after_check28 -after_check26: ; preds = %if.exit21 +after_check25: ; preds = %if.exit21 %15 = insertvalue %"any*" undef, ptr %a, 0 %16 = insertvalue %"any*" %15, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %17 = getelementptr inbounds [1 x %"any*"], ptr %varargslots23, i64 0, i64 0 + %17 = getelementptr inbounds [1 x %"any*"], ptr %varargslots22, i64 0, i64 0 store %"any*" %16, ptr %17, align 16 - %18 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 9, ptr %varargslots23, i64 1) + %18 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.6, i64 9, ptr %varargslots22, i64 1) %not_err27 = icmp eq i64 %18, 0 %19 = call i1 @llvm.expect.i1(i1 %not_err27, i1 true) br i1 %19, label %after_check28, label %after_check28 -after_check28: ; preds = %if.exit21, %after_check26, %after_check26 - %optval31 = load i64, ptr %b.f, align 8 - %not_err32 = icmp eq i64 %optval31, 0 - %20 = call i1 @llvm.expect.i1(i1 %not_err32, i1 true) - br i1 %20, label %after_check33, label %after_check35 +after_check28: ; preds = %if.exit21, %after_check25, %after_check25 + %optval30 = load i64, ptr %b.f, align 8 + %not_err31 = icmp eq i64 %optval30, 0 + %20 = call i1 @llvm.expect.i1(i1 %not_err31, i1 true) + br i1 %20, label %after_check32, label %after_check35 -after_check33: ; preds = %after_check28 +after_check32: ; preds = %after_check28 %21 = insertvalue %"any*" undef, ptr %b, 0 %22 = insertvalue %"any*" %21, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %23 = getelementptr inbounds [1 x %"any*"], ptr %varargslots30, i64 0, i64 0 + %23 = getelementptr inbounds [1 x %"any*"], ptr %varargslots29, i64 0, i64 0 store %"any*" %22, ptr %23, align 16 - %24 = call i64 @std.io.printfn(ptr %retparam29, ptr @.str.7, i64 9, ptr %varargslots30, i64 1) + %24 = call i64 @std.io.printfn(ptr %retparam33, ptr @.str.7, i64 9, ptr %varargslots29, i64 1) %not_err34 = icmp eq i64 %24, 0 %25 = call i1 @llvm.expect.i1(i1 %not_err34, i1 true) br i1 %25, label %after_check35, label %after_check35 -after_check35: ; preds = %after_check28, %after_check33, %after_check33 +after_check35: ; preds = %after_check28, %after_check32, %after_check32 ret void } @@ -317,15 +317,15 @@ entry: %b = alloca i32, align 4 %b.f = alloca i64, align 8 %err = alloca i64, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 %err8 = alloca i64, align 8 - %retparam17 = alloca i64, align 8 - %varargslots18 = alloca [1 x %"any*"], align 16 - %retparam22 = alloca i64, align 8 - %varargslots23 = alloca [1 x %"any*"], align 16 - %retparam29 = alloca i64, align 8 - %varargslots30 = alloca [1 x %"any*"], align 16 + %varargslots17 = alloca [1 x %"any*"], align 16 + %retparam18 = alloca i64, align 8 + %varargslots22 = alloca [1 x %"any*"], align 16 + %retparam26 = alloca i64, align 8 + %varargslots29 = alloca [1 x %"any*"], align 16 + %retparam33 = alloca i64, align 8 store i32 23, ptr %x, align 4 store i64 0, ptr %x.f, align 8 store i32 1, ptr %a, align 4 @@ -410,43 +410,43 @@ end_block14: ; preds = %after_check13, %ass if.then16: ; preds = %end_block14 %10 = insertvalue %"any*" undef, ptr %err8, 0 %11 = insertvalue %"any*" %10, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots18, i64 0, i64 0 + %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots17, i64 0, i64 0 store %"any*" %11, ptr %12, align 16 - %13 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.9, i64 13, ptr %varargslots18, i64 1) + %13 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.9, i64 13, ptr %varargslots17, i64 1) br label %if.exit21 if.exit21: ; preds = %if.then16, %end_block14 - %optval24 = load i64, ptr %a.f, align 8 - %not_err25 = icmp eq i64 %optval24, 0 - %14 = call i1 @llvm.expect.i1(i1 %not_err25, i1 true) - br i1 %14, label %after_check26, label %after_check28 + %optval23 = load i64, ptr %a.f, align 8 + %not_err24 = icmp eq i64 %optval23, 0 + %14 = call i1 @llvm.expect.i1(i1 %not_err24, i1 true) + br i1 %14, label %after_check25, label %after_check28 -after_check26: ; preds = %if.exit21 +after_check25: ; preds = %if.exit21 %15 = insertvalue %"any*" undef, ptr %a, 0 %16 = insertvalue %"any*" %15, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %17 = getelementptr inbounds [1 x %"any*"], ptr %varargslots23, i64 0, i64 0 + %17 = getelementptr inbounds [1 x %"any*"], ptr %varargslots22, i64 0, i64 0 store %"any*" %16, ptr %17, align 16 - %18 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.10, i64 9, ptr %varargslots23, i64 1) + %18 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.10, i64 9, ptr %varargslots22, i64 1) %not_err27 = icmp eq i64 %18, 0 %19 = call i1 @llvm.expect.i1(i1 %not_err27, i1 true) br i1 %19, label %after_check28, label %after_check28 -after_check28: ; preds = %if.exit21, %after_check26, %after_check26 - %optval31 = load i64, ptr %b.f, align 8 - %not_err32 = icmp eq i64 %optval31, 0 - %20 = call i1 @llvm.expect.i1(i1 %not_err32, i1 true) - br i1 %20, label %after_check33, label %after_check35 +after_check28: ; preds = %if.exit21, %after_check25, %after_check25 + %optval30 = load i64, ptr %b.f, align 8 + %not_err31 = icmp eq i64 %optval30, 0 + %20 = call i1 @llvm.expect.i1(i1 %not_err31, i1 true) + br i1 %20, label %after_check32, label %after_check35 -after_check33: ; preds = %after_check28 +after_check32: ; preds = %after_check28 %21 = insertvalue %"any*" undef, ptr %b, 0 %22 = insertvalue %"any*" %21, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %23 = getelementptr inbounds [1 x %"any*"], ptr %varargslots30, i64 0, i64 0 + %23 = getelementptr inbounds [1 x %"any*"], ptr %varargslots29, i64 0, i64 0 store %"any*" %22, ptr %23, align 16 - %24 = call i64 @std.io.printfn(ptr %retparam29, ptr @.str.11, i64 9, ptr %varargslots30, i64 1) + %24 = call i64 @std.io.printfn(ptr %retparam33, ptr @.str.11, i64 9, ptr %varargslots29, i64 1) %not_err34 = icmp eq i64 %24, 0 %25 = call i1 @llvm.expect.i1(i1 %not_err34, i1 true) br i1 %25, label %after_check35, label %after_check35 -after_check35: ; preds = %after_check28, %after_check33, %after_check33 +after_check35: ; preds = %after_check28, %after_check32, %after_check32 ret void } diff --git a/test/test_suite/errors/optional_with_optional.c3t b/test/test_suite/errors/optional_with_optional.c3t index 8579ce6bb..d765e92ea 100644 --- a/test/test_suite/errors/optional_with_optional.c3t +++ b/test/test_suite/errors/optional_with_optional.c3t @@ -34,146 +34,146 @@ fn int! get_b(int x) define void @test.main() #0 { entry: - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i32, align 4 %retparam1 = alloca i32, align 4 - %retparam2 = alloca i32, align 4 %taddr = alloca i32, align 4 - %retparam10 = alloca i64, align 8 - %varargslots11 = alloca [1 x %"any*"], align 16 - %retparam12 = alloca i32, align 4 - %retparam16 = alloca i32, align 4 - %taddr24 = alloca i32, align 4 - %retparam27 = alloca i64, align 8 - %varargslots28 = alloca [1 x %"any*"], align 16 - %retparam29 = alloca i32, align 4 - %retparam33 = alloca i32, align 4 - %taddr41 = alloca i32, align 4 - %retparam44 = alloca i64, align 8 - %varargslots45 = alloca [1 x %"any*"], align 16 + %retparam7 = alloca i64, align 8 + %varargslots10 = alloca [1 x %"any*"], align 16 + %retparam11 = alloca i32, align 4 + %retparam15 = alloca i32, align 4 + %taddr23 = alloca i32, align 4 + %retparam24 = alloca i64, align 8 + %varargslots27 = alloca [1 x %"any*"], align 16 + %retparam28 = alloca i32, align 4 + %retparam32 = alloca i32, align 4 + %taddr40 = alloca i32, align 4 + %retparam41 = alloca i64, align 8 + %varargslots44 = alloca [1 x %"any*"], align 16 %blockret = alloca i64, align 8 %f = alloca i64, align 8 - %retparam48 = alloca i64, align 8 - %varargslots49 = alloca [1 x %"any*"], align 16 - %taddr50 = alloca i32, align 4 - %retparam53 = alloca i64, align 8 - %varargslots54 = alloca [1 x %"any*"], align 16 - %blockret55 = alloca i64, align 8 - %f56 = alloca i64, align 8 - %retparam65 = alloca i64, align 8 - %varargslots66 = alloca [1 x %"any*"], align 16 - %blockret67 = alloca i64, align 8 - %f68 = alloca i64, align 8 + %retparam45 = alloca i64, align 8 + %varargslots48 = alloca [1 x %"any*"], align 16 + %taddr49 = alloca i32, align 4 + %retparam50 = alloca i64, align 8 + %varargslots53 = alloca [1 x %"any*"], align 16 + %blockret54 = alloca i64, align 8 + %f55 = alloca i64, align 8 + %retparam62 = alloca i64, align 8 + %varargslots65 = alloca [1 x %"any*"], align 16 + %blockret66 = alloca i64, align 8 + %f67 = alloca i64, align 8 + %retparam76 = alloca i64, align 8 %x = alloca i64, align 8 - %retparam79 = alloca i64, align 8 - %varargslots80 = alloca [1 x %"any*"], align 16 + %varargslots79 = alloca [1 x %"any*"], align 16 + %retparam80 = alloca i64, align 8 %xy = alloca i32, align 4 %xy.f = alloca i64, align 8 - %0 = call i64 @test.get_a(ptr %retparam1, i32 1) + %0 = call i64 @test.get_a(ptr %retparam, i32 1) %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 %else_block after_check: ; preds = %entry - %2 = load i32, ptr %retparam1, align 4 - br label %phi_block6 + %2 = load i32, ptr %retparam, align 4 + br label %phi_block5 else_block: ; preds = %entry - %3 = call i64 @test.get_b(ptr %retparam2, i32 4) - %not_err3 = icmp eq i64 %3, 0 - %4 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true) - br i1 %4, label %after_check4, label %else_block5 + %3 = call i64 @test.get_b(ptr %retparam1, i32 4) + %not_err2 = icmp eq i64 %3, 0 + %4 = call i1 @llvm.expect.i1(i1 %not_err2, i1 true) + br i1 %4, label %after_check3, label %else_block4 -after_check4: ; preds = %else_block - %5 = load i32, ptr %retparam2, align 4 +after_check3: ; preds = %else_block + %5 = load i32, ptr %retparam1, align 4 br label %phi_block -else_block5: ; preds = %else_block +else_block4: ; preds = %else_block br label %phi_block -phi_block: ; preds = %else_block5, %after_check4 - %val = phi i32 [ %5, %after_check4 ], [ -1, %else_block5 ] - br label %phi_block6 +phi_block: ; preds = %else_block4, %after_check3 + %val = phi i32 [ %5, %after_check3 ], [ -1, %else_block4 ] + br label %phi_block5 -phi_block6: ; preds = %phi_block, %after_check - %val7 = phi i32 [ %2, %after_check ], [ %val, %phi_block ] - store i32 %val7, ptr %taddr, align 4 +phi_block5: ; preds = %phi_block, %after_check + %val6 = phi i32 [ %2, %after_check ], [ %val, %phi_block ] + store i32 %val6, ptr %taddr, align 4 %6 = insertvalue %"any*" undef, ptr %taddr, 0 %7 = insertvalue %"any*" %6, i64 ptrtoint (ptr @"$ct.int" to i64), 1 %8 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %7, ptr %8, align 16 - %9 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 4, ptr %varargslots, i64 1) - %10 = call i64 @test.get_a(ptr %retparam12, i32 2) - %not_err13 = icmp eq i64 %10, 0 - %11 = call i1 @llvm.expect.i1(i1 %not_err13, i1 true) - br i1 %11, label %after_check14, label %else_block15 + %9 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str, i64 4, ptr %varargslots, i64 1) + %10 = call i64 @test.get_a(ptr %retparam11, i32 2) + %not_err12 = icmp eq i64 %10, 0 + %11 = call i1 @llvm.expect.i1(i1 %not_err12, i1 true) + br i1 %11, label %after_check13, label %else_block14 -after_check14: ; preds = %phi_block6 - %12 = load i32, ptr %retparam12, align 4 - br label %phi_block22 +after_check13: ; preds = %phi_block5 + %12 = load i32, ptr %retparam11, align 4 + br label %phi_block21 -else_block15: ; preds = %phi_block6 - %13 = call i64 @test.get_b(ptr %retparam16, i32 4) - %not_err17 = icmp eq i64 %13, 0 - %14 = call i1 @llvm.expect.i1(i1 %not_err17, i1 true) - br i1 %14, label %after_check18, label %else_block19 +else_block14: ; preds = %phi_block5 + %13 = call i64 @test.get_b(ptr %retparam15, i32 4) + %not_err16 = icmp eq i64 %13, 0 + %14 = call i1 @llvm.expect.i1(i1 %not_err16, i1 true) + br i1 %14, label %after_check17, label %else_block18 -after_check18: ; preds = %else_block15 - %15 = load i32, ptr %retparam16, align 4 - br label %phi_block20 +after_check17: ; preds = %else_block14 + %15 = load i32, ptr %retparam15, align 4 + br label %phi_block19 -else_block19: ; preds = %else_block15 - br label %phi_block20 +else_block18: ; preds = %else_block14 + br label %phi_block19 -phi_block20: ; preds = %else_block19, %after_check18 - %val21 = phi i32 [ %15, %after_check18 ], [ -1, %else_block19 ] - br label %phi_block22 +phi_block19: ; preds = %else_block18, %after_check17 + %val20 = phi i32 [ %15, %after_check17 ], [ -1, %else_block18 ] + br label %phi_block21 -phi_block22: ; preds = %phi_block20, %after_check14 - %val23 = phi i32 [ %12, %after_check14 ], [ %val21, %phi_block20 ] - store i32 %val23, ptr %taddr24, align 4 - %16 = insertvalue %"any*" undef, ptr %taddr24, 0 +phi_block21: ; preds = %phi_block19, %after_check13 + %val22 = phi i32 [ %12, %after_check13 ], [ %val20, %phi_block19 ] + store i32 %val22, ptr %taddr23, align 4 + %16 = insertvalue %"any*" undef, ptr %taddr23, 0 %17 = insertvalue %"any*" %16, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %18 = getelementptr inbounds [1 x %"any*"], ptr %varargslots11, i64 0, i64 0 + %18 = getelementptr inbounds [1 x %"any*"], ptr %varargslots10, i64 0, i64 0 store %"any*" %17, ptr %18, align 16 - %19 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.2, i64 4, ptr %varargslots11, i64 1) - %20 = call i64 @test.get_a(ptr %retparam29, i32 1) - %not_err30 = icmp eq i64 %20, 0 - %21 = call i1 @llvm.expect.i1(i1 %not_err30, i1 true) - br i1 %21, label %after_check31, label %else_block32 + %19 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.2, i64 4, ptr %varargslots10, i64 1) + %20 = call i64 @test.get_a(ptr %retparam28, i32 1) + %not_err29 = icmp eq i64 %20, 0 + %21 = call i1 @llvm.expect.i1(i1 %not_err29, i1 true) + br i1 %21, label %after_check30, label %else_block31 -after_check31: ; preds = %phi_block22 - %22 = load i32, ptr %retparam29, align 4 - br label %phi_block39 +after_check30: ; preds = %phi_block21 + %22 = load i32, ptr %retparam28, align 4 + br label %phi_block38 -else_block32: ; preds = %phi_block22 - %23 = call i64 @test.get_b(ptr %retparam33, i32 5) - %not_err34 = icmp eq i64 %23, 0 - %24 = call i1 @llvm.expect.i1(i1 %not_err34, i1 true) - br i1 %24, label %after_check35, label %else_block36 +else_block31: ; preds = %phi_block21 + %23 = call i64 @test.get_b(ptr %retparam32, i32 5) + %not_err33 = icmp eq i64 %23, 0 + %24 = call i1 @llvm.expect.i1(i1 %not_err33, i1 true) + br i1 %24, label %after_check34, label %else_block35 -after_check35: ; preds = %else_block32 - %25 = load i32, ptr %retparam33, align 4 - br label %phi_block37 +after_check34: ; preds = %else_block31 + %25 = load i32, ptr %retparam32, align 4 + br label %phi_block36 -else_block36: ; preds = %else_block32 - br label %phi_block37 +else_block35: ; preds = %else_block31 + br label %phi_block36 -phi_block37: ; preds = %else_block36, %after_check35 - %val38 = phi i32 [ %25, %after_check35 ], [ -1, %else_block36 ] - br label %phi_block39 +phi_block36: ; preds = %else_block35, %after_check34 + %val37 = phi i32 [ %25, %after_check34 ], [ -1, %else_block35 ] + br label %phi_block38 -phi_block39: ; preds = %phi_block37, %after_check31 - %val40 = phi i32 [ %22, %after_check31 ], [ %val38, %phi_block37 ] - store i32 %val40, ptr %taddr41, align 4 - %26 = insertvalue %"any*" undef, ptr %taddr41, 0 +phi_block38: ; preds = %phi_block36, %after_check30 + %val39 = phi i32 [ %22, %after_check30 ], [ %val37, %phi_block36 ] + store i32 %val39, ptr %taddr40, align 4 + %26 = insertvalue %"any*" undef, ptr %taddr40, 0 %27 = insertvalue %"any*" %26, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %28 = getelementptr inbounds [1 x %"any*"], ptr %varargslots28, i64 0, i64 0 + %28 = getelementptr inbounds [1 x %"any*"], ptr %varargslots27, i64 0, i64 0 store %"any*" %27, ptr %28, align 16 - %29 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.3, i64 4, ptr %varargslots28, i64 1) + %29 = call i64 @std.io.printfn(ptr %retparam41, ptr @.str.3, i64 4, ptr %varargslots27, i64 1) br label %testblock -testblock: ; preds = %phi_block39 +testblock: ; preds = %phi_block38 store i64 ptrtoint (ptr @"test.Foo$DEF" to i64), ptr %f, align 8 br label %end_block @@ -194,76 +194,76 @@ if.exit: ; preds = %end_block expr_block.exit: ; preds = %if.exit, %if.then %32 = insertvalue %"any*" undef, ptr %blockret, 0 %33 = insertvalue %"any*" %32, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %34 = getelementptr inbounds [1 x %"any*"], ptr %varargslots45, i64 0, i64 0 + %34 = getelementptr inbounds [1 x %"any*"], ptr %varargslots44, i64 0, i64 0 store %"any*" %33, ptr %34, align 16 - %35 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.4, i64 4, ptr %varargslots45, i64 1) - store i32 3, ptr %taddr50, align 4 - %36 = insertvalue %"any*" undef, ptr %taddr50, 0 + %35 = call i64 @std.io.printfn(ptr %retparam45, ptr @.str.4, i64 4, ptr %varargslots44, i64 1) + store i32 3, ptr %taddr49, align 4 + %36 = insertvalue %"any*" undef, ptr %taddr49, 0 %37 = insertvalue %"any*" %36, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %38 = getelementptr inbounds [1 x %"any*"], ptr %varargslots49, i64 0, i64 0 + %38 = getelementptr inbounds [1 x %"any*"], ptr %varargslots48, i64 0, i64 0 store %"any*" %37, ptr %38, align 16 - %39 = call i64 @std.io.printfn(ptr %retparam48, ptr @.str.5, i64 4, ptr %varargslots49, i64 1) - br label %testblock57 + %39 = call i64 @std.io.printfn(ptr %retparam50, ptr @.str.5, i64 4, ptr %varargslots48, i64 1) + br label %testblock56 -testblock57: ; preds = %expr_block.exit - store i64 ptrtoint (ptr @"test.Foo$DEF" to i64), ptr %f56, align 8 - br label %end_block58 +testblock56: ; preds = %expr_block.exit + store i64 ptrtoint (ptr @"test.Foo$DEF" to i64), ptr %f55, align 8 + br label %end_block57 -end_block58: ; preds = %testblock57 - %40 = load i64, ptr %f56, align 8 - %neq59 = icmp ne i64 %40, 0 - br i1 %neq59, label %if.then60, label %if.exit61 +end_block57: ; preds = %testblock56 + %40 = load i64, ptr %f55, align 8 + %neq58 = icmp ne i64 %40, 0 + br i1 %neq58, label %if.then59, label %if.exit60 -if.then60: ; preds = %end_block58 - %41 = load i64, ptr %f56, align 8 - store i64 %41, ptr %blockret55, align 8 - br label %expr_block.exit62 +if.then59: ; preds = %end_block57 + %41 = load i64, ptr %f55, align 8 + store i64 %41, ptr %blockret54, align 8 + br label %expr_block.exit61 -if.exit61: ; preds = %end_block58 - store i64 0, ptr %blockret55, align 8 - br label %expr_block.exit62 +if.exit60: ; preds = %end_block57 + store i64 0, ptr %blockret54, align 8 + br label %expr_block.exit61 -expr_block.exit62: ; preds = %if.exit61, %if.then60 - %42 = insertvalue %"any*" undef, ptr %blockret55, 0 +expr_block.exit61: ; preds = %if.exit60, %if.then59 + %42 = insertvalue %"any*" undef, ptr %blockret54, 0 %43 = insertvalue %"any*" %42, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %44 = getelementptr inbounds [1 x %"any*"], ptr %varargslots54, i64 0, i64 0 + %44 = getelementptr inbounds [1 x %"any*"], ptr %varargslots53, i64 0, i64 0 store %"any*" %43, ptr %44, align 16 - %45 = call i64 @std.io.printfn(ptr %retparam53, ptr @.str.6, i64 4, ptr %varargslots54, i64 1) - br label %testblock69 + %45 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.6, i64 4, ptr %varargslots53, i64 1) + br label %testblock68 -testblock69: ; preds = %expr_block.exit62 - br label %phi_block71 +testblock68: ; preds = %expr_block.exit61 + br label %phi_block70 -phi_block71: ; preds = %testblock69 - store i64 0, ptr %f68, align 8 - br label %end_block72 +phi_block70: ; preds = %testblock68 + store i64 0, ptr %f67, align 8 + br label %end_block71 -end_block72: ; preds = %phi_block71 - %46 = load i64, ptr %f68, align 8 - %neq73 = icmp ne i64 %46, 0 - br i1 %neq73, label %if.then74, label %if.exit75 +end_block71: ; preds = %phi_block70 + %46 = load i64, ptr %f67, align 8 + %neq72 = icmp ne i64 %46, 0 + br i1 %neq72, label %if.then73, label %if.exit74 -if.then74: ; preds = %end_block72 - %47 = load i64, ptr %f68, align 8 - store i64 %47, ptr %blockret67, align 8 - br label %expr_block.exit76 +if.then73: ; preds = %end_block71 + %47 = load i64, ptr %f67, align 8 + store i64 %47, ptr %blockret66, align 8 + br label %expr_block.exit75 -if.exit75: ; preds = %end_block72 - store i64 0, ptr %blockret67, align 8 - br label %expr_block.exit76 +if.exit74: ; preds = %end_block71 + store i64 0, ptr %blockret66, align 8 + br label %expr_block.exit75 -expr_block.exit76: ; preds = %if.exit75, %if.then74 - %48 = insertvalue %"any*" undef, ptr %blockret67, 0 +expr_block.exit75: ; preds = %if.exit74, %if.then73 + %48 = insertvalue %"any*" undef, ptr %blockret66, 0 %49 = insertvalue %"any*" %48, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1 - %50 = getelementptr inbounds [1 x %"any*"], ptr %varargslots66, i64 0, i64 0 + %50 = getelementptr inbounds [1 x %"any*"], ptr %varargslots65, i64 0, i64 0 store %"any*" %49, ptr %50, align 16 - %51 = call i64 @std.io.printfn(ptr %retparam65, ptr @.str.7, i64 4, ptr %varargslots66, i64 1) + %51 = call i64 @std.io.printfn(ptr %retparam76, ptr @.str.7, i64 4, ptr %varargslots65, i64 1) store i64 3, ptr %x, align 8 %52 = insertvalue %"any*" undef, ptr %x, 0 %53 = insertvalue %"any*" %52, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %54 = getelementptr inbounds [1 x %"any*"], ptr %varargslots80, i64 0, i64 0 + %54 = getelementptr inbounds [1 x %"any*"], ptr %varargslots79, i64 0, i64 0 store %"any*" %53, ptr %54, align 16 - %55 = call i64 @std.io.printfn(ptr %retparam79, ptr @.str.8, i64 4, ptr %varargslots80, i64 1) + %55 = call i64 @std.io.printfn(ptr %retparam80, ptr @.str.8, i64 4, ptr %varargslots79, i64 1) store i64 ptrtoint (ptr @"test.Foo$DEF" to i64), ptr %xy.f, align 8 ret void } diff --git a/test/test_suite/errors/or_and_rethrow.c3t b/test/test_suite/errors/or_and_rethrow.c3t index 0838c3c15..943aa3926 100644 --- a/test/test_suite/errors/or_and_rethrow.c3t +++ b/test/test_suite/errors/or_and_rethrow.c3t @@ -41,9 +41,9 @@ fn void main() define i64 @foo.test(i32 %0) #0 { entry: - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i32, align 4 + %retparam = alloca i64, align 8 %error_var = alloca i64, align 8 %blockret = alloca i32, align 4 %len = alloca i64, align 8 @@ -341,9 +341,9 @@ voiderr96: ; preds = %noerr_block94, %gua ; Function Attrs: nounwind define i64 @foo.test2(i32 %0) #0 { entry: - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i32, align 4 + %retparam = alloca i64, align 8 %error_var = alloca i64, align 8 %blockret = alloca i32, align 4 %len = alloca i64, align 8 diff --git a/test/test_suite/errors/printing_errors.c3t b/test/test_suite/errors/printing_errors.c3t index 21044ac53..3a3cf7efb 100644 --- a/test/test_suite/errors/printing_errors.c3t +++ b/test/test_suite/errors/printing_errors.c3t @@ -15,46 +15,46 @@ fn void main() /* #expect: test.ll -define void @test.main() #0 { -entry: - %x = alloca i64, align 8 - %retparam = alloca i64, align 8 - %varargslots = alloca [2 x %"any*"], align 16 - %taddr = alloca %"char[]", align 8 - %faultname_zero = alloca %"char[]", align 8 - store i64 ptrtoint (ptr @"test.Cde$WORLD" to i64), ptr %x, align 8 - store %"char[]" { ptr @.str.2, i64 5 }, ptr %taddr, align 8 - %0 = insertvalue %"any*" undef, ptr %taddr, 0 - %1 = insertvalue %"any*" %0, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %2 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 0 - store %"any*" %1, ptr %2, align 16 - %3 = load i64, ptr %x, align 8 - %eq = icmp eq i64 %3, 0 - br i1 %eq, label %faultname_no, label %faultname_ok + define void @test.main() #0 { + entry: + %x = alloca i64, align 8 + %varargslots = alloca [2 x %"any*"], align 16 + %taddr = alloca %"char[]", align 8 + %faultname_zero = alloca %"char[]", align 8 + %retparam = alloca i64, align 8 + store i64 ptrtoint (ptr @"test.Cde$WORLD" to i64), ptr %x, align 8 + store %"char[]" { ptr @.str.2, i64 5 }, ptr %taddr, align 8 + %0 = insertvalue %"any*" undef, ptr %taddr, 0 + %1 = insertvalue %"any*" %0, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %2 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 0 + store %"any*" %1, ptr %2, align 16 + %3 = load i64, ptr %x, align 8 + %eq = icmp eq i64 %3, 0 + br i1 %eq, label %faultname_no, label %faultname_ok -faultname_no: ; preds = %entry - call void @llvm.memset.p0.i64(ptr align 8 %faultname_zero, i8 0, i64 16, i1 false) - br label %faultname_exit + faultname_no: ; preds = %entry + call void @llvm.memset.p0.i64(ptr align 8 %faultname_zero, i8 0, i64 16, i1 false) + br label %faultname_exit -faultname_ok: ; preds = %entry - %4 = inttoptr i64 %3 to ptr - %5 = getelementptr inbounds %.fault, ptr %4, i32 0, i32 1 - br label %faultname_exit + faultname_ok: ; preds = %entry + %4 = inttoptr i64 %3 to ptr + %5 = getelementptr inbounds %.fault, ptr %4, i32 0, i32 1 + br label %faultname_exit -faultname_exit: ; preds = %faultname_ok, %faultname_no - %faultname = phi ptr [ %faultname_zero, %faultname_no ], [ %5, %faultname_ok ] - %6 = insertvalue %"any*" undef, ptr %faultname, 0 - %7 = insertvalue %"any*" %6, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %8 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 1 - store %"any*" %7, ptr %8, align 16 - %9 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 6, ptr %varargslots, i64 2) - ret void -} + faultname_exit: ; preds = %faultname_ok, %faultname_no + %faultname = phi ptr [ %faultname_zero, %faultname_no ], [ %5, %faultname_ok ] + %6 = insertvalue %"any*" undef, ptr %faultname, 0 + %7 = insertvalue %"any*" %6, i64 ptrtoint (ptr @"$ct.String" to i64), 1 + %8 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 1 + store %"any*" %7, ptr %8, align 16 + %9 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 6, ptr %varargslots, i64 2) + ret void + } -; Function Attrs: nounwind -define i32 @main(i32 %0, ptr %1) #0 { -entry: - call void @test.main() - ret i32 0 -} + ; Function Attrs: nounwind + define i32 @main(i32 %0, ptr %1) #0 { + entry: + call void @test.main() + ret i32 0 + } diff --git a/test/test_suite/errors/try_with_chained_unwrap.c3t b/test/test_suite/errors/try_with_chained_unwrap.c3t index 467ef4f58..1923dae57 100644 --- a/test/test_suite/errors/try_with_chained_unwrap.c3t +++ b/test/test_suite/errors/try_with_chained_unwrap.c3t @@ -22,23 +22,23 @@ fn void main() define void @try_with_chained_unwrap.main() #0 { entry: %val = alloca i32, align 4 - %retparam = alloca i32, align 4 - %retparam1 = alloca ptr, align 8 + %retparam = alloca ptr, align 8 + %retparam1 = alloca i32, align 4 store i32 0, ptr %val, align 4 - %0 = call i64 @readLine(ptr %retparam1) + %0 = call i64 @readLine(ptr %retparam) %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 %catch_landing after_check: ; preds = %entry - %2 = load ptr, ptr %retparam1, align 8 - %3 = call i64 @atoi(ptr %retparam, ptr %2) + %2 = load ptr, ptr %retparam, align 8 + %3 = call i64 @atoi(ptr %retparam1, ptr %2) %not_err2 = icmp eq i64 %3, 0 %4 = call i1 @llvm.expect.i1(i1 %not_err2, i1 true) br i1 %4, label %after_check3, label %catch_landing after_check3: ; preds = %after_check - %5 = load i32, ptr %retparam, align 4 + %5 = load i32, ptr %retparam1, align 4 store i32 %5, ptr %val, align 4 br label %phi_try_catch diff --git a/test/test_suite/expressions/addr_compiles.c3t b/test/test_suite/expressions/addr_compiles.c3t index a89ea295a..2c06ce0f9 100644 --- a/test/test_suite/expressions/addr_compiles.c3t +++ b/test/test_suite/expressions/addr_compiles.c3t @@ -72,10 +72,10 @@ entry: store i32 %0, ptr %taddr, align 4 store ptr %taddr, ptr %h, align 8 %1 = load ptr, ptr %x, align 8 - %2 = load i32, ptr %1, align 4 - %3 = load ptr, ptr %h, align 8 - %4 = load i32, ptr %3, align 4 - call void (ptr, ...) @printf(ptr @.str, i32 %2, i32 %4) + %2 = load ptr, ptr %h, align 8 + %3 = load i32, ptr %1, align 4 + %4 = load i32, ptr %2, align 4 + call void (ptr, ...) @printf(ptr @.str, i32 %3, i32 %4) ret void } @@ -107,10 +107,10 @@ entry: store ptr %1, ptr %zy, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %arr, ptr align 4 @.__const.2, i32 12, i1 false) %2 = load ptr, ptr %zx, align 8 - %3 = load i32, ptr %2, align 4 - %4 = load ptr, ptr %zy, align 8 - %5 = load i32, ptr %4, align 4 - call void (ptr, ...) @printf(ptr @.str.3, i32 %3, i32 %5) + %3 = load ptr, ptr %zy, align 8 + %4 = load i32, ptr %2, align 4 + %5 = load i32, ptr %3, align 4 + call void (ptr, ...) @printf(ptr @.str.3, i32 %4, i32 %5) %6 = getelementptr inbounds [3 x i32], ptr %arr, i64 0, i64 0 %7 = load i32, ptr %6, align 4 %sub = sub i32 %7, 1 @@ -131,12 +131,12 @@ entry: store %"int[]" %15, ptr %taddr, align 8 store ptr %taddr, ptr %e, align 8 %16 = load ptr, ptr %d, align 8 - %17 = load i32, ptr %16, align 4 - %18 = load ptr, ptr %e, align 8 - %19 = getelementptr inbounds %"int[]", ptr %18, i32 0, i32 0 - %20 = load ptr, ptr %19, align 8 - %ptroffset = getelementptr inbounds i32, ptr %20, i64 0 + %17 = load ptr, ptr %e, align 8 + %18 = getelementptr inbounds %"int[]", ptr %17, i32 0, i32 0 + %19 = load ptr, ptr %18, align 8 + %ptroffset = getelementptr inbounds i32, ptr %19, i64 0 + %20 = load i32, ptr %16, align 4 %21 = load i32, ptr %ptroffset, align 4 - call void (ptr, ...) @printf(ptr @.str.4, i32 %17, i32 %21) + call void (ptr, ...) @printf(ptr @.str.4, i32 %20, i32 %21) ret void } \ No newline at end of file diff --git a/test/test_suite/expressions/pointer_access.c3t b/test/test_suite/expressions/pointer_access.c3t index 823a426f6..08b3975a8 100644 --- a/test/test_suite/expressions/pointer_access.c3t +++ b/test/test_suite/expressions/pointer_access.c3t @@ -79,26 +79,26 @@ entry: %14 = getelementptr inbounds %c, ptr %13, i32 0, i32 4 store double 3.400000e+00, ptr %14, align 8 %15 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 0 - %16 = load i32, ptr %15, align 8 - %17 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 2 - %18 = getelementptr inbounds %c, ptr %17, i32 0, i32 0 - %19 = load double, ptr %18, align 8 + %16 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 2 + %17 = getelementptr inbounds %c, ptr %16, i32 0, i32 0 + %18 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 2 + %19 = getelementptr inbounds %c, ptr %18, i32 0, i32 3 %20 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 2 - %21 = getelementptr inbounds %c, ptr %20, i32 0, i32 3 - %22 = load double, ptr %21, align 8 - %23 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 2 - %24 = getelementptr inbounds %c, ptr %23, i32 0, i32 4 - %25 = load double, ptr %24, align 8 - %26 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 5 - %27 = load i32, ptr %26, align 8 - %28 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 4 - %29 = load double, ptr %28, align 8 - %30 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 3 - %31 = getelementptr inbounds %.anon, ptr %30, i32 0, i32 0 - %32 = load i32, ptr %31, align 8 - %33 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 3 - %34 = getelementptr inbounds %.anon, ptr %33, i32 0, i32 1 - %35 = load i32, ptr %34, align 4 - call void (ptr, ...) @printf(ptr @.str, i32 %16, double %19, double %22, double %25, i32 %27, double %29, i32 %32, i32 %35) + %21 = getelementptr inbounds %c, ptr %20, i32 0, i32 4 + %22 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 5 + %23 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 4 + %24 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 3 + %25 = getelementptr inbounds %.anon, ptr %24, i32 0, i32 0 + %26 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 3 + %27 = getelementptr inbounds %.anon, ptr %26, i32 0, i32 1 + %28 = load i32, ptr %15, align 8 + %29 = load double, ptr %17, align 8 + %30 = load double, ptr %19, align 8 + %31 = load double, ptr %21, align 8 + %32 = load i32, ptr %22, align 8 + %33 = load double, ptr %23, align 8 + %34 = load i32, ptr %25, align 8 + %35 = load i32, ptr %27, align 4 + call void (ptr, ...) @printf(ptr @.str, i32 %28, double %29, double %30, double %31, i32 %32, double %33, i32 %34, i32 %35) ret void } diff --git a/test/test_suite/functions/func_ptr_conversions_and_names.c3t b/test/test_suite/functions/func_ptr_conversions_and_names.c3t index b4b4536ac..1d83dfad9 100644 --- a/test/test_suite/functions/func_ptr_conversions_and_names.c3t +++ b/test/test_suite/functions/func_ptr_conversions_and_names.c3t @@ -55,31 +55,31 @@ define void @test.main() #0 { entry: %a = alloca ptr, align 8 %b = alloca ptr, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i32, align 4 - %retparam1 = alloca i64, align 8 - %varargslots2 = alloca [1 x %"any*"], align 16 - %taddr3 = alloca i32, align 4 + %retparam = alloca i64, align 8 + %varargslots1 = alloca [1 x %"any*"], align 16 + %taddr2 = alloca i32, align 4 + %retparam3 = alloca i64, align 8 %z = alloca ptr, align 8 - %retparam4 = alloca i64, align 8 - %varargslots5 = alloca [1 x %"any*"], align 16 - %taddr6 = alloca i32, align 4 - %retparam7 = alloca i64, align 8 - %varargslots8 = alloca [1 x %"any*"], align 16 - %taddr9 = alloca %"char[]", align 8 - %retparam10 = alloca i64, align 8 - %varargslots11 = alloca [1 x %"any*"], align 16 - %taddr12 = alloca %"char[]", align 8 - %retparam13 = alloca i64, align 8 - %varargslots14 = alloca [1 x %"any*"], align 16 - %taddr15 = alloca %"char[]", align 8 - %retparam16 = alloca i64, align 8 - %varargslots17 = alloca [1 x %"any*"], align 16 - %taddr18 = alloca %"char[]", align 8 - %retparam19 = alloca i64, align 8 - %varargslots20 = alloca [1 x %"any*"], align 16 - %taddr21 = alloca %"char[]", align 8 + %varargslots4 = alloca [1 x %"any*"], align 16 + %taddr5 = alloca i32, align 4 + %retparam6 = alloca i64, align 8 + %varargslots7 = alloca [1 x %"any*"], align 16 + %taddr8 = alloca %"char[]", align 8 + %retparam9 = alloca i64, align 8 + %varargslots10 = alloca [1 x %"any*"], align 16 + %taddr11 = alloca %"char[]", align 8 + %retparam12 = alloca i64, align 8 + %varargslots13 = alloca [1 x %"any*"], align 16 + %taddr14 = alloca %"char[]", align 8 + %retparam15 = alloca i64, align 8 + %varargslots16 = alloca [1 x %"any*"], align 16 + %taddr17 = alloca %"char[]", align 8 + %retparam18 = alloca i64, align 8 + %varargslots19 = alloca [1 x %"any*"], align 16 + %taddr20 = alloca %"char[]", align 8 + %retparam21 = alloca i64, align 8 %y = alloca ptr, align 8 %zfoke = alloca i64, align 8 store ptr @test.test, ptr %a, align 8 @@ -93,51 +93,51 @@ entry: store %"any*" %3, ptr %4, align 16 %5 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) %6 = call i32 @test.test2(i32 3) - store i32 %6, ptr %taddr3, align 4 - %7 = insertvalue %"any*" undef, ptr %taddr3, 0 + store i32 %6, ptr %taddr2, align 4 + %7 = insertvalue %"any*" undef, ptr %taddr2, 0 %8 = insertvalue %"any*" %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %9 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0 + %9 = getelementptr inbounds [1 x %"any*"], ptr %varargslots1, i64 0, i64 0 store %"any*" %8, ptr %9, align 16 - %10 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.1, i64 2, ptr %varargslots2, i64 1) + %10 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.1, i64 2, ptr %varargslots1, i64 1) store ptr @test.test2, ptr %z, align 8 %11 = load ptr, ptr %z, align 8 %12 = call i32 %11(i32 444) - store i32 %12, ptr %taddr6, align 4 - %13 = insertvalue %"any*" undef, ptr %taddr6, 0 + store i32 %12, ptr %taddr5, align 4 + %13 = insertvalue %"any*" undef, ptr %taddr5, 0 %14 = insertvalue %"any*" %13, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %15 = getelementptr inbounds [1 x %"any*"], ptr %varargslots5, i64 0, i64 0 + %15 = getelementptr inbounds [1 x %"any*"], ptr %varargslots4, i64 0, i64 0 store %"any*" %14, ptr %15, align 16 - %16 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.2, i64 2, ptr %varargslots5, i64 1) - store %"char[]" { ptr @.str.4, i64 12 }, ptr %taddr9, align 8 - %17 = insertvalue %"any*" undef, ptr %taddr9, 0 + %16 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.2, i64 2, ptr %varargslots4, i64 1) + store %"char[]" { ptr @.str.4, i64 12 }, ptr %taddr8, align 8 + %17 = insertvalue %"any*" undef, ptr %taddr8, 0 %18 = insertvalue %"any*" %17, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %19 = getelementptr inbounds [1 x %"any*"], ptr %varargslots8, i64 0, i64 0 + %19 = getelementptr inbounds [1 x %"any*"], ptr %varargslots7, i64 0, i64 0 store %"any*" %18, ptr %19, align 16 - %20 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1) - store %"char[]" { ptr @.str.6, i64 12 }, ptr %taddr12, align 8 - %21 = insertvalue %"any*" undef, ptr %taddr12, 0 + %20 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.3, i64 2, ptr %varargslots7, i64 1) + store %"char[]" { ptr @.str.6, i64 12 }, ptr %taddr11, align 8 + %21 = insertvalue %"any*" undef, ptr %taddr11, 0 %22 = insertvalue %"any*" %21, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %23 = getelementptr inbounds [1 x %"any*"], ptr %varargslots11, i64 0, i64 0 + %23 = getelementptr inbounds [1 x %"any*"], ptr %varargslots10, i64 0, i64 0 store %"any*" %22, ptr %23, align 16 - %24 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.5, i64 2, ptr %varargslots11, i64 1) - store %"char[]" { ptr @.str.8, i64 12 }, ptr %taddr15, align 8 - %25 = insertvalue %"any*" undef, ptr %taddr15, 0 + %24 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.5, i64 2, ptr %varargslots10, i64 1) + store %"char[]" { ptr @.str.8, i64 12 }, ptr %taddr14, align 8 + %25 = insertvalue %"any*" undef, ptr %taddr14, 0 %26 = insertvalue %"any*" %25, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %27 = getelementptr inbounds [1 x %"any*"], ptr %varargslots14, i64 0, i64 0 + %27 = getelementptr inbounds [1 x %"any*"], ptr %varargslots13, i64 0, i64 0 store %"any*" %26, ptr %27, align 16 - %28 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.7, i64 2, ptr %varargslots14, i64 1) - store %"char[]" { ptr @.str.10, i64 6 }, ptr %taddr18, align 8 - %29 = insertvalue %"any*" undef, ptr %taddr18, 0 + %28 = call i64 @std.io.printfn(ptr %retparam15, ptr @.str.7, i64 2, ptr %varargslots13, i64 1) + store %"char[]" { ptr @.str.10, i64 6 }, 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 [1 x %"any*"], ptr %varargslots17, i64 0, i64 0 + %31 = getelementptr inbounds [1 x %"any*"], ptr %varargslots16, i64 0, i64 0 store %"any*" %30, ptr %31, align 16 - %32 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.9, i64 2, ptr %varargslots17, i64 1) - store %"char[]" { ptr @.str.12, i64 13 }, ptr %taddr21, align 8 - %33 = insertvalue %"any*" undef, ptr %taddr21, 0 + %32 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.9, i64 2, ptr %varargslots16, i64 1) + store %"char[]" { ptr @.str.12, i64 13 }, 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 [1 x %"any*"], ptr %varargslots20, i64 0, i64 0 + %35 = getelementptr inbounds [1 x %"any*"], ptr %varargslots19, i64 0, i64 0 store %"any*" %34, ptr %35, align 16 - %36 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.11, i64 2, ptr %varargslots20, i64 1) + %36 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.11, i64 2, ptr %varargslots19, i64 1) store ptr @test.test2, ptr %y, align 8 store i64 ptrtoint (ptr @"$ct.p$fn$int$int$" to i64), ptr %zfoke, align 8 ret void diff --git a/test/test_suite/functions/splat_aarch64.c3t b/test/test_suite/functions/splat_aarch64.c3t index 6ea49b0b2..cf1d39262 100644 --- a/test/test_suite/functions/splat_aarch64.c3t +++ b/test/test_suite/functions/splat_aarch64.c3t @@ -35,8 +35,8 @@ 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 - %"#temp#" = insertvalue %"int[]" %3, i64 3, 1 - store %"int[]" %"#temp#", ptr %taddr, align 8 + %"$$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) diff --git a/test/test_suite/functions/splat_mingw.c3t b/test/test_suite/functions/splat_mingw.c3t index f88171bcc..867ebd699 100644 --- a/test/test_suite/functions/splat_mingw.c3t +++ b/test/test_suite/functions/splat_mingw.c3t @@ -33,8 +33,8 @@ 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 - %"#temp#" = insertvalue %"int[]" %3, i64 3, 1 - store %"int[]" %"#temp#", ptr %indirectarg, align 8 + %"$$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) %5 = insertvalue %"int[]" undef, ptr %x, 0 diff --git a/test/test_suite/functions/test_regression.c3t b/test/test_suite/functions/test_regression.c3t index db8b0ec84..0cd3952e7 100644 --- a/test/test_suite/functions/test_regression.c3t +++ b/test/test_suite/functions/test_regression.c3t @@ -448,10 +448,10 @@ loop.cond: ; preds = %loop.body, %entry loop.body: ; preds = %loop.cond %5 = load i32, ptr %i, align 4 - %6 = load i32, ptr %i, align 4 - %sext = sext i32 %6 to i64 - %7 = call i32 @"std.collections.linkedlist$int$.LinkedList.get"(ptr %list, i64 %sext) - %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %5, i32 %7) + %sext = sext i32 %5 to i64 + %6 = call i32 @"std.collections.linkedlist$int$.LinkedList.get"(ptr %list, i64 %sext) + %7 = load i32, ptr %i, align 4 + %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %7, i32 %6) %9 = load i32, ptr %i, align 4 %add = add i32 %9, 1 store i32 %add, ptr %i, align 4 @@ -480,10 +480,10 @@ loop.cond2: ; preds = %loop.body5, %loop.e 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) #3 - %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %14, i32 %16) + %sext6 = sext i32 %14 to i64 + %15 = call i32 @"std.collections.list$int$.List.get"(ptr %array, i64 %sext6) #3 + %16 = load i32, ptr %i1, align 4 + %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %16, i32 %15) %18 = load i32, ptr %i1, align 4 %add7 = add i32 %18, 1 store i32 %add7, ptr %i1, align 4 diff --git a/test/test_suite/functions/test_regression_mingw.c3t b/test/test_suite/functions/test_regression_mingw.c3t index 640d432a2..0459f9846 100644 --- a/test/test_suite/functions/test_regression_mingw.c3t +++ b/test/test_suite/functions/test_regression_mingw.c3t @@ -492,10 +492,10 @@ loop.cond: ; preds = %loop.body, %entry loop.body: ; preds = %loop.cond %5 = load i32, ptr %i, align 4 - %6 = load i32, ptr %i, align 4 - %sext = sext i32 %6 to i64 - %7 = call i32 @"std.collections.linkedlist$int$.LinkedList.get"(ptr %list, i64 %sext) - %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %5, i32 %7) + %sext = sext i32 %5 to i64 + %6 = call i32 @"std.collections.linkedlist$int$.LinkedList.get"(ptr %list, i64 %sext) + %7 = load i32, ptr %i, align 4 + %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %7, i32 %6) %9 = load i32, ptr %i, align 4 %add = add i32 %9, 1 store i32 %add, ptr %i, align 4 @@ -524,10 +524,10 @@ loop.cond2: ; preds = %loop.body5, %loop.e 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) #3 - %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %14, i32 %16) + %sext6 = sext i32 %14 to i64 + %15 = call i32 @"std.collections.list$int$.List.get"(ptr %array, i64 %sext6) #3 + %16 = load i32, ptr %i1, align 4 + %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %16, i32 %15) %18 = load i32, ptr %i1, align 4 %add7 = add i32 %18, 1 store i32 %add7, ptr %i1, align 4 @@ -585,15 +585,15 @@ 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 - %"#temp#" = insertvalue %"int[]" %50, i64 4, 1 - store %"int[]" %"#temp#", ptr %indirectarg12, align 8 + %"$$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 + %"$$temp14" = insertvalue %"int[]" %54, i64 1, 1 + store %"int[]" %"$$temp14", 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 diff --git a/test/test_suite/generic/enum_set_test.c3t b/test/test_suite/generic/enum_set_test.c3t index a09a1fdc6..634f7a299 100644 --- a/test/test_suite/generic/enum_set_test.c3t +++ b/test/test_suite/generic/enum_set_test.c3t @@ -30,22 +30,22 @@ fn void main() define void @test.main() #0 { entry: %set = alloca i32, align 4 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i8, align 1 - %retparam1 = alloca i64, align 8 - %varargslots2 = alloca [1 x %"any*"], align 16 - %taddr3 = alloca i8, align 1 - %retparam4 = alloca i64, align 8 - %varargslots5 = alloca [1 x %"any*"], align 16 - %taddr6 = alloca i8, align 1 + %retparam = alloca i64, align 8 + %varargslots1 = alloca [1 x %"any*"], align 16 + %taddr2 = alloca i8, align 1 + %retparam3 = alloca i64, align 8 + %varargslots4 = alloca [1 x %"any*"], align 16 + %taddr5 = alloca i8, align 1 + %retparam6 = alloca i64, align 8 %set2 = alloca i32, align 4 - %retparam7 = alloca i64, align 8 - %varargslots8 = alloca [1 x %"any*"], align 16 - %taddr9 = alloca i8, align 1 - %retparam10 = alloca i64, align 8 - %varargslots11 = alloca [1 x %"any*"], align 16 - %taddr12 = alloca i8, align 1 + %varargslots7 = alloca [1 x %"any*"], align 16 + %taddr8 = alloca i8, align 1 + %retparam9 = alloca i64, align 8 + %varargslots10 = alloca [1 x %"any*"], align 16 + %taddr11 = alloca i8, align 1 + %retparam12 = alloca i64, align 8 store i32 0, ptr %set, align 4 %0 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set, i32 1) store i8 %0, ptr %taddr, align 1 @@ -56,38 +56,38 @@ entry: %4 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 14, ptr %varargslots, i64 1) call void @"std.collections.enumset$test.Abc$.EnumSet.add"(ptr %set, i32 0) %5 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set, i32 1) - store i8 %5, ptr %taddr3, align 1 - %6 = insertvalue %"any*" undef, ptr %taddr3, 0 + store i8 %5, ptr %taddr2, align 1 + %6 = insertvalue %"any*" undef, ptr %taddr2, 0 %7 = insertvalue %"any*" %6, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %8 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0 + %8 = getelementptr inbounds [1 x %"any*"], ptr %varargslots1, i64 0, i64 0 store %"any*" %7, ptr %8, align 16 - %9 = call i64 @std.io.printf(ptr %retparam1, ptr @.str.1, i64 14, ptr %varargslots2, i64 1) + %9 = call i64 @std.io.printf(ptr %retparam3, ptr @.str.1, i64 14, ptr %varargslots1, i64 1) call void @"std.collections.enumset$test.Abc$.EnumSet.add"(ptr %set, i32 1) %10 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set, i32 1) - store i8 %10, ptr %taddr6, align 1 - %11 = insertvalue %"any*" undef, ptr %taddr6, 0 + store i8 %10, ptr %taddr5, align 1 + %11 = insertvalue %"any*" undef, ptr %taddr5, 0 %12 = insertvalue %"any*" %11, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %13 = getelementptr inbounds [1 x %"any*"], ptr %varargslots5, i64 0, i64 0 + %13 = getelementptr inbounds [1 x %"any*"], ptr %varargslots4, i64 0, i64 0 store %"any*" %12, ptr %13, align 16 - %14 = call i64 @std.io.printf(ptr %retparam4, ptr @.str.2, i64 14, ptr %varargslots5, i64 1) + %14 = call i64 @std.io.printf(ptr %retparam6, ptr @.str.2, i64 14, ptr %varargslots4, i64 1) store i32 0, ptr %set2, align 4 %15 = load i32, ptr %set, align 4 call void @"std.collections.enumset$test.Abc$.EnumSet.add_all"(ptr %set2, i32 %15) %16 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set2, i32 1) - store i8 %16, ptr %taddr9, align 1 - %17 = insertvalue %"any*" undef, ptr %taddr9, 0 + store i8 %16, ptr %taddr8, align 1 + %17 = insertvalue %"any*" undef, ptr %taddr8, 0 %18 = insertvalue %"any*" %17, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %19 = getelementptr inbounds [1 x %"any*"], ptr %varargslots8, i64 0, i64 0 + %19 = getelementptr inbounds [1 x %"any*"], ptr %varargslots7, i64 0, i64 0 store %"any*" %18, ptr %19, align 16 - %20 = call i64 @std.io.printf(ptr %retparam7, ptr @.str.3, i64 14, ptr %varargslots8, i64 1) + %20 = call i64 @std.io.printf(ptr %retparam9, ptr @.str.3, i64 14, ptr %varargslots7, i64 1) %21 = load i32, ptr %set2, align 4 call void @"std.collections.enumset$test.Abc$.EnumSet.remove_all"(ptr %set, i32 %21) %22 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set, i32 1) - store i8 %22, ptr %taddr12, align 1 - %23 = insertvalue %"any*" undef, ptr %taddr12, 0 + store i8 %22, ptr %taddr11, align 1 + %23 = insertvalue %"any*" undef, ptr %taddr11, 0 %24 = insertvalue %"any*" %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %25 = getelementptr inbounds [1 x %"any*"], ptr %varargslots11, i64 0, i64 0 + %25 = getelementptr inbounds [1 x %"any*"], ptr %varargslots10, i64 0, i64 0 store %"any*" %24, ptr %25, align 16 - %26 = call i64 @std.io.printf(ptr %retparam10, ptr @.str.4, i64 14, ptr %varargslots11, i64 1) + %26 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.4, i64 14, ptr %varargslots10, i64 1) ret void } diff --git a/test/test_suite/generic/generic_lambda_complex.c3t b/test/test_suite/generic/generic_lambda_complex.c3t index d67f19604..59604c71d 100644 --- a/test/test_suite/generic/generic_lambda_complex.c3t +++ b/test/test_suite/generic/generic_lambda_complex.c3t @@ -191,13 +191,8 @@ entry: %indirectarg5 = alloca %"any*[]", align 8 store %"char[]" { ptr @.str, i64 21 }, ptr %foo_tmpl, align 8 call void @llvm.memset.p0.i64(ptr align 8 %ft, i8 0, i64 64, i1 false) - %0 = getelementptr inbounds %"char[]", ptr %foo_tmpl, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds %"char[]", ptr %foo_tmpl, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - store %"char[]" { ptr @.str.2, i64 2 }, ptr %indirectarg, align 8 - %2 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8 - %not = icmp eq ptr %2, null + %0 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8 + %not = icmp eq ptr %0, null br i1 %not, label %if.then, label %if.exit if.then: ; preds = %entry @@ -205,8 +200,13 @@ if.then: ; preds = %entry br label %if.exit if.exit: ; preds = %if.then, %entry - %3 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8 - %4 = call i64 @"abc$text_test.Foo$.TextTemplate.init"(ptr %ft, ptr %lo, i64 %hi, ptr @.str.1, i64 2, ptr byval(%"char[]") align 8 %indirectarg, ptr %3) + %1 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8 + %2 = getelementptr inbounds %"char[]", ptr %foo_tmpl, i32 0, i32 0 + %lo = load ptr, ptr %2, align 8 + %3 = getelementptr inbounds %"char[]", ptr %foo_tmpl, i32 0, i32 1 + %hi = load i64, ptr %3, align 8 + store %"char[]" { ptr @.str.2, i64 2 }, ptr %indirectarg, align 8 + %4 = call i64 @"abc$text_test.Foo$.TextTemplate.init"(ptr %ft, ptr %lo, i64 %hi, ptr @.str.1, i64 2, ptr byval(%"char[]") align 8 %indirectarg, ptr %1) %not_err = icmp eq i64 %4, 0 %5 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) br i1 %5, label %after_check, label %assign_optional @@ -241,8 +241,8 @@ panic_block: ; preds = %assign_optional3 %11 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %10, ptr %11, align 16 %12 = insertvalue %"any*[]" undef, ptr %varargslots, 0 - %"#temp#" = insertvalue %"any*[]" %12, i64 1, 1 - store %"any*[]" %"#temp#", ptr %indirectarg5, align 8 + %"$$temp" = insertvalue %"any*[]" %12, i64 1, 1 + store %"any*[]" %"$$temp", ptr %indirectarg5, align 8 call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 25, ptr @.func, i64 4, i32 173, ptr byval(%"any*[]") align 8 %indirectarg5) unreachable diff --git a/test/test_suite/generic/generic_num.c3t b/test/test_suite/generic/generic_num.c3t index 206c23542..b9cf2c45e 100644 --- a/test/test_suite/generic/generic_num.c3t +++ b/test/test_suite/generic/generic_num.c3t @@ -21,9 +21,9 @@ fn void main() define void @test.main() #0 { entry: - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i32, align 4 + %retparam = alloca i64, align 8 %0 = call i32 @"hello$int$_123$.x"(i32 4) store i32 %0, ptr %taddr, align 4 %1 = insertvalue %"any*" undef, ptr %taddr, 0 diff --git a/test/test_suite/generic/generic_over_fn.c3t b/test/test_suite/generic/generic_over_fn.c3t index 7a213a6fb..49568ef94 100644 --- a/test/test_suite/generic/generic_over_fn.c3t +++ b/test/test_suite/generic/generic_over_fn.c3t @@ -118,12 +118,12 @@ loop.body: ; preds = %loop.cond %22 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 1 %23 = load i64, ptr %22, align 8 store i64 %23, ptr %len, align 8 - %24 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 0 - %lo = load ptr, ptr %24, align 8 - %25 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 1 - %hi = load i64, ptr %25, align 8 - %26 = load i64, ptr %len, align 8 - %sub = sub i64 %26, 1 + %24 = load i64, ptr %len, align 8 + %sub = sub i64 %24, 1 + %25 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 0 + %lo = load ptr, ptr %25, align 8 + %26 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 1 + %hi = load i64, ptr %26, align 8 call void @"test_generic$sa$int$p$fn$int$int$$int$$.sort"(ptr %lo, i64 %hi, i64 0, i64 %sub, ptr @sort_test.cmp_int_value) %27 = load i64, ptr %.anon5, align 8 %add = add i64 %27, 1 @@ -195,12 +195,12 @@ loop.body: ; preds = %loop.cond %22 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 1 %23 = load i64, ptr %22, align 8 store i64 %23, ptr %len, align 8 - %24 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 0 - %lo = load ptr, ptr %24, align 8 - %25 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 1 - %hi = load i64, ptr %25, align 8 - %26 = load i64, ptr %len, align 8 - %sub = sub i64 %26, 1 + %24 = load i64, ptr %len, align 8 + %sub = sub i64 %24, 1 + %25 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 0 + %lo = load ptr, ptr %25, align 8 + %26 = getelementptr inbounds %"int[]", ptr %list, i32 0, i32 1 + %hi = load i64, ptr %26, align 8 call void @"test_generic$sa$int$p$fn$int$int$$int$$.sort"(ptr %lo, i64 %hi, i64 0, i64 %sub, ptr @sort_test.cmp_int_value2) %27 = load i64, ptr %.anon5, align 8 %add = add i64 %27, 1 diff --git a/test/test_suite/initializer_lists/fasta.c3t b/test/test_suite/initializer_lists/fasta.c3t index 15bddb695..8dd22eb7e 100644 --- a/test/test_suite/initializer_lists/fasta.c3t +++ b/test/test_suite/initializer_lists/fasta.c3t @@ -340,26 +340,26 @@ if.then: ; preds = %entry if.exit: ; preds = %if.then, %entry %4 = call i32 (ptr, ...) @printf(ptr @.str.14) - %lo = load ptr, ptr @fasta.alu, align 8 - %hi = load i64, ptr getelementptr inbounds (%"char[]", ptr @fasta.alu, i32 0, i32 1), align 8 %5 = load i32, ptr %n, align 4 %mul = mul i32 %5, 2 + %lo = load ptr, ptr @fasta.alu, align 8 + %hi = load i64, ptr getelementptr inbounds (%"char[]", ptr @fasta.alu, i32 0, i32 1), align 8 call void @fasta.repeat_fasta(ptr %lo, i64 %hi, i32 %mul) %6 = call i32 (ptr, ...) @printf(ptr @.str.15) - %lo1 = load ptr, ptr @fasta.iub, align 8 - %hi2 = load i64, ptr getelementptr inbounds (%"char[]", ptr @fasta.iub, i32 0, i32 1), align 8 - %lo3 = load ptr, ptr @fasta.iub_p, align 8 - %hi4 = load i64, ptr getelementptr inbounds (%"double[]", ptr @fasta.iub_p, i32 0, i32 1), align 8 %7 = load i32, ptr %n, align 4 - %mul5 = mul i32 %7, 3 - call void @fasta.random_fasta(ptr %lo1, i64 %hi2, ptr %lo3, i64 %hi4, i32 %mul5) + %mul1 = mul i32 %7, 3 + %lo2 = load ptr, ptr @fasta.iub, align 8 + %hi3 = load i64, ptr getelementptr inbounds (%"char[]", ptr @fasta.iub, i32 0, i32 1), align 8 + %lo4 = load ptr, ptr @fasta.iub_p, align 8 + %hi5 = load i64, ptr getelementptr inbounds (%"double[]", ptr @fasta.iub_p, i32 0, i32 1), align 8 + call void @fasta.random_fasta(ptr %lo2, i64 %hi3, ptr %lo4, i64 %hi5, i32 %mul1) %8 = call i32 (ptr, ...) @printf(ptr @.str.16) - %lo6 = load ptr, ptr @fasta.homosapiens, align 8 - %hi7 = load i64, ptr getelementptr inbounds (%"char[]", ptr @fasta.homosapiens, i32 0, i32 1), align 8 - %lo8 = load ptr, ptr @fasta.homosapiens_p, align 8 - %hi9 = load i64, ptr getelementptr inbounds (%"double[]", ptr @fasta.homosapiens_p, i32 0, i32 1), align 8 %9 = load i32, ptr %n, align 4 - %mul10 = mul i32 %9, 5 - call void @fasta.random_fasta(ptr %lo6, i64 %hi7, ptr %lo8, i64 %hi9, i32 %mul10) + %mul6 = mul i32 %9, 5 + %lo7 = load ptr, ptr @fasta.homosapiens, align 8 + %hi8 = load i64, ptr getelementptr inbounds (%"char[]", ptr @fasta.homosapiens, i32 0, i32 1), align 8 + %lo9 = load ptr, ptr @fasta.homosapiens_p, align 8 + %hi10 = load i64, ptr getelementptr inbounds (%"double[]", ptr @fasta.homosapiens_p, i32 0, i32 1), align 8 + call void @fasta.random_fasta(ptr %lo7, i64 %hi8, ptr %lo9, i64 %hi10, i32 %mul6) ret i32 0 } \ No newline at end of file diff --git a/test/test_suite/initializer_lists/statics.c3t b/test/test_suite/initializer_lists/statics.c3t index 119cdbfed..eba8dc448 100644 --- a/test/test_suite/initializer_lists/statics.c3t +++ b/test/test_suite/initializer_lists/statics.c3t @@ -54,12 +54,12 @@ entry: %3 = load ptr, ptr %2, align 8 %ptroffset = getelementptr inbounds %Bar, ptr %3, i64 0 %4 = getelementptr inbounds %Bar, ptr %ptroffset, i32 0, i32 1 - %5 = load i32, ptr %4, align 4 - %6 = load ptr, ptr @test.c, align 8 - %ptroffset1 = getelementptr inbounds %Bar, ptr %6, i64 0 - %7 = getelementptr inbounds %Bar, ptr %ptroffset1, i32 0, i32 1 - %8 = load i32, ptr %7, align 4 - %9 = call i32 (ptr, ...) @printf(ptr @.str, i32 %5, i32 %8) + %5 = load ptr, ptr @test.c, align 8 + %ptroffset1 = getelementptr inbounds %Bar, ptr %5, i64 0 + %6 = getelementptr inbounds %Bar, ptr %ptroffset1, i32 0, i32 1 + %7 = load i32, ptr %4, align 4 + %8 = load i32, ptr %6, align 4 + %9 = call i32 (ptr, ...) @printf(ptr @.str, i32 %7, i32 %8) %10 = getelementptr inbounds %"Bar[]", ptr %b, i32 0, i32 0 %11 = load ptr, ptr %10, align 8 %ptroffset2 = getelementptr inbounds %Bar, ptr %11, i64 0 diff --git a/test/test_suite/lambda/lambda_in_macro.c3t b/test/test_suite/lambda/lambda_in_macro.c3t index 22ed123aa..58f84d875 100644 --- a/test/test_suite/lambda/lambda_in_macro.c3t +++ b/test/test_suite/lambda/lambda_in_macro.c3t @@ -29,17 +29,17 @@ fn void main() /* #expect: test.ll - store ptr @"test.test$lambda1", ptr %z, align 8 - %1 = call i32 %0(i32 3) - store ptr @"test.test$lambda2", ptr %z3, align 8 - %7 = call double %6(double 3.300000e+00) - store ptr @"test.test$lambda2", ptr %z7, align 8 - %13 = call double %12(double 3.300000e+00) - %18 = call i32 @"test.test2$lambda3"(i32 3) - %23 = call i32 @"test.test2$lambda3"(i32 3) - %28 = call double @"test.test2$lambda4"(double 3.300000e+00) + store ptr @"test.test$lambda1", ptr %z, align 8 + %1 = call i32 %0(i32 3) + store ptr @"test.test$lambda2", ptr %z2, align 8 + %7 = call double %6(double 3.300000e+00) + store ptr @"test.test$lambda2", ptr %z6, align 8 + %13 = call double %12(double 3.300000e+00) + %18 = call i32 @"test.test2$lambda3"(i32 3) + %23 = call i32 @"test.test2$lambda3"(i32 3) + %28 = call double @"test.test2$lambda4"(double 3.300000e+00) - define internal i32 @"test.test$lambda1"(i32 %0) #0 { - define internal double @"test.test$lambda2"(double %0) #0 { - define internal i32 @"test.test2$lambda3"(i32 %0) #0 { - define internal double @"test.test2$lambda4"(double %0) #0 { +define internal i32 @"test.test$lambda1"(i32 %0) #0 { +define internal double @"test.test$lambda2"(double %0) #0 { +define internal i32 @"test.test2$lambda3"(i32 %0) #0 { +define internal double @"test.test2$lambda4"(double %0) #0 { diff --git a/test/test_suite/literals/bin_literal.c3t b/test/test_suite/literals/bin_literal.c3t index 0bc9cc6e9..0ae8577e0 100644 --- a/test/test_suite/literals/bin_literal.c3t +++ b/test/test_suite/literals/bin_literal.c3t @@ -21,15 +21,15 @@ entry: %b = alloca i32, align 4 %c = alloca i32, align 4 %d = alloca i32, align 4 - %retparam = alloca i64, align 8 %varargslots = alloca [2 x %"any*"], align 16 + %retparam = alloca i64, align 8 %z = alloca i8, align 1 - %retparam1 = alloca i64, align 8 - %varargslots2 = alloca [3 x %"any*"], align 16 + %varargslots1 = alloca [3 x %"any*"], align 16 %self = alloca i8, align 1 %taddr = alloca i8, align 1 - %self3 = alloca i8, align 1 - %taddr4 = alloca i8, align 1 + %self2 = alloca i8, align 1 + %taddr3 = alloca i8, align 1 + %retparam4 = alloca i64, align 8 store i32 123, ptr %a, align 4 store i32 -23, ptr %b, align 4 %0 = load i32, ptr %a, align 4 @@ -52,7 +52,7 @@ entry: store i8 -35, ptr %z, align 1 %13 = insertvalue %"any*" undef, ptr %z, 0 %14 = insertvalue %"any*" %13, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %15 = getelementptr inbounds [3 x %"any*"], ptr %varargslots2, i64 0, i64 0 + %15 = getelementptr inbounds [3 x %"any*"], ptr %varargslots1, i64 0, i64 0 store %"any*" %14, ptr %15, align 16 %16 = load i8, ptr %z, align 1 store i8 %16, ptr %self, align 1 @@ -62,18 +62,18 @@ entry: store i8 %19, ptr %taddr, align 1 %20 = insertvalue %"any*" undef, ptr %taddr, 0 %21 = insertvalue %"any*" %20, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %22 = getelementptr inbounds [3 x %"any*"], ptr %varargslots2, i64 0, i64 1 + %22 = getelementptr inbounds [3 x %"any*"], ptr %varargslots1, i64 0, i64 1 store %"any*" %21, ptr %22, align 16 %23 = load i8, ptr %z, align 1 - store i8 %23, ptr %self3, align 1 - %24 = load i8, ptr %self3, align 1 - %25 = load i8, ptr %self3, align 1 + store i8 %23, ptr %self2, align 1 + %24 = load i8, ptr %self2, align 1 + %25 = load i8, ptr %self2, align 1 %26 = call i8 @llvm.fshl.i8(i8 %24, i8 %25, i8 1) - store i8 %26, ptr %taddr4, align 1 - %27 = insertvalue %"any*" undef, ptr %taddr4, 0 + store i8 %26, ptr %taddr3, align 1 + %27 = insertvalue %"any*" undef, ptr %taddr3, 0 %28 = insertvalue %"any*" %27, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %29 = getelementptr inbounds [3 x %"any*"], ptr %varargslots2, i64 0, i64 2 + %29 = getelementptr inbounds [3 x %"any*"], ptr %varargslots1, i64 0, i64 2 store %"any*" %28, ptr %29, align 16 - %30 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.1, i64 8, ptr %varargslots2, i64 3) + %30 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.1, i64 8, ptr %varargslots1, i64 3) ret void } diff --git a/test/test_suite/macros/macro_failable_return_rethrow.c3t b/test/test_suite/macros/macro_failable_return_rethrow.c3t index be9c95366..0b7efd6b8 100644 --- a/test/test_suite/macros/macro_failable_return_rethrow.c3t +++ b/test/test_suite/macros/macro_failable_return_rethrow.c3t @@ -44,8 +44,8 @@ panic_block: ; preds = %guard_block %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 - %"#temp#" = insertvalue %"any*[]" %6, i64 1, 1 - store %"any*[]" %"#temp#", 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 diff --git a/test/test_suite/macros/macro_typed_varargs.c3t b/test/test_suite/macros/macro_typed_varargs.c3t index 34f70acfb..81a952792 100644 --- a/test/test_suite/macros/macro_typed_varargs.c3t +++ b/test/test_suite/macros/macro_typed_varargs.c3t @@ -35,8 +35,8 @@ entry: %.anon = alloca i64, align 8 %.anon1 = alloca i64, align 8 %i = alloca i32, align 4 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 %literal2 = alloca [4 x %"any*"], align 16 %taddr = alloca i32, align 4 %taddr3 = alloca i32, align 4 @@ -46,8 +46,8 @@ entry: %.anon7 = alloca i64, align 8 %.anon8 = alloca i64, align 8 %i12 = alloca %"any*", align 8 - %retparam14 = alloca i64, align 8 - %varargslots15 = alloca [1 x %"any*"], align 16 + %varargslots14 = alloca [1 x %"any*"], align 16 + %retparam15 = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal, ptr align 16 @.__const, i32 16, i1 false) %0 = insertvalue %"int[]" undef, ptr %literal, 0 %1 = insertvalue %"int[]" %0, i64 4, 1 @@ -127,9 +127,9 @@ loop.body11: ; preds = %loop.cond9 %37 = load ptr, ptr %36, align 8 %38 = insertvalue %"any*" undef, ptr %37, 0 %39 = insertvalue %"any*" %38, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %40 = getelementptr inbounds [1 x %"any*"], ptr %varargslots15, i64 0, i64 0 + %40 = getelementptr inbounds [1 x %"any*"], ptr %varargslots14, i64 0, i64 0 store %"any*" %39, ptr %40, align 16 - %41 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.1, i64 2, ptr %varargslots15, i64 1) + %41 = call i64 @std.io.printfn(ptr %retparam15, ptr @.str.1, i64 2, ptr %varargslots14, i64 1) %42 = load i64, ptr %.anon8, align 8 %add16 = add i64 %42, 1 store i64 %add16, ptr %.anon8, align 8 diff --git a/test/test_suite/macros/macro_untyped_varargs_2.c3t b/test/test_suite/macros/macro_untyped_varargs_2.c3t index 79a7fa1d3..944af23e6 100644 --- a/test/test_suite/macros/macro_untyped_varargs_2.c3t +++ b/test/test_suite/macros/macro_untyped_varargs_2.c3t @@ -62,9 +62,9 @@ fn void main() define i32 @test.ping(i32 %0) #0 { entry: - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i32, align 4 + %retparam = alloca i64, 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 @@ -78,37 +78,37 @@ define void @test.main() #0 { entry: %i = alloca i32, align 4 %j = alloca i32, align 4 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 %taddr = alloca i32, align 4 - %retparam2 = alloca i64, align 8 - %varargslots3 = alloca [1 x %"any*"], align 16 - %taddr4 = alloca i32, align 4 - %retparam5 = alloca i64, align 8 - %varargslots6 = alloca [1 x %"any*"], align 16 - %taddr7 = alloca i32, align 4 - %retparam8 = alloca i64, align 8 - %varargslots9 = alloca [1 x %"any*"], align 16 - %taddr10 = alloca i32, align 4 + %retparam = alloca i64, align 8 + %varargslots2 = alloca [1 x %"any*"], align 16 + %taddr3 = alloca i32, align 4 + %retparam4 = alloca i64, align 8 + %varargslots5 = alloca [1 x %"any*"], align 16 + %taddr6 = alloca i32, align 4 + %retparam7 = alloca i64, align 8 + %varargslots8 = alloca [1 x %"any*"], align 16 + %taddr9 = alloca i32, align 4 + %retparam10 = alloca i64, align 8 %x = alloca i32, align 4 - %retparam11 = alloca i64, align 8 - %varargslots12 = alloca [1 x %"any*"], align 16 - %taddr13 = alloca %"char[]", align 8 + %varargslots11 = alloca [1 x %"any*"], align 16 + %taddr12 = alloca %"char[]", align 8 + %retparam13 = alloca i64, align 8 %x14 = alloca double, align 8 - %retparam15 = alloca i64, align 8 - %varargslots16 = alloca [1 x %"any*"], align 16 - %taddr17 = alloca %"char[]", align 8 - %retparam18 = alloca i64, align 8 - %varargslots19 = alloca [1 x %"any*"], align 16 - %taddr20 = alloca i32, align 4 + %varargslots15 = alloca [1 x %"any*"], align 16 + %taddr16 = alloca %"char[]", align 8 + %retparam17 = alloca i64, align 8 + %varargslots18 = alloca [1 x %"any*"], align 16 + %taddr19 = alloca i32, align 4 + %retparam20 = alloca i64, align 8 %x21 = alloca i32, align 4 %y = alloca i32, align 4 %a = alloca i32, align 4 - %retparam22 = alloca i64, align 8 - %varargslots23 = alloca [2 x %"any*"], align 16 + %varargslots22 = alloca [2 x %"any*"], align 16 + %retparam23 = alloca i64, align 8 %a24 = alloca i32, align 4 - %retparam25 = alloca i64, align 8 - %varargslots26 = alloca [2 x %"any*"], align 16 + %varargslots25 = alloca [2 x %"any*"], align 16 + %retparam26 = alloca i64, align 8 %0 = call i32 @test.ping(i32 -1) %1 = call i32 @test.ping(i32 1) %2 = call i32 @test.ping(i32 3141) @@ -125,44 +125,44 @@ entry: %8 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0 store %"any*" %7, ptr %8, align 16 %9 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.1, i64 2, ptr %varargslots, i64 1) - store i32 %0, ptr %taddr4, align 4 - %10 = insertvalue %"any*" undef, ptr %taddr4, 0 + store i32 %0, ptr %taddr3, align 4 + %10 = insertvalue %"any*" undef, ptr %taddr3, 0 %11 = insertvalue %"any*" %10, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots3, i64 0, i64 0 + %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0 store %"any*" %11, ptr %12, align 16 - %13 = call i64 @std.io.printfn(ptr %retparam2, ptr @.str.2, i64 2, ptr %varargslots3, i64 1) - store i32 %2, ptr %taddr7, align 4 - %14 = insertvalue %"any*" undef, ptr %taddr7, 0 + %13 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.2, i64 2, ptr %varargslots2, i64 1) + store i32 %2, ptr %taddr6, align 4 + %14 = insertvalue %"any*" undef, ptr %taddr6, 0 %15 = insertvalue %"any*" %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %16 = getelementptr inbounds [1 x %"any*"], ptr %varargslots6, i64 0, i64 0 + %16 = getelementptr inbounds [1 x %"any*"], ptr %varargslots5, i64 0, i64 0 store %"any*" %15, ptr %16, align 16 - %17 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1) - store i32 %3, ptr %taddr10, align 4 - %18 = insertvalue %"any*" undef, ptr %taddr10, 0 + %17 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots5, i64 1) + store i32 %3, ptr %taddr9, align 4 + %18 = insertvalue %"any*" undef, ptr %taddr9, 0 %19 = insertvalue %"any*" %18, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %20 = getelementptr inbounds [1 x %"any*"], ptr %varargslots9, i64 0, i64 0 + %20 = getelementptr inbounds [1 x %"any*"], ptr %varargslots8, i64 0, i64 0 store %"any*" %19, ptr %20, align 16 - %21 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1) + %21 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.4, i64 2, ptr %varargslots8, i64 1) store i32 0, ptr %x, align 4 - store %"char[]" { ptr @.str.6, i64 3 }, ptr %taddr13, align 8 - %22 = insertvalue %"any*" undef, ptr %taddr13, 0 + store %"char[]" { ptr @.str.6, i64 3 }, ptr %taddr12, align 8 + %22 = insertvalue %"any*" undef, ptr %taddr12, 0 %23 = insertvalue %"any*" %22, i64 ptrtoint (ptr @"$ct.String" to i64), 1 - %24 = getelementptr inbounds [1 x %"any*"], ptr %varargslots12, i64 0, i64 0 + %24 = getelementptr inbounds [1 x %"any*"], ptr %varargslots11, i64 0, i64 0 store %"any*" %23, ptr %24, align 16 - %25 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.5, i64 2, ptr %varargslots12, i64 1) + %25 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.5, i64 2, ptr %varargslots11, i64 1) store double 0.000000e+00, ptr %x14, align 8 - store %"char[]" { ptr @.str.8, i64 6 }, ptr %taddr17, align 8 - %26 = insertvalue %"any*" undef, ptr %taddr17, 0 + store %"char[]" { ptr @.str.8, i64 6 }, 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 [1 x %"any*"], ptr %varargslots16, i64 0, i64 0 + %28 = getelementptr inbounds [1 x %"any*"], ptr %varargslots15, i64 0, i64 0 store %"any*" %27, ptr %28, align 16 - %29 = call i64 @std.io.printfn(ptr %retparam15, ptr @.str.7, i64 2, ptr %varargslots16, i64 1) - store i32 105, ptr %taddr20, align 4 - %30 = insertvalue %"any*" undef, ptr %taddr20, 0 + %29 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.7, i64 2, ptr %varargslots15, i64 1) + store i32 105, ptr %taddr19, align 4 + %30 = insertvalue %"any*" undef, ptr %taddr19, 0 %31 = insertvalue %"any*" %30, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %32 = getelementptr inbounds [1 x %"any*"], ptr %varargslots19, i64 0, i64 0 + %32 = getelementptr inbounds [1 x %"any*"], ptr %varargslots18, i64 0, i64 0 store %"any*" %31, ptr %32, align 16 - %33 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.9, i64 2, ptr %varargslots19, i64 1) + %33 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.9, i64 2, ptr %varargslots18, i64 1) store i32 123, ptr %x21, align 4 store i32 33, ptr %y, align 4 %34 = load i32, ptr %x21, align 4 @@ -173,13 +173,13 @@ entry: store i32 %36, ptr %y, align 4 %37 = insertvalue %"any*" undef, ptr %x21, 0 %38 = insertvalue %"any*" %37, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %39 = getelementptr inbounds [2 x %"any*"], ptr %varargslots23, i64 0, i64 0 + %39 = getelementptr inbounds [2 x %"any*"], ptr %varargslots22, i64 0, i64 0 store %"any*" %38, ptr %39, align 16 %40 = insertvalue %"any*" undef, ptr %y, 0 %41 = insertvalue %"any*" %40, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %42 = getelementptr inbounds [2 x %"any*"], ptr %varargslots23, i64 0, i64 1 + %42 = getelementptr inbounds [2 x %"any*"], ptr %varargslots22, i64 0, i64 1 store %"any*" %41, ptr %42, align 16 - %43 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.10, i64 6, ptr %varargslots23, i64 2) + %43 = call i64 @std.io.printfn(ptr %retparam23, ptr @.str.10, i64 6, ptr %varargslots22, i64 2) %44 = load i32, ptr %x21, align 4 store i32 %44, ptr %a24, align 4 %45 = load i32, ptr %y, align 4 @@ -188,12 +188,12 @@ entry: store i32 %46, ptr %y, align 4 %47 = insertvalue %"any*" undef, ptr %x21, 0 %48 = insertvalue %"any*" %47, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %49 = getelementptr inbounds [2 x %"any*"], ptr %varargslots26, i64 0, i64 0 + %49 = getelementptr inbounds [2 x %"any*"], ptr %varargslots25, i64 0, i64 0 store %"any*" %48, ptr %49, align 16 %50 = insertvalue %"any*" undef, ptr %y, 0 %51 = insertvalue %"any*" %50, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %52 = getelementptr inbounds [2 x %"any*"], ptr %varargslots26, i64 0, i64 1 + %52 = getelementptr inbounds [2 x %"any*"], ptr %varargslots25, i64 0, i64 1 store %"any*" %51, ptr %52, align 16 - %53 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.11, i64 6, ptr %varargslots26, i64 2) + %53 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.11, i64 6, ptr %varargslots25, i64 2) ret void } \ No newline at end of file diff --git a/test/test_suite/macros/macro_vasplat.c3t b/test/test_suite/macros/macro_vasplat.c3t index 25e5f5666..34927625e 100644 --- a/test/test_suite/macros/macro_vasplat.c3t +++ b/test/test_suite/macros/macro_vasplat.c3t @@ -68,74 +68,74 @@ entry: %.anon = alloca i64, align 8 %i = alloca i64, align 8 %x = alloca i32, align 4 - %retparam = alloca i64, align 8 %varargslots = alloca [2 x %"any*"], align 16 + %retparam = alloca i64, align 8 %a1 = alloca [1 x i32], align 4 %.anon2 = alloca i64, align 8 %i6 = alloca i64, align 8 %x7 = alloca i32, align 4 - %retparam8 = alloca i64, align 8 - %varargslots9 = alloca [2 x %"any*"], align 16 + %varargslots8 = alloca [2 x %"any*"], align 16 + %retparam9 = alloca i64, align 8 %a12 = alloca [4 x i32], align 16 %.anon13 = alloca i64, align 8 %i17 = alloca i64, align 8 %x18 = alloca i32, align 4 - %retparam19 = alloca i64, align 8 - %varargslots20 = alloca [2 x %"any*"], align 16 + %varargslots19 = alloca [2 x %"any*"], align 16 + %retparam20 = alloca i64, align 8 %a23 = alloca [2 x i32], align 4 %.anon24 = alloca i64, align 8 %i28 = alloca i64, align 8 %x29 = alloca i32, align 4 - %retparam30 = alloca i64, align 8 - %varargslots31 = alloca [2 x %"any*"], align 16 + %varargslots30 = alloca [2 x %"any*"], align 16 + %retparam31 = alloca i64, align 8 %a34 = alloca [3 x i32], align 4 %.anon35 = alloca i64, align 8 %i39 = alloca i64, align 8 %x40 = alloca i32, align 4 - %retparam41 = alloca i64, align 8 - %varargslots42 = alloca [2 x %"any*"], align 16 + %varargslots41 = alloca [2 x %"any*"], align 16 + %retparam42 = alloca i64, align 8 %a45 = alloca [1 x i32], align 4 %.anon46 = alloca i64, align 8 %i50 = alloca i64, align 8 %x51 = alloca i32, align 4 - %retparam52 = alloca i64, align 8 - %varargslots53 = alloca [2 x %"any*"], align 16 + %varargslots52 = alloca [2 x %"any*"], align 16 + %retparam53 = alloca i64, align 8 %a56 = alloca [2 x i32], align 4 %.anon57 = alloca i64, align 8 %i61 = alloca i64, align 8 %x62 = alloca i32, align 4 - %retparam63 = alloca i64, align 8 - %varargslots64 = alloca [2 x %"any*"], align 16 + %varargslots63 = alloca [2 x %"any*"], align 16 + %retparam64 = alloca i64, align 8 %a67 = alloca [5 x i32], align 16 %.anon68 = alloca i64, align 8 %i72 = alloca i64, align 8 %x73 = alloca i32, align 4 - %retparam74 = alloca i64, align 8 - %varargslots75 = alloca [2 x %"any*"], align 16 + %varargslots74 = alloca [2 x %"any*"], align 16 + %retparam75 = alloca i64, align 8 %a78 = alloca [8 x i32], align 16 %.anon79 = alloca i64, align 8 %i83 = alloca i64, align 8 %x84 = alloca i32, align 4 - %retparam85 = alloca i64, align 8 - %varargslots86 = alloca [2 x %"any*"], align 16 + %varargslots85 = alloca [2 x %"any*"], align 16 + %retparam86 = alloca i64, align 8 %b = alloca [7 x i32], align 16 %.anon89 = alloca i64, align 8 %i93 = alloca i64, align 8 %x94 = alloca i32, align 4 - %retparam95 = alloca i64, align 8 - %varargslots96 = alloca [2 x %"any*"], align 16 + %varargslots95 = alloca [2 x %"any*"], align 16 + %retparam96 = alloca i64, align 8 %c = alloca [8 x i32], align 16 %.anon99 = alloca i64, align 8 %i103 = alloca i64, align 8 %x104 = alloca i32, align 4 - %retparam105 = alloca i64, align 8 - %varargslots106 = alloca [2 x %"any*"], align 16 + %varargslots105 = alloca [2 x %"any*"], align 16 + %retparam106 = alloca i64, align 8 %a109 = alloca [6 x i32], align 16 %.anon110 = alloca i64, align 8 %i114 = alloca i64, align 8 %x115 = alloca i32, align 4 - %retparam116 = alloca i64, align 8 - %varargslots117 = alloca [2 x %"any*"], align 16 + %varargslots116 = alloca [2 x %"any*"], align 16 + %retparam117 = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const, i32 12, i1 false) store i64 0, ptr %.anon, align 8 br label %loop.cond @@ -185,13 +185,13 @@ loop.body5: ; preds = %loop.cond3 store i32 %17, ptr %x7, align 4 %18 = insertvalue %"any*" undef, ptr %i6, 0 %19 = insertvalue %"any*" %18, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %20 = getelementptr inbounds [2 x %"any*"], ptr %varargslots9, i64 0, i64 0 + %20 = getelementptr inbounds [2 x %"any*"], ptr %varargslots8, i64 0, i64 0 store %"any*" %19, ptr %20, align 16 %21 = insertvalue %"any*" undef, ptr %x7, 0 %22 = insertvalue %"any*" %21, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %23 = getelementptr inbounds [2 x %"any*"], ptr %varargslots9, i64 0, i64 1 + %23 = getelementptr inbounds [2 x %"any*"], ptr %varargslots8, i64 0, i64 1 store %"any*" %22, ptr %23, align 16 - %24 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.2, i64 8, ptr %varargslots9, i64 2) + %24 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.2, i64 8, ptr %varargslots8, i64 2) %25 = load i64, ptr %.anon2, align 8 %add10 = add i64 %25, 1 store i64 %add10, ptr %.anon2, align 8 @@ -216,13 +216,13 @@ loop.body16: ; preds = %loop.cond14 store i32 %30, ptr %x18, align 4 %31 = insertvalue %"any*" undef, ptr %i17, 0 %32 = insertvalue %"any*" %31, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %33 = getelementptr inbounds [2 x %"any*"], ptr %varargslots20, i64 0, i64 0 + %33 = getelementptr inbounds [2 x %"any*"], ptr %varargslots19, i64 0, i64 0 store %"any*" %32, ptr %33, align 16 %34 = insertvalue %"any*" undef, ptr %x18, 0 %35 = insertvalue %"any*" %34, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %36 = getelementptr inbounds [2 x %"any*"], ptr %varargslots20, i64 0, i64 1 + %36 = getelementptr inbounds [2 x %"any*"], ptr %varargslots19, i64 0, i64 1 store %"any*" %35, ptr %36, align 16 - %37 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.4, i64 6, ptr %varargslots20, i64 2) + %37 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.4, i64 6, ptr %varargslots19, i64 2) %38 = load i64, ptr %.anon13, align 8 %add21 = add i64 %38, 1 store i64 %add21, ptr %.anon13, align 8 @@ -247,13 +247,13 @@ loop.body27: ; preds = %loop.cond25 store i32 %43, ptr %x29, align 4 %44 = insertvalue %"any*" undef, ptr %i28, 0 %45 = insertvalue %"any*" %44, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %46 = getelementptr inbounds [2 x %"any*"], ptr %varargslots31, i64 0, i64 0 + %46 = getelementptr inbounds [2 x %"any*"], ptr %varargslots30, i64 0, i64 0 store %"any*" %45, ptr %46, align 16 %47 = insertvalue %"any*" undef, ptr %x29, 0 %48 = insertvalue %"any*" %47, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %49 = getelementptr inbounds [2 x %"any*"], ptr %varargslots31, i64 0, i64 1 + %49 = getelementptr inbounds [2 x %"any*"], ptr %varargslots30, i64 0, i64 1 store %"any*" %48, ptr %49, align 16 - %50 = call i64 @std.io.printfn(ptr %retparam30, ptr @.str.6, i64 6, ptr %varargslots31, i64 2) + %50 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.6, i64 6, ptr %varargslots30, i64 2) %51 = load i64, ptr %.anon24, align 8 %add32 = add i64 %51, 1 store i64 %add32, ptr %.anon24, align 8 @@ -278,13 +278,13 @@ loop.body38: ; preds = %loop.cond36 store i32 %56, ptr %x40, align 4 %57 = insertvalue %"any*" undef, ptr %i39, 0 %58 = insertvalue %"any*" %57, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %59 = getelementptr inbounds [2 x %"any*"], ptr %varargslots42, i64 0, i64 0 + %59 = getelementptr inbounds [2 x %"any*"], ptr %varargslots41, i64 0, i64 0 store %"any*" %58, ptr %59, align 16 %60 = insertvalue %"any*" undef, ptr %x40, 0 %61 = insertvalue %"any*" %60, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %62 = getelementptr inbounds [2 x %"any*"], ptr %varargslots42, i64 0, i64 1 + %62 = getelementptr inbounds [2 x %"any*"], ptr %varargslots41, i64 0, i64 1 store %"any*" %61, ptr %62, align 16 - %63 = call i64 @std.io.printfn(ptr %retparam41, ptr @.str.8, i64 8, ptr %varargslots42, i64 2) + %63 = call i64 @std.io.printfn(ptr %retparam42, ptr @.str.8, i64 8, ptr %varargslots41, i64 2) %64 = load i64, ptr %.anon35, align 8 %add43 = add i64 %64, 1 store i64 %add43, ptr %.anon35, align 8 @@ -309,13 +309,13 @@ loop.body49: ; preds = %loop.cond47 store i32 %69, ptr %x51, align 4 %70 = insertvalue %"any*" undef, ptr %i50, 0 %71 = insertvalue %"any*" %70, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %72 = getelementptr inbounds [2 x %"any*"], ptr %varargslots53, i64 0, i64 0 + %72 = getelementptr inbounds [2 x %"any*"], ptr %varargslots52, i64 0, i64 0 store %"any*" %71, ptr %72, align 16 %73 = insertvalue %"any*" undef, ptr %x51, 0 %74 = insertvalue %"any*" %73, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %75 = getelementptr inbounds [2 x %"any*"], ptr %varargslots53, i64 0, i64 1 + %75 = getelementptr inbounds [2 x %"any*"], ptr %varargslots52, i64 0, i64 1 store %"any*" %74, ptr %75, align 16 - %76 = call i64 @std.io.printfn(ptr %retparam52, ptr @.str.10, i64 8, ptr %varargslots53, i64 2) + %76 = call i64 @std.io.printfn(ptr %retparam53, ptr @.str.10, i64 8, ptr %varargslots52, i64 2) %77 = load i64, ptr %.anon46, align 8 %add54 = add i64 %77, 1 store i64 %add54, ptr %.anon46, align 8 @@ -340,13 +340,13 @@ loop.body60: ; preds = %loop.cond58 store i32 %82, ptr %x62, align 4 %83 = insertvalue %"any*" undef, ptr %i61, 0 %84 = insertvalue %"any*" %83, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %85 = getelementptr inbounds [2 x %"any*"], ptr %varargslots64, i64 0, i64 0 + %85 = getelementptr inbounds [2 x %"any*"], ptr %varargslots63, i64 0, i64 0 store %"any*" %84, ptr %85, align 16 %86 = insertvalue %"any*" undef, ptr %x62, 0 %87 = insertvalue %"any*" %86, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %88 = getelementptr inbounds [2 x %"any*"], ptr %varargslots64, i64 0, i64 1 + %88 = getelementptr inbounds [2 x %"any*"], ptr %varargslots63, i64 0, i64 1 store %"any*" %87, ptr %88, align 16 - %89 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.12, i64 8, ptr %varargslots64, i64 2) + %89 = call i64 @std.io.printfn(ptr %retparam64, ptr @.str.12, i64 8, ptr %varargslots63, i64 2) %90 = load i64, ptr %.anon57, align 8 %add65 = add i64 %90, 1 store i64 %add65, ptr %.anon57, align 8 @@ -371,13 +371,13 @@ loop.body71: ; preds = %loop.cond69 store i32 %95, ptr %x73, align 4 %96 = insertvalue %"any*" undef, ptr %i72, 0 %97 = insertvalue %"any*" %96, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %98 = getelementptr inbounds [2 x %"any*"], ptr %varargslots75, i64 0, i64 0 + %98 = getelementptr inbounds [2 x %"any*"], ptr %varargslots74, i64 0, i64 0 store %"any*" %97, ptr %98, align 16 %99 = insertvalue %"any*" undef, ptr %x73, 0 %100 = insertvalue %"any*" %99, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %101 = getelementptr inbounds [2 x %"any*"], ptr %varargslots75, i64 0, i64 1 + %101 = getelementptr inbounds [2 x %"any*"], ptr %varargslots74, i64 0, i64 1 store %"any*" %100, ptr %101, align 16 - %102 = call i64 @std.io.printfn(ptr %retparam74, ptr @.str.14, i64 8, ptr %varargslots75, i64 2) + %102 = call i64 @std.io.printfn(ptr %retparam75, ptr @.str.14, i64 8, ptr %varargslots74, i64 2) %103 = load i64, ptr %.anon68, align 8 %add76 = add i64 %103, 1 store i64 %add76, ptr %.anon68, align 8 @@ -402,13 +402,13 @@ loop.body82: ; preds = %loop.cond80 store i32 %108, ptr %x84, align 4 %109 = insertvalue %"any*" undef, ptr %i83, 0 %110 = insertvalue %"any*" %109, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %111 = getelementptr inbounds [2 x %"any*"], ptr %varargslots86, i64 0, i64 0 + %111 = getelementptr inbounds [2 x %"any*"], ptr %varargslots85, i64 0, i64 0 store %"any*" %110, ptr %111, align 16 %112 = insertvalue %"any*" undef, ptr %x84, 0 %113 = insertvalue %"any*" %112, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %114 = getelementptr inbounds [2 x %"any*"], ptr %varargslots86, i64 0, i64 1 + %114 = getelementptr inbounds [2 x %"any*"], ptr %varargslots85, i64 0, i64 1 store %"any*" %113, ptr %114, align 16 - %115 = call i64 @std.io.printfn(ptr %retparam85, ptr @.str.16, i64 8, ptr %varargslots86, i64 2) + %115 = call i64 @std.io.printfn(ptr %retparam86, ptr @.str.16, i64 8, ptr %varargslots85, i64 2) %116 = load i64, ptr %.anon79, align 8 %add87 = add i64 %116, 1 store i64 %add87, ptr %.anon79, align 8 @@ -433,13 +433,13 @@ loop.body92: ; preds = %loop.cond90 store i32 %121, ptr %x94, align 4 %122 = insertvalue %"any*" undef, ptr %i93, 0 %123 = insertvalue %"any*" %122, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %124 = getelementptr inbounds [2 x %"any*"], ptr %varargslots96, i64 0, i64 0 + %124 = getelementptr inbounds [2 x %"any*"], ptr %varargslots95, i64 0, i64 0 store %"any*" %123, ptr %124, align 16 %125 = insertvalue %"any*" undef, ptr %x94, 0 %126 = insertvalue %"any*" %125, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %127 = getelementptr inbounds [2 x %"any*"], ptr %varargslots96, i64 0, i64 1 + %127 = getelementptr inbounds [2 x %"any*"], ptr %varargslots95, i64 0, i64 1 store %"any*" %126, ptr %127, align 16 - %128 = call i64 @std.io.printfn(ptr %retparam95, ptr @.str.18, i64 8, ptr %varargslots96, i64 2) + %128 = call i64 @std.io.printfn(ptr %retparam96, ptr @.str.18, i64 8, ptr %varargslots95, i64 2) %129 = load i64, ptr %.anon89, align 8 %add97 = add i64 %129, 1 store i64 %add97, ptr %.anon89, align 8 @@ -464,13 +464,13 @@ loop.body102: ; preds = %loop.cond100 store i32 %134, ptr %x104, align 4 %135 = insertvalue %"any*" undef, ptr %i103, 0 %136 = insertvalue %"any*" %135, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %137 = getelementptr inbounds [2 x %"any*"], ptr %varargslots106, i64 0, i64 0 + %137 = getelementptr inbounds [2 x %"any*"], ptr %varargslots105, i64 0, i64 0 store %"any*" %136, ptr %137, align 16 %138 = insertvalue %"any*" undef, ptr %x104, 0 %139 = insertvalue %"any*" %138, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %140 = getelementptr inbounds [2 x %"any*"], ptr %varargslots106, i64 0, i64 1 + %140 = getelementptr inbounds [2 x %"any*"], ptr %varargslots105, i64 0, i64 1 store %"any*" %139, ptr %140, align 16 - %141 = call i64 @std.io.printfn(ptr %retparam105, ptr @.str.20, i64 9, ptr %varargslots106, i64 2) + %141 = call i64 @std.io.printfn(ptr %retparam106, ptr @.str.20, i64 9, ptr %varargslots105, i64 2) %142 = load i64, ptr %.anon99, align 8 %add107 = add i64 %142, 1 store i64 %add107, ptr %.anon99, align 8 @@ -495,13 +495,13 @@ loop.body113: ; preds = %loop.cond111 store i32 %147, ptr %x115, align 4 %148 = insertvalue %"any*" undef, ptr %i114, 0 %149 = insertvalue %"any*" %148, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1 - %150 = getelementptr inbounds [2 x %"any*"], ptr %varargslots117, i64 0, i64 0 + %150 = getelementptr inbounds [2 x %"any*"], ptr %varargslots116, i64 0, i64 0 store %"any*" %149, ptr %150, align 16 %151 = insertvalue %"any*" undef, ptr %x115, 0 %152 = insertvalue %"any*" %151, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %153 = getelementptr inbounds [2 x %"any*"], ptr %varargslots117, i64 0, i64 1 + %153 = getelementptr inbounds [2 x %"any*"], ptr %varargslots116, i64 0, i64 1 store %"any*" %152, ptr %153, align 16 - %154 = call i64 @std.io.printfn(ptr %retparam116, ptr @.str.22, i64 6, ptr %varargslots117, i64 2) + %154 = call i64 @std.io.printfn(ptr %retparam117, ptr @.str.22, i64 6, ptr %varargslots116, i64 2) %155 = load i64, ptr %.anon110, align 8 %add118 = add i64 %155, 1 store i64 %add118, ptr %.anon110, align 8 diff --git a/test/test_suite/macros/userland_bitcast.c3t b/test/test_suite/macros/userland_bitcast.c3t index 0e65197b4..e4a4e33b6 100644 --- a/test/test_suite/macros/userland_bitcast.c3t +++ b/test/test_suite/macros/userland_bitcast.c3t @@ -259,10 +259,10 @@ loop.exit14: ; preds = %loop.cond8 store float %17, ptr %f2, align 4 %18 = load float, ptr %f, align 4 %fpfpext = fpext float %18 to double - %19 = load i32, ptr %i, align 4 - %20 = load float, ptr %f2, align 4 - %fpfpext15 = fpext float %20 to double - call void (ptr, ...) @printf(ptr @.str, double %fpfpext, i32 %19, double %fpfpext15) + %19 = load float, ptr %f2, align 4 + %fpfpext15 = fpext float %19 to double + %20 = load i32, ptr %i, align 4 + call void (ptr, ...) @printf(ptr @.str, double %fpfpext, i32 %20, double %fpfpext15) store double 1.235300e+268, ptr %d, align 8 %21 = load double, ptr %d, align 8 store double %21, ptr %expr16, align 8 diff --git a/test/test_suite/pointers/array_pointer_decay.c3t b/test/test_suite/pointers/array_pointer_decay.c3t index e3f8dea4c..2a0fb2023 100644 --- a/test/test_suite/pointers/array_pointer_decay.c3t +++ b/test/test_suite/pointers/array_pointer_decay.c3t @@ -60,19 +60,19 @@ entry: %ptroffset3 = getelementptr [3 x i32], ptr %11, i64 -1 store ptr %ptroffset3, ptr %zz, align 8 %12 = load ptr, ptr %y, align 8 - %13 = load ptr, ptr %z, align 8 - %14 = load ptr, ptr %zz, align 8 - %15 = load ptr, ptr %y, align 8 - %16 = getelementptr inbounds [3 x i32], ptr %15, i64 0, i64 1 + %13 = getelementptr inbounds [3 x i32], ptr %12, i64 0, i64 1 + %14 = load ptr, ptr %y, align 8 + %15 = load ptr, ptr %z, align 8 + %16 = load ptr, ptr %zz, align 8 %17 = load ptr, ptr %xx, align 8 - call void (ptr, ...) @printf(ptr @.str, ptr %12, ptr %13, ptr %14, ptr %16, ptr %17) + call void (ptr, ...) @printf(ptr @.str, ptr %14, ptr %15, ptr %16, ptr %13, ptr %17) %18 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 1 store i32 123, ptr %18, align 4 %19 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 1 - %20 = load i32, ptr %19, align 4 - %21 = load ptr, ptr %z, align 8 - %ptroffset4 = getelementptr inbounds i32, ptr %21, i64 1 + %20 = load ptr, ptr %z, align 8 + %ptroffset4 = getelementptr inbounds i32, ptr %20, i64 1 + %21 = load i32, ptr %19, align 4 %22 = load i32, ptr %ptroffset4, align 4 - call void (ptr, ...) @printf(ptr @.str.1, i32 %20, i32 %22) + call void (ptr, ...) @printf(ptr @.str.1, i32 %21, i32 %22) ret void } \ No newline at end of file diff --git a/test/test_suite/slices/slice_to_slice_assign.c3t b/test/test_suite/slices/slice_to_slice_assign.c3t index 5cee40221..5c67bfd88 100644 --- a/test/test_suite/slices/slice_to_slice_assign.c3t +++ b/test/test_suite/slices/slice_to_slice_assign.c3t @@ -25,24 +25,24 @@ entry: %z = alloca [7 x i32], align 16 %y = alloca [6 x i32], align 16 %taddr = alloca %"int[]", align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [2 x %"any*"], align 16 + %retparam = alloca i64, align 8 %taddr1 = alloca %"int[]", align 8 - %retparam2 = alloca i64, align 8 - %varargslots3 = alloca [2 x %"any*"], align 16 + %varargslots2 = alloca [2 x %"any*"], align 16 + %retparam3 = alloca i64, align 8 %a = alloca %"int[][]", align 8 %literal = alloca [1 x %"int[]"], align 16 %literal4 = alloca [1 x i32], align 4 %b = alloca %"int[][]", align 8 %literal5 = alloca [1 x %"int[]"], align 16 %literal6 = alloca [1 x i32], align 4 - %retparam7 = alloca i64, align 8 - %varargslots8 = alloca [1 x %"any*"], align 16 + %varargslots7 = alloca [1 x %"any*"], align 16 + %retparam8 = alloca i64, align 8 %taddr10 = alloca %"int[][]", align 8 - %retparam11 = alloca i64, align 8 - %varargslots12 = alloca [1 x %"any*"], align 16 - %retparam14 = alloca i64, align 8 - %varargslots15 = alloca [1 x %"any*"], align 16 + %varargslots11 = alloca [1 x %"any*"], align 16 + %retparam12 = alloca i64, align 8 + %varargslots14 = alloca [1 x %"any*"], align 16 + %retparam15 = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 16 %z, ptr align 16 @.__const, i32 28, i1 false) call void @llvm.memset.p0.i64(ptr align 16 %y, i8 0, i64 24, i1 false) %0 = getelementptr inbounds [7 x i32], ptr %z, i64 0, i64 3 @@ -82,13 +82,13 @@ entry: call void @llvm.memmove.p0.p0.i64(ptr align 4 %24, ptr align 4 %25, i64 %28, i1 false) %29 = insertvalue %"any*" undef, ptr %y, 0 %30 = insertvalue %"any*" %29, i64 ptrtoint (ptr @"$ct.a6$int" to i64), 1 - %31 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 0 + %31 = getelementptr inbounds [2 x %"any*"], ptr %varargslots2, i64 0, i64 0 store %"any*" %30, ptr %31, align 16 %32 = insertvalue %"any*" undef, ptr %z, 0 %33 = insertvalue %"any*" %32, i64 ptrtoint (ptr @"$ct.a7$int" to i64), 1 - %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 1 + %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots2, i64 0, i64 1 store %"any*" %33, ptr %34, align 16 - %35 = call i64 @std.io.printfn(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2) + %35 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.1, i64 5, ptr %varargslots2, i64 2) %36 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal4, ptr align 4 @.__const.2, i32 4, i1 false) %37 = insertvalue %"int[]" undef, ptr %literal4, 0 @@ -107,9 +107,9 @@ entry: store %"int[][]" %45, ptr %b, align 8 %46 = insertvalue %"any*" undef, ptr %a, 0 %47 = insertvalue %"any*" %46, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1 - %48 = getelementptr inbounds [1 x %"any*"], ptr %varargslots8, i64 0, i64 0 + %48 = getelementptr inbounds [1 x %"any*"], ptr %varargslots7, i64 0, i64 0 store %"any*" %47, ptr %48, align 16 - %49 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.4, i64 2, ptr %varargslots8, i64 1) + %49 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots7, i64 1) %50 = load %"int[][]", ptr %b, align 8 %51 = extractvalue %"int[][]" %50, 0 %ptroffset = getelementptr inbounds %"int[]", ptr %51, i64 0 @@ -129,9 +129,9 @@ entry: call void @llvm.memmove.p0.p0.i64(ptr align 8 %58, ptr align 8 %59, i64 %62, i1 false) %63 = insertvalue %"any*" undef, ptr %a, 0 %64 = insertvalue %"any*" %63, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1 - %65 = getelementptr inbounds [1 x %"any*"], ptr %varargslots12, i64 0, i64 0 + %65 = getelementptr inbounds [1 x %"any*"], ptr %varargslots11, i64 0, i64 0 store %"any*" %64, ptr %65, align 16 - %66 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.5, i64 2, ptr %varargslots12, i64 1) + %66 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.5, i64 2, ptr %varargslots11, i64 1) %67 = getelementptr inbounds [6 x i32], ptr %y, i64 0, i64 2 %68 = insertvalue %"int[]" undef, ptr %67, 0 %69 = insertvalue %"int[]" %68, i64 3, 1 @@ -141,8 +141,8 @@ entry: store %"int[]" %69, ptr %ptroffset13, align 8 %72 = insertvalue %"any*" undef, ptr %a, 0 %73 = insertvalue %"any*" %72, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1 - %74 = getelementptr inbounds [1 x %"any*"], ptr %varargslots15, i64 0, i64 0 + %74 = getelementptr inbounds [1 x %"any*"], ptr %varargslots14, i64 0, i64 0 store %"any*" %73, ptr %74, align 16 - %75 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.6, i64 2, ptr %varargslots15, i64 1) + %75 = call i64 @std.io.printfn(ptr %retparam15, ptr @.str.6, i64 2, ptr %varargslots14, i64 1) ret void } diff --git a/test/test_suite/slices/slice_to_slice_vector_assign.c3t b/test/test_suite/slices/slice_to_slice_vector_assign.c3t index cded731da..1024fd16d 100644 --- a/test/test_suite/slices/slice_to_slice_vector_assign.c3t +++ b/test/test_suite/slices/slice_to_slice_vector_assign.c3t @@ -26,24 +26,24 @@ entry: %z = alloca <7 x i32>, align 32 %y = alloca <6 x i32>, align 32 %taddr = alloca %"int[]", align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [2 x %"any*"], align 16 + %retparam = alloca i64, align 8 %taddr1 = alloca %"int[]", align 8 - %retparam2 = alloca i64, align 8 - %varargslots3 = alloca [2 x %"any*"], align 16 + %varargslots2 = alloca [2 x %"any*"], align 16 + %retparam3 = alloca i64, align 8 %a = alloca %"int[][]", align 8 %literal = alloca [1 x %"int[]"], align 16 %literal4 = alloca [1 x i32], align 4 %b = alloca %"int[][]", align 8 %literal5 = alloca [1 x %"int[]"], align 16 %literal6 = alloca [1 x i32], align 4 - %retparam7 = alloca i64, align 8 - %varargslots8 = alloca [1 x %"any*"], align 16 + %varargslots7 = alloca [1 x %"any*"], align 16 + %retparam8 = alloca i64, align 8 %taddr10 = alloca %"int[][]", align 8 - %retparam11 = alloca i64, align 8 - %varargslots12 = alloca [1 x %"any*"], align 16 - %retparam14 = alloca i64, align 8 - %varargslots15 = alloca [1 x %"any*"], align 16 + %varargslots11 = alloca [1 x %"any*"], align 16 + %retparam12 = alloca i64, align 8 + %varargslots14 = alloca [1 x %"any*"], align 16 + %retparam15 = alloca i64, align 8 store <7 x i32> , ptr %z, align 32 store <6 x i32> zeroinitializer, ptr %y, align 32 %0 = getelementptr inbounds <7 x i32>, ptr %z, i64 0, i64 3 @@ -83,13 +83,13 @@ entry: call void @llvm.memmove.p0.p0.i64(ptr align 4 %24, ptr align 4 %25, i64 %28, i1 false) %29 = insertvalue %"any*" undef, ptr %y, 0 %30 = insertvalue %"any*" %29, i64 ptrtoint (ptr @"$ct.v6$int" to i64), 1 - %31 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 0 + %31 = getelementptr inbounds [2 x %"any*"], ptr %varargslots2, i64 0, i64 0 store %"any*" %30, ptr %31, align 16 %32 = insertvalue %"any*" undef, ptr %z, 0 %33 = insertvalue %"any*" %32, i64 ptrtoint (ptr @"$ct.v7$int" to i64), 1 - %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 1 + %34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots2, i64 0, i64 1 store %"any*" %33, ptr %34, align 16 - %35 = call i64 @std.io.printfn(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2) + %35 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.1, i64 5, ptr %varargslots2, i64 2) %36 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal4, ptr align 4 @.__const, i32 4, i1 false) %37 = insertvalue %"int[]" undef, ptr %literal4, 0 @@ -108,9 +108,9 @@ entry: store %"int[][]" %45, ptr %b, align 8 %46 = insertvalue %"any*" undef, ptr %a, 0 %47 = insertvalue %"any*" %46, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1 - %48 = getelementptr inbounds [1 x %"any*"], ptr %varargslots8, i64 0, i64 0 + %48 = getelementptr inbounds [1 x %"any*"], ptr %varargslots7, i64 0, i64 0 store %"any*" %47, ptr %48, align 16 - %49 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1) + %49 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.3, i64 2, ptr %varargslots7, i64 1) %50 = load %"int[][]", ptr %b, align 8 %51 = extractvalue %"int[][]" %50, 0 %ptroffset = getelementptr inbounds %"int[]", ptr %51, i64 0 @@ -130,9 +130,9 @@ entry: call void @llvm.memmove.p0.p0.i64(ptr align 8 %58, ptr align 8 %59, i64 %62, i1 false) %63 = insertvalue %"any*" undef, ptr %a, 0 %64 = insertvalue %"any*" %63, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1 - %65 = getelementptr inbounds [1 x %"any*"], ptr %varargslots12, i64 0, i64 0 + %65 = getelementptr inbounds [1 x %"any*"], ptr %varargslots11, i64 0, i64 0 store %"any*" %64, ptr %65, align 16 - %66 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.4, i64 2, ptr %varargslots12, i64 1) + %66 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.4, i64 2, ptr %varargslots11, i64 1) %67 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 2 %68 = insertvalue %"int[]" undef, ptr %67, 0 %69 = insertvalue %"int[]" %68, i64 3, 1 @@ -142,8 +142,8 @@ entry: store %"int[]" %69, ptr %ptroffset13, align 8 %72 = insertvalue %"any*" undef, ptr %a, 0 %73 = insertvalue %"any*" %72, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1 - %74 = getelementptr inbounds [1 x %"any*"], ptr %varargslots15, i64 0, i64 0 + %74 = getelementptr inbounds [1 x %"any*"], ptr %varargslots14, i64 0, i64 0 store %"any*" %73, ptr %74, align 16 - %75 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.5, i64 2, ptr %varargslots15, i64 1) + %75 = call i64 @std.io.printfn(ptr %retparam15, ptr @.str.5, i64 2, ptr %varargslots14, i64 1) ret void } diff --git a/test/test_suite/statements/custom_foreach_with_ref.c3t b/test/test_suite/statements/custom_foreach_with_ref.c3t index a5d77f2a5..18c279767 100644 --- a/test/test_suite/statements/custom_foreach_with_ref.c3t +++ b/test/test_suite/statements/custom_foreach_with_ref.c3t @@ -170,14 +170,14 @@ entry: call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const.2, i32 12, i1 false) %0 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 %1 = getelementptr inbounds [3 x i32], ptr %0, i64 0, i64 0 - %2 = load i32, ptr %1, align 4 - %3 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 - %4 = getelementptr inbounds [3 x i32], ptr %3, i64 0, i64 1 - %5 = load i32, ptr %4, align 4 - %6 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 - %7 = getelementptr inbounds [3 x i32], ptr %6, i64 0, i64 2 - %8 = load i32, ptr %7, align 4 - call void (ptr, ...) @printf(ptr @.str.3, i32 %2, i32 %5, i32 %8) + %2 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 + %3 = getelementptr inbounds [3 x i32], ptr %2, i64 0, i64 1 + %4 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 + %5 = getelementptr inbounds [3 x i32], ptr %4, i64 0, i64 2 + %6 = load i32, ptr %1, align 4 + %7 = load i32, ptr %3, align 4 + %8 = load i32, ptr %5, align 4 + call void (ptr, ...) @printf(ptr @.str.3, i32 %6, i32 %7, i32 %8) %9 = call ptr @foo.call(ptr %x) store ptr %9, ptr %.anon, align 8 %10 = load ptr, ptr %.anon, align 8 @@ -236,10 +236,10 @@ loop.body7: ; preds = %loop.cond5 %31 = load i32, ptr %30, align 4 %add12 = add i32 %31, 1 store i32 %add12, ptr %30, align 4 - %32 = load i32, ptr %i8, align 4 - %33 = load ptr, ptr %y9, align 8 - %34 = load i32, ptr %33, align 4 - call void (ptr, ...) @printf(ptr @.str.5, i32 %32, i32 %34) + %32 = load ptr, ptr %y9, align 8 + %33 = load i32, ptr %i8, align 4 + %34 = load i32, ptr %32, align 4 + call void (ptr, ...) @printf(ptr @.str.5, i32 %33, i32 %34) %35 = load i32, ptr %.anon4, align 4 %add13 = add i32 %35, 1 store i32 %add13, ptr %.anon4, align 4 @@ -421,11 +421,11 @@ loop.body71: ; preds = %loop.cond69 loop.exit75: ; preds = %loop.cond69 %96 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 %97 = getelementptr inbounds [3 x i32], ptr %96, i64 0, i64 0 - %98 = load i32, ptr %97, align 4 - %99 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 - %100 = getelementptr inbounds [3 x i32], ptr %99, i64 0, i64 1 - %101 = load i32, ptr %100, align 4 - call void (ptr, ...) @printf(ptr @.str.13, i32 %98, i32 %101) + %98 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 + %99 = getelementptr inbounds [3 x i32], ptr %98, i64 0, i64 1 + %100 = load i32, ptr %97, align 4 + %101 = load i32, ptr %99, align 4 + call void (ptr, ...) @printf(ptr @.str.13, i32 %100, i32 %101) %102 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 %103 = getelementptr inbounds [3 x i32], ptr %102, i64 0, i64 1 store ptr %103, ptr %y76, align 8 @@ -435,10 +435,10 @@ loop.exit75: ; preds = %loop.cond69 store i32 %add77, ptr %104, align 4 %106 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 %107 = getelementptr inbounds [3 x i32], ptr %106, i64 0, i64 0 - %108 = load i32, ptr %107, align 4 - %109 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 - %110 = getelementptr inbounds [3 x i32], ptr %109, i64 0, i64 1 - %111 = load i32, ptr %110, align 4 - call void (ptr, ...) @printf(ptr @.str.14, i32 %108, i32 %111) + %108 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0 + %109 = getelementptr inbounds [3 x i32], ptr %108, i64 0, i64 1 + %110 = load i32, ptr %107, align 4 + %111 = load i32, ptr %109, align 4 + call void (ptr, ...) @printf(ptr @.str.14, i32 %110, i32 %111) ret void } diff --git a/test/test_suite/statements/fallthough_do.c3t b/test/test_suite/statements/fallthough_do.c3t index 673695553..3799ea3a4 100644 --- a/test/test_suite/statements/fallthough_do.c3t +++ b/test/test_suite/statements/fallthough_do.c3t @@ -45,9 +45,9 @@ entry: store i32 10, ptr %i, align 4 %0 = call i32 @foo.test() call void (ptr, ...) @printf(ptr @.str, i32 %0) - %1 = load i32, ptr %i, align 4 - %2 = call i32 @foo.test() - call void (ptr, ...) @printf(ptr @.str.1, i32 %1, i32 %2) + %1 = call i32 @foo.test() + %2 = load i32, ptr %i, align 4 + call void (ptr, ...) @printf(ptr @.str.1, i32 %2, i32 %1) %3 = load i32, ptr %i, align 4 %lt = icmp slt i32 %3, 0 br i1 %lt, label %if.then, label %if.exit @@ -56,9 +56,9 @@ if.then: ; preds = %entry br label %loop.exit if.exit: ; preds = %entry - %4 = load i32, ptr %i, align 4 - %5 = call i32 @foo.test() - call void (ptr, ...) @printf(ptr @.str.2, i32 %4, i32 %5) + %4 = call i32 @foo.test() + %5 = load i32, ptr %i, align 4 + call void (ptr, ...) @printf(ptr @.str.2, i32 %5, i32 %4) br label %loop.exit loop.exit: ; preds = %if.exit, %if.then @@ -70,9 +70,9 @@ if.then2: ; preds = %loop.exit br label %loop.exit4 if.exit3: ; preds = %loop.exit - %7 = load i32, ptr %i, align 4 - %8 = call i32 @foo.test() - call void (ptr, ...) @printf(ptr @.str.3, i32 %7, i32 %8) + %7 = call i32 @foo.test() + %8 = load i32, ptr %i, align 4 + call void (ptr, ...) @printf(ptr @.str.3, i32 %8, i32 %7) br label %loop.exit4 loop.exit4: ; preds = %if.exit3, %if.then2 diff --git a/test/test_suite/statements/foreach_common.c3t b/test/test_suite/statements/foreach_common.c3t index aa5c2df31..bafc3fb80 100644 --- a/test/test_suite/statements/foreach_common.c3t +++ b/test/test_suite/statements/foreach_common.c3t @@ -179,10 +179,10 @@ loop.body20: ; preds = %loop.cond18 %23 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %22 %24 = load float, ptr %23, align 4 store float %24, ptr %a21, align 4 - %25 = load i64, ptr %i, align 8 - %26 = load float, ptr %a21, align 4 - %fpfpext22 = fpext float %26 to double - call void (ptr, ...) @printf(ptr @.str.3, i64 %25, double %fpfpext22) + %25 = load float, ptr %a21, align 4 + %fpfpext22 = fpext float %25 to double + %26 = load i64, ptr %i, align 8 + call void (ptr, ...) @printf(ptr @.str.3, i64 %26, double %fpfpext22) %27 = load i64, ptr %.anon17, align 8 %add23 = add i64 %27, 1 store i64 %add23, ptr %.anon17, align 8 @@ -307,10 +307,10 @@ loop.body64: ; preds = %loop.cond62 %62 = load i64, ptr %.anon61, align 8 %63 = extractelement <3 x float> %61, i64 %62 store float %63, ptr %a66, align 4 - %64 = load i64, ptr %i65, align 8 - %65 = load float, ptr %a66, align 4 - %fpfpext67 = fpext float %65 to double - call void (ptr, ...) @printf(ptr @.str.8, i64 %64, double %fpfpext67) + %64 = load float, ptr %a66, align 4 + %fpfpext67 = fpext float %64 to double + %65 = load i64, ptr %i65, align 8 + call void (ptr, ...) @printf(ptr @.str.8, i64 %65, double %fpfpext67) %66 = load i64, ptr %.anon61, align 8 %add68 = add i64 %66, 1 store i64 %add68, ptr %.anon61, align 8 diff --git a/test/test_suite/statements/foreach_more_implementations.c3t b/test/test_suite/statements/foreach_more_implementations.c3t index edf4c4b9e..037dfc79d 100644 --- a/test/test_suite/statements/foreach_more_implementations.c3t +++ b/test/test_suite/statements/foreach_more_implementations.c3t @@ -49,15 +49,15 @@ entry: %.anon1 = alloca i64, align 8 %ref = alloca ptr, align 8 %element = alloca i64, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 %.anon3 = alloca i64, align 8 %vector4 = alloca %Vector, align 8 %.anon5 = alloca i64, align 8 %i = alloca i32, align 4 %element9 = alloca i64, align 8 - %retparam11 = alloca i64, align 8 - %varargslots12 = alloca [1 x %"any*"], align 16 + %varargslots11 = alloca [1 x %"any*"], align 16 + %retparam12 = alloca i64, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 8, i1 false) %0 = getelementptr inbounds %Vector, ptr %v, i32 0, i32 0 store i64 2, ptr %0, align 8 @@ -124,9 +124,9 @@ loop.body8: ; preds = %loop.cond6 store i32 %26, ptr %i, align 4 %27 = insertvalue %"any*" undef, ptr %i, 0 %28 = insertvalue %"any*" %27, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %29 = getelementptr inbounds [1 x %"any*"], ptr %varargslots12, i64 0, i64 0 + %29 = getelementptr inbounds [1 x %"any*"], ptr %varargslots11, i64 0, i64 0 store %"any*" %28, ptr %29, align 16 - %30 = call i64 @std.io.printf(ptr %retparam11, ptr @.str.1, i64 3, ptr %varargslots12, i64 1) + %30 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.1, i64 3, ptr %varargslots11, i64 1) %31 = load i64, ptr %.anon5, align 8 %add13 = add i64 %31, 1 store i64 %add13, ptr %.anon5, align 8 diff --git a/test/test_suite/statements/foreach_r_common.c3t b/test/test_suite/statements/foreach_r_common.c3t index 2f35bc1e1..ee955888b 100644 --- a/test/test_suite/statements/foreach_r_common.c3t +++ b/test/test_suite/statements/foreach_r_common.c3t @@ -177,10 +177,10 @@ loop.body20: ; preds = %loop.cond18 %24 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %23 %25 = load float, ptr %24, align 4 store float %25, ptr %a22, align 4 - %26 = load i64, ptr %i, align 8 - %27 = load float, ptr %a22, align 4 - %fpfpext23 = fpext float %27 to double - call void (ptr, ...) @printf(ptr @.str.3, i64 %26, double %fpfpext23) + %26 = load float, ptr %a22, align 4 + %fpfpext23 = fpext float %26 to double + %27 = load i64, ptr %i, align 8 + call void (ptr, ...) @printf(ptr @.str.3, i64 %27, double %fpfpext23) br label %loop.cond18 loop.exit24: ; preds = %loop.cond18 @@ -299,10 +299,10 @@ loop.body62: ; preds = %loop.cond60 %60 = load i64, ptr %.anon59, align 8 %61 = extractelement <3 x float> %59, i64 %60 store float %61, ptr %a65, align 4 - %62 = load i64, ptr %i64, align 8 - %63 = load float, ptr %a65, align 4 - %fpfpext66 = fpext float %63 to double - call void (ptr, ...) @printf(ptr @.str.8, i64 %62, double %fpfpext66) + %62 = load float, ptr %a65, align 4 + %fpfpext66 = fpext float %62 to double + %63 = load i64, ptr %i64, align 8 + call void (ptr, ...) @printf(ptr @.str.8, i64 %63, double %fpfpext66) br label %loop.cond60 loop.exit67: ; preds = %loop.cond60 diff --git a/test/test_suite/statements/simple_do.c3t b/test/test_suite/statements/simple_do.c3t index ee6114f17..842b772d1 100644 --- a/test/test_suite/statements/simple_do.c3t +++ b/test/test_suite/statements/simple_do.c3t @@ -86,9 +86,9 @@ loop.cond2: ; preds = %if.exit5 br i1 %lt, label %loop.body3, label %loop.exit6 loop.body3: ; preds = %loop.cond2, %loop.exit - %4 = load i32, ptr %i, align 4 - %5 = call i32 @foo.test() - call void (ptr, ...) @printf(ptr @.str.1, i32 %4, i32 %5) + %4 = call i32 @foo.test() + %5 = load i32, ptr %i, align 4 + call void (ptr, ...) @printf(ptr @.str.1, i32 %5, i32 %4) %6 = load i32, ptr %i, align 4 %smod = srem i32 %6, 3 %eq = icmp eq i32 %smod, 0 diff --git a/test/test_suite/stdlib/map.c3t b/test/test_suite/stdlib/map.c3t index f4d1e5629..5027920f5 100644 --- a/test/test_suite/stdlib/map.c3t +++ b/test/test_suite/stdlib/map.c3t @@ -57,8 +57,8 @@ fn void main() define { ptr, i64 } @test.Foo.to_string(ptr %0, ptr %1) #0 { entry: %s = alloca ptr, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [2 x %"any*"], align 16 + %retparam = alloca i64, align 8 %result = alloca %"char[]", align 8 %2 = call ptr @std.core.dstring.new_with_capacity(i64 128, ptr %1) store ptr %2, ptr %s, align 8 @@ -84,46 +84,46 @@ entry: define void @test.main() #0 { entry: %map = alloca %HashMap, align 8 - %retparam = alloca i64, align 8 %varargslots = alloca [1 x %"any*"], align 16 + %retparam = alloca i64, align 8 %literal = alloca %Foo, align 8 - %retparam1 = alloca i64, align 8 - %varargslots2 = alloca [1 x %"any*"], align 16 + %varargslots1 = alloca [1 x %"any*"], align 16 + %retparam2 = alloca i64, align 8 %literal3 = alloca %Foo, align 8 - %retparam6 = alloca i64, align 8 - %varargslots7 = alloca [1 x %"any*"], align 16 - %retparam8 = alloca i64, align 8 - %varargslots9 = alloca [1 x %"any*"], align 16 - %retparam10 = alloca %Foo, align 8 - %retparam13 = alloca i64, align 8 - %varargslots14 = alloca [1 x %"any*"], align 16 + %varargslots6 = alloca [1 x %"any*"], align 16 + %retparam7 = alloca i64, align 8 + %varargslots8 = alloca [1 x %"any*"], align 16 + %retparam9 = alloca %Foo, align 8 + %retparam10 = alloca i64, align 8 + %varargslots13 = alloca [1 x %"any*"], align 16 %taddr = alloca i8, align 1 - %retparam17 = alloca i64, align 8 - %varargslots18 = alloca [1 x %"any*"], align 16 - %taddr19 = alloca i8, align 1 + %retparam14 = alloca i64, align 8 + %varargslots17 = alloca [1 x %"any*"], align 16 + %taddr18 = alloca i8, align 1 + %retparam19 = alloca i64, align 8 %literal22 = alloca %Foo, align 8 - %retparam25 = alloca i64, align 8 - %varargslots26 = alloca [1 x %"any*"], align 16 + %varargslots25 = alloca [1 x %"any*"], align 16 %result = alloca %"Foo[]", align 8 + %retparam26 = alloca i64, align 8 %map2 = alloca %HashMap.0, align 8 - %retparam29 = alloca i64, align 8 - %varargslots30 = alloca [1 x %"any*"], align 16 - %taddr31 = alloca i8, align 1 - %retparam34 = alloca i64, align 8 - %varargslots35 = alloca [1 x %"any*"], align 16 - %taddr36 = alloca i8, align 1 - %retparam39 = alloca i64, align 8 - %varargslots40 = alloca [1 x %"any*"], align 16 - %result41 = alloca %"int[]", align 8 - %retparam44 = alloca i64, align 8 - %varargslots45 = alloca [1 x %"any*"], align 16 - %result46 = alloca %"double[]", align 8 + %varargslots29 = alloca [1 x %"any*"], align 16 + %taddr30 = alloca i8, align 1 + %retparam31 = alloca i64, align 8 + %varargslots34 = alloca [1 x %"any*"], align 16 + %taddr35 = alloca i8, align 1 + %retparam36 = alloca i64, align 8 + %varargslots39 = alloca [1 x %"any*"], align 16 + %result40 = alloca %"int[]", align 8 + %retparam41 = alloca i64, align 8 + %varargslots44 = alloca [1 x %"any*"], align 16 + %result45 = alloca %"double[]", align 8 + %retparam46 = alloca i64, align 8 %current = alloca ptr, align 8 %mark = alloca i64, align 8 %map3 = alloca %HashMap.0, align 8 - %retparam49 = alloca i64, align 8 - %varargslots50 = alloca [1 x %"any*"], align 16 - %result51 = alloca %"int[]", align 8 + %varargslots49 = alloca [1 x %"any*"], align 16 + %result50 = alloca %"int[]", align 8 + %retparam51 = alloca i64, align 8 %mark54 = alloca i64, align 8 %retparam55 = alloca ptr, align 8 call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false) @@ -144,9 +144,9 @@ entry: %9 = getelementptr inbounds %HashMap, ptr %map, i32 0, i32 2 %10 = insertvalue %"any*" undef, ptr %9, 0 %11 = insertvalue %"any*" %10, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0 + %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots1, i64 0, i64 0 store %"any*" %11, ptr %12, align 16 - %13 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.1, i64 12, ptr %varargslots2, i64 1) + %13 = call i64 @std.io.printfn(ptr %retparam2, ptr @.str.1, i64 12, ptr %varargslots1, i64 1) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal3, ptr align 8 @.__const.2, i32 16, i1 false) %14 = getelementptr inbounds { i64, ptr }, ptr %literal3, i32 0, i32 0 %lo4 = load i64, ptr %14, align 8 @@ -156,21 +156,21 @@ entry: %17 = getelementptr inbounds %HashMap, ptr %map, i32 0, i32 2 %18 = insertvalue %"any*" undef, ptr %17, 0 %19 = insertvalue %"any*" %18, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - %20 = getelementptr inbounds [1 x %"any*"], ptr %varargslots7, i64 0, i64 0 + %20 = getelementptr inbounds [1 x %"any*"], ptr %varargslots6, i64 0, i64 0 store %"any*" %19, ptr %20, align 16 - %21 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.3, i64 12, ptr %varargslots7, i64 1) - %22 = call i64 @"std.collections.map$int$test.Foo$.HashMap.get"(ptr %retparam10, ptr %map, i32 1) + %21 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 12, ptr %varargslots6, i64 1) + %22 = call i64 @"std.collections.map$int$test.Foo$.HashMap.get"(ptr %retparam9, ptr %map, i32 1) %not_err = icmp eq i64 %22, 0 %23 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) br i1 %23, label %after_check, label %after_check12 after_check: ; preds = %entry - %24 = getelementptr inbounds %Foo, ptr %retparam10, i32 0, i32 0 + %24 = getelementptr inbounds %Foo, ptr %retparam9, i32 0, i32 0 %25 = insertvalue %"any*" undef, ptr %24, 0 %26 = insertvalue %"any*" %25, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %27 = getelementptr inbounds [1 x %"any*"], ptr %varargslots9, i64 0, i64 0 + %27 = getelementptr inbounds [1 x %"any*"], ptr %varargslots8, i64 0, i64 0 store %"any*" %26, ptr %27, align 16 - %28 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 7, ptr %varargslots9, i64 1) + %28 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.4, i64 7, ptr %varargslots8, i64 1) %not_err11 = icmp eq i64 %28, 0 %29 = call i1 @llvm.expect.i1(i1 %not_err11, i1 true) br i1 %29, label %after_check12, label %after_check12 @@ -180,16 +180,16 @@ after_check12: ; preds = %entry, %after_check store i8 %30, ptr %taddr, align 1 %31 = insertvalue %"any*" undef, ptr %taddr, 0 %32 = insertvalue %"any*" %31, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %33 = getelementptr inbounds [1 x %"any*"], ptr %varargslots14, i64 0, i64 0 + %33 = getelementptr inbounds [1 x %"any*"], ptr %varargslots13, i64 0, i64 0 store %"any*" %32, ptr %33, align 16 - %34 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.5, i64 9, ptr %varargslots14, i64 1) + %34 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.5, i64 9, ptr %varargslots13, i64 1) %35 = call i8 @"std.collections.map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2) - store i8 %35, ptr %taddr19, align 1 - %36 = insertvalue %"any*" undef, ptr %taddr19, 0 + store i8 %35, ptr %taddr18, align 1 + %36 = insertvalue %"any*" undef, ptr %taddr18, 0 %37 = insertvalue %"any*" %36, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %38 = getelementptr inbounds [1 x %"any*"], ptr %varargslots18, i64 0, i64 0 + %38 = getelementptr inbounds [1 x %"any*"], ptr %varargslots17, i64 0, i64 0 store %"any*" %37, ptr %38, align 16 - %39 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.6, i64 9, ptr %varargslots18, i64 1) + %39 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.6, i64 9, ptr %varargslots17, i64 1) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal22, ptr align 8 @.__const.7, i32 16, i1 false) %40 = getelementptr inbounds { i64, ptr }, ptr %literal22, i32 0, i32 0 %lo23 = load i64, ptr %40, align 8 @@ -201,44 +201,44 @@ after_check12: ; preds = %entry, %after_check store { ptr, i64 } %44, ptr %result, align 8 %45 = insertvalue %"any*" undef, ptr %result, 0 %46 = insertvalue %"any*" %45, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1 - %47 = getelementptr inbounds [1 x %"any*"], ptr %varargslots26, i64 0, i64 0 + %47 = getelementptr inbounds [1 x %"any*"], ptr %varargslots25, i64 0, i64 0 store %"any*" %46, ptr %47, align 16 - %48 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.8, i64 10, ptr %varargslots26, i64 1) + %48 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.8, i64 10, ptr %varargslots25, i64 1) call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 40, i1 false) %49 = load ptr, ptr @std.core.mem.thread_allocator, align 8 call void @"std.collections.map$int$double$.HashMap.init"(ptr %map2, i32 16, float 7.500000e-01, ptr %49) %50 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00) %51 = call i8 @"std.collections.map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00) - store i8 %51, ptr %taddr31, align 1 - %52 = insertvalue %"any*" undef, ptr %taddr31, 0 + store i8 %51, ptr %taddr30, align 1 + %52 = insertvalue %"any*" undef, ptr %taddr30, 0 %53 = insertvalue %"any*" %52, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %54 = getelementptr inbounds [1 x %"any*"], ptr %varargslots30, i64 0, i64 0 + %54 = getelementptr inbounds [1 x %"any*"], ptr %varargslots29, i64 0, i64 0 store %"any*" %53, ptr %54, align 16 - %55 = call i64 @std.io.printfn(ptr %retparam29, ptr @.str.9, i64 12, ptr %varargslots30, i64 1) + %55 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.9, i64 12, ptr %varargslots29, i64 1) %56 = call i8 @"std.collections.map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00) - store i8 %56, ptr %taddr36, align 1 - %57 = insertvalue %"any*" undef, ptr %taddr36, 0 + store i8 %56, ptr %taddr35, align 1 + %57 = insertvalue %"any*" undef, ptr %taddr35, 0 %58 = insertvalue %"any*" %57, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - %59 = getelementptr inbounds [1 x %"any*"], ptr %varargslots35, i64 0, i64 0 + %59 = getelementptr inbounds [1 x %"any*"], ptr %varargslots34, i64 0, i64 0 store %"any*" %58, ptr %59, align 16 - %60 = call i64 @std.io.printfn(ptr %retparam34, ptr @.str.10, i64 12, ptr %varargslots35, i64 1) + %60 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.10, i64 12, ptr %varargslots34, i64 1) %61 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00) %62 = load ptr, ptr @std.core.mem.thread_allocator, align 8 %63 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_list"(ptr %map2, ptr %62) - store { ptr, i64 } %63, ptr %result41, align 8 - %64 = insertvalue %"any*" undef, ptr %result41, 0 + store { ptr, i64 } %63, ptr %result40, align 8 + %64 = insertvalue %"any*" undef, ptr %result40, 0 %65 = insertvalue %"any*" %64, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 - %66 = getelementptr inbounds [1 x %"any*"], ptr %varargslots40, i64 0, i64 0 + %66 = getelementptr inbounds [1 x %"any*"], ptr %varargslots39, i64 0, i64 0 store %"any*" %65, ptr %66, align 16 - %67 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.11, i64 2, ptr %varargslots40, i64 1) + %67 = call i64 @std.io.printfn(ptr %retparam41, ptr @.str.11, i64 2, ptr %varargslots39, i64 1) %68 = load ptr, ptr @std.core.mem.thread_allocator, align 8 %69 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.value_list"(ptr %map2, ptr %68) - store { ptr, i64 } %69, ptr %result46, align 8 - %70 = insertvalue %"any*" undef, ptr %result46, 0 + store { ptr, i64 } %69, ptr %result45, align 8 + %70 = insertvalue %"any*" undef, ptr %result45, 0 %71 = insertvalue %"any*" %70, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1 - %72 = getelementptr inbounds [1 x %"any*"], ptr %varargslots45, i64 0, i64 0 + %72 = getelementptr inbounds [1 x %"any*"], ptr %varargslots44, i64 0, i64 0 store %"any*" %71, ptr %72, align 16 - %73 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.12, i64 2, ptr %varargslots45, i64 1) + %73 = call i64 @std.io.printfn(ptr %retparam46, ptr @.str.12, i64 2, ptr %varargslots44, i64 1) %74 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8 %not = icmp eq ptr %74, null br i1 %not, label %if.then, label %if.exit @@ -261,12 +261,12 @@ if.exit: ; preds = %if.then, %after_che %81 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00) %82 = load ptr, ptr @std.core.mem.thread_allocator, align 8 %83 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_list"(ptr %map3, ptr %82) - store { ptr, i64 } %83, ptr %result51, align 8 - %84 = insertvalue %"any*" undef, ptr %result51, 0 + store { ptr, i64 } %83, ptr %result50, align 8 + %84 = insertvalue %"any*" undef, ptr %result50, 0 %85 = insertvalue %"any*" %84, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 - %86 = getelementptr inbounds [1 x %"any*"], ptr %varargslots50, i64 0, i64 0 + %86 = getelementptr inbounds [1 x %"any*"], ptr %varargslots49, i64 0, i64 0 store %"any*" %85, ptr %86, align 16 - %87 = call i64 @std.io.printfn(ptr %retparam49, ptr @.str.13, i64 2, ptr %varargslots50, i64 1) + %87 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.13, i64 2, ptr %varargslots49, i64 1) %88 = load ptr, ptr %current, align 8 %89 = getelementptr inbounds %TempAllocator, ptr %88, i32 0, i32 0 %90 = load i64, ptr %mark, align 8