diff --git a/lib/std/core/builtin.c3 b/lib/std/core/builtin.c3 index 78d4bf0ed..f7179051e 100644 --- a/lib/std/core/builtin.c3 +++ b/lib/std/core/builtin.c3 @@ -56,12 +56,12 @@ macro varcast(variant v, $Type) @builtin struct CallstackElement { CallstackElement* prev; - char* function; - char* file; + char[] function; + char[] file; uint line; } -fn void panic(char* message, char *file, char *function, uint line) @builtin +fn void default_panic(char[] message, char[] file, char[] function, uint line) { CallstackElement* stack = $$stacktrace(); $if ($defined(libc::stderr) && $defined(libc::fprintf)): @@ -69,24 +69,29 @@ fn void panic(char* message, char *file, char *function, uint line) @builtin if (stack) stack = stack.prev; if (stack) { - libc::fprintf(libc::stderr(), "\nERROR: '%s'\n", message); + libc::fprintf(libc::stderr(), "\nERROR: '%.*s'\n", (int)message.len, message.ptr); } else { - libc::fprintf(libc::stderr(), "\nERROR: '%s', function %s (%s:%d)\n", message, function, file, line); + libc::fprintf(libc::stderr(), "\nERROR: '%.*s', function %.*s (%.*s:%d)\n", + (int)message.len, message.ptr, (int)function.len, function.ptr, (int)file.len, file.ptr, line); } while (stack) { - libc::fprintf(libc::stderr(), " at function %s (%s:%u)\n", stack.function, stack.file, stack.line); + libc::fprintf(libc::stderr(), " at function %.*s (%.*s:%u)\n", (int)stack.function.len, stack.function.ptr, + (int)stack.file.len, stack.file.ptr, stack.line); if (stack == stack.prev) break; stack = stack.prev; } $endif; - $$trap(); } +define PanicFn = fn void(char[] message, char[] file, char[] function, uint line); + +PanicFn panic = &default_panic; + macro void unreachable($string = "Unreachable statement reached.") @builtin @noreturn { panic($string, $$FILE, $$FUNC, $$LINE); diff --git a/lib/std/runtime.c3 b/lib/std/runtime.c3 index a1e02ea15..e6422e550 100644 --- a/lib/std/runtime.c3 +++ b/lib/std/runtime.c3 @@ -28,3 +28,33 @@ struct VarArrayHeader void *allocator; } +struct TestRunner +{ + char** test_names; + void** test_fns; + uint count; +} + +fn TestRunner test_runner_create() +{ + return TestRunner { + .test_names = $$TEST_NAMES, + .test_fns = $$TEST_FNS, + .count = $$TEST_COUNT, + }; +} + +extern fn void puts(char* c); + +fn void TestRunner.run(TestRunner* runner) +{ + for (uint i = 0; i < runner.count; i++) + { + puts(runner.test_names[i]); + } +} + +fn void run_test_runner() +{ + test_runner_create().run(); +} \ No newline at end of file diff --git a/src/compiler/codegen_general.c b/src/compiler/codegen_general.c index 263ba4adb..ec4f9242a 100644 --- a/src/compiler/codegen_general.c +++ b/src/compiler/codegen_general.c @@ -1,5 +1,8 @@ #include "codegen_internal.h" +const char *test_fns_var_name = "__$C3_TEST_FN_LIST"; +const char *test_count_var_name = "__$C3_TEST_COUNT"; +const char *test_names_var_name = "__$C3_TEST_NAMES_LIST"; /** * Based on isSingleElementStruct in Clang */ diff --git a/src/compiler/codegen_internal.h b/src/compiler/codegen_internal.h index 42d18cb31..d769c57ac 100644 --- a/src/compiler/codegen_internal.h +++ b/src/compiler/codegen_internal.h @@ -56,4 +56,8 @@ static inline bool abi_type_is_promotable_integer_or_bool(AbiType type) return false; } -const char *codegen_create_asm(Ast *ast); \ No newline at end of file +const char *codegen_create_asm(Ast *ast); + +extern const char *test_fns_var_name; +extern const char *test_count_var_name; +extern const char *test_names_var_name; \ No newline at end of file diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h index c962853a7..d2bef6f02 100644 --- a/src/compiler/compiler_internal.h +++ b/src/compiler/compiler_internal.h @@ -546,6 +546,7 @@ typedef struct bool attr_noinline : 1; bool attr_extname : 1; bool attr_naked : 1; + bool attr_test : 1; }; struct { @@ -1143,6 +1144,7 @@ struct Expr_ ExprMacroBlock macro_block; // 24 Expr** cond_expr; // 8 ExprBuiltin builtin_expr; // 16 + BuiltinDefine test_hook_expr; }; }; //static_assert(sizeof(ExprConst) == 32, "Not expected size"); @@ -1457,6 +1459,7 @@ typedef struct Module_ Module *parent_module; Module *top_module; Module **sub_modules; + Decl **tests; } Module; @@ -1655,7 +1658,7 @@ typedef struct DeclTable symbols; DeclTable generic_symbols; Path std_module_path; - Decl *panic_fn; + Decl *panic_var; Decl *main; Decl *decl_stack[MAX_GLOBAL_DECL_STACK]; Decl** decl_stack_bottom; @@ -2262,6 +2265,7 @@ bool type_is_ordered(Type *type); unsigned type_get_introspection_kind(TypeKind kind); void type_mangle_introspect_name_to_buffer(Type *type); AlignSize type_abi_alignment(Type *type); +bool type_func_match(Type *fn_type, Type *rtype, unsigned arg_count, ...); AlignSize type_alloca_alignment(Type *type); Type *type_find_common_ancestor(Type *left, Type *right); Type *type_find_largest_union_element(Type *type); @@ -2743,6 +2747,13 @@ bool type_is_scalar(Type *type); INLINE bool type_is_signed(Type *type) { return type->type_kind >= TYPE_I8 && type->type_kind < TYPE_U8; } +INLINE bool type_is_func_ptr(Type *fn_type) +{ + fn_type = fn_type->canonical; + if (fn_type->type_kind != TYPE_POINTER) return false; + return fn_type->pointer->type_kind == TYPE_FUNC; +} + INLINE bool type_is_len_inferred(Type *type) { TypeKind kind = type->type_kind; diff --git a/src/compiler/copying.c b/src/compiler/copying.c index 71fdcf9a0..bfe5854af 100644 --- a/src/compiler/copying.c +++ b/src/compiler/copying.c @@ -345,6 +345,7 @@ Expr *copy_expr(CopyStruct *c, Expr *source_expr) case EXPR_HASH_IDENT: assert(expr->resolve_status != RESOLVE_DONE); return expr; + case EXPR_TEST_HOOK: case EXPR_COMPILER_CONST: return expr; case EXPR_DESIGNATOR: diff --git a/src/compiler/enums.h b/src/compiler/enums.h index 846d22a4a..22b5fe264 100644 --- a/src/compiler/enums.h +++ b/src/compiler/enums.h @@ -256,6 +256,7 @@ typedef enum EXPR_SUBSCRIPT_ADDR, EXPR_SUBSCRIPT_ASSIGN, EXPR_TERNARY, + EXPR_TEST_HOOK, EXPR_TRY, EXPR_TRY_UNWRAP, EXPR_TRY_UNWRAP_CHAIN, @@ -776,6 +777,7 @@ typedef enum ATTRIBUTE_REGCALL, ATTRIBUTE_SECTION, ATTRIBUTE_STDCALL, + ATTRIBUTE_TEST, ATTRIBUTE_UNUSED, ATTRIBUTE_USED, ATTRIBUTE_VECCALL, @@ -898,6 +900,9 @@ typedef enum BUILTIN_DEF_LINE, BUILTIN_DEF_LINE_RAW, BUILTIN_DEF_MODULE, + BUILTIN_DEF_TEST_COUNT, + BUILTIN_DEF_TEST_NAMES, + BUILTIN_DEF_TEST_FNS, BUILTIN_DEF_TIME, BUILTIN_DEF_NONE, NUMBER_OF_BUILTIN_DEFINES = BUILTIN_DEF_NONE diff --git a/src/compiler/expr.c b/src/compiler/expr.c index ba5cecf5d..22de22261 100644 --- a/src/compiler/expr.c +++ b/src/compiler/expr.c @@ -80,6 +80,8 @@ bool expr_may_addr(Expr *expr) case EXPR_SUBSCRIPT: case EXPR_SLICE: return true; + case EXPR_TEST_HOOK: + return false; case EXPR_ARGV_TO_SUBARRAY: case EXPR_ASM: case EXPR_BINARY: @@ -163,6 +165,7 @@ bool expr_is_constant_eval(Expr *expr, ConstantEvalKind eval_kind) case EXPR_BUILTIN: case EXPR_CT_EVAL: case EXPR_VASPLAT: + case EXPR_TEST_HOOK: return false; case EXPR_BITACCESS: case EXPR_ACCESS: @@ -309,13 +312,15 @@ bool expr_is_constant_eval(Expr *expr, ConstantEvalKind eval_kind) return false; } UNREACHABLE + case EXPR_COMPILER_CONST: + // Not foldable + return false; case EXPR_CT_CALL: case EXPR_TYPEINFO: case EXPR_HASH_IDENT: case EXPR_CT_IDENT: case EXPR_FLATPATH: case EXPR_COMPOUND_LITERAL: - case EXPR_COMPILER_CONST: case EXPR_POISONED: case EXPR_ARGV_TO_SUBARRAY: case EXPR_CT_ARG: @@ -629,6 +634,7 @@ bool expr_is_pure(Expr *expr) switch (expr->expr_kind) { case EXPR_BUILTIN: + case EXPR_TEST_HOOK: return false; case EXPR_BUILTIN_ACCESS: return exprid_is_pure(expr->builtin_access_expr.inner); diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c index 5680c3260..27281bc30 100644 --- a/src/compiler/llvm_codegen.c +++ b/src/compiler/llvm_codegen.c @@ -1004,6 +1004,77 @@ LLVMValueRef llvm_get_ref(GenContext *c, Decl *decl) UNREACHABLE } +INLINE void llvm_gen_tests(GenContext *test_owner, Module** modules, unsigned module_count) +{ + LLVMValueRef *names = NULL; + LLVMValueRef *decls = NULL; + + LLVMTypeRef void_test = LLVMFunctionType(LLVMVoidTypeInContext(test_owner->context), NULL, 0, false); + LLVMTypeRef opt_test = LLVMFunctionType(test_owner->fault_type, NULL, 0, false); + for (unsigned i = 0; i < module_count; i++) + { + Module *module = modules[i]; + bool gen_proto = test_owner->code_module != module; + FOREACH_BEGIN(Decl *test, module->tests) + LLVMValueRef ref; + if (gen_proto) + { + LLVMTypeRef type = test->type->function.prototype->rtype == type_void ? void_test : opt_test; + ref = LLVMAddFunction(test_owner->module, test->extname, type); + } + else + { + ref = test->backend_ref; + } + scratch_buffer_clear(); + scratch_buffer_printf("%s::%s", module->name->module, test->name); + LLVMTypeRef char_array_type = LLVMArrayType(test_owner->byte_type, scratch_buffer.len + 1); + LLVMValueRef global_string = llvm_add_global_raw(test_owner, ".test", char_array_type, 0); + llvm_set_internal_linkage(global_string); + LLVMSetGlobalConstant(global_string, 1); + LLVMSetInitializer(global_string, llvm_get_zstring(test_owner, scratch_buffer_to_string(), scratch_buffer.len)); + LLVMValueRef str = LLVMBuildBitCast(test_owner->builder, global_string, test_owner->char_ptr_type, ""); + vec_add(names, str); + ref = LLVMBuildBitCast(test_owner->builder, ref, test_owner->char_ptr_type, ""); + vec_add(decls, ref); + FOREACH_END(); + } + unsigned test_count = vec_size(decls); + LLVMTypeRef ptr_of_chars_ptrs = LLVMPointerType(test_owner->char_ptr_type, 0); + LLVMValueRef name_ref; + LLVMValueRef decl_ref; + if (test_count) + { + LLVMValueRef array_of_names = LLVMConstArray(test_owner->char_ptr_type, names, test_count); + LLVMValueRef array_of_decls = LLVMConstArray(test_owner->char_ptr_type, decls, test_count); + LLVMTypeRef arr_type = LLVMTypeOf(array_of_names); + name_ref = llvm_add_global_raw(test_owner, ".test_names", arr_type, llvm_alloc_size(test_owner, arr_type)); + decl_ref = llvm_add_global_raw(test_owner, ".test_decls", arr_type, llvm_alloc_size(test_owner, arr_type)); + llvm_set_internal_linkage(name_ref); + llvm_set_internal_linkage(decl_ref); + LLVMSetGlobalConstant(name_ref, 1); + LLVMSetGlobalConstant(decl_ref, 1); + LLVMSetInitializer(name_ref, array_of_names); + LLVMSetInitializer(decl_ref, array_of_decls); + name_ref = LLVMBuildBitCast(test_owner->builder, name_ref, ptr_of_chars_ptrs, ""); + decl_ref = LLVMBuildBitCast(test_owner->builder, decl_ref, ptr_of_chars_ptrs, ""); + } + else + { + name_ref = LLVMConstNull(ptr_of_chars_ptrs); + decl_ref = LLVMConstNull(ptr_of_chars_ptrs); + } + LLVMValueRef name_list = llvm_add_global_raw(test_owner, "C3_TEST_NAME_LIST", ptr_of_chars_ptrs, llvm_alloc_size(test_owner, ptr_of_chars_ptrs)); + LLVMSetGlobalConstant(name_list, 1); + LLVMSetInitializer(name_list, name_ref); + LLVMValueRef decl_list = llvm_add_global_raw(test_owner, "C3_TEST_DECL_LIST", ptr_of_chars_ptrs, llvm_alloc_size(test_owner, ptr_of_chars_ptrs)); + LLVMSetGlobalConstant(decl_list, 1); + LLVMSetInitializer(decl_list, decl_ref); + LLVMTypeRef int_len_type = LLVMInt32TypeInContext(test_owner->context); + LLVMValueRef name_count = llvm_add_global_raw(test_owner, "C3_TEST_COUNT", int_len_type, llvm_alloc_size(test_owner, int_len_type)); + LLVMSetGlobalConstant(name_count, 1); + LLVMSetInitializer(name_count, LLVMConstInt(int_len_type, test_count, false)); +} void **llvm_gen(Module** modules, unsigned module_count) { if (!module_count) return NULL; @@ -1022,6 +1093,7 @@ void **llvm_gen(Module** modules, unsigned module_count) } if (!gen_contexts) return NULL; GenContext *first = gen_contexts[0]; + llvm_gen_tests(first, modules, module_count); unsigned count = vec_size(gen_contexts); for (unsigned i = 1; i < count; i++) { @@ -1038,6 +1110,7 @@ void **llvm_gen(Module** modules, unsigned module_count) if (!result) continue; vec_add(gen_contexts, result); } + llvm_gen_tests(gen_contexts[0], modules, module_count); return (void**)gen_contexts; } @@ -1072,10 +1145,15 @@ static GenContext *llvm_gen_module(Module *module, LLVMContextRef shared_context FOREACH_END(); FOREACH_BEGIN(Decl *func, unit->functions) + if (func->func_decl.attr_test) + { + if (!active_target.testing) continue; + vec_add(module->tests, func); + } llvm_emit_function_decl(gen_context, func); FOREACH_END(); - if (unit->main_function && unit->main_function->is_synthetic) + if (!active_target.testing && unit->main_function && unit->main_function->is_synthetic) { llvm_emit_function_decl(gen_context, unit->main_function); } @@ -1096,10 +1174,11 @@ static GenContext *llvm_gen_module(Module *module, LLVMContextRef shared_context FOREACH_END(); FOREACH_BEGIN(Decl *decl, unit->functions) + if (decl->func_decl.attr_test && !active_target.testing) continue; if (decl->func_decl.body) llvm_emit_function_body(gen_context, decl); FOREACH_END(); - if (unit->main_function && unit->main_function->is_synthetic) + if (!active_target.testing && unit->main_function && unit->main_function->is_synthetic) { llvm_emit_function_body(gen_context, unit->main_function); } diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c index 959afc9c8..64a5a07c7 100644 --- a/src/compiler/llvm_codegen_expr.c +++ b/src/compiler/llvm_codegen_expr.c @@ -47,7 +47,7 @@ static void llvm_emit_macro_body_expansion(GenContext *c, BEValue *value, Expr * static void llvm_emit_post_unary_expr(GenContext *context, BEValue *be_value, Expr *expr); static void llvm_emit_unary_expr(GenContext *c, BEValue *value, Expr *expr); static void llvm_enter_struct_for_coerce(GenContext *c, LLVMValueRef *struct_ptr, LLVMTypeRef *type, ByteSize dest_size); -static void llvm_expand_type_to_args(GenContext *context, Type *param_type, LLVMValueRef expand_ptr, LLVMValueRef **values, AlignSize alignment); +static void llvm_expand_type_to_args(GenContext *context, Type *param_type, LLVMValueRef expand_ptr, LLVMValueRef *args, unsigned *arg_count_ref, AlignSize alignment); INLINE LLVMValueRef llvm_emit_bitstruct_value_update(GenContext *c, LLVMValueRef current_val, TypeSize bits, LLVMTypeRef bitstruct_type, Decl *member, LLVMValueRef val); INLINE void llvm_emit_initialize_reference_bitstruct_array(GenContext *c, BEValue *ref, Decl *bitstruct, Expr** elements); @@ -4353,18 +4353,18 @@ static void llvm_emit_const_expr(GenContext *c, BEValue *be_value, Expr *expr) -static void llvm_expand_array_to_args(GenContext *c, Type *param_type, LLVMValueRef expand_ptr, LLVMValueRef **values, AlignSize alignment) +static void llvm_expand_array_to_args(GenContext *c, Type *param_type, LLVMValueRef expand_ptr, LLVMValueRef *args, unsigned *arg_count_ref, AlignSize alignment) { LLVMTypeRef array_type = llvm_get_type(c, param_type); for (ByteSize i = 0; i < param_type->array.len; i++) { AlignSize load_align; LLVMValueRef element_ptr = llvm_emit_array_gep_raw(c, expand_ptr, array_type, (unsigned)i, alignment, &load_align); - llvm_expand_type_to_args(c, param_type->array.base, element_ptr, values, load_align); + llvm_expand_type_to_args(c, param_type->array.base, element_ptr, args, arg_count_ref, load_align); } } -static void llvm_expand_struct_to_args(GenContext *context, Type *param_type, LLVMValueRef expand_ptr, LLVMValueRef **values, AlignSize alignment) +static void llvm_expand_struct_to_args(GenContext *context, Type *param_type, LLVMValueRef expand_ptr, LLVMValueRef *args, unsigned *arg_count_ref, AlignSize alignment) { Decl **members = param_type->decl->strukt.members; VECEACH(members, i) @@ -4377,11 +4377,11 @@ static void llvm_expand_struct_to_args(GenContext *context, Type *param_type, LL i, alignment, &load_align); - llvm_expand_type_to_args(context, member_type, member_ptr, values, load_align); + llvm_expand_type_to_args(context, member_type, member_ptr, args, arg_count_ref, load_align); } } -static void llvm_expand_type_to_args(GenContext *context, Type *param_type, LLVMValueRef expand_ptr, LLVMValueRef **values, AlignSize alignment) +static void llvm_expand_type_to_args(GenContext *context, Type *param_type, LLVMValueRef expand_ptr, LLVMValueRef *args, unsigned *arg_count_ref, AlignSize alignment) { REDO: switch (type_lowering(param_type)->type_kind) @@ -4405,21 +4405,20 @@ static void llvm_expand_type_to_args(GenContext *context, Type *param_type, LLVM case ALL_INTS: case ALL_FLOATS: case TYPE_POINTER: - vec_add(*values, - llvm_load(context, - llvm_get_type(context, param_type), - expand_ptr, - alignment, - "loadexpanded")); + args[(*arg_count_ref)++] = llvm_load(context, + llvm_get_type(context, param_type), + expand_ptr, + alignment, + "loadexpanded"); return; case TYPE_TYPEDEF: param_type = param_type->canonical; goto REDO; case TYPE_STRUCT: - llvm_expand_struct_to_args(context, param_type, expand_ptr, values, alignment); + llvm_expand_struct_to_args(context, param_type, expand_ptr, args, arg_count_ref, alignment); break; case TYPE_ARRAY: - llvm_expand_array_to_args(context, param_type, expand_ptr, values, alignment); + llvm_expand_array_to_args(context, param_type, expand_ptr, args, arg_count_ref, alignment); break; case TYPE_UNION: case TYPE_SUBARRAY: @@ -4543,7 +4542,7 @@ void llvm_value_struct_gep(GenContext *c, BEValue *element, BEValue *struct_poin } -void llvm_emit_parameter(GenContext *c, LLVMValueRef **args, ABIArgInfo *info, BEValue *be_value, Type *type) +void llvm_emit_parameter(GenContext *c, LLVMValueRef *args, unsigned *arg_count_ref, ABIArgInfo *info, BEValue *be_value, Type *type) { type = type_lowering(type); assert(be_value->type->canonical == type); @@ -4559,16 +4558,16 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef **args, ABIArgInfo *info, B if (info->attributes.by_val && llvm_value_is_addr(be_value) && info->indirect.alignment <= be_value->alignment) { llvm_value_fold_optional(c, be_value); - vec_add(*args, be_value->value); + args[(*arg_count_ref)++] = be_value->value; return; } LLVMValueRef indirect = llvm_emit_alloca(c, llvm_get_type(c, type), info->indirect.alignment, "indirectarg"); llvm_store_to_ptr_aligned(c, indirect, be_value, info->indirect.alignment); - vec_add(*args, indirect); + args[(*arg_count_ref)++] = indirect; return; } case ABI_ARG_DIRECT: - vec_add(*args, llvm_load_value_store(c, be_value)); + args[(*arg_count_ref)++] = llvm_load_value_store(c, be_value); return; case ABI_ARG_DIRECT_SPLIT_STRUCT: { @@ -4583,7 +4582,7 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef **args, ABIArgInfo *info, B { AlignSize load_align; LLVMValueRef element_ptr = llvm_emit_struct_gep_raw(c, cast, coerce_type, idx, alignment, &load_align); - vec_add(*args, llvm_load(c, element, element_ptr, load_align, "")); + args[(*arg_count_ref)++] = llvm_load(c, element, element_ptr, load_align, ""); } return; } @@ -4592,10 +4591,10 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef **args, ABIArgInfo *info, B LLVMTypeRef coerce_type = llvm_get_type(c, info->direct_coerce_type); if (coerce_type == llvm_get_type(c, type)) { - vec_add(*args, llvm_load_value_store(c, be_value)); + args[(*arg_count_ref)++] = llvm_load_value_store(c, be_value); return; } - vec_add(*args, llvm_emit_coerce(c, coerce_type, be_value, type)); + args[(*arg_count_ref)++] = llvm_emit_coerce(c, coerce_type, be_value, type); return; } case ABI_ARG_DIRECT_COERCE_INT: @@ -4603,32 +4602,70 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef **args, ABIArgInfo *info, B LLVMTypeRef coerce_type = LLVMIntTypeInContext(c->context, type_size(type) * 8); if (coerce_type == llvm_get_type(c, type)) { - vec_add(*args, llvm_load_value_store(c, be_value)); + args[(*arg_count_ref)++] = llvm_load_value_store(c, be_value); return; } - vec_add(*args, llvm_emit_coerce(c, coerce_type, be_value, type)); + args[(*arg_count_ref)++] = llvm_emit_coerce(c, coerce_type, be_value, type); return; } case ABI_ARG_DIRECT_PAIR: { + assert(type_flatten(be_value->type) == be_value->type); + LLVMTypeRef original_type = llvm_get_type(c, be_value->type); + LLVMTypeRef struct_type = llvm_get_coerce_type(c, info); + AlignSize alignment; + if (llvm_types_are_similar(original_type, struct_type)) + { + // Optimization + assert(LLVMGetTypeKind(original_type) == LLVMStructTypeKind && LLVMCountStructElementTypes(original_type) == 2); + if (llvm_value_is_addr(be_value)) + { + LLVMValueRef ptr = llvm_emit_struct_gep_raw(c, be_value->value, original_type, 0, be_value->alignment, &alignment); + args[(*arg_count_ref)++] = llvm_load(c, LLVMStructGetTypeAtIndex(original_type, 0), ptr, alignment, "lo"); + ptr = llvm_emit_struct_gep_raw(c, be_value->value, original_type, 1, be_value->alignment, &alignment); + args[(*arg_count_ref)++] = llvm_load(c, LLVMStructGetTypeAtIndex(original_type, 1), ptr, alignment, "hi"); + return; + } + LLVMValueRef val = be_value->value; + // Maybe it's just created? Let's optimize codegen. + if (!LLVMGetFirstUse(val) && LLVMIsAInsertValueInst(val) && LLVMIsAInsertValueInst( + LLVMGetPreviousInstruction(val))) + { + LLVMValueRef prev = LLVMGetPreviousInstruction(val); + // Isn't this a second insert? + if (LLVMGetOperand(val, 0) != prev) goto NO_OPT; + // Is it used in between? + if (LLVMGetNextUse(LLVMGetFirstUse(prev))) goto NO_OPT; + // No, then we can replace the instructions with the values. + LLVMValueRef first_val = LLVMGetOperand(prev, 1); + LLVMValueRef second_val = LLVMGetOperand(val, 1); + LLVMInstructionEraseFromParent(val); + LLVMInstructionEraseFromParent(prev); + args[(*arg_count_ref)++] = first_val; + args[(*arg_count_ref)++] = second_val; + return; + } + NO_OPT: + args[(*arg_count_ref)++] = llvm_emit_extract_value(c, be_value->value, 0); + args[(*arg_count_ref)++] = llvm_emit_extract_value(c, be_value->value, 1); + return; + } llvm_value_addr(c, be_value); REMINDER("Handle invalid alignment"); // Here we do the following transform: // struct -> { lo, hi } -> lo, hi LLVMTypeRef lo = llvm_abi_type(c, info->direct_pair.lo); LLVMTypeRef hi = llvm_abi_type(c, info->direct_pair.hi); - LLVMTypeRef struct_type = llvm_get_coerce_type(c, info); AlignSize struct_align; LLVMValueRef cast = llvm_emit_coerce_alignment(c, be_value, struct_type, llvm_abi_alignment(c, struct_type), &struct_align); // Get the lo value. - AlignSize alignment; LLVMValueRef lo_ptr = llvm_emit_struct_gep_raw(c, cast, struct_type, 0, struct_align, &alignment); - vec_add(*args, llvm_load(c, lo, lo_ptr, alignment, "lo")); + args[(*arg_count_ref)++] = llvm_load(c, lo, lo_ptr, alignment, "lo"); // Get the hi value. LLVMValueRef hi_ptr = llvm_emit_struct_gep_raw(c, cast, struct_type, 1, struct_align, &alignment); - vec_add(*args, llvm_load(c, hi, hi_ptr, alignment, "hi")); + args[(*arg_count_ref)++] = llvm_load(c, hi, hi_ptr, alignment, "hi"); return; } case ABI_ARG_EXPAND_COERCE: @@ -4641,11 +4678,11 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef **args, ABIArgInfo *info, B AlignSize align; LLVMValueRef gep_first = llvm_emit_struct_gep_raw(c, temp, coerce_type, info->coerce_expand.lo_index, alignment, &align); - vec_add(*args, llvm_load(c, llvm_abi_type(c, info->coerce_expand.lo), gep_first, align, "")); + args[(*arg_count_ref)++] = llvm_load(c, llvm_abi_type(c, info->coerce_expand.lo), gep_first, align, ""); if (abi_type_is_valid(info->coerce_expand.hi)) { LLVMValueRef gep_second = llvm_emit_struct_gep_raw(c, temp, coerce_type, info->coerce_expand.hi_index, alignment, &align); - vec_add(*args, llvm_load(c, llvm_abi_type(c, info->coerce_expand.hi), gep_second, align, "")); + args[(*arg_count_ref)++] = llvm_load(c, llvm_abi_type(c, info->coerce_expand.hi), gep_second, align, ""); } return; } @@ -4653,41 +4690,33 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef **args, ABIArgInfo *info, B { // Move this to an address (if needed) llvm_value_addr(c, be_value); - llvm_expand_type_to_args(c, type, be_value->value, args, be_value->alignment); + llvm_expand_type_to_args(c, type, be_value->value, args, arg_count_ref, be_value->alignment); // Expand the padding here. if (info->expand.padding_type) { - vec_add(*args, llvm_get_undef(c, info->expand.padding_type)); + args[(*arg_count_ref)++] = llvm_get_undef(c, info->expand.padding_type); } return; } } } -static void llvm_emit_splatted_variadic_arg(GenContext *c, Expr *expr, BEValue *subarray) +static void llvm_emit_splatted_variadic_arg(GenContext *c, Expr *expr, Type *vararg_type, BEValue *subarray) { BEValue value; llvm_emit_expr(c, &value, expr); - BEValue len_addr; - BEValue pointer_addr; - llvm_emit_subarray_len(c, subarray, &len_addr); - llvm_emit_subarray_pointer(c, subarray, &pointer_addr); Type *type = expr->type->canonical; switch (type->type_kind) { case TYPE_ARRAY: - { - llvm_store_raw(c, &len_addr, llvm_const_int(c, type_usize, type->array.len)); llvm_value_addr(c, &value); llvm_value_bitcast(c, &value, type->array.base); - llvm_store_raw(c, &pointer_addr, value.value); + llvm_value_aggregate_two(c, subarray, vararg_type, value.value, llvm_const_int(c, type_usize, type->array.len)); return; - } case TYPE_POINTER: // Load the pointer llvm_value_rvalue(c, &value); - llvm_store_raw(c, &len_addr, llvm_const_int(c, type_usize, type->pointer->array.len)); - llvm_store_raw(c, &pointer_addr, llvm_emit_bitcast_ptr(c, value.value, type->pointer->array.base)); + llvm_value_aggregate_two(c, subarray, vararg_type, llvm_emit_bitcast_ptr(c, value.value, type->pointer->array.base), llvm_const_int(c, type_usize, type->pointer->array.len)); return; case TYPE_SUBARRAY: *subarray = value; @@ -4745,20 +4774,17 @@ static inline void llvm_emit_vararg_parameter(GenContext *c, BEValue *value, Typ { REMINDER("All varargs should be called with non-alias!"); - llvm_value_set_address_abi_aligned(value, llvm_emit_alloca_aligned(c, vararg_type, "vararg"), vararg_type); // 9a. Special case, empty argument if (!vararg_splat && !varargs) { // Just set the size to zero. - BEValue len_addr; - llvm_emit_subarray_len(c, value, &len_addr); - llvm_store_raw(c, &len_addr, llvm_get_zero(c, type_usize)); + 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, value); + llvm_emit_splatted_variadic_arg(c, vararg_splat, vararg_type, value); return; } BEValue temp_value; @@ -4781,252 +4807,35 @@ static inline void llvm_emit_vararg_parameter(GenContext *c, BEValue *value, Typ &store_alignment); llvm_store_to_ptr_aligned(c, slot, &temp_value, store_alignment); } - BEValue len_addr; - llvm_emit_subarray_len(c, value, &len_addr); - llvm_store_raw(c, &len_addr, llvm_const_int(c, type_usize, elements)); - BEValue pointer_addr; - llvm_emit_subarray_pointer(c, value, &pointer_addr); - llvm_store_raw(c, &pointer_addr, llvm_emit_bitcast_ptr(c, array_ref, pointee_type)); + llvm_value_aggregate_two(c, value, vararg_type, llvm_emit_bitcast_ptr(c, array_ref, pointee_type), llvm_const_int(c, type_usize, elements)); } -static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr, BEValue *target) +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) { - if (expr->call_expr.is_builtin) - { - llvm_emit_builtin_call(c, result_value, expr); - return; - } - - if (c->debug.stack_slot_row) - { - llvm_store_to_ptr_raw_aligned(c, - c->debug.stack_slot_row, - llvm_const_int(c, type_uint, expr->span.row), - type_abi_alignment(type_uint)); - } - - LLVMTypeRef func_type; - LLVMValueRef func; - BEValue temp_value; - - bool always_inline = false; - - FunctionPrototype *prototype; - // 1. Call through a pointer. - if (!expr->call_expr.is_func_ref) - { - 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->function.prototype; - - // 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 = function_decl->type->function.prototype; - func = llvm_get_ref(c, function_decl); - assert(func); - func_type = llvm_get_type(c, function_decl->type); - } - - LLVMValueRef *values = NULL; - Type **params = prototype->param_types; - ABIArgInfo **abi_args = prototype->abi_args; - unsigned param_count = vec_size(params); - Expr **args = expr->call_expr.arguments; - Expr **varargs = NULL; - Expr *vararg_splat = NULL; - if (prototype->variadic != VARIADIC_NONE) - { - if (expr->call_expr.splat_vararg) - { - vararg_splat = expr->call_expr.splat; - } - else - { - varargs = expr->call_expr.varargs; - } - } - FunctionPrototype copy; - if (prototype->variadic == VARIADIC_RAW) - { - if (varargs || vararg_splat) - { - assert(!vararg_splat); - copy = *prototype; - copy.varargs = NULL; - - foreach(Expr*, varargs) - { - vec_add(copy.varargs, type_flatten(val->type)); - } - copy.ret_abi_info = NULL; - copy.ret_by_ref_abi_info = NULL; - copy.abi_args = NULL; - c_abi_func_create(©); - prototype = © - LLVMTypeRef *params_type = NULL; - llvm_update_prototype_abi(c, prototype, ¶ms_type); - } - } ABIArgInfo *ret_info = prototype->ret_abi_info; Type *call_return_type = prototype->abi_ret_type; - // 5. In the case of a failable, the error is replacing the regular return abi. - LLVMValueRef error_var = NULL; - - *result_value = (BEValue){ .kind = BE_VALUE, .value = NULL }; - // 6. Generate data for the return value. - bool sret_return = false; - switch (ret_info->kind) - { - case ABI_ARG_INDIRECT: - // 6a. We can use the stored error var if there is no redirect. - if (prototype->is_failable && c->opt_var && !ret_info->attributes.realign) - { - error_var = c->opt_var; - vec_add(values, error_var); - break; - } - // 6b. Return true is indirect, in this case we allocate a local, using the desired alignment on the caller side. - assert(ret_info->attributes.realign || ret_info->indirect.alignment == type_abi_alignment(call_return_type)); - AlignSize alignment = ret_info->indirect.alignment; - // If we have a target, then use it. - if (target && alignment <= target->alignment) - { - assert(target->kind == BE_ADDRESS); - vec_add(values, target->value); - sret_return = true; - break; - } - llvm_value_set_address(result_value, - 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. - vec_add(values, result_value->value); - break; - case ABI_ARG_EXPAND: - case ABI_ARG_DIRECT_SPLIT_STRUCT: - UNREACHABLE - case ABI_ARG_DIRECT_PAIR: - case ABI_ARG_IGNORE: - case ABI_ARG_DIRECT_COERCE_INT: - case ABI_ARG_DIRECT_COERCE: - case ABI_ARG_DIRECT: - case ABI_ARG_EXPAND_COERCE: - break; - } - - - // 7. We might have a failable indirect return and a normal return. - // In this case we need to add it by hand. - BEValue synthetic_return_param = { 0 }; - if (prototype->ret_by_ref) - { - // 7b. Create the address to hold the return. - Type *actual_return_type = type_lowering(prototype->ret_by_ref_type); - llvm_value_set(&synthetic_return_param, llvm_emit_alloca_aligned(c, actual_return_type, "retparam"), type_get_ptr(actual_return_type)); - // 7c. Emit it as a parameter as a pointer (will implicitly add it to the value list) - llvm_emit_parameter(c, &values, prototype->ret_by_ref_abi_info, &synthetic_return_param, synthetic_return_param.type); - // 7d. Update the be_value to actually be an address. - llvm_value_set_address_abi_aligned(&synthetic_return_param, synthetic_return_param.value, actual_return_type); - } - - - // 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) - { - llvm_emit_expr(c, &temp_value, arg_expr); - } - else - { - assert(prototype->variadic == VARIADIC_TYPED || prototype->variadic == VARIADIC_ANY); - llvm_emit_vararg_parameter(c, &temp_value, param, info, varargs, vararg_splat); - } - - // 8b. Emit the parameter according to ABI rules. - llvm_emit_parameter(c, &values, info, &temp_value, param); - } - - // 9. Typed varargs - - if (prototype->variadic == VARIADIC_RAW) - { - if (prototype->abi_varargs) - { - // 9. Emit varargs. - unsigned index = 0; - ABIArgInfo **abi_varargs = prototype->abi_varargs; - foreach(Expr*, varargs) - { - llvm_emit_expr(c, &temp_value, val); - ABIArgInfo *info = abi_varargs[index]; - llvm_emit_parameter(c, &values, info, &temp_value, prototype->varargs[index]); - index++; - } - } - else - { - // 9. Emit varargs. - foreach(Expr*, varargs) - { - llvm_emit_expr(c, &temp_value, val); - REMINDER("Varargs should be expanded correctly"); - vec_add(values, llvm_load_value_store(c, &temp_value)); - } - } - } - - - // 10. Create the actual call (remember to emit a loc, because we might have shifted loc emitting the params) - EMIT_LOC(c, expr); - LLVMValueRef call_value = LLVMBuildCall2(c->builder, func_type, func, values, vec_size(values), ""); + LLVMValueRef call_value = LLVMBuildCall2(c->builder, func_type, func, args, arg_count, ""); if (prototype->call_abi) { LLVMSetInstructionCallConv(call_value, llvm_call_convention_from_call(prototype->call_abi)); } - if (expr->call_expr.attr_force_noinline) + switch (inline_flag) { - llvm_attribute_add_call(c, call_value, attribute_id.noinline, -1, 0); - } - else - { - if (expr->call_expr.attr_force_inline || always_inline) - { + case -1: + llvm_attribute_add_call(c, call_value, attribute_id.noinline, -1, 0); + break; + case 1: llvm_attribute_add_call(c, call_value, attribute_id.alwaysinline, -1, 0); - } + break; + default: + break; } assert(!prototype->ret_by_ref || prototype->ret_by_ref_abi_info->kind != ABI_ARG_INDIRECT); - llvm_add_abi_call_attributes(c, call_value, param_count, abi_args); + + llvm_add_abi_call_attributes(c, call_value, vec_size(prototype->param_types), prototype->abi_args); if (prototype->abi_varargs) { llvm_add_abi_call_attributes(c, @@ -5055,7 +4864,7 @@ static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr // 13a. In the case of an already present error_var, we don't need to do a load here. if (error_var || sret_return) break; - // 13b. Otherwise it will be contained in a be_value that is an address + // 13b. If not it will be contained in a be_value that is an address // so we don't need to do anything more. assert(result_value->kind == BE_ADDRESS); @@ -5094,7 +4903,7 @@ static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr // 15d. Find the address to the low value AlignSize alignment; LLVMValueRef lo = llvm_emit_struct_gep_raw(c, coerce, coerce_type, ret_info->coerce_expand.lo_index, - type_abi_alignment(call_return_type), &alignment); + type_abi_alignment(call_return_type), &alignment); // 15e. If there is only a single field, we simply store the value, // so { lo } set into { pad, lo, pad } -> original type. @@ -5114,7 +4923,7 @@ static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr // 15i. Calculate the address to the high value (like for the low in 15d. LLVMValueRef hi = llvm_emit_struct_gep_raw(c, coerce, coerce_type, ret_info->coerce_expand.hi_index, - type_abi_alignment(call_return_type), &alignment); + type_abi_alignment(call_return_type), &alignment); // 15h. Store the high value. llvm_store_to_ptr_raw_aligned(c, hi, hi_value, alignment); @@ -5209,7 +5018,7 @@ static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr } // 17h. Assign the return param to be_value. - *result_value = synthetic_return_param; + *result_value = *synthetic_return_param; return; } @@ -5220,6 +5029,248 @@ static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr c->debug.stack_slot, type_alloca_alignment(type_voidptr)); + // 17i. The simple case here is where there is a normal return. + // In this case be_value already holds the result +} +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; + } + + if (c->debug.stack_slot_row) + { + llvm_store_to_ptr_raw_aligned(c, + c->debug.stack_slot_row, + llvm_const_int(c, type_uint, expr->span.row), + type_abi_alignment(type_uint)); + } + + LLVMTypeRef func_type; + LLVMValueRef func; + BEValue temp_value; + + bool always_inline = false; + + FunctionPrototype *prototype; + // 1. Call through a pointer. + if (!expr->call_expr.is_func_ref) + { + 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->function.prototype; + + // 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 = function_decl->type->function.prototype; + 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 **args = expr->call_expr.arguments; + Expr **varargs = NULL; + Expr *vararg_splat = NULL; + if (prototype->variadic != VARIADIC_NONE) + { + if (expr->call_expr.splat_vararg) + { + vararg_splat = expr->call_expr.splat; + } + else + { + varargs = expr->call_expr.varargs; + } + } + FunctionPrototype copy; + if (prototype->variadic == VARIADIC_RAW) + { + if (varargs || vararg_splat) + { + assert(!vararg_splat); + copy = *prototype; + copy.varargs = NULL; + + foreach(Expr*, varargs) + { + vec_add(copy.varargs, type_flatten(val->type)); + } + copy.ret_abi_info = NULL; + copy.ret_by_ref_abi_info = NULL; + copy.abi_args = NULL; + c_abi_func_create(©); + prototype = © + LLVMTypeRef *params_type = NULL; + llvm_update_prototype_abi(c, prototype, ¶ms_type); + } + } + ABIArgInfo *ret_info = prototype->ret_abi_info; + Type *call_return_type = prototype->abi_ret_type; + + // 5. In the case of a failable, the error is replacing the regular return abi. + LLVMValueRef error_var = NULL; + + *result_value = (BEValue){ .kind = BE_VALUE, .value = NULL }; + // 6. Generate data for the return value. + bool sret_return = false; + switch (ret_info->kind) + { + case ABI_ARG_INDIRECT: + // 6a. We can use the stored error var if there is no redirect. + if (prototype->is_failable && c->opt_var && !ret_info->attributes.realign) + { + error_var = c->opt_var; + arg_values[arg_count++] = error_var; + break; + } + // 6b. Return true is indirect, in this case we allocate a local, using the desired alignment on the caller side. + assert(ret_info->attributes.realign || ret_info->indirect.alignment == type_abi_alignment(call_return_type)); + AlignSize alignment = ret_info->indirect.alignment; + // If we have a target, then use it. + if (target && alignment <= target->alignment) + { + assert(target->kind == BE_ADDRESS); + arg_values[arg_count++] = target->value; + sret_return = true; + break; + } + llvm_value_set_address(result_value, + 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; + break; + case ABI_ARG_EXPAND: + case ABI_ARG_DIRECT_SPLIT_STRUCT: + UNREACHABLE + case ABI_ARG_DIRECT_PAIR: + case ABI_ARG_IGNORE: + case ABI_ARG_DIRECT_COERCE_INT: + case ABI_ARG_DIRECT_COERCE: + case ABI_ARG_DIRECT: + case ABI_ARG_EXPAND_COERCE: + break; + } + + + // 7. We might have a failable indirect return and a normal return. + // In this case we need to add it by hand. + BEValue synthetic_return_param = { 0 }; + if (prototype->ret_by_ref) + { + // 7b. Create the address to hold the return. + Type *actual_return_type = type_lowering(prototype->ret_by_ref_type); + llvm_value_set(&synthetic_return_param, llvm_emit_alloca_aligned(c, actual_return_type, "retparam"), type_get_ptr(actual_return_type)); + // 7c. Emit it as a parameter as a pointer (will implicitly add it to the value list) + llvm_emit_parameter(c, arg_values, &arg_count, prototype->ret_by_ref_abi_info, &synthetic_return_param, synthetic_return_param.type); + // 7d. Update the be_value to actually be an address. + llvm_value_set_address_abi_aligned(&synthetic_return_param, synthetic_return_param.value, actual_return_type); + } + + + // 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) + { + llvm_emit_expr(c, &temp_value, arg_expr); + } + else + { + assert(prototype->variadic == VARIADIC_TYPED || prototype->variadic == VARIADIC_ANY); + 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); + } + + // 9. Typed varargs + + if (prototype->variadic == VARIADIC_RAW) + { + if (prototype->abi_varargs) + { + // 9. Emit varargs. + unsigned index = 0; + ABIArgInfo **abi_varargs = prototype->abi_varargs; + foreach(Expr*, varargs) + { + 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]); + index++; + } + } + else + { + // 9. Emit varargs. + foreach(Expr*, varargs) + { + llvm_emit_expr(c, &temp_value, val); + REMINDER("Varargs should be expanded correctly"); + arg_values[arg_count++] = llvm_load_value_store(c, &temp_value); + } + } + } + + + // 10. Create the actual call (remember to emit a loc, because we might have shifted loc emitting the params) + EMIT_LOC(c, expr); + int inline_flag = 0; + if (expr->call_expr.attr_force_noinline) + { + inline_flag = -1; + } + else + { + 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. + if (c->debug.last_ptr) + { + llvm_store_to_ptr_raw_aligned(c, + c->debug.last_ptr, + c->debug.stack_slot, + type_alloca_alignment(type_voidptr)); + } + // 17i. The simple case here is where there is a normal return. // In this case be_value already holds the result return; @@ -5966,6 +6017,37 @@ static inline void llvm_emit_builtin_access(GenContext *c, BEValue *be_value, Ex UNREACHABLE } +static LLVMValueRef llvm_get_test_hook_global(GenContext *c, Expr *expr) +{ + const char *name; + switch (expr->test_hook_expr) + { + case BUILTIN_DEF_TEST_FNS: + name = "C3_TEST_DECL_LIST"; + break; + case BUILTIN_DEF_TEST_COUNT: + name = "C3_TEST_COUNT"; + break; + case BUILTIN_DEF_TEST_NAMES: + name = "C3_TEST_NAME_LIST"; + break; + default: + UNREACHABLE + } + LLVMValueRef global = LLVMGetNamedGlobal(c->module, name); + if (global) return global; + global = LLVMAddGlobal(c->module, llvm_get_type(c, expr->type), name); + LLVMSetExternallyInitialized(global, true); + LLVMSetGlobalConstant(global, true); + return global; +} + +static void llmv_emit_test_hook(GenContext *c, BEValue *value, Expr *expr) +{ + LLVMValueRef get_global = llvm_get_test_hook_global(c, expr); + llvm_value_set_address_abi_aligned(value, get_global, expr->type); +} + void llvm_emit_expr(GenContext *c, BEValue *value, Expr *expr) { EMIT_LOC(c, expr); @@ -5978,6 +6060,9 @@ void llvm_emit_expr(GenContext *c, BEValue *value, Expr *expr) case EXPR_VASPLAT: case EXPR_CT_CHECKS: UNREACHABLE + case EXPR_TEST_HOOK: + llmv_emit_test_hook(c, value, expr); + return; case EXPR_BUILTIN_ACCESS: llvm_emit_builtin_access(c, value, expr); return; diff --git a/src/compiler/llvm_codegen_function.c b/src/compiler/llvm_codegen_function.c index f7d18f2b5..aa69759b3 100644 --- a/src/compiler/llvm_codegen_function.c +++ b/src/compiler/llvm_codegen_function.c @@ -9,7 +9,7 @@ static void llvm_emit_param_attributes(GenContext *c, LLVMValueRef function, ABI static inline void llvm_emit_return_value(GenContext *context, LLVMValueRef value); static void llvm_expand_from_args(GenContext *c, Type *type, LLVMValueRef ref, unsigned *index, AlignSize alignment); static inline void llvm_process_parameter_value(GenContext *c, Decl *decl, ABIArgInfo *info, unsigned *index); -static inline void llvm_emit_parameter(GenContext *context, Decl *decl, ABIArgInfo *abi_info, unsigned *index, unsigned real_index); +static inline void llvm_emit_func_parameter(GenContext *context, Decl *decl, ABIArgInfo *abi_info, unsigned *index, unsigned real_index); static inline void llvm_emit_body(GenContext *c, LLVMValueRef function, const char *module_name, const char *function_name, FileId file_id, FunctionPrototype *prototype, Signature *signature, Ast *body); @@ -246,7 +246,7 @@ static inline void llvm_process_parameter_value(GenContext *c, Decl *decl, ABIAr } } } -static inline void llvm_emit_parameter(GenContext *context, Decl *decl, ABIArgInfo *abi_info, unsigned *index, unsigned real_index) +static inline void llvm_emit_func_parameter(GenContext *context, Decl *decl, ABIArgInfo *abi_info, unsigned *index, unsigned real_index) { assert(decl->decl_kind == DECL_VAR && decl->var.kind == VARDECL_PARAM); @@ -272,6 +272,7 @@ static inline void llvm_emit_return_value(GenContext *context, LLVMValueRef valu context->current_block_is_target = false; } + void llvm_emit_return_abi(GenContext *c, BEValue *return_value, BEValue *failable) { FunctionPrototype *prototype = c->cur_func.prototype; @@ -447,10 +448,10 @@ void llvm_emit_body(GenContext *c, LLVMValueRef function, const char *module_nam scratch_buffer_append(module_name); scratch_buffer_append("::"); scratch_buffer_append(function_name); - c->debug.func_name = llvm_emit_zstring(c, scratch_buffer_to_string()); + c->debug.func_name = llvm_emit_string_const(c, scratch_buffer_to_string(), ".funcname"); File *file = source_file_by_id(file_id); - c->debug.file_name = llvm_emit_zstring(c, file->name); + c->debug.file_name = llvm_emit_string_const(c, file->name, ".filename"); } } @@ -527,7 +528,7 @@ void llvm_emit_body(GenContext *c, LLVMValueRef function, const char *module_nam { // Generate LLVMValueRef's for all parameters, so we can use them as local vars in code FOREACH_BEGIN_IDX(i, Decl *param, signature->params) - llvm_emit_parameter(c, param, prototype->abi_args[i], &arg, i); + llvm_emit_func_parameter(c, param, prototype->abi_args[i], &arg, i); FOREACH_END(); } diff --git a/src/compiler/llvm_codegen_internal.h b/src/compiler/llvm_codegen_internal.h index e1718e19b..42701fa78 100644 --- a/src/compiler/llvm_codegen_internal.h +++ b/src/compiler/llvm_codegen_internal.h @@ -85,7 +85,8 @@ typedef struct GenContext_ LLVMTypeRef introspect_type; LLVMTypeRef fault_type; LLVMTypeRef size_type; - Decl *panicfn; + LLVMTypeRef char_ptr_type; + Decl *panic_var; struct { const char *name; @@ -277,6 +278,7 @@ LLVMTypeRef llvm_get_type(GenContext *c, Type *any_type); LLVMTypeRef llvm_get_pointee_type(GenContext *c, Type *any_type); void llvm_emit_function_decl(GenContext *c, Decl *decl); void llvm_emit_xxlizer(GenContext *c, Decl *decl); +bool llvm_types_are_similar(LLVMTypeRef original, LLVMTypeRef coerce); INLINE LLVMTypeRef llvm_get_ptr_type(GenContext *c, Type *type); // -- Attributes --- @@ -319,6 +321,8 @@ INLINE LLVMValueRef llvm_zext_trunc(GenContext *c, LLVMValueRef data, LLVMTypeRe void llvm_emit_typeid(GenContext *c, BEValue *be_value, Type *type); LLVMValueRef llvm_emit_const_initializer(GenContext *c, ConstInitializer *const_init); LLVMValueRef llvm_emit_const_padding(GenContext *c, AlignSize size); +LLVMValueRef llvm_emit_string_const(GenContext *c, const char *str, const char *extname); +LLVMValueRef llvm_emit_empty_string_const(GenContext *c); LLVMValueRef llvm_emit_zstring(GenContext *c, const char *str); LLVMValueRef llvm_emit_zstring_named(GenContext *c, const char *str, const char *extname); INLINE LLVMValueRef llvm_const_int(GenContext *c, Type *type, uint64_t val); @@ -419,6 +423,8 @@ void llvm_emit_coerce_store(GenContext *c, LLVMValueRef addr, AlignSize alignmen LLVMValueRef llvm_emit_coerce(GenContext *c, LLVMTypeRef coerced, BEValue *value, Type *original_type); INLINE bool call_supports_variadic(CallABI abi); 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); // -- C3 Lowering -- void llvm_emit_expr(GenContext *c, BEValue *value, Expr *expr); diff --git a/src/compiler/llvm_codegen_internal_impl.h b/src/compiler/llvm_codegen_internal_impl.h index d2dba95c5..92ff0964c 100644 --- a/src/compiler/llvm_codegen_internal_impl.h +++ b/src/compiler/llvm_codegen_internal_impl.h @@ -334,3 +334,4 @@ INLINE void llvm_emit_statement_chain(GenContext *c, AstId current) llvm_emit_stmt(c, ast_next(¤t)); } } + diff --git a/src/compiler/llvm_codegen_module.c b/src/compiler/llvm_codegen_module.c index d6df28cb1..d1fd4ea9d 100644 --- a/src/compiler/llvm_codegen_module.c +++ b/src/compiler/llvm_codegen_module.c @@ -50,7 +50,7 @@ void gencontext_begin_module(GenContext *c) if (active_target.asm_file_dir) c->asm_filename = file_append_path(active_target.asm_file_dir, c->asm_filename); } if (active_target.object_file_dir) c->object_filename = file_append_path(active_target.object_file_dir, c->object_filename); - c->panicfn = global_context.panic_fn; + c->panic_var = global_context.panic_var; c->module = LLVMModuleCreateWithNameInContext(c->code_module->name->module, c->context); c->machine = llvm_target_machine_create(); c->target_data = LLVMCreateTargetDataLayout(c->machine); @@ -126,7 +126,8 @@ void gencontext_begin_module(GenContext *c) c->introspect_type = create_introspection_type(c); c->fault_type = create_fault_type(c); c->size_type = llvm_get_type(c, type_usize); - if (c->panicfn) c->panicfn->backend_ref = NULL; + c->char_ptr_type = LLVMPointerType(c->byte_type, 0); + if (c->panic_var) c->panic_var->backend_ref = NULL; if (active_target.debug_info != DEBUG_INFO_NONE) { diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c index beef96d39..00dedb395 100644 --- a/src/compiler/llvm_codegen_stmt.c +++ b/src/compiler/llvm_codegen_stmt.c @@ -1239,6 +1239,21 @@ void gencontext_emit_expr_stmt(GenContext *c, Ast *ast) llvm_emit_expr(c, &value, ast->expr_stmt); } +LLVMValueRef llvm_emit_string_const(GenContext *c, const char *str, const char *extname) +{ + size_t len = str ? strlen(str) : 0; + if (!len) return llvm_emit_empty_string_const(c); + LLVMValueRef val = llvm_emit_zstring_named(c, str, extname); + LLVMValueRef data[2] = { val, llvm_const_int(c, type_usize, strlen(str)) }; + return llvm_get_struct_named(llvm_get_type(c, type_chars), data, 2); +} + +LLVMValueRef llvm_emit_empty_string_const(GenContext *c) +{ + LLVMValueRef data[2] = { LLVMConstNull(c->char_ptr_type), llvm_const_int(c, type_usize, 0) }; + return llvm_get_struct_named(llvm_get_type(c, type_chars), data, 2); +} + LLVMValueRef llvm_emit_zstring(GenContext *c, const char *str) { return llvm_emit_zstring_named(c, str, ".zstr"); @@ -1269,20 +1284,38 @@ void llvm_emit_panic(GenContext *c, const char *message, const char *file, const type_abi_alignment(type_uint)); } - Decl *panicfn = c->panicfn; - if (!panicfn) + Decl *panic_var = c->panic_var; + if (!panic_var) { llvm_emit_call_intrinsic(c, intrinsic_id.trap, NULL, 0, NULL, 0); return; } + LLVMValueRef args[4] = { - llvm_emit_zstring(c, message), - llvm_emit_zstring(c, file), - func ? llvm_emit_zstring(c, func) : llvm_get_zero(c, type_get_ptr(type_char)), + llvm_emit_string_const(c, message, ".panic_msg"), + llvm_emit_string_const(c, file, ".file"), + llvm_emit_string_const(c, func, ".func"), llvm_const_int(c, type_uint, line) }; + FunctionPrototype *prototype = panic_var->type->canonical->pointer->function.prototype; + LLVMValueRef actual_args[16]; + unsigned count = 0; + ABIArgInfo **abi_args = prototype->abi_args; + Type **types = prototype->param_types; + for (unsigned i = 0; i < 4; i++) + { + Type *type = types[i]->canonical; + BEValue value = { .value = args[i], .type = type }; + llvm_emit_parameter(c, actual_args, &count, abi_args[i], &value, type); + } - LLVMBuildCall2(c->builder, llvm_get_type(c, panicfn->type), llvm_get_ref(c, panicfn), args, 4, ""); + BEValue val; + llvm_value_set_decl(c, &val, panic_var); + llvm_value_rvalue(c, &val); + + BEValue res; + llvm_emit_raw_call(c, &res, prototype, llvm_func_type(c, prototype), val.value, actual_args, + count, 0, NULL, false, NULL); } void llvm_emit_panic_if_true(GenContext *c, BEValue *value, const char *panic_name, SourceSpan loc) diff --git a/src/compiler/llvm_codegen_type.c b/src/compiler/llvm_codegen_type.c index 5961ab143..dc08bea2b 100644 --- a/src/compiler/llvm_codegen_type.c +++ b/src/compiler/llvm_codegen_type.c @@ -314,6 +314,20 @@ LLVMTypeRef llvm_get_pointee_type(GenContext *c, Type *any_type) return llvm_get_type(c, any_type->pointer); } +bool llvm_types_are_similar(LLVMTypeRef original, LLVMTypeRef coerce) +{ + if (original == coerce) return true; + if (LLVMGetTypeKind(original) != LLVMStructTypeKind) return false; + if (LLVMGetTypeKind(coerce) != LLVMStructTypeKind) return false; + unsigned types = LLVMCountStructElementTypes(original); + if (types != LLVMCountStructElementTypes(coerce)) return false; + for (unsigned i = 0; i < types; i++) + { + if (LLVMStructGetTypeAtIndex(original, i) != LLVMStructGetTypeAtIndex(coerce, i)) return false; + } + return true; +} + LLVMTypeRef llvm_get_type(GenContext *c, Type *any_type) { if (any_type->backend_type) @@ -550,19 +564,15 @@ static LLVMValueRef llvm_get_introspection_for_enum(GenContext *c, Type *type) { BEValue value; const char *name = enum_vals[i]->name; - size_t len = strlen(name); scratch_buffer_clear(); scratch_buffer_append(".enum."); scratch_buffer_append_unsigned_int(i); const char *name_desc = scratch_buffer_to_string(); if (obfuscate) { - len = strlen(name_desc); name = name_desc; } - LLVMValueRef name_ref = llvm_emit_zstring_named(c, name, scratch_buffer_to_string()); - LLVMValueRef data[2] = { name_ref, llvm_const_int(c, type_usize, len) }; - values[i] = llvm_get_struct_named(subarray, data, 2); + values[i] = llvm_emit_string_const(c, name, scratch_buffer_to_string()); } LLVMValueRef names = llvm_get_array(subarray, values, elements); @@ -653,8 +663,7 @@ static LLVMValueRef llvm_get_introspection_for_fault(GenContext *c, Type *type) LLVMSetGlobalConstant(global_name, 1); LLVMValueRef vals[2] = { LLVMBuildPtrToInt(c->builder, ref, llvm_get_type(c, type_typeid), ""), - llvm_emit_aggregate_two(c, type_chars, llvm_emit_zstring_named(c, val->name, ".fault"), - llvm_const_int(c, type_usize, strlen(val->name))) }; + llvm_emit_string_const(c, val->name, ".fault") }; LLVMSetInitializer(global_name, llvm_get_struct_named(c->fault_type, vals, 2)); llvm_set_linkonce(c, global_name); diff --git a/src/compiler/sema_casts.c b/src/compiler/sema_casts.c index e03c590fc..0214c3b43 100644 --- a/src/compiler/sema_casts.c +++ b/src/compiler/sema_casts.c @@ -1016,6 +1016,7 @@ Expr *recursive_may_narrow_float(Expr *expr, Type *type) case EXPR_SUBSCRIPT_ASSIGN: UNREACHABLE case EXPR_BUILTIN_ACCESS: + case EXPR_TEST_HOOK: return false; case EXPR_POST_UNARY: return recursive_may_narrow_float(expr->unary_expr.expr, type); @@ -1188,6 +1189,8 @@ Expr *recursive_may_narrow_int(Expr *expr, Type *type) case EXPR_OPERATOR_CHARS: case EXPR_CT_CHECKS: UNREACHABLE + case EXPR_TEST_HOOK: + return false; case EXPR_POST_UNARY: return recursive_may_narrow_int(expr->unary_expr.expr, type); case EXPR_TRY: diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c index 9a8590635..921cd7a37 100644 --- a/src/compiler/sema_decls.c +++ b/src/compiler/sema_decls.c @@ -1429,34 +1429,34 @@ static bool sema_analyse_attribute(SemaContext *context, Decl *decl, Attr *attr, AttributeType type = attr->attr_kind; assert(type >= 0 && type < NUMBER_OF_ATTRIBUTES); static AttributeDomain attribute_domain[NUMBER_OF_ATTRIBUTES] = { - [ATTRIBUTE_WEAK] = ATTR_FUNC | ATTR_CONST | ATTR_GLOBAL, - [ATTRIBUTE_EXTNAME] = (AttributeDomain)~(ATTR_CALL | ATTR_BITSTRUCT | ATTR_MACRO | ATTR_XXLIZER), - [ATTRIBUTE_SECTION] = ATTR_FUNC | ATTR_CONST | ATTR_GLOBAL, - [ATTRIBUTE_PACKED] = ATTR_STRUCT | ATTR_UNION, - [ATTRIBUTE_NORETURN] = ATTR_FUNC | ATTR_MACRO, - [ATTRIBUTE_ALIGN] = ATTR_FUNC | ATTR_CONST | ATTR_LOCAL | ATTR_GLOBAL | ATTR_STRUCT | ATTR_UNION | - ATTR_MEMBER, - [ATTRIBUTE_INLINE] = ATTR_FUNC | ATTR_CALL, - [ATTRIBUTE_NOINLINE] = ATTR_FUNC | ATTR_CALL, - [ATTRIBUTE_NODISCARD] = ATTR_FUNC | ATTR_MACRO, - [ATTRIBUTE_MAYDISCARD] = ATTR_FUNC | ATTR_MACRO, + [ATTRIBUTE_ALIGN] = ATTR_FUNC | ATTR_CONST | ATTR_LOCAL | ATTR_GLOBAL | ATTR_STRUCT | ATTR_UNION | ATTR_MEMBER, [ATTRIBUTE_BIGENDIAN] = ATTR_BITSTRUCT, - [ATTRIBUTE_LITTLEENDIAN] = ATTR_BITSTRUCT, - [ATTRIBUTE_USED] = (AttributeDomain)~(ATTR_CALL | ATTR_XXLIZER ), - [ATTRIBUTE_UNUSED] = (AttributeDomain)~(ATTR_CALL | ATTR_XXLIZER), - [ATTRIBUTE_NAKED] = ATTR_FUNC, - [ATTRIBUTE_CDECL] = ATTR_FUNC, - [ATTRIBUTE_STDCALL] = ATTR_FUNC, - [ATTRIBUTE_VECCALL] = ATTR_FUNC, - [ATTRIBUTE_REGCALL] = ATTR_FUNC, - [ATTRIBUTE_FASTCALL] = ATTR_FUNC, - [ATTRIBUTE_OVERLAP] = ATTR_BITSTRUCT, [ATTRIBUTE_BUILTIN] = ATTR_MACRO | ATTR_FUNC, - [ATTRIBUTE_OPERATOR] = ATTR_MACRO | ATTR_FUNC, - [ATTRIBUTE_REFLECT] = ATTR_ENUM, + [ATTRIBUTE_CDECL] = ATTR_FUNC, + [ATTRIBUTE_EXTNAME] = (AttributeDomain)~(ATTR_CALL | ATTR_BITSTRUCT | ATTR_MACRO | ATTR_XXLIZER), + [ATTRIBUTE_FASTCALL] = ATTR_FUNC, + [ATTRIBUTE_INLINE] = ATTR_FUNC | ATTR_CALL, + [ATTRIBUTE_LITTLEENDIAN] = ATTR_BITSTRUCT, + [ATTRIBUTE_MAYDISCARD] = ATTR_FUNC | ATTR_MACRO, + [ATTRIBUTE_NAKED] = ATTR_FUNC, + [ATTRIBUTE_NODISCARD] = ATTR_FUNC | ATTR_MACRO, + [ATTRIBUTE_NOINLINE] = ATTR_FUNC | ATTR_CALL, + [ATTRIBUTE_NORETURN] = ATTR_FUNC | ATTR_MACRO, [ATTRIBUTE_OBFUSCATE] = ATTR_ENUM, - [ATTRIBUTE_PURE] = ATTR_CALL, + [ATTRIBUTE_OPERATOR] = ATTR_MACRO | ATTR_FUNC, + [ATTRIBUTE_OVERLAP] = ATTR_BITSTRUCT, + [ATTRIBUTE_PACKED] = ATTR_STRUCT | ATTR_UNION, [ATTRIBUTE_PRIORITY] = ATTR_XXLIZER, + [ATTRIBUTE_PURE] = ATTR_CALL, + [ATTRIBUTE_REFLECT] = ATTR_ENUM, + [ATTRIBUTE_REGCALL] = ATTR_FUNC, + [ATTRIBUTE_SECTION] = ATTR_FUNC | ATTR_CONST | ATTR_GLOBAL, + [ATTRIBUTE_STDCALL] = ATTR_FUNC, + [ATTRIBUTE_TEST] = ATTR_FUNC, + [ATTRIBUTE_UNUSED] = (AttributeDomain)~(ATTR_CALL | ATTR_XXLIZER), + [ATTRIBUTE_USED] = (AttributeDomain)~(ATTR_CALL | ATTR_XXLIZER ), + [ATTRIBUTE_VECCALL] = ATTR_FUNC, + [ATTRIBUTE_WEAK] = ATTR_FUNC | ATTR_CONST | ATTR_GLOBAL, }; if ((attribute_domain[type] & domain) != domain) @@ -1494,6 +1494,9 @@ static bool sema_analyse_attribute(SemaContext *context, Decl *decl, Attr *attr, break; } break; + case ATTRIBUTE_TEST: + decl->func_decl.attr_test = true; + break; case ATTRIBUTE_STDCALL: assert(decl->decl_kind == DECL_FUNC); if (platform_target.arch == ARCH_TYPE_X86 || platform_target.arch == ARCH_TYPE_X86_64) @@ -2065,13 +2068,14 @@ static inline bool sema_analyse_func(SemaContext *context, Decl *decl) if (!sema_analyse_func_macro(context, decl, true)) return false; - Type *func_type = sema_analyse_function_signature(context, decl, decl->func_decl.signature.abi, &decl->func_decl.signature, true); + Signature *sig = &decl->func_decl.signature; + Type *func_type = sema_analyse_function_signature(context, decl, sig->abi, sig, true); decl->type = func_type; if (!func_type) return decl_poison(decl); - TypeInfo *rtype_info = type_infoptr(decl->func_decl.signature.rtype); + TypeInfo *rtype_info = type_infoptr(sig->rtype); assert(rtype_info); Type *rtype = rtype_info->type->canonical; - if (decl->func_decl.signature.attrs.nodiscard) + if (sig->attrs.nodiscard) { if (rtype == type_void) { @@ -2079,7 +2083,7 @@ static inline bool sema_analyse_func(SemaContext *context, Decl *decl) return decl_poison(decl); } } - if (decl->func_decl.signature.attrs.maydiscard) + if (sig->attrs.maydiscard) { if (!type_is_optional(rtype)) { @@ -2087,18 +2091,35 @@ static inline bool sema_analyse_func(SemaContext *context, Decl *decl) return decl_poison(decl); } } + bool is_test = decl->func_decl.attr_test; if (decl->func_decl.type_parent) { + if (is_test) SEMA_ERROR(decl, "Methods may not be annotated @test."); if (!sema_analyse_method(context, decl)) return decl_poison(decl); } else { if (decl->name == kw_main) { + if (is_test) SEMA_ERROR(decl, "Main functions may not be annotated @test."); if (!sema_analyse_main_function(context, decl)) return decl_poison(decl); } decl_set_external_name(decl); + if (is_test) + { + if (vec_size(sig->params)) + { + SEMA_ERROR(sig->params[0], "'@test' functions may not take any parameters."); + return false; + } + if (type_no_optional(rtype) != type_void) + { + SEMA_ERROR(rtype_info, "'@test' functions may only return 'void' or 'void!'."); + return false; + } + } } + bool pure = false; if (!sema_analyse_doc_header(decl->func_decl.docs, decl->func_decl.signature.params, NULL, &pure)) return decl_poison(decl); decl->func_decl.signature.attrs.is_pure = pure; diff --git a/src/compiler/sema_expr.c b/src/compiler/sema_expr.c index 46e06aa51..f02d49fe6 100644 --- a/src/compiler/sema_expr.c +++ b/src/compiler/sema_expr.c @@ -475,6 +475,7 @@ static bool sema_binary_is_expr_lvalue(Expr *top_expr, Expr *expr) case EXPR_VARIANT: case EXPR_VARIANTSWITCH: case EXPR_VASPLAT: + case EXPR_TEST_HOOK: goto ERR; } UNREACHABLE @@ -1582,6 +1583,11 @@ static inline Type *context_unify_returns(SemaContext *context) static inline bool sema_expr_analyse_func_call(SemaContext *context, Expr *expr, Decl *decl, Expr *struct_var, bool failable) { expr->call_expr.is_pointer_call = false; + if (decl->func_decl.attr_test) + { + SEMA_ERROR(expr, "@test functions may not be directly called."); + return false; + } return sema_call_analyse_func_invocation(context, decl->type, expr, @@ -5112,6 +5118,11 @@ static inline bool sema_addr_may_take_of_ident(Expr *inner) switch (decl->decl_kind) { case DECL_FUNC: + if (decl->func_decl.attr_test) + { + SEMA_ERROR(inner, "You may not take the address of a '@test' function."); + return false; + } return true; case DECL_VAR: return sema_addr_may_take_of_var(inner, decl); @@ -5936,6 +5947,21 @@ static inline bool sema_expr_analyse_compiler_const(SemaContext *context, Expr * expr_replace(expr, value); return true; } + case BUILTIN_DEF_TEST_COUNT: + expr->type = type_uint; + expr->test_hook_expr = BUILTIN_DEF_TEST_COUNT; + expr->expr_kind = EXPR_TEST_HOOK; + return true; + case BUILTIN_DEF_TEST_NAMES: + expr->type = type_get_ptr(type_get_ptr(type_char)); + expr->test_hook_expr = BUILTIN_DEF_TEST_NAMES; + expr->expr_kind = EXPR_TEST_HOOK; + return true; + case BUILTIN_DEF_TEST_FNS: + expr->type = type_get_ptr(type_voidptr); + expr->test_hook_expr = BUILTIN_DEF_TEST_FNS; + expr->expr_kind = EXPR_TEST_HOOK; + return true; } UNREACHABLE } @@ -6685,6 +6711,7 @@ static inline bool sema_analyse_expr_dispatch(SemaContext *context, Expr *expr) case EXPR_TYPEID_INFO: case EXPR_ASM: case EXPR_OPERATOR_CHARS: + case EXPR_TEST_HOOK: UNREACHABLE case EXPR_VASPLAT: SEMA_ERROR(expr, "'$vasplat' can only be used inside of macros."); diff --git a/src/compiler/sema_passes.c b/src/compiler/sema_passes.c index a54d0d2d6..8b16f459c 100644 --- a/src/compiler/sema_passes.c +++ b/src/compiler/sema_passes.c @@ -340,6 +340,8 @@ void sema_analysis_pass_ct_assert(Module *module) static inline bool analyse_func_body(SemaContext *context, Decl *decl) { if (!decl->func_decl.body) return true; + // Don't analyse functions that are tests. + if (decl->func_decl.attr_test && !active_target.testing) return true; if (!sema_analyse_function_body(context, decl)) return decl_poison(decl); return true; } diff --git a/src/compiler/semantic_analyser.c b/src/compiler/semantic_analyser.c index 277dfb914..be508881d 100644 --- a/src/compiler/semantic_analyser.c +++ b/src/compiler/semantic_analyser.c @@ -256,9 +256,10 @@ void sema_analysis_run(void) global_context.std_module.stage = ANALYSIS_LAST; global_context.locals_list = NULL; - // Set a maximum of symbols in the std_module + // Set a maximum of symbols in the std_module and test module htable_init(&global_context.std_module.symbols, 0x10000); + // Setup the func prototype hash map type_func_prototype_init(0x10000); @@ -297,26 +298,22 @@ void sema_analysis_run(void) Decl *decl = sema_find_decl_in_modules(global_context.module_list, path, ident); if (!decl) { - error_exit("Panic function '%s::%s' could not be found.", path->module, ident); + error_exit("Panic function pointer '%s::%s' could not be found.", path->module, ident); } - if (decl->decl_kind != DECL_FUNC) + Type *panic_fn_type = decl->type->canonical; + if (decl->decl_kind != DECL_VAR || !type_is_func_ptr(panic_fn_type)) { - error_exit("'%s::%s' is not a function.", path->module, ident); + error_exit("'%s::%s' is not a function pointer.", path->module, ident); } - Decl **params = decl->func_decl.signature.params; - if (vec_size(params) != 4 || params[0]->type != type_get_ptr(type_char) - || params[1]->type != type_get_ptr(type_char) - || params[2]->type != type_get_ptr(type_char) - || params[3]->type != type_uint - || typeinfotype(decl->func_decl.signature.rtype) != type_void) + if (!type_func_match(panic_fn_type, type_void, 4, type_chars, type_chars, type_chars, type_uint)) { - error_exit("Expected panic function to have the signature fn void(char*, char*, uint, uint)."); + error_exit("Expected panic function to have the signature fn void(char[], char[], char[], uint)."); } - global_context.panic_fn = decl; + global_context.panic_var = decl; } else { - global_context.panic_fn = NULL; + global_context.panic_var = NULL; } compiler_sema_time = bench_mark(); diff --git a/src/compiler/symtab.c b/src/compiler/symtab.c index 1558ac662..e856d2a5b 100644 --- a/src/compiler/symtab.c +++ b/src/compiler/symtab.c @@ -129,6 +129,10 @@ void symtab_init(uint32_t capacity) builtin_defines[BUILTIN_DEF_LINE_RAW] = KW_DEF("LINE_RAW"); builtin_defines[BUILTIN_DEF_MODULE] = KW_DEF("MODULE"); builtin_defines[BUILTIN_DEF_TIME] = KW_DEF("TIME"); + builtin_defines[BUILTIN_DEF_TEST_NAMES] = KW_DEF("TEST_NAMES"); + builtin_defines[BUILTIN_DEF_TEST_FNS] = KW_DEF("TEST_FNS"); + builtin_defines[BUILTIN_DEF_TEST_COUNT] = KW_DEF("TEST_COUNT"); + type = TOKEN_TYPE_IDENT; kw_typekind = KW_DEF("TypeKind"); @@ -290,6 +294,7 @@ void symtab_init(uint32_t capacity) attribute_list[ATTRIBUTE_REGCALL] = KW_DEF("@regcall"); attribute_list[ATTRIBUTE_SECTION] = KW_DEF("@section"); attribute_list[ATTRIBUTE_STDCALL] = KW_DEF("@stdcall"); + attribute_list[ATTRIBUTE_TEST] = KW_DEF("@test"); attribute_list[ATTRIBUTE_UNUSED] = KW_DEF("@unused"); attribute_list[ATTRIBUTE_USED] = KW_DEF("@used"); attribute_list[ATTRIBUTE_VECCALL] = KW_DEF("@veccall"); diff --git a/src/compiler/types.c b/src/compiler/types.c index 402114e0c..0cfec7ad2 100644 --- a/src/compiler/types.c +++ b/src/compiler/types.c @@ -582,6 +582,25 @@ void type_mangle_introspect_name_to_buffer(Type *type) UNREACHABLE } +bool type_func_match(Type *fn_type, Type *rtype, unsigned arg_count, ...) +{ + assert(type_is_func_ptr(fn_type)); + Signature *sig = fn_type->pointer->function.signature; + if (rtype->canonical != typeinfotype(sig->rtype)->canonical) return false; + if (vec_size(sig->params) != arg_count) return false; + va_list ap; + va_start(ap, arg_count); + FOREACH_BEGIN(Decl* decl, sig->params) + Type *arg = va_arg(ap, Type*); + if (decl->type->canonical != arg->canonical) + { + va_end(ap); + return false; + } + FOREACH_END(); + va_end(ap); + return true; +} AlignSize type_abi_alignment(Type *type) { RETRY: diff --git a/test/test_suite/abi/darwin64_avx.c3t b/test/test_suite/abi/darwin64_avx.c3t index 8898e31aa..b5e3d5fc0 100644 --- a/test/test_suite/abi/darwin64_avx.c3t +++ b/test/test_suite/abi/darwin64_avx.c3t @@ -129,7 +129,7 @@ entry: call void (i32, ...) @test52_helper(i32 0, <8 x float> %0, double 1.000000e+00, 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 (<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 (<8 x float>, ...) @test54_helper(<8 x float> %7, <8 x float> %8, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, %Complex* byval(%Complex) align 8 %literal1) + call void (<8 x float>, ...) @test54_helper(<8 x float> %6, <8 x float> %7, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, %Complex* byval(%Complex) align 8 %literal1) declare void @f55(%St512* byval(%St512) align 64) #0 declare void @f56(<16 x float>* byval(<16 x float>) align 64) #0 @@ -138,4 +138,4 @@ declare void @f58(%Two256* byval(%Two256) align 32) #0 define void @test_f59(%Two256* byval(%Two256) align 32 %0) #0 { declare void @f60(%SAtwo256* byval(%SAtwo256) align 32) #0 -define void @test_f61(%SAtwo256* byval(%SAtwo256) align 32 %0) #0 { +define void @test_f61(%SAtwo256* byval(%SAtwo256) align 32 %0) #0 { \ No newline at end of file diff --git a/test/test_suite/abi/darwin64_avx512.c3t b/test/test_suite/abi/darwin64_avx512.c3t index 73dd4a9c6..26e579226 100644 --- a/test/test_suite/abi/darwin64_avx512.c3t +++ b/test/test_suite/abi/darwin64_avx512.c3t @@ -72,4 +72,4 @@ define void @test_f62() #0 { call void (i32, ...) @test_f62_helper(i32 0, <16 x float> %0, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double %lo, double %hi) define void @test_f64() #0 { call void (<16 x float>, ...) @test_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 (<16 x float>, ...) @test_f64_helper(<16 x float> %7, <16 x float> %8, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, %Complex* byval(%Complex) align 8 %literal1) + call void (<16 x float>, ...) @test_f64_helper(<16 x float> %6, <16 x float> %7, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, %Complex* byval(%Complex) align 8 %literal1) diff --git a/test/test_suite/assert/unreachable.c3t b/test/test_suite/assert/unreachable.c3t index 02ccb8552..774891b82 100644 --- a/test/test_suite/assert/unreachable.c3t +++ b/test/test_suite/assert/unreachable.c3t @@ -1,3 +1,4 @@ +// #target: macos-x64 fn int foo() { return 1; @@ -27,13 +28,13 @@ if.then: ; preds = %entry ret void if.exit: ; preds = %entry - call void @std_core_builtin_panic(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0), i32 10) + %2 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %2(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i32 0, i32 0), i64 30, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i32 0, i32 0), i64 14, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0), i64 4, i32 10) unreachable after.unreachable: ; No predecessors! - %2 = load i32, i32* %x, align 4 - %add = add i32 %2, 1 + %3 = load i32, i32* %x, align 4 + %add = add i32 %3, 1 store i32 %add, i32* %x, align 4 ret void -} - +} \ No newline at end of file diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t index c2a0764be..b24968b59 100644 --- a/test/test_suite/bitstruct/bitstruct_be.c3t +++ b/test/test_suite/bitstruct/bitstruct_be.c3t @@ -46,37 +46,30 @@ fn void main() %0 = load i32, i32* %x, align 4 %1 = call i32 @llvm.bswap.i32(i32 %0) store i32 2063597568, i32* %x, align 4 - store %"char[]" { i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), i64 18 }, %"char[]"* %taddr, align 8 - %2 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 0 - %lo = load i8*, i8** %3, align 8 - %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 1 - %hi = load i64, i64* %4, align 8 - %5 = bitcast i32* %x to i8* - %6 = insertvalue %variant undef, i8* %5, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %8 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 - store %variant %7, %variant* %8, align 16 - %9 = load i32, i32* %x, align 4 - %10 = call i32 @llvm.bswap.i32(i32 %9) - store i32 %10, i32* %taddr1, align 4 - %11 = bitcast i32* %taddr1 to i8* - %12 = insertvalue %variant undef, i8* %11, 0 - %13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %14 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 - store %variant %13, %variant* %14, align 16 - %15 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 2, i64* %15, align 8 - %16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %17 = bitcast [2 x %variant]* %varargslots to %variant* - store %variant* %17, %variant** %16, align 8 - %18 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 - %lo2 = load i8*, i8** %19, align 8 - %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 - %hi3 = load i64, i64* %20, align 8 - %21 = call i64 @std_io_printf(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %21, 0 + %2 = bitcast i32* %x to i8* + %3 = insertvalue %variant undef, i8* %2, 0 + %4 = insertvalue %variant %3, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %5 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 + store %variant %4, %variant* %5, align 16 + %6 = load i32, i32* %x, align 4 + %7 = call i32 @llvm.bswap.i32(i32 %6) + store i32 %7, i32* %taddr, align 4 + %8 = bitcast i32* %taddr to i8* + %9 = insertvalue %variant undef, i8* %8, 0 + %10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %11 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 + store %variant %10, %variant* %11, align 16 + %12 = bitcast [2 x %variant]* %varargslots to %variant* + %13 = insertvalue %"variant[]" undef, %variant* %12, 0 + %14 = insertvalue %"variant[]" %13, i64 2, 1 + store %"variant[]" %14, %"variant[]"* %taddr1, align 8 + %15 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 0 + %lo = load i8*, i8** %16, align 8 + %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 1 + %hi = load i64, i64* %17, align 8 + %18 = call i64 @std_io_printf(i64* %retparam, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), i64 18, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %18, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -88,277 +81,235 @@ voiderr: ; preds = %after_check, %entry %ptrptr = bitcast i32* %abc to [4 x i8]* store [4 x i8]* %ptrptr, [4 x i8]** %z, align 8 store [4 x i8]* %abc2, [4 x i8]** %z2, align 8 - %22 = load [4 x i8]*, [4 x i8]** %z2, align 8 - store [4 x i8]* %22, [4 x i8]** %.anon, align 8 - store i64 0, i64* %.anon4, align 8 + %19 = load [4 x i8]*, [4 x i8]** %z2, align 8 + store [4 x i8]* %19, [4 x i8]** %.anon, align 8 + store i64 0, i64* %.anon2, align 8 br label %loop.cond -loop.cond: ; preds = %voiderr15, %voiderr - %23 = load i64, i64* %.anon4, align 8 - %gt = icmp ugt i64 4, %23 +loop.cond: ; preds = %voiderr10, %voiderr + %20 = load i64, i64* %.anon2, align 8 + %gt = icmp ugt i64 4, %20 br i1 %gt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %24 = load [4 x i8]*, [4 x i8]** %.anon, align 8 - %25 = load i64, i64* %.anon4, align 8 - %26 = getelementptr inbounds [4 x i8], [4 x i8]* %24, i64 0, i64 %25 - %27 = load i8, i8* %26, align 1 - store i8 %27, i8* %d, align 1 - store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3 }, %"char[]"* %taddr6, align 8 - %28 = bitcast %"char[]"* %taddr6 to { i8*, i64 }* - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 0 - %lo7 = load i8*, i8** %29, align 8 - %30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 1 - %hi8 = load i64, i64* %30, align 8 - %31 = insertvalue %variant undef, i8* %d, 0 - %32 = insertvalue %variant %31, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 - %33 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots10, i64 0, i64 0 - store %variant %32, %variant* %33, align 16 - %34 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 1 - store i64 1, i64* %34, align 8 - %35 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 0 - %36 = bitcast [1 x %variant]* %varargslots10 to %variant* - store %variant* %36, %variant** %35, align 8 - %37 = bitcast %"variant[]"* %vararg9 to { i8*, i64 }* - %38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %37, i32 0, i32 0 - %lo11 = load i8*, i8** %38, align 8 - %39 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %37, i32 0, i32 1 - %hi12 = load i64, i64* %39, align 8 - %40 = call i64 @std_io_printf(i64* %retparam5, i8* %lo7, i64 %hi8, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %40, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %21 = load [4 x i8]*, [4 x i8]** %.anon, align 8 + %22 = load i64, i64* %.anon2, align 8 + %23 = getelementptr inbounds [4 x i8], [4 x i8]* %21, i64 0, i64 %22 + %24 = load i8, i8* %23, align 1 + store i8 %24, i8* %d, align 1 + %25 = insertvalue %variant undef, i8* %d, 0 + %26 = insertvalue %variant %25, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 + %27 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots4, i64 0, i64 0 + store %variant %26, %variant* %27, align 16 + %28 = bitcast [1 x %variant]* %varargslots4 to %variant* + %29 = insertvalue %"variant[]" undef, %variant* %28, 0 + %30 = insertvalue %"variant[]" %29, i64 1, 1 + store %"variant[]" %30, %"variant[]"* %taddr5, align 8 + %31 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }* + %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 + %lo6 = load i8*, i8** %32, align 8 + %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 + %hi7 = load i64, i64* %33, align 8 + %34 = call i64 @std_io_printf(i64* %retparam3, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %34, 0 + br i1 %not_err8, label %after_check9, label %voiderr10 -after_check14: ; preds = %loop.body - br label %voiderr15 +after_check9: ; preds = %loop.body + br label %voiderr10 -voiderr15: ; preds = %after_check14, %loop.body - %41 = load i64, i64* %.anon4, align 8 - %add = add i64 %41, 1 - store i64 %add, i64* %.anon4, align 8 +voiderr10: ; preds = %after_check9, %loop.body + %35 = load i64, i64* %.anon2, align 8 + %add = add i64 %35, 1 + store i64 %add, i64* %.anon2, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - %42 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i32 0, i32 0)) #2 - %43 = load [4 x i8]*, [4 x i8]** %z, align 8 - store [4 x i8]* %43, [4 x i8]** %.anon16, align 8 - store i64 0, i64* %.anon17, align 8 - br label %loop.cond18 + %36 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i32 0, i32 0)) #2 + %37 = load [4 x i8]*, [4 x i8]** %z, align 8 + store [4 x i8]* %37, [4 x i8]** %.anon11, align 8 + store i64 0, i64* %.anon12, align 8 + br label %loop.cond13 -loop.cond18: ; preds = %voiderr32, %loop.exit - %44 = load i64, i64* %.anon17, align 8 - %gt19 = icmp ugt i64 4, %44 - br i1 %gt19, label %loop.body20, label %loop.exit34 +loop.cond13: ; preds = %voiderr24, %loop.exit + %38 = load i64, i64* %.anon12, align 8 + %gt14 = icmp ugt i64 4, %38 + br i1 %gt14, label %loop.body15, label %loop.exit26 -loop.body20: ; preds = %loop.cond18 - %45 = load [4 x i8]*, [4 x i8]** %.anon16, align 8 - %46 = load i64, i64* %.anon17, align 8 - %47 = getelementptr inbounds [4 x i8], [4 x i8]* %45, i64 0, i64 %46 - %48 = load i8, i8* %47, align 1 - store i8 %48, i8* %d21, align 1 - store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i64 3 }, %"char[]"* %taddr23, align 8 - %49 = bitcast %"char[]"* %taddr23 to { i8*, i64 }* +loop.body15: ; preds = %loop.cond13 + %39 = load [4 x i8]*, [4 x i8]** %.anon11, align 8 + %40 = load i64, i64* %.anon12, align 8 + %41 = getelementptr inbounds [4 x i8], [4 x i8]* %39, i64 0, i64 %40 + %42 = load i8, i8* %41, align 1 + store i8 %42, i8* %d16, align 1 + %43 = insertvalue %variant undef, i8* %d16, 0 + %44 = insertvalue %variant %43, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 + %45 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots18, i64 0, i64 0 + store %variant %44, %variant* %45, align 16 + %46 = bitcast [1 x %variant]* %varargslots18 to %variant* + %47 = insertvalue %"variant[]" undef, %variant* %46, 0 + %48 = insertvalue %"variant[]" %47, i64 1, 1 + store %"variant[]" %48, %"variant[]"* %taddr19, align 8 + %49 = bitcast %"variant[]"* %taddr19 to { i8*, i64 }* %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 0 - %lo24 = load i8*, i8** %50, align 8 + %lo20 = load i8*, i8** %50, align 8 %51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 1 - %hi25 = load i64, i64* %51, align 8 - %52 = insertvalue %variant undef, i8* %d21, 0 - %53 = insertvalue %variant %52, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 - %54 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots27, i64 0, i64 0 - store %variant %53, %variant* %54, align 16 - %55 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg26, i32 0, i32 1 - store i64 1, i64* %55, align 8 - %56 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg26, i32 0, i32 0 - %57 = bitcast [1 x %variant]* %varargslots27 to %variant* - store %variant* %57, %variant** %56, align 8 - %58 = bitcast %"variant[]"* %vararg26 to { i8*, i64 }* - %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0 - %lo28 = load i8*, i8** %59, align 8 - %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1 - %hi29 = load i64, i64* %60, align 8 - %61 = call i64 @std_io_printf(i64* %retparam22, i8* %lo24, i64 %hi25, i8* %lo28, i64 %hi29) - %not_err30 = icmp eq i64 %61, 0 - br i1 %not_err30, label %after_check31, label %voiderr32 + %hi21 = load i64, i64* %51, align 8 + %52 = call i64 @std_io_printf(i64* %retparam17, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i64 3, i8* %lo20, i64 %hi21) + %not_err22 = icmp eq i64 %52, 0 + br i1 %not_err22, label %after_check23, label %voiderr24 -after_check31: ; preds = %loop.body20 - br label %voiderr32 +after_check23: ; preds = %loop.body15 + br label %voiderr24 -voiderr32: ; preds = %after_check31, %loop.body20 - %62 = load i64, i64* %.anon17, align 8 - %add33 = add i64 %62, 1 - store i64 %add33, i64* %.anon17, align 8 - br label %loop.cond18 +voiderr24: ; preds = %after_check23, %loop.body15 + %53 = load i64, i64* %.anon12, align 8 + %add25 = add i64 %53, 1 + store i64 %add25, i64* %.anon12, align 8 + br label %loop.cond13 -loop.exit34: ; preds = %loop.cond18 - %63 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i32 0, i32 0)) #2 - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i64 10 }, %"char[]"* %taddr36, align 8 - %64 = bitcast %"char[]"* %taddr36 to { i8*, i64 }* - %65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 0 - %lo37 = load i8*, i8** %65, align 8 - %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 1 - %hi38 = load i64, i64* %66, align 8 - %67 = load i32, i32* %abc, align 4 - %68 = call i32 @llvm.bswap.i32(i32 %67) - %69 = and i32 65535, %68 - %ztrunc = trunc i32 %69 to i16 - store i16 %ztrunc, i16* %taddr41, align 2 - %70 = bitcast i16* %taddr41 to i8* - %71 = insertvalue %variant undef, i8* %70, 0 - %72 = insertvalue %variant %71, i64 ptrtoint (%.introspect* @"ct$ushort" to i64), 1 - %73 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots40, i64 0, i64 0 - store %variant %72, %variant* %73, align 16 - %74 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg39, i32 0, i32 1 - store i64 1, i64* %74, align 8 - %75 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg39, i32 0, i32 0 - %76 = bitcast [1 x %variant]* %varargslots40 to %variant* - store %variant* %76, %variant** %75, align 8 - %77 = bitcast %"variant[]"* %vararg39 to { i8*, i64 }* - %78 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %77, i32 0, i32 0 - %lo42 = load i8*, i8** %78, align 8 - %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %77, i32 0, i32 1 - %hi43 = load i64, i64* %79, align 8 - %80 = call i64 @std_io_printfln(i64* %retparam35, i8* %lo37, i64 %hi38, i8* %lo42, i64 %hi43) - %not_err44 = icmp eq i64 %80, 0 - br i1 %not_err44, label %after_check45, label %voiderr46 +loop.exit26: ; preds = %loop.cond13 + %54 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i32 0, i32 0)) #2 + %55 = load i32, i32* %abc, align 4 + %56 = call i32 @llvm.bswap.i32(i32 %55) + %57 = and i32 65535, %56 + %ztrunc = trunc i32 %57 to i16 + store i16 %ztrunc, i16* %taddr29, align 2 + %58 = bitcast i16* %taddr29 to i8* + %59 = insertvalue %variant undef, i8* %58, 0 + %60 = insertvalue %variant %59, i64 ptrtoint (%.introspect* @"ct$ushort" to i64), 1 + %61 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots28, i64 0, i64 0 + store %variant %60, %variant* %61, align 16 + %62 = bitcast [1 x %variant]* %varargslots28 to %variant* + %63 = insertvalue %"variant[]" undef, %variant* %62, 0 + %64 = insertvalue %"variant[]" %63, i64 1, 1 + store %"variant[]" %64, %"variant[]"* %taddr30, align 8 + %65 = bitcast %"variant[]"* %taddr30 to { i8*, i64 }* + %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 0 + %lo31 = load i8*, i8** %66, align 8 + %67 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 1 + %hi32 = load i64, i64* %67, align 8 + %68 = call i64 @std_io_printfln(i64* %retparam27, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i64 10, i8* %lo31, i64 %hi32) + %not_err33 = icmp eq i64 %68, 0 + br i1 %not_err33, label %after_check34, label %voiderr35 -after_check45: ; preds = %loop.exit34 - br label %voiderr46 +after_check34: ; preds = %loop.exit26 + br label %voiderr35 -voiderr46: ; preds = %after_check45, %loop.exit34 - %81 = load i32, i32* %abc, align 4 - %82 = call i32 @llvm.bswap.i32(i32 %81) - %83 = and i32 %82, -65536 - %84 = or i32 %83, 4660 - %85 = call i32 @llvm.bswap.i32(i32 %84) - store i32 %85, i32* %abc, align 4 - %86 = load i32, i32* %abc, align 4 - %87 = call i32 @llvm.bswap.i32(i32 %86) - %88 = and i32 %87, 65535 - %89 = or i32 %88, 1450704896 - %90 = call i32 @llvm.bswap.i32(i32 %89) - store i32 %90, i32* %abc, align 4 - store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i32 0, i32 0), i64 12 }, %"char[]"* %taddr48, align 8 - %91 = bitcast %"char[]"* %taddr48 to { i8*, i64 }* - %92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %91, i32 0, i32 0 - %lo49 = load i8*, i8** %92, align 8 - %93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %91, i32 0, i32 1 - %hi50 = load i64, i64* %93, align 8 - %94 = load i32, i32* %abc, align 4 - %95 = call i32 @llvm.bswap.i32(i32 %94) - %96 = and i32 65535, %95 - %ztrunc53 = trunc i32 %96 to i16 - store i16 %ztrunc53, i16* %taddr54, align 2 - %97 = bitcast i16* %taddr54 to i8* - %98 = insertvalue %variant undef, i8* %97, 0 - %99 = insertvalue %variant %98, i64 ptrtoint (%.introspect* @"ct$ushort" to i64), 1 - %100 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots52, i64 0, i64 0 - store %variant %99, %variant* %100, align 16 - %101 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg51, i32 0, i32 1 - store i64 1, i64* %101, align 8 - %102 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg51, i32 0, i32 0 - %103 = bitcast [1 x %variant]* %varargslots52 to %variant* - store %variant* %103, %variant** %102, align 8 - %104 = bitcast %"variant[]"* %vararg51 to { i8*, i64 }* - %105 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %104, i32 0, i32 0 - %lo55 = load i8*, i8** %105, align 8 - %106 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %104, i32 0, i32 1 - %hi56 = load i64, i64* %106, align 8 - %107 = call i64 @std_io_printfln(i64* %retparam47, i8* %lo49, i64 %hi50, i8* %lo55, i64 %hi56) - %not_err57 = icmp eq i64 %107, 0 +voiderr35: ; preds = %after_check34, %loop.exit26 + %69 = load i32, i32* %abc, align 4 + %70 = call i32 @llvm.bswap.i32(i32 %69) + %71 = and i32 %70, -65536 + %72 = or i32 %71, 4660 + %73 = call i32 @llvm.bswap.i32(i32 %72) + store i32 %73, i32* %abc, align 4 + %74 = load i32, i32* %abc, align 4 + %75 = call i32 @llvm.bswap.i32(i32 %74) + %76 = and i32 %75, 65535 + %77 = or i32 %76, 1450704896 + %78 = call i32 @llvm.bswap.i32(i32 %77) + store i32 %78, i32* %abc, align 4 + %79 = load i32, i32* %abc, align 4 + %80 = call i32 @llvm.bswap.i32(i32 %79) + %81 = and i32 65535, %80 + %ztrunc38 = trunc i32 %81 to i16 + store i16 %ztrunc38, i16* %taddr39, align 2 + %82 = bitcast i16* %taddr39 to i8* + %83 = insertvalue %variant undef, i8* %82, 0 + %84 = insertvalue %variant %83, i64 ptrtoint (%.introspect* @"ct$ushort" to i64), 1 + %85 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots37, i64 0, i64 0 + store %variant %84, %variant* %85, align 16 + %86 = bitcast [1 x %variant]* %varargslots37 to %variant* + %87 = insertvalue %"variant[]" undef, %variant* %86, 0 + %88 = insertvalue %"variant[]" %87, i64 1, 1 + store %"variant[]" %88, %"variant[]"* %taddr40, align 8 + %89 = bitcast %"variant[]"* %taddr40 to { i8*, i64 }* + %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %89, i32 0, i32 0 + %lo41 = load i8*, i8** %90, align 8 + %91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %89, i32 0, i32 1 + %hi42 = load i64, i64* %91, align 8 + %92 = call i64 @std_io_printfln(i64* %retparam36, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i32 0, i32 0), i64 12, i8* %lo41, i64 %hi42) + %not_err43 = icmp eq i64 %92, 0 + br i1 %not_err43, label %after_check44, label %voiderr45 + +after_check44: ; preds = %voiderr35 + br label %voiderr45 + +voiderr45: ; preds = %after_check44, %voiderr35 + %93 = load [4 x i8]*, [4 x i8]** %z, align 8 + store [4 x i8]* %93, [4 x i8]** %.anon46, align 8 + store i64 0, i64* %.anon47, align 8 + br label %loop.cond48 + +loop.cond48: ; preds = %voiderr59, %voiderr45 + %94 = load i64, i64* %.anon47, align 8 + %gt49 = icmp ugt i64 4, %94 + br i1 %gt49, label %loop.body50, label %loop.exit61 + +loop.body50: ; preds = %loop.cond48 + %95 = load [4 x i8]*, [4 x i8]** %.anon46, align 8 + %96 = load i64, i64* %.anon47, align 8 + %97 = getelementptr inbounds [4 x i8], [4 x i8]* %95, i64 0, i64 %96 + %98 = load i8, i8* %97, align 1 + store i8 %98, i8* %d51, align 1 + %99 = insertvalue %variant undef, i8* %d51, 0 + %100 = insertvalue %variant %99, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 + %101 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots53, i64 0, i64 0 + store %variant %100, %variant* %101, align 16 + %102 = bitcast [1 x %variant]* %varargslots53 to %variant* + %103 = insertvalue %"variant[]" undef, %variant* %102, 0 + %104 = insertvalue %"variant[]" %103, i64 1, 1 + store %"variant[]" %104, %"variant[]"* %taddr54, align 8 + %105 = bitcast %"variant[]"* %taddr54 to { i8*, i64 }* + %106 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %105, i32 0, i32 0 + %lo55 = load i8*, i8** %106, align 8 + %107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %105, i32 0, i32 1 + %hi56 = load i64, i64* %107, align 8 + %108 = call i64 @std_io_printf(i64* %retparam52, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i32 0, i32 0), i64 3, i8* %lo55, i64 %hi56) + %not_err57 = icmp eq i64 %108, 0 br i1 %not_err57, label %after_check58, label %voiderr59 -after_check58: ; preds = %voiderr46 +after_check58: ; preds = %loop.body50 br label %voiderr59 -voiderr59: ; preds = %after_check58, %voiderr46 - %108 = load [4 x i8]*, [4 x i8]** %z, align 8 - store [4 x i8]* %108, [4 x i8]** %.anon60, align 8 - store i64 0, i64* %.anon61, align 8 - br label %loop.cond62 +voiderr59: ; preds = %after_check58, %loop.body50 + %109 = load i64, i64* %.anon47, align 8 + %add60 = add i64 %109, 1 + store i64 %add60, i64* %.anon47, align 8 + br label %loop.cond48 -loop.cond62: ; preds = %voiderr76, %voiderr59 - %109 = load i64, i64* %.anon61, align 8 - %gt63 = icmp ugt i64 4, %109 - br i1 %gt63, label %loop.body64, label %loop.exit78 - -loop.body64: ; preds = %loop.cond62 - %110 = load [4 x i8]*, [4 x i8]** %.anon60, align 8 - %111 = load i64, i64* %.anon61, align 8 - %112 = getelementptr inbounds [4 x i8], [4 x i8]* %110, i64 0, i64 %111 - %113 = load i8, i8* %112, align 1 - store i8 %113, i8* %d65, align 1 - store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i32 0, i32 0), i64 3 }, %"char[]"* %taddr67, align 8 - %114 = bitcast %"char[]"* %taddr67 to { i8*, i64 }* - %115 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %114, i32 0, i32 0 - %lo68 = load i8*, i8** %115, align 8 - %116 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %114, i32 0, i32 1 - %hi69 = load i64, i64* %116, align 8 - %117 = insertvalue %variant undef, i8* %d65, 0 - %118 = insertvalue %variant %117, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 - %119 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots71, i64 0, i64 0 - store %variant %118, %variant* %119, align 16 - %120 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg70, i32 0, i32 1 - store i64 1, i64* %120, align 8 - %121 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg70, i32 0, i32 0 - %122 = bitcast [1 x %variant]* %varargslots71 to %variant* - store %variant* %122, %variant** %121, align 8 - %123 = bitcast %"variant[]"* %vararg70 to { i8*, i64 }* - %124 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 0 - %lo72 = load i8*, i8** %124, align 8 - %125 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 1 - %hi73 = load i64, i64* %125, align 8 - %126 = call i64 @std_io_printf(i64* %retparam66, i8* %lo68, i64 %hi69, i8* %lo72, i64 %hi73) - %not_err74 = icmp eq i64 %126, 0 - br i1 %not_err74, label %after_check75, label %voiderr76 - -after_check75: ; preds = %loop.body64 - br label %voiderr76 - -voiderr76: ; preds = %after_check75, %loop.body64 - %127 = load i64, i64* %.anon61, align 8 - %add77 = add i64 %127, 1 - store i64 %add77, i64* %.anon61, align 8 - br label %loop.cond62 - -loop.exit78: ; preds = %loop.cond62 - %128 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.8, i32 0, i32 0)) #2 +loop.exit61: ; preds = %loop.cond48 + %110 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.8, i32 0, i32 0)) #2 store i32 0, i32* %y, align 4 - %129 = load i32, i32* %y, align 4 + %111 = load i32, i32* %y, align 4 store i32 123, i32* %y, align 4 - store %"char[]" { i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i32 0, i32 0), i64 18 }, %"char[]"* %taddr80, align 8 - %130 = bitcast %"char[]"* %taddr80 to { i8*, i64 }* - %131 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %130, i32 0, i32 0 - %lo81 = load i8*, i8** %131, align 8 - %132 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %130, i32 0, i32 1 - %hi82 = load i64, i64* %132, align 8 - %133 = bitcast i32* %y to i8* - %134 = insertvalue %variant undef, i8* %133, 0 - %135 = insertvalue %variant %134, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %136 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots84, i64 0, i64 0 - store %variant %135, %variant* %136, align 16 - %137 = load i32, i32* %y, align 4 - store i32 %137, i32* %taddr85, align 4 - %138 = bitcast i32* %taddr85 to i8* - %139 = insertvalue %variant undef, i8* %138, 0 - %140 = insertvalue %variant %139, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %141 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots84, i64 0, i64 1 - store %variant %140, %variant* %141, align 16 - %142 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg83, i32 0, i32 1 - store i64 2, i64* %142, align 8 - %143 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg83, i32 0, i32 0 - %144 = bitcast [2 x %variant]* %varargslots84 to %variant* - store %variant* %144, %variant** %143, align 8 - %145 = bitcast %"variant[]"* %vararg83 to { i8*, i64 }* - %146 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %145, i32 0, i32 0 - %lo86 = load i8*, i8** %146, align 8 - %147 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %145, i32 0, i32 1 - %hi87 = load i64, i64* %147, align 8 - %148 = call i64 @std_io_printf(i64* %retparam79, i8* %lo81, i64 %hi82, i8* %lo86, i64 %hi87) - %not_err88 = icmp eq i64 %148, 0 - br i1 %not_err88, label %after_check89, label %voiderr90 + %112 = bitcast i32* %y to i8* + %113 = insertvalue %variant undef, i8* %112, 0 + %114 = insertvalue %variant %113, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %115 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots63, i64 0, i64 0 + store %variant %114, %variant* %115, align 16 + %116 = load i32, i32* %y, align 4 + store i32 %116, i32* %taddr64, align 4 + %117 = bitcast i32* %taddr64 to i8* + %118 = insertvalue %variant undef, i8* %117, 0 + %119 = insertvalue %variant %118, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %120 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots63, i64 0, i64 1 + store %variant %119, %variant* %120, align 16 + %121 = bitcast [2 x %variant]* %varargslots63 to %variant* + %122 = insertvalue %"variant[]" undef, %variant* %121, 0 + %123 = insertvalue %"variant[]" %122, i64 2, 1 + store %"variant[]" %123, %"variant[]"* %taddr65, align 8 + %124 = bitcast %"variant[]"* %taddr65 to { i8*, i64 }* + %125 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %124, i32 0, i32 0 + %lo66 = load i8*, i8** %125, align 8 + %126 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %124, i32 0, i32 1 + %hi67 = load i64, i64* %126, align 8 + %127 = call i64 @std_io_printf(i64* %retparam62, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i32 0, i32 0), i64 18, i8* %lo66, i64 %hi67) + %not_err68 = icmp eq i64 %127, 0 + br i1 %not_err68, label %after_check69, label %voiderr70 -after_check89: ; preds = %loop.exit78 - br label %voiderr90 +after_check69: ; preds = %loop.exit61 + br label %voiderr70 -voiderr90: ; preds = %after_check89, %loop.exit78 +voiderr70: ; preds = %after_check69, %loop.exit61 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 cee00c8bb..1887fb4bd 100644 --- a/test/test_suite/bitstruct/bitstruct_initializer.c3t +++ b/test/test_suite/bitstruct/bitstruct_initializer.c3t @@ -55,47 +55,41 @@ entry: %d = alloca %Abc, align 8 %b = alloca [8 x i8], align 1 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [3 x %variant], align 16 - %taddr11 = alloca i32, align 4 - %taddr14 = alloca i32, align 4 - %taddr17 = alloca i8, align 1 - %retparam20 = alloca i64, align 8 - %taddr21 = alloca %"char[]", align 8 - %vararg24 = alloca %"variant[]", align 8 - %varargslots25 = alloca [3 x %variant], align 16 - %taddr27 = alloca i32, align 4 - %taddr30 = alloca i32, align 4 - %taddr33 = alloca i8, align 1 - %retparam39 = alloca i64, align 8 - %taddr40 = alloca %"char[]", align 8 - %vararg43 = alloca %"variant[]", align 8 - %varargslots44 = alloca [3 x %variant], align 16 - %taddr52 = alloca i32, align 4 - %taddr60 = alloca i32, align 4 - %taddr62 = alloca i8, align 1 - %retparam82 = alloca i64, align 8 - %taddr83 = alloca %"char[]", align 8 - %vararg86 = alloca %"variant[]", align 8 - %varargslots87 = alloca [3 x %variant], align 16 - %taddr89 = alloca i32, align 4 - %taddr92 = alloca i32, align 4 - %taddr95 = alloca i8, align 1 - %retparam101 = alloca i64, align 8 - %taddr102 = alloca %"char[]", align 8 - %vararg105 = alloca %"variant[]", align 8 - %varargslots106 = alloca [3 x %variant], align 16 - %taddr108 = alloca i32, align 4 - %taddr111 = alloca i32, align 4 - %taddr114 = alloca i8, align 1 - %retparam120 = alloca i64, align 8 - %taddr121 = alloca %"char[]", align 8 - %vararg124 = alloca %"variant[]", align 8 - %varargslots125 = alloca [3 x %variant], align 16 - %taddr133 = alloca i32, align 4 - %taddr141 = alloca i32, align 4 - %taddr143 = alloca i8, align 1 + %taddr = alloca i32, align 4 + %taddr13 = alloca i32, align 4 + %taddr16 = alloca i8, align 1 + %taddr17 = alloca %"variant[]", align 8 + %retparam18 = alloca i64, align 8 + %varargslots19 = alloca [3 x %variant], align 16 + %taddr21 = alloca i32, align 4 + %taddr24 = alloca i32, align 4 + %taddr27 = alloca i8, align 1 + %taddr28 = alloca %"variant[]", align 8 + %retparam34 = alloca i64, align 8 + %varargslots35 = alloca [3 x %variant], align 16 + %taddr43 = alloca i32, align 4 + %taddr51 = alloca i32, align 4 + %taddr53 = alloca i8, align 1 + %taddr54 = alloca %"variant[]", align 8 + %retparam74 = alloca i64, align 8 + %varargslots75 = alloca [3 x %variant], align 16 + %taddr77 = alloca i32, align 4 + %taddr80 = alloca i32, align 4 + %taddr83 = alloca i8, align 1 + %taddr84 = alloca %"variant[]", align 8 + %retparam90 = alloca i64, align 8 + %varargslots91 = alloca [3 x %variant], align 16 + %taddr93 = alloca i32, align 4 + %taddr96 = alloca i32, align 4 + %taddr99 = alloca i8, align 1 + %taddr100 = alloca %"variant[]", align 8 + %retparam106 = alloca i64, align 8 + %varargslots107 = alloca [3 x %variant], align 16 + %taddr115 = alloca i32, align 4 + %taddr123 = alloca i32, align 4 + %taddr125 = alloca i8, align 1 + %taddr126 = alloca %"variant[]", align 8 store i64 0, i64* %x, align 8 %zext = zext i32 %0 to i64 %1 = and i64 %zext, 4294967295 @@ -167,451 +161,409 @@ entry: %31 = and i8 %30, 127 %32 = or i8 %31, %shl9 store i8 %32, i8* %29, align 1 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8 - %33 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 0 - %lo = load i8*, i8** %34, align 8 - %35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 1 - %hi = load i64, i64* %35, align 8 - %36 = load i64, i64* %x, align 8 - %37 = and i64 4294967295, %36 - %ztrunc10 = trunc i64 %37 to i32 - store i32 %ztrunc10, i32* %taddr11, align 4 - %38 = bitcast i32* %taddr11 to i8* - %39 = insertvalue %variant undef, i8* %38, 0 - %40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %41 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 0 - store %variant %40, %variant* %41, align 16 - %42 = load i64, i64* %x, align 8 - %lshrl12 = lshr i64 %42, 32 - %43 = and i64 2147483647, %lshrl12 - %ztrunc13 = trunc i64 %43 to i32 - store i32 %ztrunc13, i32* %taddr14, align 4 - %44 = bitcast i32* %taddr14 to i8* - %45 = insertvalue %variant undef, i8* %44, 0 - %46 = insertvalue %variant %45, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %47 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 1 - store %variant %46, %variant* %47, align 16 - %48 = load i64, i64* %x, align 8 - %lshrl15 = lshr i64 %48, 63 - %49 = and i64 1, %lshrl15 - %ztrunc16 = trunc i64 %49 to i8 - store i8 %ztrunc16, i8* %taddr17, align 1 - %50 = insertvalue %variant undef, i8* %taddr17, 0 - %51 = insertvalue %variant %50, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %52 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 2 - store %variant %51, %variant* %52, align 16 - %53 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 3, i64* %53, align 8 - %54 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %55 = bitcast [3 x %variant]* %varargslots to %variant* - store %variant* %55, %variant** %54, align 8 - %56 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 0 - %lo18 = load i8*, i8** %57, align 8 - %58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 1 - %hi19 = load i64, i64* %58, align 8 - %59 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo18, i64 %hi19) - %not_err = icmp eq i64 %59, 0 + %33 = load i64, i64* %x, align 8 + %34 = and i64 4294967295, %33 + %ztrunc10 = trunc i64 %34 to i32 + store i32 %ztrunc10, i32* %taddr, align 4 + %35 = bitcast i32* %taddr to i8* + %36 = insertvalue %variant undef, i8* %35, 0 + %37 = insertvalue %variant %36, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %38 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 0 + store %variant %37, %variant* %38, align 16 + %39 = load i64, i64* %x, align 8 + %lshrl11 = lshr i64 %39, 32 + %40 = and i64 2147483647, %lshrl11 + %ztrunc12 = trunc i64 %40 to i32 + store i32 %ztrunc12, i32* %taddr13, align 4 + %41 = bitcast i32* %taddr13 to i8* + %42 = insertvalue %variant undef, i8* %41, 0 + %43 = insertvalue %variant %42, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %44 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 1 + store %variant %43, %variant* %44, align 16 + %45 = load i64, i64* %x, align 8 + %lshrl14 = lshr i64 %45, 63 + %46 = and i64 1, %lshrl14 + %ztrunc15 = trunc i64 %46 to i8 + store i8 %ztrunc15, i8* %taddr16, align 1 + %47 = insertvalue %variant undef, i8* %taddr16, 0 + %48 = insertvalue %variant %47, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %49 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 2 + store %variant %48, %variant* %49, align 16 + %50 = bitcast [3 x %variant]* %varargslots to %variant* + %51 = insertvalue %"variant[]" undef, %variant* %50, 0 + %52 = insertvalue %"variant[]" %51, i64 3, 1 + store %"variant[]" %52, %"variant[]"* %taddr17, align 8 + %53 = bitcast %"variant[]"* %taddr17 to { i8*, i64 }* + %54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 0 + %lo = load i8*, i8** %54, align 8 + %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 1 + %hi = load i64, i64* %55, align 8 + %56 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %56, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8 }, %"char[]"* %taddr21, align 8 - %60 = bitcast %"char[]"* %taddr21 to { i8*, i64 }* - %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0 - %lo22 = load i8*, i8** %61, align 8 - %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1 - %hi23 = load i64, i64* %62, align 8 - %63 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 - %64 = load i64, i64* %63, align 8 - %65 = and i64 4294967295, %64 - %ztrunc26 = trunc i64 %65 to i32 - store i32 %ztrunc26, i32* %taddr27, align 4 - %66 = bitcast i32* %taddr27 to i8* - %67 = insertvalue %variant undef, i8* %66, 0 - %68 = insertvalue %variant %67, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %69 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 0 - store %variant %68, %variant* %69, align 16 - %70 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 - %71 = load i64, i64* %70, align 8 - %lshrl28 = lshr i64 %71, 32 - %72 = and i64 2147483647, %lshrl28 - %ztrunc29 = trunc i64 %72 to i32 - store i32 %ztrunc29, i32* %taddr30, align 4 - %73 = bitcast i32* %taddr30 to i8* - %74 = insertvalue %variant undef, i8* %73, 0 - %75 = insertvalue %variant %74, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %76 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 1 + %57 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 + %58 = load i64, i64* %57, align 8 + %59 = and i64 4294967295, %58 + %ztrunc20 = trunc i64 %59 to i32 + store i32 %ztrunc20, i32* %taddr21, align 4 + %60 = bitcast i32* %taddr21 to i8* + %61 = insertvalue %variant undef, i8* %60, 0 + %62 = insertvalue %variant %61, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %63 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 0 + store %variant %62, %variant* %63, align 16 + %64 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 + %65 = load i64, i64* %64, align 8 + %lshrl22 = lshr i64 %65, 32 + %66 = and i64 2147483647, %lshrl22 + %ztrunc23 = trunc i64 %66 to i32 + store i32 %ztrunc23, i32* %taddr24, align 4 + %67 = bitcast i32* %taddr24 to i8* + %68 = insertvalue %variant undef, i8* %67, 0 + %69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %70 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 1 + store %variant %69, %variant* %70, align 16 + %71 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 + %72 = load i64, i64* %71, align 8 + %lshrl25 = lshr i64 %72, 63 + %73 = and i64 1, %lshrl25 + %ztrunc26 = trunc i64 %73 to i8 + store i8 %ztrunc26, i8* %taddr27, align 1 + %74 = insertvalue %variant undef, i8* %taddr27, 0 + %75 = insertvalue %variant %74, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %76 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 2 store %variant %75, %variant* %76, align 16 - %77 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 - %78 = load i64, i64* %77, align 8 - %lshrl31 = lshr i64 %78, 63 - %79 = and i64 1, %lshrl31 - %ztrunc32 = trunc i64 %79 to i8 - store i8 %ztrunc32, i8* %taddr33, align 1 - %80 = insertvalue %variant undef, i8* %taddr33, 0 - %81 = insertvalue %variant %80, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %82 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 2 - store %variant %81, %variant* %82, align 16 - %83 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg24, i32 0, i32 1 - store i64 3, i64* %83, align 8 - %84 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg24, i32 0, i32 0 - %85 = bitcast [3 x %variant]* %varargslots25 to %variant* - store %variant* %85, %variant** %84, align 8 - %86 = bitcast %"variant[]"* %vararg24 to { i8*, i64 }* - %87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 0 - %lo34 = load i8*, i8** %87, align 8 - %88 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 1 - %hi35 = load i64, i64* %88, align 8 - %89 = call i64 @std_io_printfln(i64* %retparam20, i8* %lo22, i64 %hi23, i8* %lo34, i64 %hi35) - %not_err36 = icmp eq i64 %89, 0 - br i1 %not_err36, label %after_check37, label %voiderr38 + %77 = bitcast [3 x %variant]* %varargslots19 to %variant* + %78 = insertvalue %"variant[]" undef, %variant* %77, 0 + %79 = insertvalue %"variant[]" %78, i64 3, 1 + store %"variant[]" %79, %"variant[]"* %taddr28, align 8 + %80 = bitcast %"variant[]"* %taddr28 to { i8*, i64 }* + %81 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 0 + %lo29 = load i8*, i8** %81, align 8 + %82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 1 + %hi30 = load i64, i64* %82, align 8 + %83 = call i64 @std_io_printfln(i64* %retparam18, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8, i8* %lo29, i64 %hi30) + %not_err31 = icmp eq i64 %83, 0 + br i1 %not_err31, label %after_check32, label %voiderr33 -after_check37: ; preds = %voiderr - br label %voiderr38 +after_check32: ; preds = %voiderr + br label %voiderr33 -voiderr38: ; preds = %after_check37, %voiderr - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0), i64 8 }, %"char[]"* %taddr40, align 8 - %90 = bitcast %"char[]"* %taddr40 to { i8*, i64 }* - %91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 0 - %lo41 = load i8*, i8** %91, align 8 - %92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 1 - %hi42 = load i64, i64* %92, align 8 - %93 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0 - %94 = load i8, i8* %93, align 1 - %zext45 = zext i8 %94 to i32 - %95 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1 - %96 = load i8, i8* %95, align 1 - %zext46 = zext i8 %96 to i32 - %shl47 = shl i32 %zext46, 8 - %97 = or i32 %shl47, %zext45 - %98 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2 - %99 = load i8, i8* %98, align 1 - %zext48 = zext i8 %99 to i32 - %shl49 = shl i32 %zext48, 16 - %100 = or i32 %shl49, %97 - %101 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3 +voiderr33: ; preds = %after_check32, %voiderr + %84 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0 + %85 = load i8, i8* %84, align 1 + %zext36 = zext i8 %85 to i32 + %86 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1 + %87 = load i8, i8* %86, align 1 + %zext37 = zext i8 %87 to i32 + %shl38 = shl i32 %zext37, 8 + %88 = or i32 %shl38, %zext36 + %89 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2 + %90 = load i8, i8* %89, align 1 + %zext39 = zext i8 %90 to i32 + %shl40 = shl i32 %zext39, 16 + %91 = or i32 %shl40, %88 + %92 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3 + %93 = load i8, i8* %92, align 1 + %zext41 = zext i8 %93 to i32 + %shl42 = shl i32 %zext41, 24 + %94 = or i32 %shl42, %91 + store i32 %94, i32* %taddr43, align 4 + %95 = bitcast i32* %taddr43 to i8* + %96 = insertvalue %variant undef, i8* %95, 0 + %97 = insertvalue %variant %96, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %98 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 0 + store %variant %97, %variant* %98, align 16 + %99 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4 + %100 = load i8, i8* %99, align 1 + %zext44 = zext i8 %100 to i32 + %101 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5 %102 = load i8, i8* %101, align 1 - %zext50 = zext i8 %102 to i32 - %shl51 = shl i32 %zext50, 24 - %103 = or i32 %shl51, %100 - store i32 %103, i32* %taddr52, align 4 - %104 = bitcast i32* %taddr52 to i8* - %105 = insertvalue %variant undef, i8* %104, 0 - %106 = insertvalue %variant %105, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %107 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 0 - store %variant %106, %variant* %107, align 16 - %108 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4 - %109 = load i8, i8* %108, align 1 - %zext53 = zext i8 %109 to i32 - %110 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5 - %111 = load i8, i8* %110, align 1 - %zext54 = zext i8 %111 to i32 - %shl55 = shl i32 %zext54, 8 - %112 = or i32 %shl55, %zext53 - %113 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6 - %114 = load i8, i8* %113, align 1 - %zext56 = zext i8 %114 to i32 - %shl57 = shl i32 %zext56, 16 - %115 = or i32 %shl57, %112 - %116 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 - %117 = load i8, i8* %116, align 1 - %zext58 = zext i8 %117 to i32 - %shl59 = shl i32 %zext58, 24 - %118 = or i32 %shl59, %115 - %119 = and i32 2147483647, %118 - store i32 %119, i32* %taddr60, align 4 - %120 = bitcast i32* %taddr60 to i8* - %121 = insertvalue %variant undef, i8* %120, 0 - %122 = insertvalue %variant %121, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %123 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 1 - store %variant %122, %variant* %123, align 16 - %124 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 - %125 = load i8, i8* %124, align 1 - %lshrl61 = lshr i8 %125, 7 - %126 = trunc i8 %lshrl61 to i1 - %127 = zext i1 %126 to i8 - store i8 %127, i8* %taddr62, align 1 - %128 = insertvalue %variant undef, i8* %taddr62, 0 - %129 = insertvalue %variant %128, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %130 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 2 - store %variant %129, %variant* %130, align 16 - %131 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg43, i32 0, i32 1 - store i64 3, i64* %131, align 8 - %132 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg43, i32 0, i32 0 - %133 = bitcast [3 x %variant]* %varargslots44 to %variant* - store %variant* %133, %variant** %132, align 8 - %134 = bitcast %"variant[]"* %vararg43 to { i8*, i64 }* - %135 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %134, i32 0, i32 0 - %lo63 = load i8*, i8** %135, align 8 - %136 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %134, i32 0, i32 1 - %hi64 = load i64, i64* %136, align 8 - %137 = call i64 @std_io_printfln(i64* %retparam39, i8* %lo41, i64 %hi42, i8* %lo63, i64 %hi64) - %not_err65 = icmp eq i64 %137, 0 - br i1 %not_err65, label %after_check66, label %voiderr67 + %zext45 = zext i8 %102 to i32 + %shl46 = shl i32 %zext45, 8 + %103 = or i32 %shl46, %zext44 + %104 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6 + %105 = load i8, i8* %104, align 1 + %zext47 = zext i8 %105 to i32 + %shl48 = shl i32 %zext47, 16 + %106 = or i32 %shl48, %103 + %107 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 + %108 = load i8, i8* %107, align 1 + %zext49 = zext i8 %108 to i32 + %shl50 = shl i32 %zext49, 24 + %109 = or i32 %shl50, %106 + %110 = and i32 2147483647, %109 + store i32 %110, i32* %taddr51, align 4 + %111 = bitcast i32* %taddr51 to i8* + %112 = insertvalue %variant undef, i8* %111, 0 + %113 = insertvalue %variant %112, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %114 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 1 + store %variant %113, %variant* %114, align 16 + %115 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 + %116 = load i8, i8* %115, align 1 + %lshrl52 = lshr i8 %116, 7 + %117 = trunc i8 %lshrl52 to i1 + %118 = zext i1 %117 to i8 + store i8 %118, i8* %taddr53, align 1 + %119 = insertvalue %variant undef, i8* %taddr53, 0 + %120 = insertvalue %variant %119, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %121 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 2 + store %variant %120, %variant* %121, align 16 + %122 = bitcast [3 x %variant]* %varargslots35 to %variant* + %123 = insertvalue %"variant[]" undef, %variant* %122, 0 + %124 = insertvalue %"variant[]" %123, i64 3, 1 + store %"variant[]" %124, %"variant[]"* %taddr54, align 8 + %125 = bitcast %"variant[]"* %taddr54 to { i8*, i64 }* + %126 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %125, i32 0, i32 0 + %lo55 = load i8*, i8** %126, align 8 + %127 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %125, i32 0, i32 1 + %hi56 = load i64, i64* %127, align 8 + %128 = call i64 @std_io_printfln(i64* %retparam34, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0), i64 8, i8* %lo55, i64 %hi56) + %not_err57 = icmp eq i64 %128, 0 + br i1 %not_err57, label %after_check58, label %voiderr59 -after_check66: ; preds = %voiderr38 - br label %voiderr67 +after_check58: ; preds = %voiderr33 + br label %voiderr59 -voiderr67: ; preds = %after_check66, %voiderr38 +voiderr59: ; preds = %after_check58, %voiderr33 %add = add i32 %0, 1 - %zext68 = zext i32 %add to i64 - %138 = and i64 %zext68, 4294967295 - %139 = and i64 %138, -9223372032559808513 - %140 = or i64 %139, 4294967296 + %zext60 = zext i32 %add to i64 + %129 = and i64 %zext60, 4294967295 + %130 = and i64 %129, -9223372032559808513 + %131 = or i64 %130, 4294967296 %gt = icmp sgt i32 %0, 100 - %141 = zext i1 %gt to i8 - %zext69 = zext i8 %141 to i64 - %shl70 = shl i64 %zext69, 63 - %142 = and i64 %shl70, -9223372036854775808 - %143 = and i64 %140, 9223372036854775807 - %144 = or i64 %143, %142 - store i64 %144, i64* %x, align 8 - %145 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 - store i64 -9223371989610135519, i64* %145, align 8 - %146 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0 - store i8 0, i8* %146, align 1 - %147 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1 - store i8 0, i8* %147, align 1 - %148 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2 - store i8 0, i8* %148, align 1 - %149 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3 - store i8 0, i8* %149, align 1 - %150 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4 + %132 = zext i1 %gt to i8 + %zext61 = zext i8 %132 to i64 + %shl62 = shl i64 %zext61, 63 + %133 = and i64 %shl62, -9223372036854775808 + %134 = and i64 %131, 9223372036854775807 + %135 = or i64 %134, %133 + store i64 %135, i64* %x, align 8 + %136 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 + store i64 -9223371989610135519, i64* %136, align 8 + %137 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0 + store i8 0, i8* %137, align 1 + %138 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1 + store i8 0, i8* %138, align 1 + %139 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2 + store i8 0, i8* %139, align 1 + %140 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3 + store i8 0, i8* %140, align 1 + %141 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4 + store i8 0, i8* %141, align 1 + %142 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5 + store i8 0, i8* %142, align 1 + %143 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6 + store i8 0, i8* %143, align 1 + %144 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 + store i8 0, i8* %144, align 1 + %add63 = add i32 %0, 1 + %145 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0 + %ztrunc64 = trunc i32 %add63 to i8 + store i8 %ztrunc64, i8* %145, align 1 + %lshrl65 = lshr i32 %add63, 8 + %146 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1 + %ztrunc66 = trunc i32 %lshrl65 to i8 + store i8 %ztrunc66, i8* %146, align 1 + %lshrl67 = lshr i32 %lshrl65, 8 + %147 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2 + %ztrunc68 = trunc i32 %lshrl67 to i8 + store i8 %ztrunc68, i8* %147, align 1 + %lshrl69 = lshr i32 %lshrl67, 8 + %148 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3 + %ztrunc70 = trunc i32 %lshrl69 to i8 + store i8 %ztrunc70, i8* %148, align 1 + %lshrl71 = lshr i32 %lshrl69, 8 + %149 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4 + store i8 1, i8* %149, align 1 + %150 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5 store i8 0, i8* %150, align 1 - %151 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5 + %151 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6 store i8 0, i8* %151, align 1 - %152 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6 - store i8 0, i8* %152, align 1 - %153 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 - store i8 0, i8* %153, align 1 - %add71 = add i32 %0, 1 - %154 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0 - %ztrunc72 = trunc i32 %add71 to i8 - store i8 %ztrunc72, i8* %154, align 1 - %lshrl73 = lshr i32 %add71, 8 - %155 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1 - %ztrunc74 = trunc i32 %lshrl73 to i8 - store i8 %ztrunc74, i8* %155, align 1 - %lshrl75 = lshr i32 %lshrl73, 8 - %156 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2 - %ztrunc76 = trunc i32 %lshrl75 to i8 - store i8 %ztrunc76, i8* %156, align 1 - %lshrl77 = lshr i32 %lshrl75, 8 - %157 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3 - %ztrunc78 = trunc i32 %lshrl77 to i8 - store i8 %ztrunc78, i8* %157, align 1 - %lshrl79 = lshr i32 %lshrl77, 8 - %158 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4 - store i8 1, i8* %158, align 1 - %159 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5 - store i8 0, i8* %159, align 1 - %160 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6 - store i8 0, i8* %160, align 1 - %161 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 - %162 = load i8, i8* %161, align 1 - %163 = and i8 %162, -128 - store i8 %163, i8* %161, align 1 - %gt80 = icmp sgt i32 %0, 100 - %164 = zext i1 %gt80 to i8 - %shl81 = shl i8 %164, 7 - %165 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 - %166 = load i8, i8* %165, align 1 - %167 = and i8 %166, 127 - %168 = or i8 %167, %shl81 - store i8 %168, i8* %165, align 1 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i32 0, i32 0), i64 8 }, %"char[]"* %taddr83, align 8 - %169 = bitcast %"char[]"* %taddr83 to { i8*, i64 }* - %170 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 0 - %lo84 = load i8*, i8** %170, align 8 - %171 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 1 - %hi85 = load i64, i64* %171, align 8 + %152 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 + %153 = load i8, i8* %152, align 1 + %154 = and i8 %153, -128 + store i8 %154, i8* %152, align 1 + %gt72 = icmp sgt i32 %0, 100 + %155 = zext i1 %gt72 to i8 + %shl73 = shl i8 %155, 7 + %156 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 + %157 = load i8, i8* %156, align 1 + %158 = and i8 %157, 127 + %159 = or i8 %158, %shl73 + store i8 %159, i8* %156, align 1 + %160 = load i64, i64* %x, align 8 + %161 = and i64 4294967295, %160 + %ztrunc76 = trunc i64 %161 to i32 + store i32 %ztrunc76, i32* %taddr77, align 4 + %162 = bitcast i32* %taddr77 to i8* + %163 = insertvalue %variant undef, i8* %162, 0 + %164 = insertvalue %variant %163, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %165 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 0 + store %variant %164, %variant* %165, align 16 + %166 = load i64, i64* %x, align 8 + %lshrl78 = lshr i64 %166, 32 + %167 = and i64 2147483647, %lshrl78 + %ztrunc79 = trunc i64 %167 to i32 + store i32 %ztrunc79, i32* %taddr80, align 4 + %168 = bitcast i32* %taddr80 to i8* + %169 = insertvalue %variant undef, i8* %168, 0 + %170 = insertvalue %variant %169, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %171 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 1 + store %variant %170, %variant* %171, align 16 %172 = load i64, i64* %x, align 8 - %173 = and i64 4294967295, %172 - %ztrunc88 = trunc i64 %173 to i32 - store i32 %ztrunc88, i32* %taddr89, align 4 - %174 = bitcast i32* %taddr89 to i8* - %175 = insertvalue %variant undef, i8* %174, 0 - %176 = insertvalue %variant %175, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %177 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 0 - store %variant %176, %variant* %177, align 16 - %178 = load i64, i64* %x, align 8 - %lshrl90 = lshr i64 %178, 32 - %179 = and i64 2147483647, %lshrl90 - %ztrunc91 = trunc i64 %179 to i32 - store i32 %ztrunc91, i32* %taddr92, align 4 - %180 = bitcast i32* %taddr92 to i8* - %181 = insertvalue %variant undef, i8* %180, 0 - %182 = insertvalue %variant %181, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %183 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 1 - store %variant %182, %variant* %183, align 16 - %184 = load i64, i64* %x, align 8 - %lshrl93 = lshr i64 %184, 63 - %185 = and i64 1, %lshrl93 - %ztrunc94 = trunc i64 %185 to i8 - store i8 %ztrunc94, i8* %taddr95, align 1 - %186 = insertvalue %variant undef, i8* %taddr95, 0 - %187 = insertvalue %variant %186, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %188 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 2 - store %variant %187, %variant* %188, align 16 - %189 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 1 - store i64 3, i64* %189, align 8 - %190 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 0 - %191 = bitcast [3 x %variant]* %varargslots87 to %variant* - store %variant* %191, %variant** %190, align 8 - %192 = bitcast %"variant[]"* %vararg86 to { i8*, i64 }* - %193 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %192, i32 0, i32 0 - %lo96 = load i8*, i8** %193, align 8 - %194 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %192, i32 0, i32 1 - %hi97 = load i64, i64* %194, align 8 - %195 = call i64 @std_io_printfln(i64* %retparam82, i8* %lo84, i64 %hi85, i8* %lo96, i64 %hi97) - %not_err98 = icmp eq i64 %195, 0 - br i1 %not_err98, label %after_check99, label %voiderr100 + %lshrl81 = lshr i64 %172, 63 + %173 = and i64 1, %lshrl81 + %ztrunc82 = trunc i64 %173 to i8 + store i8 %ztrunc82, i8* %taddr83, align 1 + %174 = insertvalue %variant undef, i8* %taddr83, 0 + %175 = insertvalue %variant %174, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %176 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 2 + store %variant %175, %variant* %176, align 16 + %177 = bitcast [3 x %variant]* %varargslots75 to %variant* + %178 = insertvalue %"variant[]" undef, %variant* %177, 0 + %179 = insertvalue %"variant[]" %178, i64 3, 1 + store %"variant[]" %179, %"variant[]"* %taddr84, align 8 + %180 = bitcast %"variant[]"* %taddr84 to { i8*, i64 }* + %181 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %180, i32 0, i32 0 + %lo85 = load i8*, i8** %181, align 8 + %182 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %180, i32 0, i32 1 + %hi86 = load i64, i64* %182, align 8 + %183 = call i64 @std_io_printfln(i64* %retparam74, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i32 0, i32 0), i64 8, i8* %lo85, i64 %hi86) + %not_err87 = icmp eq i64 %183, 0 + br i1 %not_err87, label %after_check88, label %voiderr89 -after_check99: ; preds = %voiderr67 - br label %voiderr100 +after_check88: ; preds = %voiderr59 + br label %voiderr89 -voiderr100: ; preds = %after_check99, %voiderr67 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i32 0, i32 0), i64 8 }, %"char[]"* %taddr102, align 8 - %196 = bitcast %"char[]"* %taddr102 to { i8*, i64 }* - %197 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %196, i32 0, i32 0 - %lo103 = load i8*, i8** %197, align 8 - %198 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %196, i32 0, i32 1 - %hi104 = load i64, i64* %198, align 8 - %199 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 - %200 = load i64, i64* %199, align 8 - %201 = and i64 4294967295, %200 - %ztrunc107 = trunc i64 %201 to i32 - store i32 %ztrunc107, i32* %taddr108, align 4 - %202 = bitcast i32* %taddr108 to i8* - %203 = insertvalue %variant undef, i8* %202, 0 - %204 = insertvalue %variant %203, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %205 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 0 - store %variant %204, %variant* %205, align 16 - %206 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 - %207 = load i64, i64* %206, align 8 - %lshrl109 = lshr i64 %207, 32 - %208 = and i64 2147483647, %lshrl109 - %ztrunc110 = trunc i64 %208 to i32 - store i32 %ztrunc110, i32* %taddr111, align 4 - %209 = bitcast i32* %taddr111 to i8* - %210 = insertvalue %variant undef, i8* %209, 0 - %211 = insertvalue %variant %210, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %212 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 1 - store %variant %211, %variant* %212, align 16 - %213 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 - %214 = load i64, i64* %213, align 8 - %lshrl112 = lshr i64 %214, 63 - %215 = and i64 1, %lshrl112 - %ztrunc113 = trunc i64 %215 to i8 - store i8 %ztrunc113, i8* %taddr114, align 1 - %216 = insertvalue %variant undef, i8* %taddr114, 0 - %217 = insertvalue %variant %216, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %218 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 2 - store %variant %217, %variant* %218, align 16 - %219 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg105, i32 0, i32 1 - store i64 3, i64* %219, align 8 - %220 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg105, i32 0, i32 0 - %221 = bitcast [3 x %variant]* %varargslots106 to %variant* - store %variant* %221, %variant** %220, align 8 - %222 = bitcast %"variant[]"* %vararg105 to { i8*, i64 }* - %223 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %222, i32 0, i32 0 - %lo115 = load i8*, i8** %223, align 8 - %224 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %222, i32 0, i32 1 - %hi116 = load i64, i64* %224, align 8 - %225 = call i64 @std_io_printfln(i64* %retparam101, i8* %lo103, i64 %hi104, i8* %lo115, i64 %hi116) - %not_err117 = icmp eq i64 %225, 0 - br i1 %not_err117, label %after_check118, label %voiderr119 +voiderr89: ; preds = %after_check88, %voiderr59 + %184 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 + %185 = load i64, i64* %184, align 8 + %186 = and i64 4294967295, %185 + %ztrunc92 = trunc i64 %186 to i32 + store i32 %ztrunc92, i32* %taddr93, align 4 + %187 = bitcast i32* %taddr93 to i8* + %188 = insertvalue %variant undef, i8* %187, 0 + %189 = insertvalue %variant %188, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %190 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 0 + store %variant %189, %variant* %190, align 16 + %191 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 + %192 = load i64, i64* %191, align 8 + %lshrl94 = lshr i64 %192, 32 + %193 = and i64 2147483647, %lshrl94 + %ztrunc95 = trunc i64 %193 to i32 + store i32 %ztrunc95, i32* %taddr96, align 4 + %194 = bitcast i32* %taddr96 to i8* + %195 = insertvalue %variant undef, i8* %194, 0 + %196 = insertvalue %variant %195, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %197 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 1 + store %variant %196, %variant* %197, align 16 + %198 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1 + %199 = load i64, i64* %198, align 8 + %lshrl97 = lshr i64 %199, 63 + %200 = and i64 1, %lshrl97 + %ztrunc98 = trunc i64 %200 to i8 + store i8 %ztrunc98, i8* %taddr99, align 1 + %201 = insertvalue %variant undef, i8* %taddr99, 0 + %202 = insertvalue %variant %201, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %203 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 2 + store %variant %202, %variant* %203, align 16 + %204 = bitcast [3 x %variant]* %varargslots91 to %variant* + %205 = insertvalue %"variant[]" undef, %variant* %204, 0 + %206 = insertvalue %"variant[]" %205, i64 3, 1 + store %"variant[]" %206, %"variant[]"* %taddr100, align 8 + %207 = bitcast %"variant[]"* %taddr100 to { i8*, i64 }* + %208 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %207, i32 0, i32 0 + %lo101 = load i8*, i8** %208, align 8 + %209 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %207, i32 0, i32 1 + %hi102 = load i64, i64* %209, align 8 + %210 = call i64 @std_io_printfln(i64* %retparam90, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i32 0, i32 0), i64 8, i8* %lo101, i64 %hi102) + %not_err103 = icmp eq i64 %210, 0 + br i1 %not_err103, label %after_check104, label %voiderr105 -after_check118: ; preds = %voiderr100 - br label %voiderr119 +after_check104: ; preds = %voiderr89 + br label %voiderr105 -voiderr119: ; preds = %after_check118, %voiderr100 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i32 0, i32 0), i64 8 }, %"char[]"* %taddr121, align 8 - %226 = bitcast %"char[]"* %taddr121 to { i8*, i64 }* - %227 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %226, i32 0, i32 0 - %lo122 = load i8*, i8** %227, align 8 - %228 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %226, i32 0, i32 1 - %hi123 = load i64, i64* %228, align 8 - %229 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0 - %230 = load i8, i8* %229, align 1 - %zext126 = zext i8 %230 to i32 - %231 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1 +voiderr105: ; preds = %after_check104, %voiderr89 + %211 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0 + %212 = load i8, i8* %211, align 1 + %zext108 = zext i8 %212 to i32 + %213 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1 + %214 = load i8, i8* %213, align 1 + %zext109 = zext i8 %214 to i32 + %shl110 = shl i32 %zext109, 8 + %215 = or i32 %shl110, %zext108 + %216 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2 + %217 = load i8, i8* %216, align 1 + %zext111 = zext i8 %217 to i32 + %shl112 = shl i32 %zext111, 16 + %218 = or i32 %shl112, %215 + %219 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3 + %220 = load i8, i8* %219, align 1 + %zext113 = zext i8 %220 to i32 + %shl114 = shl i32 %zext113, 24 + %221 = or i32 %shl114, %218 + store i32 %221, i32* %taddr115, align 4 + %222 = bitcast i32* %taddr115 to i8* + %223 = insertvalue %variant undef, i8* %222, 0 + %224 = insertvalue %variant %223, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %225 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 0 + store %variant %224, %variant* %225, align 16 + %226 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4 + %227 = load i8, i8* %226, align 1 + %zext116 = zext i8 %227 to i32 + %228 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5 + %229 = load i8, i8* %228, align 1 + %zext117 = zext i8 %229 to i32 + %shl118 = shl i32 %zext117, 8 + %230 = or i32 %shl118, %zext116 + %231 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6 %232 = load i8, i8* %231, align 1 - %zext127 = zext i8 %232 to i32 - %shl128 = shl i32 %zext127, 8 - %233 = or i32 %shl128, %zext126 - %234 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2 + %zext119 = zext i8 %232 to i32 + %shl120 = shl i32 %zext119, 16 + %233 = or i32 %shl120, %230 + %234 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 %235 = load i8, i8* %234, align 1 - %zext129 = zext i8 %235 to i32 - %shl130 = shl i32 %zext129, 16 - %236 = or i32 %shl130, %233 - %237 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3 - %238 = load i8, i8* %237, align 1 - %zext131 = zext i8 %238 to i32 - %shl132 = shl i32 %zext131, 24 - %239 = or i32 %shl132, %236 - store i32 %239, i32* %taddr133, align 4 - %240 = bitcast i32* %taddr133 to i8* - %241 = insertvalue %variant undef, i8* %240, 0 - %242 = insertvalue %variant %241, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %243 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 0 - store %variant %242, %variant* %243, align 16 - %244 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4 - %245 = load i8, i8* %244, align 1 - %zext134 = zext i8 %245 to i32 - %246 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5 - %247 = load i8, i8* %246, align 1 - %zext135 = zext i8 %247 to i32 - %shl136 = shl i32 %zext135, 8 - %248 = or i32 %shl136, %zext134 - %249 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6 - %250 = load i8, i8* %249, align 1 - %zext137 = zext i8 %250 to i32 - %shl138 = shl i32 %zext137, 16 - %251 = or i32 %shl138, %248 - %252 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 - %253 = load i8, i8* %252, align 1 - %zext139 = zext i8 %253 to i32 - %shl140 = shl i32 %zext139, 24 - %254 = or i32 %shl140, %251 - %255 = and i32 2147483647, %254 - store i32 %255, i32* %taddr141, align 4 - %256 = bitcast i32* %taddr141 to i8* - %257 = insertvalue %variant undef, i8* %256, 0 - %258 = insertvalue %variant %257, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %259 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 1 - store %variant %258, %variant* %259, align 16 - %260 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 - %261 = load i8, i8* %260, align 1 - %lshrl142 = lshr i8 %261, 7 - %262 = trunc i8 %lshrl142 to i1 - %263 = zext i1 %262 to i8 - store i8 %263, i8* %taddr143, align 1 - %264 = insertvalue %variant undef, i8* %taddr143, 0 - %265 = insertvalue %variant %264, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %266 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 2 - store %variant %265, %variant* %266, align 16 - %267 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg124, i32 0, i32 1 - store i64 3, i64* %267, align 8 - %268 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg124, i32 0, i32 0 - %269 = bitcast [3 x %variant]* %varargslots125 to %variant* - store %variant* %269, %variant** %268, align 8 - %270 = bitcast %"variant[]"* %vararg124 to { i8*, i64 }* - %271 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 0 - %lo144 = load i8*, i8** %271, align 8 - %272 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 1 - %hi145 = load i64, i64* %272, align 8 - %273 = call i64 @std_io_printfln(i64* %retparam120, i8* %lo122, i64 %hi123, i8* %lo144, i64 %hi145) - %not_err146 = icmp eq i64 %273, 0 - br i1 %not_err146, label %after_check147, label %voiderr148 + %zext121 = zext i8 %235 to i32 + %shl122 = shl i32 %zext121, 24 + %236 = or i32 %shl122, %233 + %237 = and i32 2147483647, %236 + store i32 %237, i32* %taddr123, align 4 + %238 = bitcast i32* %taddr123 to i8* + %239 = insertvalue %variant undef, i8* %238, 0 + %240 = insertvalue %variant %239, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %241 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 1 + store %variant %240, %variant* %241, align 16 + %242 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7 + %243 = load i8, i8* %242, align 1 + %lshrl124 = lshr i8 %243, 7 + %244 = trunc i8 %lshrl124 to i1 + %245 = zext i1 %244 to i8 + store i8 %245, i8* %taddr125, align 1 + %246 = insertvalue %variant undef, i8* %taddr125, 0 + %247 = insertvalue %variant %246, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %248 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 2 + store %variant %247, %variant* %248, align 16 + %249 = bitcast [3 x %variant]* %varargslots107 to %variant* + %250 = insertvalue %"variant[]" undef, %variant* %249, 0 + %251 = insertvalue %"variant[]" %250, i64 3, 1 + store %"variant[]" %251, %"variant[]"* %taddr126, align 8 + %252 = bitcast %"variant[]"* %taddr126 to { i8*, i64 }* + %253 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %252, i32 0, i32 0 + %lo127 = load i8*, i8** %253, align 8 + %254 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %252, i32 0, i32 1 + %hi128 = load i64, i64* %254, align 8 + %255 = call i64 @std_io_printfln(i64* %retparam106, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i32 0, i32 0), i64 8, i8* %lo127, i64 %hi128) + %not_err129 = icmp eq i64 %255, 0 + br i1 %not_err129, label %after_check130, label %voiderr131 -after_check147: ; preds = %voiderr119 - br label %voiderr148 +after_check130: ; preds = %voiderr105 + br label %voiderr131 -voiderr148: ; preds = %after_check147, %voiderr119 +voiderr131: ; preds = %after_check130, %voiderr105 ret void } diff --git a/test/test_suite/builtins/reverse_builtin.c3t b/test/test_suite/builtins/reverse_builtin.c3t index 9072e6bea..a3b556f78 100644 --- a/test/test_suite/builtins/reverse_builtin.c3t +++ b/test/test_suite/builtins/reverse_builtin.c3t @@ -11,4 +11,4 @@ fn void main() /* #expect: test.ll -%reverse = shufflevector <4 x i32> %3, <4 x i32> poison, <4 x i32> \ No newline at end of file + %reverse = shufflevector <4 x i32> %0, <4 x i32> poison, <4 x i32> \ No newline at end of file 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 f960bdcdc..a1e8f7bd0 100644 --- a/test/test_suite/compile_time/compile_time_access_subscript.c3t +++ b/test/test_suite/compile_time/compile_time_access_subscript.c3t @@ -56,10 +56,9 @@ fn void main() %z9 = alloca [2 x i32], align 4 %z10 = alloca %"int[]", align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 %literal = alloca %Abc, align 4 + %taddr = alloca %"variant[]", align 8 store i32 0, i32* %z, align 4 %0 = getelementptr inbounds %Abc, %Abc* %z1, i32 0, i32 0 store float 0.000000e+00, float* %0, align 4 @@ -89,37 +88,30 @@ fn void main() store i32 0, i32* %9, align 4 %10 = bitcast %"int[]"* %z10 to i8* call void @llvm.memset.p0i8.i64(i8* align 8 %10, i8 0, i64 16, i1 false) - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2 }, %"char[]"* %taddr, align 8 - %11 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 - %lo = load i8*, i8** %12, align 8 - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 - %hi = load i64, i64* %13, align 8 - %14 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 0 + %11 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 0 + store float 0.000000e+00, float* %11, align 4 + %12 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 1 + store float 0.000000e+00, float* %12, align 4 + %13 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 2 + store float 0.000000e+00, float* %13, align 4 + %14 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 3 store float 0.000000e+00, float* %14, align 4 - %15 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 1 - store float 0.000000e+00, float* %15, align 4 - %16 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 2 - store float 0.000000e+00, float* %16, align 4 - %17 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 3 - store float 0.000000e+00, float* %17, align 4 - %18 = bitcast %Abc* %literal to i8* - %19 = insertvalue %variant undef, i8* %18, 0 - %20 = insertvalue %variant %19, i64 ptrtoint (%.introspect* @"ct$test_Abc" to i64), 1 - %21 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %20, %variant* %21, align 16 - %22 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %22, align 8 - %23 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %24 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %24, %variant** %23, align 8 - %25 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 0 - %lo11 = load i8*, i8** %26, align 8 - %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 1 - %hi12 = load i64, i64* %27, align 8 - %28 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo11, i64 %hi12) - %not_err = icmp eq i64 %28, 0 + %15 = bitcast %Abc* %literal to i8* + %16 = insertvalue %variant undef, i8* %15, 0 + %17 = insertvalue %variant %16, i64 ptrtoint (%.introspect* @"ct$test_Abc" to i64), 1 + %18 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %17, %variant* %18, align 16 + %19 = bitcast [1 x %variant]* %varargslots to %variant* + %20 = insertvalue %"variant[]" undef, %variant* %19, 0 + %21 = insertvalue %"variant[]" %20, i64 1, 1 + store %"variant[]" %21, %"variant[]"* %taddr, align 8 + %22 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0 + %lo = load i8*, i8** %23, align 8 + %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1 + %hi = load i64, i64* %24, align 8 + %25 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %25, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry 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 ab1b459a1..52de8ef8e 100644 --- a/test/test_suite/compile_time/ct_builtin_time_date.c3t +++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t @@ -29,44 +29,34 @@ fn void main() define void @test_test(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 - %taddr10 = alloca i64, align 8 - %retparam16 = alloca i64, align 8 - %taddr17 = alloca %"char[]", align 8 - %vararg20 = alloca %"variant[]", align 8 - %varargslots21 = alloca [1 x %variant], align 16 - %taddr22 = alloca i64, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2 }, %"char[]"* %taddr, align 8 - %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 - %lo = load i8*, i8** %2, align 8 - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 - %hi = load i64, i64* %3, align 8 - store i32 %0, i32* %taddr1, align 4 - %4 = bitcast i32* %taddr1 to i8* - %5 = insertvalue %variant undef, i8* %4, 0 - %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %6, %variant* %7, align 16 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %8, align 8 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %10 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %10, %variant** %9, align 8 - %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 - %lo2 = load i8*, i8** %12, align 8 - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 - %hi3 = load i64, i64* %13, align 8 - %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %14, 0 + %taddr = alloca i32, align 4 + %taddr1 = alloca %"variant[]", align 8 + %retparam2 = alloca i64, align 8 + %varargslots3 = alloca [1 x %variant], align 16 + %taddr4 = alloca i64, align 8 + %taddr5 = alloca %"variant[]", align 8 + %retparam11 = alloca i64, align 8 + %varargslots12 = alloca [1 x %variant], align 16 + %taddr13 = alloca i64, align 8 + %taddr14 = alloca %"variant[]", align 8 + store i32 %0, i32* %taddr, align 4 + %1 = bitcast i32* %taddr to i8* + %2 = insertvalue %variant undef, i8* %1, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %3, %variant* %4, align 16 + %5 = bitcast [1 x %variant]* %varargslots to %variant* + %6 = insertvalue %"variant[]" undef, %variant* %5, 0 + %7 = insertvalue %"variant[]" %6, i64 1, 1 + store %"variant[]" %7, %"variant[]"* %taddr1, align 8 + %8 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 + %lo = load i8*, i8** %9, align 8 + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 + %hi = load i64, i64* %10, align 8 + %11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -82,69 +72,55 @@ if.then: ; preds = %voiderr br label %if.exit if.exit: ; preds = %if.then, %voiderr - %15 = call i32 @std_io_println(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0)) #1 - %16 = call i32 @std_io_println(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0)) #1 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2 }, %"char[]"* %taddr5, align 8 - %17 = bitcast %"char[]"* %taddr5 to { i8*, i64 }* - %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 - %lo6 = load i8*, i8** %18, align 8 - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 - %hi7 = load i64, i64* %19, align 8 - store i64 14, i64* %taddr10, align 8 - %20 = bitcast i64* %taddr10 to i8* - %21 = insertvalue %variant undef, i8* %20, 0 - %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 - %23 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots9, i64 0, i64 0 - store %variant %22, %variant* %23, align 16 - %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 1 - store i64 1, i64* %24, align 8 - %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 0 - %26 = bitcast [1 x %variant]* %varargslots9 to %variant* - store %variant* %26, %variant** %25, align 8 - %27 = bitcast %"variant[]"* %vararg8 to { i8*, i64 }* - %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 - %lo11 = load i8*, i8** %28, align 8 - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 - %hi12 = load i64, i64* %29, align 8 - %30 = call i64 @std_io_printfln(i64* %retparam4, i8* %lo6, i64 %hi7, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %30, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %12 = call i32 @std_io_println(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0)) #1 + %13 = call i32 @std_io_println(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0)) #1 + store i64 14, i64* %taddr4, align 8 + %14 = bitcast i64* %taddr4 to i8* + %15 = insertvalue %variant undef, i8* %14, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 + %17 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots3, i64 0, i64 0 + store %variant %16, %variant* %17, align 16 + %18 = bitcast [1 x %variant]* %varargslots3 to %variant* + %19 = insertvalue %"variant[]" undef, %variant* %18, 0 + %20 = insertvalue %"variant[]" %19, i64 1, 1 + store %"variant[]" %20, %"variant[]"* %taddr5, align 8 + %21 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }* + %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 0 + %lo6 = load i8*, i8** %22, align 8 + %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 1 + %hi7 = load i64, i64* %23, align 8 + %24 = call i64 @std_io_printfln(i64* %retparam2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %24, 0 + br i1 %not_err8, label %after_check9, label %voiderr10 -after_check14: ; preds = %if.exit - br label %voiderr15 +after_check9: ; preds = %if.exit + br label %voiderr10 -voiderr15: ; preds = %after_check14, %if.exit - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2 }, %"char[]"* %taddr17, align 8 - %31 = bitcast %"char[]"* %taddr17 to { i8*, i64 }* - %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 - %lo18 = load i8*, i8** %32, align 8 - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 - %hi19 = load i64, i64* %33, align 8 - store i64 6, i64* %taddr22, align 8 - %34 = bitcast i64* %taddr22 to i8* - %35 = insertvalue %variant undef, i8* %34, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 - %37 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots21, i64 0, i64 0 - store %variant %36, %variant* %37, align 16 - %38 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 1 - store i64 1, i64* %38, align 8 - %39 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 0 - %40 = bitcast [1 x %variant]* %varargslots21 to %variant* - store %variant* %40, %variant** %39, align 8 - %41 = bitcast %"variant[]"* %vararg20 to { i8*, i64 }* - %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 - %lo23 = load i8*, i8** %42, align 8 - %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 - %hi24 = load i64, i64* %43, align 8 - %44 = call i64 @std_io_printfln(i64* %retparam16, i8* %lo18, i64 %hi19, i8* %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %44, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 +voiderr10: ; preds = %after_check9, %if.exit + store i64 6, i64* %taddr13, align 8 + %25 = bitcast i64* %taddr13 to i8* + %26 = insertvalue %variant undef, i8* %25, 0 + %27 = insertvalue %variant %26, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 + %28 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots12, i64 0, i64 0 + store %variant %27, %variant* %28, align 16 + %29 = bitcast [1 x %variant]* %varargslots12 to %variant* + %30 = insertvalue %"variant[]" undef, %variant* %29, 0 + %31 = insertvalue %"variant[]" %30, i64 1, 1 + store %"variant[]" %31, %"variant[]"* %taddr14, align 8 + %32 = bitcast %"variant[]"* %taddr14 to { i8*, i64 }* + %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0 + %lo15 = load i8*, i8** %33, align 8 + %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1 + %hi16 = load i64, i64* %34, align 8 + %35 = call i64 @std_io_printfln(i64* %retparam11, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2, i8* %lo15, i64 %hi16) + %not_err17 = icmp eq i64 %35, 0 + br i1 %not_err17, label %after_check18, label %voiderr19 -after_check26: ; preds = %voiderr15 - br label %voiderr27 +after_check18: ; preds = %voiderr10 + br label %voiderr19 -voiderr27: ; preds = %after_check26, %voiderr15 - %45 = call i32 @std_io_println(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.5, i32 0, i32 0)) #1 - %46 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0)) #1 +voiderr19: ; preds = %after_check18, %voiderr10 + %36 = call i32 @std_io_println(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.5, i32 0, i32 0)) #1 + %37 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0)) #1 ret void -} +} \ No newline at end of file diff --git a/test/test_suite/compile_time/ct_funcptr.c3t b/test/test_suite/compile_time/ct_funcptr.c3t index d20eb10b4..b0e48ac67 100644 --- a/test/test_suite/compile_time/ct_funcptr.c3t +++ b/test/test_suite/compile_time/ct_funcptr.c3t @@ -20,35 +20,27 @@ define void @test_test(i32 %0) #0 { entry: %ptr = alloca void (i32)*, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 + %taddr = alloca i32, align 4 + %taddr1 = alloca %"variant[]", align 8 store void (i32)* @test_test, void (i32)** %ptr, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2 }, %"char[]"* %taddr, align 8 - %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 - %lo = load i8*, i8** %2, align 8 - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 - %hi = load i64, i64* %3, align 8 - store i32 %0, i32* %taddr1, align 4 - %4 = bitcast i32* %taddr1 to i8* - %5 = insertvalue %variant undef, i8* %4, 0 - %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %6, %variant* %7, align 16 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %8, align 8 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %10 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %10, %variant** %9, align 8 - %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 - %lo2 = load i8*, i8** %12, align 8 - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 - %hi3 = load i64, i64* %13, align 8 - %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %14, 0 + store i32 %0, i32* %taddr, align 4 + %1 = bitcast i32* %taddr to i8* + %2 = insertvalue %variant undef, i8* %1, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %3, %variant* %4, align 16 + %5 = bitcast [1 x %variant]* %varargslots to %variant* + %6 = insertvalue %"variant[]" undef, %variant* %5, 0 + %7 = insertvalue %"variant[]" %6, i64 1, 1 + store %"variant[]" %7, %"variant[]"* %taddr1, align 8 + %8 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 + %lo = load i8*, i8** %9, align 8 + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 + %hi = load i64, i64* %10, align 8 + %11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -59,9 +51,9 @@ voiderr: ; preds = %after_check, %entry br i1 %gt, label %if.then, label %if.exit if.then: ; preds = %voiderr - %15 = load void (i32)*, void (i32)** %ptr, align 8 + %12 = load void (i32)*, void (i32)** %ptr, align 8 %sub = sub i32 %0, 1 - call void %15(i32 %sub) + call void %12(i32 %sub) br label %if.exit if.exit: ; preds = %if.then, %voiderr diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t index 6e5277261..443e812bb 100644 --- a/test/test_suite/compile_time/ct_memberof.c3t +++ b/test/test_suite/compile_time/ct_memberof.c3t @@ -122,80 +122,67 @@ entry: define void @test_test(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca [3 x i8]*, align 8 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [2 x %variant], align 16 - %taddr10 = alloca [1 x i8]*, align 8 - %taddr11 = alloca [3 x i8]*, align 8 - %retparam17 = alloca i64, align 8 - %taddr18 = alloca %"char[]", align 8 - %vararg21 = alloca %"variant[]", align 8 - %varargslots22 = alloca [2 x %variant], align 16 - %taddr23 = alloca [4 x i8]*, align 8 - %taddr24 = alloca [4 x i8]*, align 8 - %retparam30 = alloca i64, align 8 - %taddr31 = alloca %"char[]", align 8 - %vararg34 = alloca %"variant[]", align 8 - %varargslots35 = alloca [2 x %variant], align 16 - %taddr36 = alloca [0 x i8]*, align 8 - %taddr37 = alloca [5 x i8]*, align 8 - %retparam43 = alloca i64, align 8 - %taddr44 = alloca %"char[]", align 8 - %vararg47 = alloca %"variant[]", align 8 - %varargslots48 = alloca [2 x %variant], align 16 - %taddr49 = alloca [1 x i8]*, align 8 - %taddr50 = alloca [6 x i8]*, align 8 - %retparam56 = alloca i64, align 8 - %taddr57 = alloca %"char[]", align 8 - %vararg60 = alloca %"variant[]", align 8 - %varargslots61 = alloca [1 x %variant], align 16 - %taddr62 = alloca [3 x i8]*, align 8 - %retparam68 = alloca i64, align 8 - %taddr69 = alloca %"char[]", align 8 - %vararg72 = alloca %"variant[]", align 8 - %varargslots73 = alloca [2 x %variant], align 16 - %taddr74 = alloca [1 x i8]*, align 8 - %taddr75 = alloca [4 x i8]*, align 8 + %taddr = alloca [3 x i8]*, align 8 + %taddr1 = alloca %"variant[]", align 8 + %retparam2 = alloca i64, align 8 + %varargslots3 = alloca [2 x %variant], align 16 + %taddr4 = alloca [1 x i8]*, align 8 + %taddr5 = alloca [3 x i8]*, align 8 + %taddr6 = alloca %"variant[]", align 8 + %retparam12 = alloca i64, align 8 + %varargslots13 = alloca [2 x %variant], align 16 + %taddr14 = alloca [4 x i8]*, align 8 + %taddr15 = alloca [4 x i8]*, align 8 + %taddr16 = alloca %"variant[]", align 8 + %retparam22 = alloca i64, align 8 + %varargslots23 = alloca [2 x %variant], align 16 + %taddr24 = alloca [0 x i8]*, align 8 + %taddr25 = alloca [5 x i8]*, align 8 + %taddr26 = alloca %"variant[]", align 8 + %retparam32 = alloca i64, align 8 + %varargslots33 = alloca [2 x %variant], align 16 + %taddr34 = alloca [1 x i8]*, align 8 + %taddr35 = alloca [6 x i8]*, align 8 + %taddr36 = alloca %"variant[]", align 8 + %retparam42 = alloca i64, align 8 + %varargslots43 = alloca [1 x %variant], align 16 + %taddr44 = alloca [3 x i8]*, align 8 + %taddr45 = alloca %"variant[]", align 8 + %retparam51 = alloca i64, align 8 + %varargslots52 = alloca [2 x %variant], align 16 + %taddr53 = alloca [1 x i8]*, align 8 + %taddr54 = alloca [4 x i8]*, align 8 + %taddr55 = alloca %"variant[]", align 8 + %retparam61 = alloca i64, align 8 + %varargslots62 = alloca [2 x %variant], align 16 + %taddr63 = alloca [1 x i8]*, align 8 + %taddr64 = alloca [5 x i8]*, align 8 + %taddr65 = alloca %"variant[]", align 8 + %retparam71 = alloca i64, align 8 + %varargslots72 = alloca [2 x %variant], align 16 + %taddr73 = alloca [0 x i8]*, align 8 + %taddr74 = alloca [5 x i8]*, align 8 + %taddr75 = alloca %"variant[]", align 8 %retparam81 = alloca i64, align 8 - %taddr82 = alloca %"char[]", align 8 - %vararg85 = alloca %"variant[]", align 8 - %varargslots86 = alloca [2 x %variant], align 16 - %taddr87 = alloca [1 x i8]*, align 8 - %taddr88 = alloca [5 x i8]*, align 8 - %retparam94 = alloca i64, align 8 - %taddr95 = alloca %"char[]", align 8 - %vararg98 = alloca %"variant[]", align 8 - %varargslots99 = alloca [2 x %variant], align 16 - %taddr100 = alloca [0 x i8]*, align 8 - %taddr101 = alloca [5 x i8]*, align 8 - %retparam107 = alloca i64, align 8 - %taddr108 = alloca %"char[]", align 8 - %vararg111 = alloca %"variant[]", align 8 - %varargslots112 = alloca [2 x %variant], align 16 - %taddr113 = alloca [3 x i8]*, align 8 - %taddr114 = alloca [3 x i8]*, align 8 - %retparam120 = alloca i64, align 8 - %taddr121 = alloca %"char[]", align 8 - %vararg124 = alloca %"variant[]", align 8 - %varargslots125 = alloca [1 x %variant], align 16 - %taddr126 = alloca [4 x i8]*, align 8 - %retparam132 = alloca i64, align 8 - %taddr133 = alloca %"char[]", align 8 - %vararg136 = alloca %"variant[]", align 8 - %varargslots137 = alloca [2 x %variant], align 16 - %taddr138 = alloca [1 x i8]*, align 8 - %taddr139 = alloca [3 x i8]*, align 8 - %retparam145 = alloca i64, align 8 - %taddr146 = alloca %"char[]", align 8 - %vararg149 = alloca %"variant[]", align 8 - %varargslots150 = alloca [2 x %variant], align 16 - %taddr151 = alloca [1 x i8]*, align 8 - %taddr152 = alloca [5 x i8]*, align 8 + %varargslots82 = alloca [2 x %variant], align 16 + %taddr83 = alloca [3 x i8]*, align 8 + %taddr84 = alloca [3 x i8]*, align 8 + %taddr85 = alloca %"variant[]", align 8 + %retparam91 = alloca i64, align 8 + %varargslots92 = alloca [1 x %variant], align 16 + %taddr93 = alloca [4 x i8]*, align 8 + %taddr94 = alloca %"variant[]", align 8 + %retparam100 = alloca i64, align 8 + %varargslots101 = alloca [2 x %variant], align 16 + %taddr102 = alloca [1 x i8]*, align 8 + %taddr103 = alloca [3 x i8]*, align 8 + %taddr104 = alloca %"variant[]", align 8 + %retparam110 = alloca i64, align 8 + %varargslots111 = alloca [2 x %variant], align 16 + %taddr112 = alloca [1 x i8]*, align 8 + %taddr113 = alloca [5 x i8]*, align 8 + %taddr114 = alloca %"variant[]", align 8 %1 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0)) #1 %2 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i32 0, i32 0)) #1 %3 = call i32 @std_io_println(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.11, i32 0, i32 0)) #1 @@ -203,456 +190,365 @@ entry: %5 = call i32 @std_io_println(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i32 0, i32 0)) #1 %6 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i32 0, i32 0)) #1 %7 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i32 0, i32 0)) #1 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.16, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8 - %8 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 - %lo = load i8*, i8** %9, align 8 - %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 - %hi = load i64, i64* %10, align 8 - store [3 x i8]* bitcast ([4 x i8]* @.str.17 to [3 x i8]*), [3 x i8]** %taddr1, align 8 - %11 = bitcast [3 x i8]** %taddr1 to i8* - %12 = insertvalue %variant undef, i8* %11, 0 - %13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %14 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %13, %variant* %14, align 16 - %15 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %15, align 8 - %16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %17 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %17, %variant** %16, align 8 - %18 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 - %lo2 = load i8*, i8** %19, align 8 - %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 - %hi3 = load i64, i64* %20, align 8 - %21 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %21, 0 + store [3 x i8]* bitcast ([4 x i8]* @.str.17 to [3 x i8]*), [3 x i8]** %taddr, align 8 + %8 = bitcast [3 x i8]** %taddr to i8* + %9 = insertvalue %variant undef, i8* %8, 0 + %10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 + %11 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %10, %variant* %11, align 16 + %12 = bitcast [1 x %variant]* %varargslots to %variant* + %13 = insertvalue %"variant[]" undef, %variant* %12, 0 + %14 = insertvalue %"variant[]" %13, i64 1, 1 + store %"variant[]" %14, %"variant[]"* %taddr1, align 8 + %15 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 0 + %lo = load i8*, i8** %16, align 8 + %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 1 + %hi = load i64, i64* %17, align 8 + %18 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.16, i32 0, i32 0), i64 8, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %18, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.18, i32 0, i32 0), i64 6 }, %"char[]"* %taddr5, align 8 - %22 = bitcast %"char[]"* %taddr5 to { i8*, i64 }* - %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0 - %lo6 = load i8*, i8** %23, align 8 - %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1 - %hi7 = load i64, i64* %24, align 8 - store [1 x i8]* bitcast ([2 x i8]* @.str.19 to [1 x i8]*), [1 x i8]** %taddr10, align 8 - %25 = bitcast [1 x i8]** %taddr10 to i8* - %26 = insertvalue %variant undef, i8* %25, 0 - %27 = insertvalue %variant %26, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 - %28 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots9, i64 0, i64 0 - store %variant %27, %variant* %28, align 16 - store [3 x i8]* bitcast ([4 x i8]* @.str.20 to [3 x i8]*), [3 x i8]** %taddr11, align 8 - %29 = bitcast [3 x i8]** %taddr11 to i8* - %30 = insertvalue %variant undef, i8* %29, 0 - %31 = insertvalue %variant %30, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %32 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots9, i64 0, i64 1 - store %variant %31, %variant* %32, align 16 - %33 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 1 - store i64 2, i64* %33, align 8 - %34 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 0 - %35 = bitcast [2 x %variant]* %varargslots9 to %variant* - store %variant* %35, %variant** %34, align 8 - %36 = bitcast %"variant[]"* %vararg8 to { i8*, i64 }* - %37 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 0 - %lo12 = load i8*, i8** %37, align 8 - %38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 1 - %hi13 = load i64, i64* %38, align 8 - %39 = call i64 @std_io_printfln(i64* %retparam4, i8* %lo6, i64 %hi7, i8* %lo12, i64 %hi13) - %not_err14 = icmp eq i64 %39, 0 - br i1 %not_err14, label %after_check15, label %voiderr16 + store [1 x i8]* bitcast ([2 x i8]* @.str.19 to [1 x i8]*), [1 x i8]** %taddr4, align 8 + %19 = bitcast [1 x i8]** %taddr4 to i8* + %20 = insertvalue %variant undef, i8* %19, 0 + %21 = insertvalue %variant %20, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 + %22 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots3, i64 0, i64 0 + store %variant %21, %variant* %22, align 16 + store [3 x i8]* bitcast ([4 x i8]* @.str.20 to [3 x i8]*), [3 x i8]** %taddr5, align 8 + %23 = bitcast [3 x i8]** %taddr5 to i8* + %24 = insertvalue %variant undef, i8* %23, 0 + %25 = insertvalue %variant %24, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 + %26 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots3, i64 0, i64 1 + store %variant %25, %variant* %26, align 16 + %27 = bitcast [2 x %variant]* %varargslots3 to %variant* + %28 = insertvalue %"variant[]" undef, %variant* %27, 0 + %29 = insertvalue %"variant[]" %28, i64 2, 1 + store %"variant[]" %29, %"variant[]"* %taddr6, align 8 + %30 = bitcast %"variant[]"* %taddr6 to { i8*, i64 }* + %31 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 0 + %lo7 = load i8*, i8** %31, align 8 + %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 1 + %hi8 = load i64, i64* %32, align 8 + %33 = call i64 @std_io_printfln(i64* %retparam2, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.18, i32 0, i32 0), i64 6, i8* %lo7, i64 %hi8) + %not_err9 = icmp eq i64 %33, 0 + br i1 %not_err9, label %after_check10, label %voiderr11 -after_check15: ; preds = %voiderr - br label %voiderr16 +after_check10: ; preds = %voiderr + br label %voiderr11 -voiderr16: ; preds = %after_check15, %voiderr - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i32 0, i32 0), i64 6 }, %"char[]"* %taddr18, align 8 - %40 = bitcast %"char[]"* %taddr18 to { i8*, i64 }* - %41 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %40, i32 0, i32 0 - %lo19 = load i8*, i8** %41, align 8 - %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %40, i32 0, i32 1 - %hi20 = load i64, i64* %42, align 8 - store [4 x i8]* bitcast ([5 x i8]* @.str.22 to [4 x i8]*), [4 x i8]** %taddr23, align 8 - %43 = bitcast [4 x i8]** %taddr23 to i8* - %44 = insertvalue %variant undef, i8* %43, 0 - %45 = insertvalue %variant %44, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 - %46 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots22, i64 0, i64 0 - store %variant %45, %variant* %46, align 16 - store [4 x i8]* bitcast ([5 x i8]* @.str.23 to [4 x i8]*), [4 x i8]** %taddr24, align 8 - %47 = bitcast [4 x i8]** %taddr24 to i8* - %48 = insertvalue %variant undef, i8* %47, 0 - %49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 - %50 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots22, i64 0, i64 1 - store %variant %49, %variant* %50, align 16 - %51 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg21, i32 0, i32 1 - store i64 2, i64* %51, align 8 - %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg21, i32 0, i32 0 - %53 = bitcast [2 x %variant]* %varargslots22 to %variant* - store %variant* %53, %variant** %52, align 8 - %54 = bitcast %"variant[]"* %vararg21 to { i8*, i64 }* - %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 0 - %lo25 = load i8*, i8** %55, align 8 - %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 1 - %hi26 = load i64, i64* %56, align 8 - %57 = call i64 @std_io_printfln(i64* %retparam17, i8* %lo19, i64 %hi20, i8* %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %57, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 +voiderr11: ; preds = %after_check10, %voiderr + store [4 x i8]* bitcast ([5 x i8]* @.str.22 to [4 x i8]*), [4 x i8]** %taddr14, align 8 + %34 = bitcast [4 x i8]** %taddr14 to i8* + %35 = insertvalue %variant undef, i8* %34, 0 + %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 + %37 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots13, i64 0, i64 0 + store %variant %36, %variant* %37, align 16 + store [4 x i8]* bitcast ([5 x i8]* @.str.23 to [4 x i8]*), [4 x i8]** %taddr15, align 8 + %38 = bitcast [4 x i8]** %taddr15 to i8* + %39 = insertvalue %variant undef, i8* %38, 0 + %40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 + %41 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots13, i64 0, i64 1 + store %variant %40, %variant* %41, align 16 + %42 = bitcast [2 x %variant]* %varargslots13 to %variant* + %43 = insertvalue %"variant[]" undef, %variant* %42, 0 + %44 = insertvalue %"variant[]" %43, i64 2, 1 + store %"variant[]" %44, %"variant[]"* %taddr16, align 8 + %45 = bitcast %"variant[]"* %taddr16 to { i8*, i64 }* + %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 + %lo17 = load i8*, i8** %46, align 8 + %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 + %hi18 = load i64, i64* %47, align 8 + %48 = call i64 @std_io_printfln(i64* %retparam12, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i32 0, i32 0), i64 6, i8* %lo17, i64 %hi18) + %not_err19 = icmp eq i64 %48, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 -after_check28: ; preds = %voiderr16 - br label %voiderr29 +after_check20: ; preds = %voiderr11 + br label %voiderr21 -voiderr29: ; preds = %after_check28, %voiderr16 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i32 0, i32 0), i64 6 }, %"char[]"* %taddr31, align 8 - %58 = bitcast %"char[]"* %taddr31 to { i8*, i64 }* - %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0 - %lo32 = load i8*, i8** %59, align 8 - %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1 - %hi33 = load i64, i64* %60, align 8 - store [0 x i8]* bitcast ([1 x i8]* @.str.25 to [0 x i8]*), [0 x i8]** %taddr36, align 8 - %61 = bitcast [0 x i8]** %taddr36 to i8* - %62 = insertvalue %variant undef, i8* %61, 0 - %63 = insertvalue %variant %62, i64 ptrtoint (%.introspect* @"ct$p$a0$char" to i64), 1 - %64 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots35, i64 0, i64 0 - store %variant %63, %variant* %64, align 16 - store [5 x i8]* bitcast ([6 x i8]* @.str.26 to [5 x i8]*), [5 x i8]** %taddr37, align 8 - %65 = bitcast [5 x i8]** %taddr37 to i8* - %66 = insertvalue %variant undef, i8* %65, 0 - %67 = insertvalue %variant %66, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 - %68 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots35, i64 0, i64 1 - store %variant %67, %variant* %68, align 16 - %69 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 1 - store i64 2, i64* %69, align 8 - %70 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 0 - %71 = bitcast [2 x %variant]* %varargslots35 to %variant* - store %variant* %71, %variant** %70, align 8 - %72 = bitcast %"variant[]"* %vararg34 to { i8*, i64 }* - %73 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %72, i32 0, i32 0 - %lo38 = load i8*, i8** %73, align 8 - %74 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %72, i32 0, i32 1 - %hi39 = load i64, i64* %74, align 8 - %75 = call i64 @std_io_printfln(i64* %retparam30, i8* %lo32, i64 %hi33, i8* %lo38, i64 %hi39) - %not_err40 = icmp eq i64 %75, 0 - br i1 %not_err40, label %after_check41, label %voiderr42 +voiderr21: ; preds = %after_check20, %voiderr11 + store [0 x i8]* bitcast ([1 x i8]* @.str.25 to [0 x i8]*), [0 x i8]** %taddr24, align 8 + %49 = bitcast [0 x i8]** %taddr24 to i8* + %50 = insertvalue %variant undef, i8* %49, 0 + %51 = insertvalue %variant %50, i64 ptrtoint (%.introspect* @"ct$p$a0$char" to i64), 1 + %52 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots23, i64 0, i64 0 + store %variant %51, %variant* %52, align 16 + store [5 x i8]* bitcast ([6 x i8]* @.str.26 to [5 x i8]*), [5 x i8]** %taddr25, align 8 + %53 = bitcast [5 x i8]** %taddr25 to i8* + %54 = insertvalue %variant undef, i8* %53, 0 + %55 = insertvalue %variant %54, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 + %56 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots23, i64 0, i64 1 + store %variant %55, %variant* %56, align 16 + %57 = bitcast [2 x %variant]* %varargslots23 to %variant* + %58 = insertvalue %"variant[]" undef, %variant* %57, 0 + %59 = insertvalue %"variant[]" %58, i64 2, 1 + store %"variant[]" %59, %"variant[]"* %taddr26, align 8 + %60 = bitcast %"variant[]"* %taddr26 to { i8*, i64 }* + %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0 + %lo27 = load i8*, i8** %61, align 8 + %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1 + %hi28 = load i64, i64* %62, align 8 + %63 = call i64 @std_io_printfln(i64* %retparam22, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i32 0, i32 0), i64 6, i8* %lo27, i64 %hi28) + %not_err29 = icmp eq i64 %63, 0 + br i1 %not_err29, label %after_check30, label %voiderr31 -after_check41: ; preds = %voiderr29 - br label %voiderr42 +after_check30: ; preds = %voiderr21 + br label %voiderr31 -voiderr42: ; preds = %after_check41, %voiderr29 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i32 0, i32 0), i64 6 }, %"char[]"* %taddr44, align 8 - %76 = bitcast %"char[]"* %taddr44 to { i8*, i64 }* - %77 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %76, i32 0, i32 0 - %lo45 = load i8*, i8** %77, align 8 - %78 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %76, i32 0, i32 1 - %hi46 = load i64, i64* %78, align 8 - store [1 x i8]* bitcast ([2 x i8]* @.str.28 to [1 x i8]*), [1 x i8]** %taddr49, align 8 - %79 = bitcast [1 x i8]** %taddr49 to i8* +voiderr31: ; preds = %after_check30, %voiderr21 + store [1 x i8]* bitcast ([2 x i8]* @.str.28 to [1 x i8]*), [1 x i8]** %taddr34, align 8 + %64 = bitcast [1 x i8]** %taddr34 to i8* + %65 = insertvalue %variant undef, i8* %64, 0 + %66 = insertvalue %variant %65, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 + %67 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots33, i64 0, i64 0 + store %variant %66, %variant* %67, align 16 + store [6 x i8]* bitcast ([7 x i8]* @.str.29 to [6 x i8]*), [6 x i8]** %taddr35, align 8 + %68 = bitcast [6 x i8]** %taddr35 to i8* + %69 = insertvalue %variant undef, i8* %68, 0 + %70 = insertvalue %variant %69, i64 ptrtoint (%.introspect* @"ct$p$a6$char" to i64), 1 + %71 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots33, i64 0, i64 1 + store %variant %70, %variant* %71, align 16 + %72 = bitcast [2 x %variant]* %varargslots33 to %variant* + %73 = insertvalue %"variant[]" undef, %variant* %72, 0 + %74 = insertvalue %"variant[]" %73, i64 2, 1 + store %"variant[]" %74, %"variant[]"* %taddr36, align 8 + %75 = bitcast %"variant[]"* %taddr36 to { i8*, i64 }* + %76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %75, i32 0, i32 0 + %lo37 = load i8*, i8** %76, align 8 + %77 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %75, i32 0, i32 1 + %hi38 = load i64, i64* %77, align 8 + %78 = call i64 @std_io_printfln(i64* %retparam32, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i32 0, i32 0), i64 6, i8* %lo37, i64 %hi38) + %not_err39 = icmp eq i64 %78, 0 + br i1 %not_err39, label %after_check40, label %voiderr41 + +after_check40: ; preds = %voiderr31 + br label %voiderr41 + +voiderr41: ; preds = %after_check40, %voiderr31 + store [3 x i8]* bitcast ([4 x i8]* @.str.31 to [3 x i8]*), [3 x i8]** %taddr44, align 8 + %79 = bitcast [3 x i8]** %taddr44 to i8* %80 = insertvalue %variant undef, i8* %79, 0 - %81 = insertvalue %variant %80, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 - %82 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots48, i64 0, i64 0 + %81 = insertvalue %variant %80, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 + %82 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots43, i64 0, i64 0 store %variant %81, %variant* %82, align 16 - store [6 x i8]* bitcast ([7 x i8]* @.str.29 to [6 x i8]*), [6 x i8]** %taddr50, align 8 - %83 = bitcast [6 x i8]** %taddr50 to i8* - %84 = insertvalue %variant undef, i8* %83, 0 - %85 = insertvalue %variant %84, i64 ptrtoint (%.introspect* @"ct$p$a6$char" to i64), 1 - %86 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots48, i64 0, i64 1 - store %variant %85, %variant* %86, align 16 - %87 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg47, i32 0, i32 1 - store i64 2, i64* %87, align 8 - %88 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg47, i32 0, i32 0 - %89 = bitcast [2 x %variant]* %varargslots48 to %variant* - store %variant* %89, %variant** %88, align 8 - %90 = bitcast %"variant[]"* %vararg47 to { i8*, i64 }* - %91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 0 - %lo51 = load i8*, i8** %91, align 8 - %92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 1 - %hi52 = load i64, i64* %92, align 8 - %93 = call i64 @std_io_printfln(i64* %retparam43, i8* %lo45, i64 %hi46, i8* %lo51, i64 %hi52) - %not_err53 = icmp eq i64 %93, 0 - br i1 %not_err53, label %after_check54, label %voiderr55 + %83 = bitcast [1 x %variant]* %varargslots43 to %variant* + %84 = insertvalue %"variant[]" undef, %variant* %83, 0 + %85 = insertvalue %"variant[]" %84, i64 1, 1 + store %"variant[]" %85, %"variant[]"* %taddr45, align 8 + %86 = bitcast %"variant[]"* %taddr45 to { i8*, i64 }* + %87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 0 + %lo46 = load i8*, i8** %87, align 8 + %88 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 1 + %hi47 = load i64, i64* %88, align 8 + %89 = call i64 @std_io_printfln(i64* %retparam42, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i32 0, i32 0), i64 8, i8* %lo46, i64 %hi47) + %not_err48 = icmp eq i64 %89, 0 + br i1 %not_err48, label %after_check49, label %voiderr50 -after_check54: ; preds = %voiderr42 - br label %voiderr55 +after_check49: ; preds = %voiderr41 + br label %voiderr50 -voiderr55: ; preds = %after_check54, %voiderr42 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i32 0, i32 0), i64 8 }, %"char[]"* %taddr57, align 8 - %94 = bitcast %"char[]"* %taddr57 to { i8*, i64 }* - %95 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %94, i32 0, i32 0 - %lo58 = load i8*, i8** %95, align 8 - %96 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %94, i32 0, i32 1 - %hi59 = load i64, i64* %96, align 8 - store [3 x i8]* bitcast ([4 x i8]* @.str.31 to [3 x i8]*), [3 x i8]** %taddr62, align 8 - %97 = bitcast [3 x i8]** %taddr62 to i8* - %98 = insertvalue %variant undef, i8* %97, 0 - %99 = insertvalue %variant %98, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %100 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots61, i64 0, i64 0 - store %variant %99, %variant* %100, align 16 - %101 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg60, i32 0, i32 1 - store i64 1, i64* %101, align 8 - %102 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg60, i32 0, i32 0 - %103 = bitcast [1 x %variant]* %varargslots61 to %variant* - store %variant* %103, %variant** %102, align 8 - %104 = bitcast %"variant[]"* %vararg60 to { i8*, i64 }* - %105 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %104, i32 0, i32 0 - %lo63 = load i8*, i8** %105, align 8 - %106 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %104, i32 0, i32 1 - %hi64 = load i64, i64* %106, align 8 - %107 = call i64 @std_io_printfln(i64* %retparam56, i8* %lo58, i64 %hi59, i8* %lo63, i64 %hi64) - %not_err65 = icmp eq i64 %107, 0 - br i1 %not_err65, label %after_check66, label %voiderr67 +voiderr50: ; preds = %after_check49, %voiderr41 + store [1 x i8]* bitcast ([2 x i8]* @.str.33 to [1 x i8]*), [1 x i8]** %taddr53, align 8 + %90 = bitcast [1 x i8]** %taddr53 to i8* + %91 = insertvalue %variant undef, i8* %90, 0 + %92 = insertvalue %variant %91, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 + %93 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots52, i64 0, i64 0 + store %variant %92, %variant* %93, align 16 + store [4 x i8]* bitcast ([5 x i8]* @.str.34 to [4 x i8]*), [4 x i8]** %taddr54, align 8 + %94 = bitcast [4 x i8]** %taddr54 to i8* + %95 = insertvalue %variant undef, i8* %94, 0 + %96 = insertvalue %variant %95, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 + %97 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots52, i64 0, i64 1 + store %variant %96, %variant* %97, align 16 + %98 = bitcast [2 x %variant]* %varargslots52 to %variant* + %99 = insertvalue %"variant[]" undef, %variant* %98, 0 + %100 = insertvalue %"variant[]" %99, i64 2, 1 + store %"variant[]" %100, %"variant[]"* %taddr55, align 8 + %101 = bitcast %"variant[]"* %taddr55 to { i8*, i64 }* + %102 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %101, i32 0, i32 0 + %lo56 = load i8*, i8** %102, align 8 + %103 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %101, i32 0, i32 1 + %hi57 = load i64, i64* %103, align 8 + %104 = call i64 @std_io_printfln(i64* %retparam51, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.32, i32 0, i32 0), i64 6, i8* %lo56, i64 %hi57) + %not_err58 = icmp eq i64 %104, 0 + br i1 %not_err58, label %after_check59, label %voiderr60 -after_check66: ; preds = %voiderr55 - br label %voiderr67 +after_check59: ; preds = %voiderr50 + br label %voiderr60 -voiderr67: ; preds = %after_check66, %voiderr55 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.32, i32 0, i32 0), i64 6 }, %"char[]"* %taddr69, align 8 - %108 = bitcast %"char[]"* %taddr69 to { i8*, i64 }* - %109 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %108, i32 0, i32 0 - %lo70 = load i8*, i8** %109, align 8 - %110 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %108, i32 0, i32 1 - %hi71 = load i64, i64* %110, align 8 - store [1 x i8]* bitcast ([2 x i8]* @.str.33 to [1 x i8]*), [1 x i8]** %taddr74, align 8 - %111 = bitcast [1 x i8]** %taddr74 to i8* - %112 = insertvalue %variant undef, i8* %111, 0 - %113 = insertvalue %variant %112, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 - %114 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots73, i64 0, i64 0 - store %variant %113, %variant* %114, align 16 - store [4 x i8]* bitcast ([5 x i8]* @.str.34 to [4 x i8]*), [4 x i8]** %taddr75, align 8 - %115 = bitcast [4 x i8]** %taddr75 to i8* - %116 = insertvalue %variant undef, i8* %115, 0 - %117 = insertvalue %variant %116, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 - %118 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots73, i64 0, i64 1 - store %variant %117, %variant* %118, align 16 - %119 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg72, i32 0, i32 1 - store i64 2, i64* %119, align 8 - %120 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg72, i32 0, i32 0 - %121 = bitcast [2 x %variant]* %varargslots73 to %variant* - store %variant* %121, %variant** %120, align 8 - %122 = bitcast %"variant[]"* %vararg72 to { i8*, i64 }* - %123 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %122, i32 0, i32 0 - %lo76 = load i8*, i8** %123, align 8 - %124 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %122, i32 0, i32 1 - %hi77 = load i64, i64* %124, align 8 - %125 = call i64 @std_io_printfln(i64* %retparam68, i8* %lo70, i64 %hi71, i8* %lo76, i64 %hi77) - %not_err78 = icmp eq i64 %125, 0 +voiderr60: ; preds = %after_check59, %voiderr50 + store [1 x i8]* bitcast ([2 x i8]* @.str.36 to [1 x i8]*), [1 x i8]** %taddr63, align 8 + %105 = bitcast [1 x i8]** %taddr63 to i8* + %106 = insertvalue %variant undef, i8* %105, 0 + %107 = insertvalue %variant %106, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 + %108 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots62, i64 0, i64 0 + store %variant %107, %variant* %108, align 16 + store [5 x i8]* bitcast ([6 x i8]* @.str.37 to [5 x i8]*), [5 x i8]** %taddr64, align 8 + %109 = bitcast [5 x i8]** %taddr64 to i8* + %110 = insertvalue %variant undef, i8* %109, 0 + %111 = insertvalue %variant %110, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 + %112 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots62, i64 0, i64 1 + store %variant %111, %variant* %112, align 16 + %113 = bitcast [2 x %variant]* %varargslots62 to %variant* + %114 = insertvalue %"variant[]" undef, %variant* %113, 0 + %115 = insertvalue %"variant[]" %114, i64 2, 1 + store %"variant[]" %115, %"variant[]"* %taddr65, align 8 + %116 = bitcast %"variant[]"* %taddr65 to { i8*, i64 }* + %117 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %116, i32 0, i32 0 + %lo66 = load i8*, i8** %117, align 8 + %118 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %116, i32 0, i32 1 + %hi67 = load i64, i64* %118, align 8 + %119 = call i64 @std_io_printfln(i64* %retparam61, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.35, i32 0, i32 0), i64 6, i8* %lo66, i64 %hi67) + %not_err68 = icmp eq i64 %119, 0 + br i1 %not_err68, label %after_check69, label %voiderr70 + +after_check69: ; preds = %voiderr60 + br label %voiderr70 + +voiderr70: ; preds = %after_check69, %voiderr60 + store [0 x i8]* bitcast ([1 x i8]* @.str.39 to [0 x i8]*), [0 x i8]** %taddr73, align 8 + %120 = bitcast [0 x i8]** %taddr73 to i8* + %121 = insertvalue %variant undef, i8* %120, 0 + %122 = insertvalue %variant %121, i64 ptrtoint (%.introspect* @"ct$p$a0$char" to i64), 1 + %123 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots72, i64 0, i64 0 + store %variant %122, %variant* %123, align 16 + store [5 x i8]* bitcast ([6 x i8]* @.str.40 to [5 x i8]*), [5 x i8]** %taddr74, align 8 + %124 = bitcast [5 x i8]** %taddr74 to i8* + %125 = insertvalue %variant undef, i8* %124, 0 + %126 = insertvalue %variant %125, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 + %127 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots72, i64 0, i64 1 + store %variant %126, %variant* %127, align 16 + %128 = bitcast [2 x %variant]* %varargslots72 to %variant* + %129 = insertvalue %"variant[]" undef, %variant* %128, 0 + %130 = insertvalue %"variant[]" %129, i64 2, 1 + store %"variant[]" %130, %"variant[]"* %taddr75, align 8 + %131 = bitcast %"variant[]"* %taddr75 to { i8*, i64 }* + %132 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %131, i32 0, i32 0 + %lo76 = load i8*, i8** %132, align 8 + %133 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %131, i32 0, i32 1 + %hi77 = load i64, i64* %133, align 8 + %134 = call i64 @std_io_printfln(i64* %retparam71, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.38, i32 0, i32 0), i64 6, i8* %lo76, i64 %hi77) + %not_err78 = icmp eq i64 %134, 0 br i1 %not_err78, label %after_check79, label %voiderr80 -after_check79: ; preds = %voiderr67 +after_check79: ; preds = %voiderr70 br label %voiderr80 -voiderr80: ; preds = %after_check79, %voiderr67 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.35, i32 0, i32 0), i64 6 }, %"char[]"* %taddr82, align 8 - %126 = bitcast %"char[]"* %taddr82 to { i8*, i64 }* - %127 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %126, i32 0, i32 0 - %lo83 = load i8*, i8** %127, align 8 - %128 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %126, i32 0, i32 1 - %hi84 = load i64, i64* %128, align 8 - store [1 x i8]* bitcast ([2 x i8]* @.str.36 to [1 x i8]*), [1 x i8]** %taddr87, align 8 - %129 = bitcast [1 x i8]** %taddr87 to i8* - %130 = insertvalue %variant undef, i8* %129, 0 - %131 = insertvalue %variant %130, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 - %132 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots86, i64 0, i64 0 - store %variant %131, %variant* %132, align 16 - store [5 x i8]* bitcast ([6 x i8]* @.str.37 to [5 x i8]*), [5 x i8]** %taddr88, align 8 - %133 = bitcast [5 x i8]** %taddr88 to i8* - %134 = insertvalue %variant undef, i8* %133, 0 - %135 = insertvalue %variant %134, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 - %136 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots86, i64 0, i64 1 - store %variant %135, %variant* %136, align 16 - %137 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg85, i32 0, i32 1 - store i64 2, i64* %137, align 8 - %138 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg85, i32 0, i32 0 - %139 = bitcast [2 x %variant]* %varargslots86 to %variant* - store %variant* %139, %variant** %138, align 8 - %140 = bitcast %"variant[]"* %vararg85 to { i8*, i64 }* - %141 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %140, i32 0, i32 0 - %lo89 = load i8*, i8** %141, align 8 - %142 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %140, i32 0, i32 1 - %hi90 = load i64, i64* %142, align 8 - %143 = call i64 @std_io_printfln(i64* %retparam81, i8* %lo83, i64 %hi84, i8* %lo89, i64 %hi90) - %not_err91 = icmp eq i64 %143, 0 - br i1 %not_err91, label %after_check92, label %voiderr93 +voiderr80: ; preds = %after_check79, %voiderr70 + store [3 x i8]* bitcast ([4 x i8]* @.str.42 to [3 x i8]*), [3 x i8]** %taddr83, align 8 + %135 = bitcast [3 x i8]** %taddr83 to i8* + %136 = insertvalue %variant undef, i8* %135, 0 + %137 = insertvalue %variant %136, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 + %138 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots82, i64 0, i64 0 + store %variant %137, %variant* %138, align 16 + store [3 x i8]* bitcast ([4 x i8]* @.str.43 to [3 x i8]*), [3 x i8]** %taddr84, align 8 + %139 = bitcast [3 x i8]** %taddr84 to i8* + %140 = insertvalue %variant undef, i8* %139, 0 + %141 = insertvalue %variant %140, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 + %142 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots82, i64 0, i64 1 + store %variant %141, %variant* %142, align 16 + %143 = bitcast [2 x %variant]* %varargslots82 to %variant* + %144 = insertvalue %"variant[]" undef, %variant* %143, 0 + %145 = insertvalue %"variant[]" %144, i64 2, 1 + store %"variant[]" %145, %"variant[]"* %taddr85, align 8 + %146 = bitcast %"variant[]"* %taddr85 to { i8*, i64 }* + %147 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %146, i32 0, i32 0 + %lo86 = load i8*, i8** %147, align 8 + %148 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %146, i32 0, i32 1 + %hi87 = load i64, i64* %148, align 8 + %149 = call i64 @std_io_printfln(i64* %retparam81, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.41, i32 0, i32 0), i64 6, i8* %lo86, i64 %hi87) + %not_err88 = icmp eq i64 %149, 0 + br i1 %not_err88, label %after_check89, label %voiderr90 -after_check92: ; preds = %voiderr80 - br label %voiderr93 +after_check89: ; preds = %voiderr80 + br label %voiderr90 -voiderr93: ; preds = %after_check92, %voiderr80 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.38, i32 0, i32 0), i64 6 }, %"char[]"* %taddr95, align 8 - %144 = bitcast %"char[]"* %taddr95 to { i8*, i64 }* - %145 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %144, i32 0, i32 0 - %lo96 = load i8*, i8** %145, align 8 - %146 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %144, i32 0, i32 1 - %hi97 = load i64, i64* %146, align 8 - store [0 x i8]* bitcast ([1 x i8]* @.str.39 to [0 x i8]*), [0 x i8]** %taddr100, align 8 - %147 = bitcast [0 x i8]** %taddr100 to i8* - %148 = insertvalue %variant undef, i8* %147, 0 - %149 = insertvalue %variant %148, i64 ptrtoint (%.introspect* @"ct$p$a0$char" to i64), 1 - %150 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots99, i64 0, i64 0 - store %variant %149, %variant* %150, align 16 - store [5 x i8]* bitcast ([6 x i8]* @.str.40 to [5 x i8]*), [5 x i8]** %taddr101, align 8 - %151 = bitcast [5 x i8]** %taddr101 to i8* - %152 = insertvalue %variant undef, i8* %151, 0 - %153 = insertvalue %variant %152, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 - %154 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots99, i64 0, i64 1 - store %variant %153, %variant* %154, align 16 - %155 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 1 - store i64 2, i64* %155, align 8 - %156 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 0 - %157 = bitcast [2 x %variant]* %varargslots99 to %variant* - store %variant* %157, %variant** %156, align 8 - %158 = bitcast %"variant[]"* %vararg98 to { i8*, i64 }* - %159 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %158, i32 0, i32 0 - %lo102 = load i8*, i8** %159, align 8 - %160 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %158, i32 0, i32 1 - %hi103 = load i64, i64* %160, align 8 - %161 = call i64 @std_io_printfln(i64* %retparam94, i8* %lo96, i64 %hi97, i8* %lo102, i64 %hi103) - %not_err104 = icmp eq i64 %161, 0 - br i1 %not_err104, label %after_check105, label %voiderr106 +voiderr90: ; preds = %after_check89, %voiderr80 + store [4 x i8]* bitcast ([5 x i8]* @.str.45 to [4 x i8]*), [4 x i8]** %taddr93, align 8 + %150 = bitcast [4 x i8]** %taddr93 to i8* + %151 = insertvalue %variant undef, i8* %150, 0 + %152 = insertvalue %variant %151, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 + %153 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots92, i64 0, i64 0 + store %variant %152, %variant* %153, align 16 + %154 = bitcast [1 x %variant]* %varargslots92 to %variant* + %155 = insertvalue %"variant[]" undef, %variant* %154, 0 + %156 = insertvalue %"variant[]" %155, i64 1, 1 + store %"variant[]" %156, %"variant[]"* %taddr94, align 8 + %157 = bitcast %"variant[]"* %taddr94 to { i8*, i64 }* + %158 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %157, i32 0, i32 0 + %lo95 = load i8*, i8** %158, align 8 + %159 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %157, i32 0, i32 1 + %hi96 = load i64, i64* %159, align 8 + %160 = call i64 @std_io_printfln(i64* %retparam91, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.44, i32 0, i32 0), i64 8, i8* %lo95, i64 %hi96) + %not_err97 = icmp eq i64 %160, 0 + br i1 %not_err97, label %after_check98, label %voiderr99 -after_check105: ; preds = %voiderr93 - br label %voiderr106 +after_check98: ; preds = %voiderr90 + br label %voiderr99 -voiderr106: ; preds = %after_check105, %voiderr93 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.41, i32 0, i32 0), i64 6 }, %"char[]"* %taddr108, align 8 - %162 = bitcast %"char[]"* %taddr108 to { i8*, i64 }* - %163 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %162, i32 0, i32 0 - %lo109 = load i8*, i8** %163, align 8 - %164 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %162, i32 0, i32 1 - %hi110 = load i64, i64* %164, align 8 - store [3 x i8]* bitcast ([4 x i8]* @.str.42 to [3 x i8]*), [3 x i8]** %taddr113, align 8 - %165 = bitcast [3 x i8]** %taddr113 to i8* +voiderr99: ; preds = %after_check98, %voiderr90 + store [1 x i8]* bitcast ([2 x i8]* @.str.47 to [1 x i8]*), [1 x i8]** %taddr102, align 8 + %161 = bitcast [1 x i8]** %taddr102 to i8* + %162 = insertvalue %variant undef, i8* %161, 0 + %163 = insertvalue %variant %162, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 + %164 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots101, i64 0, i64 0 + store %variant %163, %variant* %164, align 16 + store [3 x i8]* bitcast ([4 x i8]* @.str.48 to [3 x i8]*), [3 x i8]** %taddr103, align 8 + %165 = bitcast [3 x i8]** %taddr103 to i8* %166 = insertvalue %variant undef, i8* %165, 0 %167 = insertvalue %variant %166, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %168 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots112, i64 0, i64 0 + %168 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots101, i64 0, i64 1 store %variant %167, %variant* %168, align 16 - store [3 x i8]* bitcast ([4 x i8]* @.str.43 to [3 x i8]*), [3 x i8]** %taddr114, align 8 - %169 = bitcast [3 x i8]** %taddr114 to i8* - %170 = insertvalue %variant undef, i8* %169, 0 - %171 = insertvalue %variant %170, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %172 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots112, i64 0, i64 1 - store %variant %171, %variant* %172, align 16 - %173 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg111, i32 0, i32 1 - store i64 2, i64* %173, align 8 - %174 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg111, i32 0, i32 0 - %175 = bitcast [2 x %variant]* %varargslots112 to %variant* - store %variant* %175, %variant** %174, align 8 - %176 = bitcast %"variant[]"* %vararg111 to { i8*, i64 }* - %177 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %176, i32 0, i32 0 - %lo115 = load i8*, i8** %177, align 8 - %178 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %176, i32 0, i32 1 - %hi116 = load i64, i64* %178, align 8 - %179 = call i64 @std_io_printfln(i64* %retparam107, i8* %lo109, i64 %hi110, i8* %lo115, i64 %hi116) - %not_err117 = icmp eq i64 %179, 0 + %169 = bitcast [2 x %variant]* %varargslots101 to %variant* + %170 = insertvalue %"variant[]" undef, %variant* %169, 0 + %171 = insertvalue %"variant[]" %170, i64 2, 1 + store %"variant[]" %171, %"variant[]"* %taddr104, align 8 + %172 = bitcast %"variant[]"* %taddr104 to { i8*, i64 }* + %173 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %172, i32 0, i32 0 + %lo105 = load i8*, i8** %173, align 8 + %174 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %172, i32 0, i32 1 + %hi106 = load i64, i64* %174, align 8 + %175 = call i64 @std_io_printfln(i64* %retparam100, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.46, i32 0, i32 0), i64 6, i8* %lo105, i64 %hi106) + %not_err107 = icmp eq i64 %175, 0 + br i1 %not_err107, label %after_check108, label %voiderr109 + +after_check108: ; preds = %voiderr99 + br label %voiderr109 + +voiderr109: ; preds = %after_check108, %voiderr99 + store [1 x i8]* bitcast ([2 x i8]* @.str.50 to [1 x i8]*), [1 x i8]** %taddr112, align 8 + %176 = bitcast [1 x i8]** %taddr112 to i8* + %177 = insertvalue %variant undef, i8* %176, 0 + %178 = insertvalue %variant %177, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 + %179 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots111, i64 0, i64 0 + store %variant %178, %variant* %179, align 16 + store [5 x i8]* bitcast ([6 x i8]* @.str.51 to [5 x i8]*), [5 x i8]** %taddr113, align 8 + %180 = bitcast [5 x i8]** %taddr113 to i8* + %181 = insertvalue %variant undef, i8* %180, 0 + %182 = insertvalue %variant %181, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 + %183 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots111, i64 0, i64 1 + store %variant %182, %variant* %183, align 16 + %184 = bitcast [2 x %variant]* %varargslots111 to %variant* + %185 = insertvalue %"variant[]" undef, %variant* %184, 0 + %186 = insertvalue %"variant[]" %185, i64 2, 1 + store %"variant[]" %186, %"variant[]"* %taddr114, align 8 + %187 = bitcast %"variant[]"* %taddr114 to { i8*, i64 }* + %188 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %187, i32 0, i32 0 + %lo115 = load i8*, i8** %188, align 8 + %189 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %187, i32 0, i32 1 + %hi116 = load i64, i64* %189, align 8 + %190 = call i64 @std_io_printfln(i64* %retparam110, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.49, i32 0, i32 0), i64 6, i8* %lo115, i64 %hi116) + %not_err117 = icmp eq i64 %190, 0 br i1 %not_err117, label %after_check118, label %voiderr119 -after_check118: ; preds = %voiderr106 +after_check118: ; preds = %voiderr109 br label %voiderr119 -voiderr119: ; preds = %after_check118, %voiderr106 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.44, i32 0, i32 0), i64 8 }, %"char[]"* %taddr121, align 8 - %180 = bitcast %"char[]"* %taddr121 to { i8*, i64 }* - %181 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %180, i32 0, i32 0 - %lo122 = load i8*, i8** %181, align 8 - %182 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %180, i32 0, i32 1 - %hi123 = load i64, i64* %182, align 8 - store [4 x i8]* bitcast ([5 x i8]* @.str.45 to [4 x i8]*), [4 x i8]** %taddr126, align 8 - %183 = bitcast [4 x i8]** %taddr126 to i8* - %184 = insertvalue %variant undef, i8* %183, 0 - %185 = insertvalue %variant %184, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 - %186 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots125, i64 0, i64 0 - store %variant %185, %variant* %186, align 16 - %187 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg124, i32 0, i32 1 - store i64 1, i64* %187, align 8 - %188 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg124, i32 0, i32 0 - %189 = bitcast [1 x %variant]* %varargslots125 to %variant* - store %variant* %189, %variant** %188, align 8 - %190 = bitcast %"variant[]"* %vararg124 to { i8*, i64 }* - %191 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %190, i32 0, i32 0 - %lo127 = load i8*, i8** %191, align 8 - %192 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %190, i32 0, i32 1 - %hi128 = load i64, i64* %192, align 8 - %193 = call i64 @std_io_printfln(i64* %retparam120, i8* %lo122, i64 %hi123, i8* %lo127, i64 %hi128) - %not_err129 = icmp eq i64 %193, 0 - br i1 %not_err129, label %after_check130, label %voiderr131 - -after_check130: ; preds = %voiderr119 - br label %voiderr131 - -voiderr131: ; preds = %after_check130, %voiderr119 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.46, i32 0, i32 0), i64 6 }, %"char[]"* %taddr133, align 8 - %194 = bitcast %"char[]"* %taddr133 to { i8*, i64 }* - %195 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %194, i32 0, i32 0 - %lo134 = load i8*, i8** %195, align 8 - %196 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %194, i32 0, i32 1 - %hi135 = load i64, i64* %196, align 8 - store [1 x i8]* bitcast ([2 x i8]* @.str.47 to [1 x i8]*), [1 x i8]** %taddr138, align 8 - %197 = bitcast [1 x i8]** %taddr138 to i8* - %198 = insertvalue %variant undef, i8* %197, 0 - %199 = insertvalue %variant %198, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 - %200 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots137, i64 0, i64 0 - store %variant %199, %variant* %200, align 16 - store [3 x i8]* bitcast ([4 x i8]* @.str.48 to [3 x i8]*), [3 x i8]** %taddr139, align 8 - %201 = bitcast [3 x i8]** %taddr139 to i8* - %202 = insertvalue %variant undef, i8* %201, 0 - %203 = insertvalue %variant %202, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %204 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots137, i64 0, i64 1 - store %variant %203, %variant* %204, align 16 - %205 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg136, i32 0, i32 1 - store i64 2, i64* %205, align 8 - %206 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg136, i32 0, i32 0 - %207 = bitcast [2 x %variant]* %varargslots137 to %variant* - store %variant* %207, %variant** %206, align 8 - %208 = bitcast %"variant[]"* %vararg136 to { i8*, i64 }* - %209 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %208, i32 0, i32 0 - %lo140 = load i8*, i8** %209, align 8 - %210 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %208, i32 0, i32 1 - %hi141 = load i64, i64* %210, align 8 - %211 = call i64 @std_io_printfln(i64* %retparam132, i8* %lo134, i64 %hi135, i8* %lo140, i64 %hi141) - %not_err142 = icmp eq i64 %211, 0 - br i1 %not_err142, label %after_check143, label %voiderr144 - -after_check143: ; preds = %voiderr131 - br label %voiderr144 - -voiderr144: ; preds = %after_check143, %voiderr131 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.49, i32 0, i32 0), i64 6 }, %"char[]"* %taddr146, align 8 - %212 = bitcast %"char[]"* %taddr146 to { i8*, i64 }* - %213 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %212, i32 0, i32 0 - %lo147 = load i8*, i8** %213, align 8 - %214 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %212, i32 0, i32 1 - %hi148 = load i64, i64* %214, align 8 - store [1 x i8]* bitcast ([2 x i8]* @.str.50 to [1 x i8]*), [1 x i8]** %taddr151, align 8 - %215 = bitcast [1 x i8]** %taddr151 to i8* - %216 = insertvalue %variant undef, i8* %215, 0 - %217 = insertvalue %variant %216, i64 ptrtoint (%.introspect* @"ct$p$a1$char" to i64), 1 - %218 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots150, i64 0, i64 0 - store %variant %217, %variant* %218, align 16 - store [5 x i8]* bitcast ([6 x i8]* @.str.51 to [5 x i8]*), [5 x i8]** %taddr152, align 8 - %219 = bitcast [5 x i8]** %taddr152 to i8* - %220 = insertvalue %variant undef, i8* %219, 0 - %221 = insertvalue %variant %220, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 - %222 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots150, i64 0, i64 1 - store %variant %221, %variant* %222, align 16 - %223 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg149, i32 0, i32 1 - store i64 2, i64* %223, align 8 - %224 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg149, i32 0, i32 0 - %225 = bitcast [2 x %variant]* %varargslots150 to %variant* - store %variant* %225, %variant** %224, align 8 - %226 = bitcast %"variant[]"* %vararg149 to { i8*, i64 }* - %227 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %226, i32 0, i32 0 - %lo153 = load i8*, i8** %227, align 8 - %228 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %226, i32 0, i32 1 - %hi154 = load i64, i64* %228, align 8 - %229 = call i64 @std_io_printfln(i64* %retparam145, i8* %lo147, i64 %hi148, i8* %lo153, i64 %hi154) - %not_err155 = icmp eq i64 %229, 0 - br i1 %not_err155, label %after_check156, label %voiderr157 - -after_check156: ; preds = %voiderr144 - br label %voiderr157 - -voiderr157: ; preds = %after_check156, %voiderr144 +voiderr119: ; preds = %after_check118, %voiderr109 ret void } @@ -660,446 +556,358 @@ voiderr157: ; preds = %after_check156, %vo define void @test_main() #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i64, align 8 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 - %taddr10 = alloca i64, align 8 - %retparam16 = alloca i64, align 8 - %taddr17 = alloca %"char[]", align 8 - %vararg20 = alloca %"variant[]", align 8 - %varargslots21 = alloca [2 x %variant], align 16 - %taddr22 = alloca i64, align 8 + %taddr = alloca i64, align 8 + %taddr1 = alloca %"variant[]", align 8 + %retparam2 = alloca i64, align 8 + %varargslots3 = alloca [1 x %variant], align 16 + %taddr4 = alloca i64, align 8 + %taddr5 = alloca %"variant[]", align 8 + %retparam11 = alloca i64, align 8 + %varargslots12 = alloca [2 x %variant], align 16 + %taddr13 = alloca i64, align 8 + %taddr14 = alloca i64, align 8 + %taddr15 = alloca %"variant[]", align 8 + %retparam21 = alloca i64, align 8 + %varargslots22 = alloca [2 x %variant], align 16 %taddr23 = alloca i64, align 8 - %retparam29 = alloca i64, align 8 - %taddr30 = alloca %"char[]", align 8 - %vararg33 = alloca %"variant[]", align 8 - %varargslots34 = alloca [2 x %variant], align 16 - %taddr35 = alloca i64, align 8 - %taddr36 = alloca i64, align 8 - %retparam42 = alloca i64, align 8 - %taddr43 = alloca %"char[]", align 8 - %vararg46 = alloca %"variant[]", align 8 - %varargslots47 = alloca [2 x %variant], align 16 - %taddr48 = alloca i64, align 8 - %taddr49 = alloca i64, align 8 - %retparam55 = alloca i64, align 8 - %taddr56 = alloca %"char[]", align 8 - %vararg59 = alloca %"variant[]", align 8 - %varargslots60 = alloca [2 x %variant], align 16 - %taddr61 = alloca i64, align 8 - %taddr62 = alloca i64, align 8 - %retparam68 = alloca i64, align 8 - %taddr69 = alloca %"char[]", align 8 - %vararg72 = alloca %"variant[]", align 8 - %varargslots73 = alloca [2 x %variant], align 16 + %taddr24 = alloca i64, align 8 + %taddr25 = alloca %"variant[]", align 8 + %retparam31 = alloca i64, align 8 + %varargslots32 = alloca [2 x %variant], align 16 + %taddr33 = alloca i64, align 8 + %taddr34 = alloca i64, align 8 + %taddr35 = alloca %"variant[]", align 8 + %retparam41 = alloca i64, align 8 + %varargslots42 = alloca [2 x %variant], align 16 + %taddr43 = alloca i64, align 8 + %taddr44 = alloca i64, align 8 + %taddr45 = alloca %"variant[]", align 8 + %retparam51 = alloca i64, align 8 + %varargslots52 = alloca [2 x %variant], align 16 + %taddr53 = alloca i64, align 8 + %taddr54 = alloca i64, align 8 + %taddr55 = alloca %"variant[]", align 8 + %retparam61 = alloca i64, align 8 + %varargslots62 = alloca [2 x %variant], align 16 + %taddr63 = alloca i64, align 8 + %taddr64 = alloca i64, align 8 + %taddr65 = alloca %"variant[]", align 8 + %retparam71 = alloca i64, align 8 + %varargslots72 = alloca [2 x %variant], align 16 + %taddr73 = alloca i64, align 8 %taddr74 = alloca i64, align 8 - %taddr75 = alloca i64, align 8 + %taddr75 = alloca %"variant[]", align 8 %retparam81 = alloca i64, align 8 - %taddr82 = alloca %"char[]", align 8 - %vararg85 = alloca %"variant[]", align 8 - %varargslots86 = alloca [2 x %variant], align 16 - %taddr87 = alloca i64, align 8 - %taddr88 = alloca i64, align 8 - %retparam94 = alloca i64, align 8 - %taddr95 = alloca %"char[]", align 8 - %vararg98 = alloca %"variant[]", align 8 - %varargslots99 = alloca [2 x %variant], align 16 - %taddr100 = alloca i64, align 8 - %taddr101 = alloca i64, align 8 - %retparam107 = alloca i64, align 8 - %taddr108 = alloca %"char[]", align 8 - %vararg111 = alloca %"variant[]", align 8 - %varargslots112 = alloca [1 x %variant], align 16 - %taddr113 = alloca i64, align 8 - %retparam119 = alloca i64, align 8 - %taddr120 = alloca %"char[]", align 8 - %vararg123 = alloca %"variant[]", align 8 - %varargslots124 = alloca [2 x %variant], align 16 - %taddr125 = alloca i64, align 8 - %taddr126 = alloca i64, align 8 - store %"char[]" { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.52, i32 0, i32 0), i64 7 }, %"char[]"* %taddr, align 8 - %0 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %1 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 0 - %lo = load i8*, i8** %1, align 8 - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 1 - %hi = load i64, i64* %2, align 8 - store i64 4, i64* %taddr1, align 8 - %3 = bitcast i64* %taddr1 to i8* - %4 = insertvalue %variant undef, i8* %3, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 - %6 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %5, %variant* %6, align 16 - %7 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %7, align 8 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %9 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %9, %variant** %8, align 8 - %10 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %11 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %10, i32 0, i32 0 - %lo2 = load i8*, i8** %11, align 8 - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %10, i32 0, i32 1 - %hi3 = load i64, i64* %12, align 8 - %13 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %13, 0 + %varargslots82 = alloca [1 x %variant], align 16 + %taddr83 = alloca i64, align 8 + %taddr84 = alloca %"variant[]", align 8 + %retparam90 = alloca i64, align 8 + %varargslots91 = alloca [2 x %variant], align 16 + %taddr92 = alloca i64, align 8 + %taddr93 = alloca i64, align 8 + %taddr94 = alloca %"variant[]", align 8 + store i64 4, i64* %taddr, align 8 + %0 = bitcast i64* %taddr to i8* + %1 = insertvalue %variant undef, i8* %0, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %2, %variant* %3, align 16 + %4 = bitcast [1 x %variant]* %varargslots to %variant* + %5 = insertvalue %"variant[]" undef, %variant* %4, 0 + %6 = insertvalue %"variant[]" %5, i64 1, 1 + store %"variant[]" %6, %"variant[]"* %taddr1, align 8 + %7 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %7, i32 0, i32 0 + %lo = load i8*, i8** %8, align 8 + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %7, i32 0, i32 1 + %hi = load i64, i64* %9, align 8 + %10 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.52, i32 0, i32 0), i64 7, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %10, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.53, i32 0, i32 0), i64 7 }, %"char[]"* %taddr5, align 8 - %14 = bitcast %"char[]"* %taddr5 to { i8*, i64 }* - %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 0 - %lo6 = load i8*, i8** %15, align 8 - %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 1 - %hi7 = load i64, i64* %16, align 8 - store i64 1, i64* %taddr10, align 8 - %17 = bitcast i64* %taddr10 to i8* - %18 = insertvalue %variant undef, i8* %17, 0 - %19 = insertvalue %variant %18, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 - %20 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots9, i64 0, i64 0 - store %variant %19, %variant* %20, align 16 - %21 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 1 - store i64 1, i64* %21, align 8 - %22 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 0 - %23 = bitcast [1 x %variant]* %varargslots9 to %variant* - store %variant* %23, %variant** %22, align 8 - %24 = bitcast %"variant[]"* %vararg8 to { i8*, i64 }* - %25 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 0 - %lo11 = load i8*, i8** %25, align 8 - %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 1 - %hi12 = load i64, i64* %26, align 8 - %27 = call i64 @std_io_printfln(i64* %retparam4, i8* %lo6, i64 %hi7, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %27, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + store i64 1, i64* %taddr4, align 8 + %11 = bitcast i64* %taddr4 to i8* + %12 = insertvalue %variant undef, i8* %11, 0 + %13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 + %14 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots3, i64 0, i64 0 + store %variant %13, %variant* %14, align 16 + %15 = bitcast [1 x %variant]* %varargslots3 to %variant* + %16 = insertvalue %"variant[]" undef, %variant* %15, 0 + %17 = insertvalue %"variant[]" %16, i64 1, 1 + store %"variant[]" %17, %"variant[]"* %taddr5, align 8 + %18 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }* + %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 + %lo6 = load i8*, i8** %19, align 8 + %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 + %hi7 = load i64, i64* %20, align 8 + %21 = call i64 @std_io_printfln(i64* %retparam2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.53, i32 0, i32 0), i64 7, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %21, 0 + br i1 %not_err8, label %after_check9, label %voiderr10 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check9: ; preds = %voiderr + br label %voiderr10 -voiderr15: ; preds = %after_check14, %voiderr - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.54, i32 0, i32 0), i64 8 }, %"char[]"* %taddr17, align 8 - %28 = bitcast %"char[]"* %taddr17 to { i8*, i64 }* - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 0 - %lo18 = load i8*, i8** %29, align 8 - %30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 1 - %hi19 = load i64, i64* %30, align 8 - store i64 0, i64* %taddr22, align 8 - %31 = bitcast i64* %taddr22 to i8* - %32 = insertvalue %variant undef, i8* %31, 0 - %33 = insertvalue %variant %32, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %34 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots21, i64 0, i64 0 - store %variant %33, %variant* %34, align 16 - store i64 4, i64* %taddr23, align 8 - %35 = bitcast i64* %taddr23 to i8* - %36 = insertvalue %variant undef, i8* %35, 0 - %37 = insertvalue %variant %36, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %38 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots21, i64 0, i64 1 - store %variant %37, %variant* %38, align 16 - %39 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 1 - store i64 2, i64* %39, align 8 - %40 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 0 - %41 = bitcast [2 x %variant]* %varargslots21 to %variant* - store %variant* %41, %variant** %40, align 8 - %42 = bitcast %"variant[]"* %vararg20 to { i8*, i64 }* - %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %42, i32 0, i32 0 - %lo24 = load i8*, i8** %43, align 8 - %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %42, i32 0, i32 1 - %hi25 = load i64, i64* %44, align 8 - %45 = call i64 @std_io_printfln(i64* %retparam16, i8* %lo18, i64 %hi19, i8* %lo24, i64 %hi25) - %not_err26 = icmp eq i64 %45, 0 - br i1 %not_err26, label %after_check27, label %voiderr28 +voiderr10: ; preds = %after_check9, %voiderr + store i64 0, i64* %taddr13, align 8 + %22 = bitcast i64* %taddr13 to i8* + %23 = insertvalue %variant undef, i8* %22, 0 + %24 = insertvalue %variant %23, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %25 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots12, i64 0, i64 0 + store %variant %24, %variant* %25, align 16 + store i64 4, i64* %taddr14, align 8 + %26 = bitcast i64* %taddr14 to i8* + %27 = insertvalue %variant undef, i8* %26, 0 + %28 = insertvalue %variant %27, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %29 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots12, i64 0, i64 1 + store %variant %28, %variant* %29, align 16 + %30 = bitcast [2 x %variant]* %varargslots12 to %variant* + %31 = insertvalue %"variant[]" undef, %variant* %30, 0 + %32 = insertvalue %"variant[]" %31, i64 2, 1 + store %"variant[]" %32, %"variant[]"* %taddr15, align 8 + %33 = bitcast %"variant[]"* %taddr15 to { i8*, i64 }* + %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 0 + %lo16 = load i8*, i8** %34, align 8 + %35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 1 + %hi17 = load i64, i64* %35, align 8 + %36 = call i64 @std_io_printfln(i64* %retparam11, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.54, i32 0, i32 0), i64 8, i8* %lo16, i64 %hi17) + %not_err18 = icmp eq i64 %36, 0 + br i1 %not_err18, label %after_check19, label %voiderr20 -after_check27: ; preds = %voiderr15 - br label %voiderr28 +after_check19: ; preds = %voiderr10 + br label %voiderr20 -voiderr28: ; preds = %after_check27, %voiderr15 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.55, i32 0, i32 0), i64 8 }, %"char[]"* %taddr30, align 8 - %46 = bitcast %"char[]"* %taddr30 to { i8*, i64 }* - %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 0 - %lo31 = load i8*, i8** %47, align 8 - %48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 1 - %hi32 = load i64, i64* %48, align 8 - store i64 2, i64* %taddr35, align 8 - %49 = bitcast i64* %taddr35 to i8* - %50 = insertvalue %variant undef, i8* %49, 0 - %51 = insertvalue %variant %50, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %52 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots34, i64 0, i64 0 - store %variant %51, %variant* %52, align 16 - store i64 2, i64* %taddr36, align 8 - %53 = bitcast i64* %taddr36 to i8* - %54 = insertvalue %variant undef, i8* %53, 0 - %55 = insertvalue %variant %54, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %56 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots34, i64 0, i64 1 - store %variant %55, %variant* %56, align 16 - %57 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg33, i32 0, i32 1 - store i64 2, i64* %57, align 8 - %58 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg33, i32 0, i32 0 - %59 = bitcast [2 x %variant]* %varargslots34 to %variant* - store %variant* %59, %variant** %58, align 8 - %60 = bitcast %"variant[]"* %vararg33 to { i8*, i64 }* - %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0 - %lo37 = load i8*, i8** %61, align 8 - %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1 - %hi38 = load i64, i64* %62, align 8 - %63 = call i64 @std_io_printfln(i64* %retparam29, i8* %lo31, i64 %hi32, i8* %lo37, i64 %hi38) - %not_err39 = icmp eq i64 %63, 0 - br i1 %not_err39, label %after_check40, label %voiderr41 +voiderr20: ; preds = %after_check19, %voiderr10 + store i64 2, i64* %taddr23, align 8 + %37 = bitcast i64* %taddr23 to i8* + %38 = insertvalue %variant undef, i8* %37, 0 + %39 = insertvalue %variant %38, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %40 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots22, i64 0, i64 0 + store %variant %39, %variant* %40, align 16 + store i64 2, i64* %taddr24, align 8 + %41 = bitcast i64* %taddr24 to i8* + %42 = insertvalue %variant undef, i8* %41, 0 + %43 = insertvalue %variant %42, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %44 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots22, i64 0, i64 1 + store %variant %43, %variant* %44, align 16 + %45 = bitcast [2 x %variant]* %varargslots22 to %variant* + %46 = insertvalue %"variant[]" undef, %variant* %45, 0 + %47 = insertvalue %"variant[]" %46, i64 2, 1 + store %"variant[]" %47, %"variant[]"* %taddr25, align 8 + %48 = bitcast %"variant[]"* %taddr25 to { i8*, i64 }* + %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 0 + %lo26 = load i8*, i8** %49, align 8 + %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 1 + %hi27 = load i64, i64* %50, align 8 + %51 = call i64 @std_io_printfln(i64* %retparam21, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.55, i32 0, i32 0), i64 8, i8* %lo26, i64 %hi27) + %not_err28 = icmp eq i64 %51, 0 + br i1 %not_err28, label %after_check29, label %voiderr30 -after_check40: ; preds = %voiderr28 - br label %voiderr41 +after_check29: ; preds = %voiderr20 + br label %voiderr30 -voiderr41: ; preds = %after_check40, %voiderr28 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.56, i32 0, i32 0), i64 8 }, %"char[]"* %taddr43, align 8 - %64 = bitcast %"char[]"* %taddr43 to { i8*, i64 }* - %65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 0 - %lo44 = load i8*, i8** %65, align 8 - %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 1 - %hi45 = load i64, i64* %66, align 8 - store i64 4, i64* %taddr48, align 8 - %67 = bitcast i64* %taddr48 to i8* +voiderr30: ; preds = %after_check29, %voiderr20 + store i64 4, i64* %taddr33, align 8 + %52 = bitcast i64* %taddr33 to i8* + %53 = insertvalue %variant undef, i8* %52, 0 + %54 = insertvalue %variant %53, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %55 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots32, i64 0, i64 0 + store %variant %54, %variant* %55, align 16 + store i64 4, i64* %taddr34, align 8 + %56 = bitcast i64* %taddr34 to i8* + %57 = insertvalue %variant undef, i8* %56, 0 + %58 = insertvalue %variant %57, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %59 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots32, i64 0, i64 1 + store %variant %58, %variant* %59, align 16 + %60 = bitcast [2 x %variant]* %varargslots32 to %variant* + %61 = insertvalue %"variant[]" undef, %variant* %60, 0 + %62 = insertvalue %"variant[]" %61, i64 2, 1 + store %"variant[]" %62, %"variant[]"* %taddr35, align 8 + %63 = bitcast %"variant[]"* %taddr35 to { i8*, i64 }* + %64 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %63, i32 0, i32 0 + %lo36 = load i8*, i8** %64, align 8 + %65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %63, i32 0, i32 1 + %hi37 = load i64, i64* %65, align 8 + %66 = call i64 @std_io_printfln(i64* %retparam31, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.56, i32 0, i32 0), i64 8, i8* %lo36, i64 %hi37) + %not_err38 = icmp eq i64 %66, 0 + br i1 %not_err38, label %after_check39, label %voiderr40 + +after_check39: ; preds = %voiderr30 + br label %voiderr40 + +voiderr40: ; preds = %after_check39, %voiderr30 + store i64 4, i64* %taddr43, align 8 + %67 = bitcast i64* %taddr43 to i8* %68 = insertvalue %variant undef, i8* %67, 0 %69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %70 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots47, i64 0, i64 0 + %70 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots42, i64 0, i64 0 store %variant %69, %variant* %70, align 16 - store i64 4, i64* %taddr49, align 8 - %71 = bitcast i64* %taddr49 to i8* + store i64 4, i64* %taddr44, align 8 + %71 = bitcast i64* %taddr44 to i8* %72 = insertvalue %variant undef, i8* %71, 0 %73 = insertvalue %variant %72, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %74 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots47, i64 0, i64 1 + %74 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots42, i64 0, i64 1 store %variant %73, %variant* %74, align 16 - %75 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg46, i32 0, i32 1 - store i64 2, i64* %75, align 8 - %76 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg46, i32 0, i32 0 - %77 = bitcast [2 x %variant]* %varargslots47 to %variant* - store %variant* %77, %variant** %76, align 8 - %78 = bitcast %"variant[]"* %vararg46 to { i8*, i64 }* + %75 = bitcast [2 x %variant]* %varargslots42 to %variant* + %76 = insertvalue %"variant[]" undef, %variant* %75, 0 + %77 = insertvalue %"variant[]" %76, i64 2, 1 + store %"variant[]" %77, %"variant[]"* %taddr45, align 8 + %78 = bitcast %"variant[]"* %taddr45 to { i8*, i64 }* %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0 - %lo50 = load i8*, i8** %79, align 8 + %lo46 = load i8*, i8** %79, align 8 %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1 - %hi51 = load i64, i64* %80, align 8 - %81 = call i64 @std_io_printfln(i64* %retparam42, i8* %lo44, i64 %hi45, i8* %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %81, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 + %hi47 = load i64, i64* %80, align 8 + %81 = call i64 @std_io_printfln(i64* %retparam41, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.57, i32 0, i32 0), i64 8, i8* %lo46, i64 %hi47) + %not_err48 = icmp eq i64 %81, 0 + br i1 %not_err48, label %after_check49, label %voiderr50 -after_check53: ; preds = %voiderr41 - br label %voiderr54 +after_check49: ; preds = %voiderr40 + br label %voiderr50 -voiderr54: ; preds = %after_check53, %voiderr41 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.57, i32 0, i32 0), i64 8 }, %"char[]"* %taddr56, align 8 - %82 = bitcast %"char[]"* %taddr56 to { i8*, i64 }* - %83 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %82, i32 0, i32 0 - %lo57 = load i8*, i8** %83, align 8 - %84 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %82, i32 0, i32 1 - %hi58 = load i64, i64* %84, align 8 - store i64 4, i64* %taddr61, align 8 - %85 = bitcast i64* %taddr61 to i8* - %86 = insertvalue %variant undef, i8* %85, 0 - %87 = insertvalue %variant %86, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %88 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots60, i64 0, i64 0 - store %variant %87, %variant* %88, align 16 - store i64 4, i64* %taddr62, align 8 - %89 = bitcast i64* %taddr62 to i8* - %90 = insertvalue %variant undef, i8* %89, 0 - %91 = insertvalue %variant %90, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %92 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots60, i64 0, i64 1 - store %variant %91, %variant* %92, align 16 - %93 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg59, i32 0, i32 1 - store i64 2, i64* %93, align 8 - %94 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg59, i32 0, i32 0 - %95 = bitcast [2 x %variant]* %varargslots60 to %variant* - store %variant* %95, %variant** %94, align 8 - %96 = bitcast %"variant[]"* %vararg59 to { i8*, i64 }* - %97 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %96, i32 0, i32 0 - %lo63 = load i8*, i8** %97, align 8 - %98 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %96, i32 0, i32 1 - %hi64 = load i64, i64* %98, align 8 - %99 = call i64 @std_io_printfln(i64* %retparam55, i8* %lo57, i64 %hi58, i8* %lo63, i64 %hi64) - %not_err65 = icmp eq i64 %99, 0 - br i1 %not_err65, label %after_check66, label %voiderr67 +voiderr50: ; preds = %after_check49, %voiderr40 + store i64 4, i64* %taddr53, align 8 + %82 = bitcast i64* %taddr53 to i8* + %83 = insertvalue %variant undef, i8* %82, 0 + %84 = insertvalue %variant %83, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %85 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots52, i64 0, i64 0 + store %variant %84, %variant* %85, align 16 + store i64 4, i64* %taddr54, align 8 + %86 = bitcast i64* %taddr54 to i8* + %87 = insertvalue %variant undef, i8* %86, 0 + %88 = insertvalue %variant %87, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %89 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots52, i64 0, i64 1 + store %variant %88, %variant* %89, align 16 + %90 = bitcast [2 x %variant]* %varargslots52 to %variant* + %91 = insertvalue %"variant[]" undef, %variant* %90, 0 + %92 = insertvalue %"variant[]" %91, i64 2, 1 + store %"variant[]" %92, %"variant[]"* %taddr55, align 8 + %93 = bitcast %"variant[]"* %taddr55 to { i8*, i64 }* + %94 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %93, i32 0, i32 0 + %lo56 = load i8*, i8** %94, align 8 + %95 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %93, i32 0, i32 1 + %hi57 = load i64, i64* %95, align 8 + %96 = call i64 @std_io_printfln(i64* %retparam51, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.58, i32 0, i32 0), i64 9, i8* %lo56, i64 %hi57) + %not_err58 = icmp eq i64 %96, 0 + br i1 %not_err58, label %after_check59, label %voiderr60 -after_check66: ; preds = %voiderr54 - br label %voiderr67 +after_check59: ; preds = %voiderr50 + br label %voiderr60 -voiderr67: ; preds = %after_check66, %voiderr54 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.58, i32 0, i32 0), i64 9 }, %"char[]"* %taddr69, align 8 - %100 = bitcast %"char[]"* %taddr69 to { i8*, i64 }* - %101 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %100, i32 0, i32 0 - %lo70 = load i8*, i8** %101, align 8 - %102 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %100, i32 0, i32 1 - %hi71 = load i64, i64* %102, align 8 +voiderr60: ; preds = %after_check59, %voiderr50 + store i64 5, i64* %taddr63, align 8 + %97 = bitcast i64* %taddr63 to i8* + %98 = insertvalue %variant undef, i8* %97, 0 + %99 = insertvalue %variant %98, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %100 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots62, i64 0, i64 0 + store %variant %99, %variant* %100, align 16 + store i64 1, i64* %taddr64, align 8 + %101 = bitcast i64* %taddr64 to i8* + %102 = insertvalue %variant undef, i8* %101, 0 + %103 = insertvalue %variant %102, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %104 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots62, i64 0, i64 1 + store %variant %103, %variant* %104, align 16 + %105 = bitcast [2 x %variant]* %varargslots62 to %variant* + %106 = insertvalue %"variant[]" undef, %variant* %105, 0 + %107 = insertvalue %"variant[]" %106, i64 2, 1 + store %"variant[]" %107, %"variant[]"* %taddr65, align 8 + %108 = bitcast %"variant[]"* %taddr65 to { i8*, i64 }* + %109 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %108, i32 0, i32 0 + %lo66 = load i8*, i8** %109, align 8 + %110 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %108, i32 0, i32 1 + %hi67 = load i64, i64* %110, align 8 + %111 = call i64 @std_io_printfln(i64* %retparam61, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.59, i32 0, i32 0), i64 9, i8* %lo66, i64 %hi67) + %not_err68 = icmp eq i64 %111, 0 + br i1 %not_err68, label %after_check69, label %voiderr70 + +after_check69: ; preds = %voiderr60 + br label %voiderr70 + +voiderr70: ; preds = %after_check69, %voiderr60 + store i64 8, i64* %taddr73, align 8 + %112 = bitcast i64* %taddr73 to i8* + %113 = insertvalue %variant undef, i8* %112, 0 + %114 = insertvalue %variant %113, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %115 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots72, i64 0, i64 0 + store %variant %114, %variant* %115, align 16 store i64 4, i64* %taddr74, align 8 - %103 = bitcast i64* %taddr74 to i8* - %104 = insertvalue %variant undef, i8* %103, 0 - %105 = insertvalue %variant %104, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %106 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots73, i64 0, i64 0 - store %variant %105, %variant* %106, align 16 - store i64 4, i64* %taddr75, align 8 - %107 = bitcast i64* %taddr75 to i8* - %108 = insertvalue %variant undef, i8* %107, 0 - %109 = insertvalue %variant %108, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %110 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots73, i64 0, i64 1 - store %variant %109, %variant* %110, align 16 - %111 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg72, i32 0, i32 1 - store i64 2, i64* %111, align 8 - %112 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg72, i32 0, i32 0 - %113 = bitcast [2 x %variant]* %varargslots73 to %variant* - store %variant* %113, %variant** %112, align 8 - %114 = bitcast %"variant[]"* %vararg72 to { i8*, i64 }* - %115 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %114, i32 0, i32 0 - %lo76 = load i8*, i8** %115, align 8 - %116 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %114, i32 0, i32 1 - %hi77 = load i64, i64* %116, align 8 - %117 = call i64 @std_io_printfln(i64* %retparam68, i8* %lo70, i64 %hi71, i8* %lo76, i64 %hi77) - %not_err78 = icmp eq i64 %117, 0 + %116 = bitcast i64* %taddr74 to i8* + %117 = insertvalue %variant undef, i8* %116, 0 + %118 = insertvalue %variant %117, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %119 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots72, i64 0, i64 1 + store %variant %118, %variant* %119, align 16 + %120 = bitcast [2 x %variant]* %varargslots72 to %variant* + %121 = insertvalue %"variant[]" undef, %variant* %120, 0 + %122 = insertvalue %"variant[]" %121, i64 2, 1 + store %"variant[]" %122, %"variant[]"* %taddr75, align 8 + %123 = bitcast %"variant[]"* %taddr75 to { i8*, i64 }* + %124 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 0 + %lo76 = load i8*, i8** %124, align 8 + %125 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 1 + %hi77 = load i64, i64* %125, align 8 + %126 = call i64 @std_io_printfln(i64* %retparam71, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.60, i32 0, i32 0), i64 10, i8* %lo76, i64 %hi77) + %not_err78 = icmp eq i64 %126, 0 br i1 %not_err78, label %after_check79, label %voiderr80 -after_check79: ; preds = %voiderr67 +after_check79: ; preds = %voiderr70 br label %voiderr80 -voiderr80: ; preds = %after_check79, %voiderr67 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.59, i32 0, i32 0), i64 9 }, %"char[]"* %taddr82, align 8 - %118 = bitcast %"char[]"* %taddr82 to { i8*, i64 }* - %119 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %118, i32 0, i32 0 - %lo83 = load i8*, i8** %119, align 8 - %120 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %118, i32 0, i32 1 - %hi84 = load i64, i64* %120, align 8 - store i64 5, i64* %taddr87, align 8 - %121 = bitcast i64* %taddr87 to i8* - %122 = insertvalue %variant undef, i8* %121, 0 - %123 = insertvalue %variant %122, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %124 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots86, i64 0, i64 0 - store %variant %123, %variant* %124, align 16 - store i64 1, i64* %taddr88, align 8 - %125 = bitcast i64* %taddr88 to i8* - %126 = insertvalue %variant undef, i8* %125, 0 - %127 = insertvalue %variant %126, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %128 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots86, i64 0, i64 1 - store %variant %127, %variant* %128, align 16 - %129 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg85, i32 0, i32 1 - store i64 2, i64* %129, align 8 - %130 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg85, i32 0, i32 0 - %131 = bitcast [2 x %variant]* %varargslots86 to %variant* - store %variant* %131, %variant** %130, align 8 - %132 = bitcast %"variant[]"* %vararg85 to { i8*, i64 }* - %133 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %132, i32 0, i32 0 - %lo89 = load i8*, i8** %133, align 8 - %134 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %132, i32 0, i32 1 - %hi90 = load i64, i64* %134, align 8 - %135 = call i64 @std_io_printfln(i64* %retparam81, i8* %lo83, i64 %hi84, i8* %lo89, i64 %hi90) - %not_err91 = icmp eq i64 %135, 0 - br i1 %not_err91, label %after_check92, label %voiderr93 +voiderr80: ; preds = %after_check79, %voiderr70 + store i64 4, i64* %taddr83, align 8 + %127 = bitcast i64* %taddr83 to i8* + %128 = insertvalue %variant undef, i8* %127, 0 + %129 = insertvalue %variant %128, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %130 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots82, i64 0, i64 0 + store %variant %129, %variant* %130, align 16 + %131 = bitcast [1 x %variant]* %varargslots82 to %variant* + %132 = insertvalue %"variant[]" undef, %variant* %131, 0 + %133 = insertvalue %"variant[]" %132, i64 1, 1 + store %"variant[]" %133, %"variant[]"* %taddr84, align 8 + %134 = bitcast %"variant[]"* %taddr84 to { i8*, i64 }* + %135 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %134, i32 0, i32 0 + %lo85 = load i8*, i8** %135, align 8 + %136 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %134, i32 0, i32 1 + %hi86 = load i64, i64* %136, align 8 + %137 = call i64 @std_io_printfln(i64* %retparam81, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.61, i32 0, i32 0), i64 7, i8* %lo85, i64 %hi86) + %not_err87 = icmp eq i64 %137, 0 + br i1 %not_err87, label %after_check88, label %voiderr89 -after_check92: ; preds = %voiderr80 - br label %voiderr93 +after_check88: ; preds = %voiderr80 + br label %voiderr89 -voiderr93: ; preds = %after_check92, %voiderr80 - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.60, i32 0, i32 0), i64 10 }, %"char[]"* %taddr95, align 8 - %136 = bitcast %"char[]"* %taddr95 to { i8*, i64 }* - %137 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %136, i32 0, i32 0 - %lo96 = load i8*, i8** %137, align 8 - %138 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %136, i32 0, i32 1 - %hi97 = load i64, i64* %138, align 8 - store i64 8, i64* %taddr100, align 8 - %139 = bitcast i64* %taddr100 to i8* - %140 = insertvalue %variant undef, i8* %139, 0 - %141 = insertvalue %variant %140, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %142 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots99, i64 0, i64 0 - store %variant %141, %variant* %142, align 16 - store i64 4, i64* %taddr101, align 8 - %143 = bitcast i64* %taddr101 to i8* - %144 = insertvalue %variant undef, i8* %143, 0 - %145 = insertvalue %variant %144, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %146 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots99, i64 0, i64 1 - store %variant %145, %variant* %146, align 16 - %147 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 1 - store i64 2, i64* %147, align 8 - %148 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 0 - %149 = bitcast [2 x %variant]* %varargslots99 to %variant* - store %variant* %149, %variant** %148, align 8 - %150 = bitcast %"variant[]"* %vararg98 to { i8*, i64 }* - %151 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %150, i32 0, i32 0 - %lo102 = load i8*, i8** %151, align 8 - %152 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %150, i32 0, i32 1 - %hi103 = load i64, i64* %152, align 8 - %153 = call i64 @std_io_printfln(i64* %retparam94, i8* %lo96, i64 %hi97, i8* %lo102, i64 %hi103) - %not_err104 = icmp eq i64 %153, 0 - br i1 %not_err104, label %after_check105, label %voiderr106 +voiderr89: ; preds = %after_check88, %voiderr80 + store i64 8, i64* %taddr92, align 8 + %138 = bitcast i64* %taddr92 to i8* + %139 = insertvalue %variant undef, i8* %138, 0 + %140 = insertvalue %variant %139, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %141 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots91, i64 0, i64 0 + store %variant %140, %variant* %141, align 16 + store i64 4, i64* %taddr93, align 8 + %142 = bitcast i64* %taddr93 to i8* + %143 = insertvalue %variant undef, i8* %142, 0 + %144 = insertvalue %variant %143, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %145 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots91, i64 0, i64 1 + store %variant %144, %variant* %145, align 16 + %146 = bitcast [2 x %variant]* %varargslots91 to %variant* + %147 = insertvalue %"variant[]" undef, %variant* %146, 0 + %148 = insertvalue %"variant[]" %147, i64 2, 1 + store %"variant[]" %148, %"variant[]"* %taddr94, align 8 + %149 = bitcast %"variant[]"* %taddr94 to { i8*, i64 }* + %150 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %149, i32 0, i32 0 + %lo95 = load i8*, i8** %150, align 8 + %151 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %149, i32 0, i32 1 + %hi96 = load i64, i64* %151, align 8 + %152 = call i64 @std_io_printfln(i64* %retparam90, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.62, i32 0, i32 0), i64 10, i8* %lo95, i64 %hi96) + %not_err97 = icmp eq i64 %152, 0 + br i1 %not_err97, label %after_check98, label %voiderr99 -after_check105: ; preds = %voiderr93 - br label %voiderr106 +after_check98: ; preds = %voiderr89 + br label %voiderr99 -voiderr106: ; preds = %after_check105, %voiderr93 - store %"char[]" { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.61, i32 0, i32 0), i64 7 }, %"char[]"* %taddr108, align 8 - %154 = bitcast %"char[]"* %taddr108 to { i8*, i64 }* - %155 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %154, i32 0, i32 0 - %lo109 = load i8*, i8** %155, align 8 - %156 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %154, i32 0, i32 1 - %hi110 = load i64, i64* %156, align 8 - store i64 4, i64* %taddr113, align 8 - %157 = bitcast i64* %taddr113 to i8* - %158 = insertvalue %variant undef, i8* %157, 0 - %159 = insertvalue %variant %158, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %160 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots112, i64 0, i64 0 - store %variant %159, %variant* %160, align 16 - %161 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg111, i32 0, i32 1 - store i64 1, i64* %161, align 8 - %162 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg111, i32 0, i32 0 - %163 = bitcast [1 x %variant]* %varargslots112 to %variant* - store %variant* %163, %variant** %162, align 8 - %164 = bitcast %"variant[]"* %vararg111 to { i8*, i64 }* - %165 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %164, i32 0, i32 0 - %lo114 = load i8*, i8** %165, align 8 - %166 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %164, i32 0, i32 1 - %hi115 = load i64, i64* %166, align 8 - %167 = call i64 @std_io_printfln(i64* %retparam107, i8* %lo109, i64 %hi110, i8* %lo114, i64 %hi115) - %not_err116 = icmp eq i64 %167, 0 - br i1 %not_err116, label %after_check117, label %voiderr118 - -after_check117: ; preds = %voiderr106 - br label %voiderr118 - -voiderr118: ; preds = %after_check117, %voiderr106 - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.62, i32 0, i32 0), i64 10 }, %"char[]"* %taddr120, align 8 - %168 = bitcast %"char[]"* %taddr120 to { i8*, i64 }* - %169 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %168, i32 0, i32 0 - %lo121 = load i8*, i8** %169, align 8 - %170 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %168, i32 0, i32 1 - %hi122 = load i64, i64* %170, align 8 - store i64 8, i64* %taddr125, align 8 - %171 = bitcast i64* %taddr125 to i8* - %172 = insertvalue %variant undef, i8* %171, 0 - %173 = insertvalue %variant %172, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %174 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots124, i64 0, i64 0 - store %variant %173, %variant* %174, align 16 - store i64 4, i64* %taddr126, align 8 - %175 = bitcast i64* %taddr126 to i8* - %176 = insertvalue %variant undef, i8* %175, 0 - %177 = insertvalue %variant %176, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %178 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots124, i64 0, i64 1 - store %variant %177, %variant* %178, align 16 - %179 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg123, i32 0, i32 1 - store i64 2, i64* %179, align 8 - %180 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg123, i32 0, i32 0 - %181 = bitcast [2 x %variant]* %varargslots124 to %variant* - store %variant* %181, %variant** %180, align 8 - %182 = bitcast %"variant[]"* %vararg123 to { i8*, i64 }* - %183 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %182, i32 0, i32 0 - %lo127 = load i8*, i8** %183, align 8 - %184 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %182, i32 0, i32 1 - %hi128 = load i64, i64* %184, align 8 - %185 = call i64 @std_io_printfln(i64* %retparam119, i8* %lo121, i64 %hi122, i8* %lo127, i64 %hi128) - %not_err129 = icmp eq i64 %185, 0 - br i1 %not_err129, label %after_check130, label %voiderr131 - -after_check130: ; preds = %voiderr118 - br label %voiderr131 - -voiderr131: ; preds = %after_check130, %voiderr118 +voiderr99: ; preds = %after_check98, %voiderr89 call void @test_test(i32 10) ret void } diff --git a/test/test_suite/compile_time/untyped_conversions.c3t b/test/test_suite/compile_time/untyped_conversions.c3t index 5d1ecfe36..2533befc8 100644 --- a/test/test_suite/compile_time/untyped_conversions.c3t +++ b/test/test_suite/compile_time/untyped_conversions.c3t @@ -30,17 +30,16 @@ entry: %y = alloca [1 x [2 x i32]], align 4 %y2 = alloca [1 x [2 x double]], align 16 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [4 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 %literal = alloca [2 x i32], align 4 - %literal3 = alloca [2 x i32], align 4 - %taddr4 = alloca %"int[]", align 8 - %taddr7 = alloca <2 x i32>, align 8 - %literal8 = alloca [2 x i32], align 4 - %literal9 = alloca [2 x i32], align 4 - %taddr10 = alloca %"int[]", align 8 - %taddr13 = alloca <2 x i32>, align 8 + %literal1 = alloca [2 x i32], align 4 + %taddr2 = alloca %"int[]", align 8 + %taddr5 = alloca <2 x i32>, align 8 + %literal6 = alloca [2 x i32], align 4 + %literal7 = alloca [2 x i32], align 4 + %taddr8 = alloca %"int[]", align 8 + %taddr11 = alloca <2 x i32>, align 8 %0 = bitcast [1 x %Foo]* %abc to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([1 x %Foo]* @.__const to i8*), i32 8, i1 false) %1 = bitcast %Foo* %def to i8* @@ -49,97 +48,90 @@ entry: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %2, i8* align 4 bitcast ([1 x [2 x i32]]* @.__const.2 to i8*), i32 8, i1 false) %3 = bitcast [1 x [2 x double]]* %y2 to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %3, i8* align 16 bitcast ([1 x [2 x double]]* @.__const.3 to i8*), i32 16, i1 false) - store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i32 0, i32 0), i64 14 }, %"char[]"* %taddr, align 8 - %4 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %5 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 0 - %lo = load i8*, i8** %5, align 8 - %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 1 - %hi = load i64, i64* %6, align 8 - %7 = bitcast [1 x [2 x i32]]* %y to i8* - %8 = insertvalue %variant undef, i8* %7, 0 - %9 = insertvalue %variant %8, i64 ptrtoint (%.introspect* @"ct$a1$a2$int" to i64), 1 - %10 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 0 - store %variant %9, %variant* %10, align 16 - %11 = bitcast [1 x [2 x double]]* %y2 to i8* - %12 = insertvalue %variant undef, i8* %11, 0 - %13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$a1$a2$double" to i64), 1 - %14 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 1 - store %variant %13, %variant* %14, align 16 - %15 = getelementptr inbounds %Foo, %Foo* %def, i32 0, i32 0 - %16 = bitcast i32* %15 to i8* - %17 = insertvalue %variant undef, i8* %16, 0 - %18 = insertvalue %variant %17, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %19 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 2 - store %variant %18, %variant* %19, align 16 - %20 = getelementptr inbounds %Foo, %Foo* %def, i32 0, i32 1 - %21 = bitcast i32* %20 to i8* - %22 = insertvalue %variant undef, i8* %21, 0 - %23 = insertvalue %variant %22, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %24 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 3 - store %variant %23, %variant* %24, align 16 - %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 4, i64* %25, align 8 - %26 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %27 = bitcast [4 x %variant]* %varargslots to %variant* - store %variant* %27, %variant** %26, align 8 - %28 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 0 - %lo1 = load i8*, i8** %29, align 8 - %30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 1 - %hi2 = load i64, i64* %30, align 8 - %31 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) - %not_err = icmp eq i64 %31, 0 + %4 = bitcast [1 x [2 x i32]]* %y to i8* + %5 = insertvalue %variant undef, i8* %4, 0 + %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$a1$a2$int" to i64), 1 + %7 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 0 + store %variant %6, %variant* %7, align 16 + %8 = bitcast [1 x [2 x double]]* %y2 to i8* + %9 = insertvalue %variant undef, i8* %8, 0 + %10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$a1$a2$double" to i64), 1 + %11 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 1 + store %variant %10, %variant* %11, align 16 + %12 = getelementptr inbounds %Foo, %Foo* %def, i32 0, i32 0 + %13 = bitcast i32* %12 to i8* + %14 = insertvalue %variant undef, i8* %13, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %16 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 2 + store %variant %15, %variant* %16, align 16 + %17 = getelementptr inbounds %Foo, %Foo* %def, i32 0, i32 1 + %18 = bitcast i32* %17 to i8* + %19 = insertvalue %variant undef, i8* %18, 0 + %20 = insertvalue %variant %19, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %21 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 3 + store %variant %20, %variant* %21, align 16 + %22 = bitcast [4 x %variant]* %varargslots to %variant* + %23 = insertvalue %"variant[]" undef, %variant* %22, 0 + %24 = insertvalue %"variant[]" %23, i64 4, 1 + store %"variant[]" %24, %"variant[]"* %taddr, align 8 + %25 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 0 + %lo = load i8*, i8** %26, align 8 + %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 1 + %hi = load i64, i64* %27, align 8 + %28 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i32 0, i32 0), i64 14, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %28, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %32 = getelementptr inbounds [2 x i32], [2 x i32]* %literal, i64 0, i64 0 - store i32 1, i32* %32, align 4 - %33 = getelementptr inbounds [2 x i32], [2 x i32]* %literal, i64 0, i64 1 - store i32 2, i32* %33, align 4 - %34 = bitcast [2 x i32]* %literal to i64* - %35 = load i64, i64* %34, align 4 - %36 = getelementptr inbounds [2 x i32], [2 x i32]* %literal3, i64 0, i64 0 - store i32 3, i32* %36, align 4 - %37 = getelementptr inbounds [2 x i32], [2 x i32]* %literal3, i64 0, i64 1 - store i32 4, i32* %37, align 4 - %38 = bitcast [2 x i32]* %literal3 to i32* - %39 = insertvalue %"int[]" undef, i32* %38, 0 - %40 = insertvalue %"int[]" %39, i64 2, 1 - store %"int[]" %40, %"int[]"* %taddr4, align 8 - %41 = bitcast %"int[]"* %taddr4 to { i8*, i64 }* - %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 - %lo5 = load i8*, i8** %42, align 8 - %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 - %hi6 = load i64, i64* %43, align 8 - store <2 x i32> , <2 x i32>* %taddr7, align 8 - %44 = bitcast <2 x i32>* %taddr7 to double* - %45 = load double, double* %44, align 8 - call void @test_test(i64 %35, i8* %lo5, i64 %hi6, double %45) - %46 = getelementptr inbounds [2 x i32], [2 x i32]* %literal8, i64 0, i64 0 - store i32 2, i32* %46, align 4 - %47 = getelementptr inbounds [2 x i32], [2 x i32]* %literal8, i64 0, i64 1 - store i32 7, i32* %47, align 4 - %48 = bitcast [2 x i32]* %literal8 to i64* - %49 = load i64, i64* %48, align 4 - %50 = getelementptr inbounds [2 x i32], [2 x i32]* %literal9, i64 0, i64 0 - store i32 2, i32* %50, align 4 - %51 = getelementptr inbounds [2 x i32], [2 x i32]* %literal9, i64 0, i64 1 - store i32 7, i32* %51, align 4 - %52 = bitcast [2 x i32]* %literal9 to i32* - %53 = insertvalue %"int[]" undef, i32* %52, 0 - %54 = insertvalue %"int[]" %53, i64 2, 1 - store %"int[]" %54, %"int[]"* %taddr10, align 8 - %55 = bitcast %"int[]"* %taddr10 to { i8*, i64 }* - %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 0 - %lo11 = load i8*, i8** %56, align 8 - %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 1 - %hi12 = load i64, i64* %57, align 8 - store <2 x i32> , <2 x i32>* %taddr13, align 8 - %58 = bitcast <2 x i32>* %taddr13 to double* - %59 = load double, double* %58, align 8 - call void @test_test(i64 %49, i8* %lo11, i64 %hi12, double %59) + %29 = getelementptr inbounds [2 x i32], [2 x i32]* %literal, i64 0, i64 0 + store i32 1, i32* %29, align 4 + %30 = getelementptr inbounds [2 x i32], [2 x i32]* %literal, i64 0, i64 1 + store i32 2, i32* %30, align 4 + %31 = bitcast [2 x i32]* %literal to i64* + %32 = load i64, i64* %31, align 4 + %33 = getelementptr inbounds [2 x i32], [2 x i32]* %literal1, i64 0, i64 0 + store i32 3, i32* %33, align 4 + %34 = getelementptr inbounds [2 x i32], [2 x i32]* %literal1, i64 0, i64 1 + store i32 4, i32* %34, align 4 + %35 = bitcast [2 x i32]* %literal1 to i32* + %36 = insertvalue %"int[]" undef, i32* %35, 0 + %37 = insertvalue %"int[]" %36, i64 2, 1 + store %"int[]" %37, %"int[]"* %taddr2, align 8 + %38 = bitcast %"int[]"* %taddr2 to { i8*, i64 }* + %39 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %38, i32 0, i32 0 + %lo3 = load i8*, i8** %39, align 8 + %40 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %38, i32 0, i32 1 + %hi4 = load i64, i64* %40, align 8 + store <2 x i32> , <2 x i32>* %taddr5, align 8 + %41 = bitcast <2 x i32>* %taddr5 to double* + %42 = load double, double* %41, align 8 + call void @test_test(i64 %32, i8* %lo3, i64 %hi4, double %42) + %43 = getelementptr inbounds [2 x i32], [2 x i32]* %literal6, i64 0, i64 0 + store i32 2, i32* %43, align 4 + %44 = getelementptr inbounds [2 x i32], [2 x i32]* %literal6, i64 0, i64 1 + store i32 7, i32* %44, align 4 + %45 = bitcast [2 x i32]* %literal6 to i64* + %46 = load i64, i64* %45, align 4 + %47 = getelementptr inbounds [2 x i32], [2 x i32]* %literal7, i64 0, i64 0 + store i32 2, i32* %47, align 4 + %48 = getelementptr inbounds [2 x i32], [2 x i32]* %literal7, i64 0, i64 1 + store i32 7, i32* %48, align 4 + %49 = bitcast [2 x i32]* %literal7 to i32* + %50 = insertvalue %"int[]" undef, i32* %49, 0 + %51 = insertvalue %"int[]" %50, i64 2, 1 + store %"int[]" %51, %"int[]"* %taddr8, align 8 + %52 = bitcast %"int[]"* %taddr8 to { i8*, i64 }* + %53 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %52, i32 0, i32 0 + %lo9 = load i8*, i8** %53, align 8 + %54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %52, i32 0, i32 1 + %hi10 = load i64, i64* %54, align 8 + store <2 x i32> , <2 x i32>* %taddr11, align 8 + %55 = bitcast <2 x i32>* %taddr11 to double* + %56 = load double, double* %55, align 8 + call void @test_test(i64 %46, i8* %lo9, i64 %hi10, double %56) ret void } \ No newline at end of file diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t index 66867c687..2dd74c493 100644 --- a/test/test_suite/errors/error_regression_2.c3t +++ b/test/test_suite/errors/error_regression_2.c3t @@ -267,319 +267,287 @@ loop.exit: ; preds = %loop.cond define i64 @test_readDoc(%Doc* %0, i8* %1, i64 %2) #0 { entry: %url = alloca %"char[]", align 8 - %taddr = alloca %"char[]", align 8 - %taddr5 = alloca %"char[]", align 8 %reterr = alloca i64, align 8 %literal = alloca %Doc, align 8 - %taddr12 = alloca %"char[]", align 8 - %reterr16 = alloca i64, align 8 - %literal17 = alloca %Doc, align 8 + %reterr8 = alloca i64, align 8 + %literal9 = alloca %Doc, align 8 %error_var = alloca i64, align 8 %value = alloca %Head, align 8 - %literal18 = alloca %Head, align 8 + %literal10 = alloca %Head, align 8 %temp = alloca %Head*, align 8 - %taddr24 = alloca %"char[]", align 8 - %reterr28 = alloca i64, align 8 - %literal29 = alloca %Doc, align 8 - %error_var30 = alloca i64, align 8 - %value31 = alloca %Head, align 8 - %literal32 = alloca %Head, align 8 - %error_var33 = alloca i64, align 8 - %value34 = alloca %"char[]", align 8 - %temp35 = alloca %"char[]"*, align 8 - %temp42 = alloca %Head*, align 8 + %reterr17 = alloca i64, align 8 + %literal18 = alloca %Doc, align 8 + %error_var19 = alloca i64, align 8 + %value20 = alloca %Head, align 8 + %literal21 = alloca %Head, align 8 + %error_var22 = alloca i64, align 8 + %value23 = alloca %"char[]", align 8 + %temp24 = alloca %"char[]"*, align 8 + %temp31 = alloca %Head*, align 8 %len = alloca i32, align 4 %str = alloca i8*, align 8 - %reterr56 = alloca i64, align 8 - %literal57 = alloca %Doc, align 8 - %error_var58 = alloca i64, align 8 - %value59 = alloca %Head, align 8 - %literal60 = alloca %Head, align 8 - %error_var61 = alloca i64, align 8 - %value62 = alloca %"char[]", align 8 - %temp63 = alloca %"char[]"*, align 8 - %temp70 = alloca %Head*, align 8 + %reterr45 = alloca i64, align 8 + %literal46 = alloca %Doc, align 8 + %error_var47 = alloca i64, align 8 + %value48 = alloca %Head, align 8 + %literal49 = alloca %Head, align 8 + %error_var50 = alloca i64, align 8 + %value51 = alloca %"char[]", align 8 + %temp52 = alloca %"char[]"*, align 8 + %temp59 = alloca %Head*, align 8 %pair = bitcast %"char[]"* %url to { i8*, i64 }* %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 0 store i8* %1, i8** %3, align 8 %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 1 store i64 %2, i64* %4, align 8 - %5 = bitcast %"char[]"* %url to { i8*, i64 }* - %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 0 - %lo = load i8*, i8** %6, align 8 - %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 1 - %hi = load i64, i64* %7, align 8 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0), i64 4 }, %"char[]"* %taddr, align 8 - %8 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 - %lo1 = load i8*, i8** %9, align 8 - %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 - %hi2 = load i64, i64* %10, align 8 - %11 = call i8 @test_contains(i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) - %12 = trunc i8 %11 to i1 - br i1 %12, label %if.then, label %if.exit + %5 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %lo = load i8*, i8** %5, align 8 + %6 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %hi = load i64, i64* %6, align 8 + %7 = call i8 @test_contains(i8* %lo, i64 %hi, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0), i64 4) + %8 = trunc i8 %7 to i1 + br i1 %8, label %if.then, label %if.exit if.then: ; preds = %entry ret i64 ptrtoint (%.fault* @"test_ReadError$BAD_READ" to i64) if.exit: ; preds = %entry - %13 = bitcast %"char[]"* %url to { i8*, i64 }* - %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 0 - %lo3 = load i8*, i8** %14, align 8 - %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 1 - %hi4 = load i64, i64* %15, align 8 - store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i32 0, i32 0), i64 12 }, %"char[]"* %taddr5, align 8 - %16 = bitcast %"char[]"* %taddr5 to { i8*, i64 }* - %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 0 - %lo6 = load i8*, i8** %17, align 8 - %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 1 - %hi7 = load i64, i64* %18, align 8 - %19 = call i8 @test_contains(i8* %lo3, i64 %hi4, i8* %lo6, i64 %hi7) - %20 = trunc i8 %19 to i1 - br i1 %20, label %if.then8, label %if.exit9 + %9 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %lo1 = load i8*, i8** %9, align 8 + %10 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %hi2 = load i64, i64* %10, align 8 + %11 = call i8 @test_contains(i8* %lo1, i64 %hi2, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i32 0, i32 0), i64 12) + %12 = trunc i8 %11 to i1 + br i1 %12, label %if.then3, label %if.exit4 -if.then8: ; preds = %if.exit - %21 = getelementptr inbounds %Doc, %Doc* %literal, i32 0, i32 0 - store %Head* null, %Head** %21, align 8 - %22 = bitcast %Doc* %0 to i8* - %23 = bitcast %Doc* %literal to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %22, i8* align 8 %23, i32 8, i1 false) +if.then3: ; preds = %if.exit + %13 = getelementptr inbounds %Doc, %Doc* %literal, i32 0, i32 0 + store %Head* null, %Head** %13, align 8 + %14 = bitcast %Doc* %0 to i8* + %15 = bitcast %Doc* %literal to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %14, i8* align 8 %15, i32 8, i1 false) ret i64 0 -if.exit9: ; preds = %if.exit - %24 = bitcast %"char[]"* %url to { i8*, i64 }* - %25 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 0 - %lo10 = load i8*, i8** %25, align 8 - %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 1 - %hi11 = load i64, i64* %26, align 8 - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i32 0, i32 0), i64 13 }, %"char[]"* %taddr12, align 8 - %27 = bitcast %"char[]"* %taddr12 to { i8*, i64 }* - %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 - %lo13 = load i8*, i8** %28, align 8 - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 - %hi14 = load i64, i64* %29, align 8 - %30 = call i8 @test_contains(i8* %lo10, i64 %hi11, i8* %lo13, i64 %hi14) - %31 = trunc i8 %30 to i1 - br i1 %31, label %if.then15, label %if.exit21 +if.exit4: ; preds = %if.exit + %16 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %lo5 = load i8*, i8** %16, align 8 + %17 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %hi6 = load i64, i64* %17, align 8 + %18 = call i8 @test_contains(i8* %lo5, i64 %hi6, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i32 0, i32 0), i64 13) + %19 = trunc i8 %18 to i1 + br i1 %19, label %if.then7, label %if.exit13 -if.then15: ; preds = %if.exit9 - %32 = getelementptr inbounds %Doc, %Doc* %literal17, i32 0, i32 0 - %33 = getelementptr inbounds %Head, %Head* %literal18, i32 0, i32 0 - store %"char[]"* null, %"char[]"** %33, align 8 - %34 = bitcast %Head* %value to i8* - %35 = bitcast %Head* %literal18 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %34, i8* align 8 %35, i32 8, i1 false) - %36 = call i8* @std_core_mem_malloc(i64 8) #2 - %ptrptr = bitcast i8* %36 to %Head* +if.then7: ; preds = %if.exit4 + %20 = getelementptr inbounds %Doc, %Doc* %literal9, i32 0, i32 0 + %21 = getelementptr inbounds %Head, %Head* %literal10, i32 0, i32 0 + store %"char[]"* null, %"char[]"** %21, align 8 + %22 = bitcast %Head* %value to i8* + %23 = bitcast %Head* %literal10 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %22, i8* align 8 %23, i32 8, i1 false) + %24 = call i8* @std_core_mem_malloc(i64 8) #2 + %ptrptr = bitcast i8* %24 to %Head* store %Head* %ptrptr, %Head** %temp, align 8 - %37 = load %Head*, %Head** %temp, align 8 - %not = icmp eq %Head* %37, null - br i1 %not, label %if.then19, label %if.exit20 + %25 = load %Head*, %Head** %temp, align 8 + %not = icmp eq %Head* %25, null + br i1 %not, label %if.then11, label %if.exit12 -if.then19: ; preds = %if.then15 +if.then11: ; preds = %if.then7 store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var, align 8 br label %guard_block -if.exit20: ; preds = %if.then15 - %38 = load %Head*, %Head** %temp, align 8 - %39 = bitcast %Head* %38 to i8* - %40 = bitcast %Head* %value to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %39, i8* align 8 %40, i32 8, i1 false) +if.exit12: ; preds = %if.then7 + %26 = load %Head*, %Head** %temp, align 8 + %27 = bitcast %Head* %26 to i8* + %28 = bitcast %Head* %value to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %27, i8* align 8 %28, i32 8, i1 false) br label %noerr_block -guard_block: ; preds = %if.then19 - %41 = load i64, i64* %error_var, align 8 - ret i64 %41 +guard_block: ; preds = %if.then11 + %29 = load i64, i64* %error_var, align 8 + ret i64 %29 -noerr_block: ; preds = %if.exit20 - %42 = load %Head*, %Head** %temp, align 8 - store %Head* %42, %Head** %32, align 8 - %43 = bitcast %Doc* %0 to i8* - %44 = bitcast %Doc* %literal17 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %43, i8* align 8 %44, i32 8, i1 false) +noerr_block: ; preds = %if.exit12 + %30 = load %Head*, %Head** %temp, align 8 + store %Head* %30, %Head** %20, align 8 + %31 = bitcast %Doc* %0 to i8* + %32 = bitcast %Doc* %literal9 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %31, i8* align 8 %32, i32 8, i1 false) ret i64 0 -if.exit21: ; preds = %if.exit9 - %45 = bitcast %"char[]"* %url to { i8*, i64 }* - %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 - %lo22 = load i8*, i8** %46, align 8 - %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 - %hi23 = load i64, i64* %47, align 8 - store %"char[]" { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i32 0, i32 0), i64 11 }, %"char[]"* %taddr24, align 8 - %48 = bitcast %"char[]"* %taddr24 to { i8*, i64 }* - %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 0 - %lo25 = load i8*, i8** %49, align 8 - %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 1 - %hi26 = load i64, i64* %50, align 8 - %51 = call i8 @test_contains(i8* %lo22, i64 %hi23, i8* %lo25, i64 %hi26) - %52 = trunc i8 %51 to i1 - br i1 %52, label %if.then27, label %if.exit49 +if.exit13: ; preds = %if.exit4 + %33 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %lo14 = load i8*, i8** %33, align 8 + %34 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %hi15 = load i64, i64* %34, align 8 + %35 = call i8 @test_contains(i8* %lo14, i64 %hi15, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i32 0, i32 0), i64 11) + %36 = trunc i8 %35 to i1 + br i1 %36, label %if.then16, label %if.exit38 -if.then27: ; preds = %if.exit21 - %53 = getelementptr inbounds %Doc, %Doc* %literal29, i32 0, i32 0 - %54 = bitcast %Head* %literal32 to %"char[]"** - store %"char[]"* null, %"char[]"** %54, align 8 - %55 = getelementptr inbounds %Head, %Head* %literal32, i32 0, i32 0 - store %"char[]" zeroinitializer, %"char[]"* %value34, align 8 - %56 = call i8* @std_core_mem_malloc(i64 16) #2 - %ptrptr36 = bitcast i8* %56 to %"char[]"* - store %"char[]"* %ptrptr36, %"char[]"** %temp35, align 8 - %57 = load %"char[]"*, %"char[]"** %temp35, align 8 - %not37 = icmp eq %"char[]"* %57, null - br i1 %not37, label %if.then38, label %if.exit39 +if.then16: ; preds = %if.exit13 + %37 = getelementptr inbounds %Doc, %Doc* %literal18, i32 0, i32 0 + %38 = bitcast %Head* %literal21 to %"char[]"** + store %"char[]"* null, %"char[]"** %38, align 8 + %39 = getelementptr inbounds %Head, %Head* %literal21, i32 0, i32 0 + store %"char[]" zeroinitializer, %"char[]"* %value23, align 8 + %40 = call i8* @std_core_mem_malloc(i64 16) #2 + %ptrptr25 = bitcast i8* %40 to %"char[]"* + store %"char[]"* %ptrptr25, %"char[]"** %temp24, align 8 + %41 = load %"char[]"*, %"char[]"** %temp24, align 8 + %not26 = icmp eq %"char[]"* %41, null + br i1 %not26, label %if.then27, label %if.exit28 -if.then38: ; preds = %if.then27 - store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var33, align 8 - br label %guard_block40 +if.then27: ; preds = %if.then16 + store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var22, align 8 + br label %guard_block29 -if.exit39: ; preds = %if.then27 - %58 = load %"char[]"*, %"char[]"** %temp35, align 8 - %59 = bitcast %"char[]"* %58 to i8* - %60 = bitcast %"char[]"* %value34 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %59, i8* align 8 %60, i32 16, i1 false) - br label %noerr_block41 +if.exit28: ; preds = %if.then16 + %42 = load %"char[]"*, %"char[]"** %temp24, align 8 + %43 = bitcast %"char[]"* %42 to i8* + %44 = bitcast %"char[]"* %value23 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %43, i8* align 8 %44, i32 16, i1 false) + br label %noerr_block30 -guard_block40: ; preds = %if.then38 - %61 = load i64, i64* %error_var33, align 8 - ret i64 %61 +guard_block29: ; preds = %if.then27 + %45 = load i64, i64* %error_var22, align 8 + ret i64 %45 -noerr_block41: ; preds = %if.exit39 - %62 = load %"char[]"*, %"char[]"** %temp35, align 8 - store %"char[]"* %62, %"char[]"** %55, align 8 - %63 = bitcast %Head* %value31 to i8* - %64 = bitcast %Head* %literal32 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %63, i8* align 8 %64, i32 8, i1 false) - %65 = call i8* @std_core_mem_malloc(i64 8) #2 - %ptrptr43 = bitcast i8* %65 to %Head* - store %Head* %ptrptr43, %Head** %temp42, align 8 - %66 = load %Head*, %Head** %temp42, align 8 - %not44 = icmp eq %Head* %66, null - br i1 %not44, label %if.then45, label %if.exit46 +noerr_block30: ; preds = %if.exit28 + %46 = load %"char[]"*, %"char[]"** %temp24, align 8 + store %"char[]"* %46, %"char[]"** %39, align 8 + %47 = bitcast %Head* %value20 to i8* + %48 = bitcast %Head* %literal21 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %47, i8* align 8 %48, i32 8, i1 false) + %49 = call i8* @std_core_mem_malloc(i64 8) #2 + %ptrptr32 = bitcast i8* %49 to %Head* + store %Head* %ptrptr32, %Head** %temp31, align 8 + %50 = load %Head*, %Head** %temp31, align 8 + %not33 = icmp eq %Head* %50, null + br i1 %not33, label %if.then34, label %if.exit35 -if.then45: ; preds = %noerr_block41 - store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var30, align 8 - br label %guard_block47 +if.then34: ; preds = %noerr_block30 + store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var19, align 8 + br label %guard_block36 -if.exit46: ; preds = %noerr_block41 - %67 = load %Head*, %Head** %temp42, align 8 - %68 = bitcast %Head* %67 to i8* - %69 = bitcast %Head* %value31 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %68, i8* align 8 %69, i32 8, i1 false) - br label %noerr_block48 +if.exit35: ; preds = %noerr_block30 + %51 = load %Head*, %Head** %temp31, align 8 + %52 = bitcast %Head* %51 to i8* + %53 = bitcast %Head* %value20 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %52, i8* align 8 %53, i32 8, i1 false) + br label %noerr_block37 -guard_block47: ; preds = %if.then45 - %70 = load i64, i64* %error_var30, align 8 - ret i64 %70 +guard_block36: ; preds = %if.then34 + %54 = load i64, i64* %error_var19, align 8 + ret i64 %54 -noerr_block48: ; preds = %if.exit46 - %71 = load %Head*, %Head** %temp42, align 8 - store %Head* %71, %Head** %53, align 8 - %72 = bitcast %Doc* %0 to i8* - %73 = bitcast %Doc* %literal29 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %72, i8* align 8 %73, i32 8, i1 false) +noerr_block37: ; preds = %if.exit35 + %55 = load %Head*, %Head** %temp31, align 8 + store %Head* %55, %Head** %37, align 8 + %56 = bitcast %Doc* %0 to i8* + %57 = bitcast %Doc* %literal18 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %56, i8* align 8 %57, i32 8, i1 false) ret i64 0 -if.exit49: ; preds = %if.exit21 - %74 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 - %75 = load i64, i64* %74, align 8 - %uisitrunc = trunc i64 %75 to i32 - %76 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 - %77 = load i8*, i8** %76, align 8 - %78 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i32 0, i32 0), i32 %uisitrunc, i8* %77) - store i32 %78, i32* %len, align 4 - %79 = load i32, i32* %len, align 4 - %siuiext = sext i32 %79 to i64 +if.exit38: ; preds = %if.exit13 + %58 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %59 = load i64, i64* %58, align 8 + %uisitrunc = trunc i64 %59 to i32 + %60 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %61 = load i8*, i8** %60, align 8 + %62 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i32 0, i32 0), i32 %uisitrunc, i8* %61) + store i32 %62, i32* %len, align 4 + %63 = load i32, i32* %len, align 4 + %siuiext = sext i32 %63 to i64 %add = add i64 %siuiext, 1 - %80 = call i8* @std_core_mem_malloc(i64 %add) #2 - store i8* %80, i8** %str, align 8 - %81 = load i8*, i8** %str, align 8 - %not50 = icmp eq i8* %81, null - br i1 %not50, label %if.then51, label %if.exit52 + %64 = call i8* @std_core_mem_malloc(i64 %add) #2 + store i8* %64, i8** %str, align 8 + %65 = load i8*, i8** %str, align 8 + %not39 = icmp eq i8* %65, null + br i1 %not39, label %if.then40, label %if.exit41 -if.then51: ; preds = %if.exit49 +if.then40: ; preds = %if.exit38 ret i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64) -if.exit52: ; preds = %if.exit49 - %82 = load i8*, i8** %str, align 8 - %83 = load i32, i32* %len, align 4 - %siuiext53 = sext i32 %83 to i64 - %add54 = add i64 %siuiext53, 1 - %84 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 - %85 = load i64, i64* %84, align 8 - %uisitrunc55 = trunc i64 %85 to i32 - %86 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 - %87 = load i8*, i8** %86, align 8 - %88 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %82, i64 %add54, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i32 0, i32 0), i32 %uisitrunc55, i8* %87) - %89 = getelementptr inbounds %Doc, %Doc* %literal57, i32 0, i32 0 - %90 = bitcast %Head* %literal60 to %"char[]"** - store %"char[]"* null, %"char[]"** %90, align 8 - %91 = getelementptr inbounds %Head, %Head* %literal60, i32 0, i32 0 - %92 = load i8*, i8** %str, align 8 - %93 = load i32, i32* %len, align 4 - %sub = sub i32 %93, 1 +if.exit41: ; preds = %if.exit38 + %66 = load i8*, i8** %str, align 8 + %67 = load i32, i32* %len, align 4 + %siuiext42 = sext i32 %67 to i64 + %add43 = add i64 %siuiext42, 1 + %68 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %69 = load i64, i64* %68, align 8 + %uisitrunc44 = trunc i64 %69 to i32 + %70 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %71 = load i8*, i8** %70, align 8 + %72 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %66, i64 %add43, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i32 0, i32 0), i32 %uisitrunc44, i8* %71) + %73 = getelementptr inbounds %Doc, %Doc* %literal46, i32 0, i32 0 + %74 = bitcast %Head* %literal49 to %"char[]"** + store %"char[]"* null, %"char[]"** %74, align 8 + %75 = getelementptr inbounds %Head, %Head* %literal49, i32 0, i32 0 + %76 = load i8*, i8** %str, align 8 + %77 = load i32, i32* %len, align 4 + %sub = sub i32 %77, 1 %sisiext = sext i32 %sub to i64 - %94 = add i64 %sisiext, 1 - %size = sub i64 %94, 0 - %ptroffset = getelementptr inbounds i8, i8* %92, i64 0 - %95 = insertvalue %"char[]" undef, i8* %ptroffset, 0 - %96 = insertvalue %"char[]" %95, i64 %size, 1 - store %"char[]" %96, %"char[]"* %value62, align 8 - %97 = call i8* @std_core_mem_malloc(i64 16) #2 - %ptrptr64 = bitcast i8* %97 to %"char[]"* - store %"char[]"* %ptrptr64, %"char[]"** %temp63, align 8 - %98 = load %"char[]"*, %"char[]"** %temp63, align 8 - %not65 = icmp eq %"char[]"* %98, null - br i1 %not65, label %if.then66, label %if.exit67 + %78 = add i64 %sisiext, 1 + %size = sub i64 %78, 0 + %ptroffset = getelementptr inbounds i8, i8* %76, i64 0 + %79 = insertvalue %"char[]" undef, i8* %ptroffset, 0 + %80 = insertvalue %"char[]" %79, i64 %size, 1 + store %"char[]" %80, %"char[]"* %value51, align 8 + %81 = call i8* @std_core_mem_malloc(i64 16) #2 + %ptrptr53 = bitcast i8* %81 to %"char[]"* + store %"char[]"* %ptrptr53, %"char[]"** %temp52, align 8 + %82 = load %"char[]"*, %"char[]"** %temp52, align 8 + %not54 = icmp eq %"char[]"* %82, null + br i1 %not54, label %if.then55, label %if.exit56 -if.then66: ; preds = %if.exit52 - store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var61, align 8 - br label %guard_block68 +if.then55: ; preds = %if.exit41 + store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var50, align 8 + br label %guard_block57 -if.exit67: ; preds = %if.exit52 - %99 = load %"char[]"*, %"char[]"** %temp63, align 8 - %100 = bitcast %"char[]"* %99 to i8* - %101 = bitcast %"char[]"* %value62 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %100, i8* align 8 %101, i32 16, i1 false) - br label %noerr_block69 +if.exit56: ; preds = %if.exit41 + %83 = load %"char[]"*, %"char[]"** %temp52, align 8 + %84 = bitcast %"char[]"* %83 to i8* + %85 = bitcast %"char[]"* %value51 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %84, i8* align 8 %85, i32 16, i1 false) + br label %noerr_block58 -guard_block68: ; preds = %if.then66 - %102 = load i64, i64* %error_var61, align 8 - ret i64 %102 +guard_block57: ; preds = %if.then55 + %86 = load i64, i64* %error_var50, align 8 + ret i64 %86 -noerr_block69: ; preds = %if.exit67 - %103 = load %"char[]"*, %"char[]"** %temp63, align 8 - store %"char[]"* %103, %"char[]"** %91, align 8 - %104 = bitcast %Head* %value59 to i8* - %105 = bitcast %Head* %literal60 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %104, i8* align 8 %105, i32 8, i1 false) - %106 = call i8* @std_core_mem_malloc(i64 8) #2 - %ptrptr71 = bitcast i8* %106 to %Head* - store %Head* %ptrptr71, %Head** %temp70, align 8 - %107 = load %Head*, %Head** %temp70, align 8 - %not72 = icmp eq %Head* %107, null - br i1 %not72, label %if.then73, label %if.exit74 +noerr_block58: ; preds = %if.exit56 + %87 = load %"char[]"*, %"char[]"** %temp52, align 8 + store %"char[]"* %87, %"char[]"** %75, align 8 + %88 = bitcast %Head* %value48 to i8* + %89 = bitcast %Head* %literal49 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %88, i8* align 8 %89, i32 8, i1 false) + %90 = call i8* @std_core_mem_malloc(i64 8) #2 + %ptrptr60 = bitcast i8* %90 to %Head* + store %Head* %ptrptr60, %Head** %temp59, align 8 + %91 = load %Head*, %Head** %temp59, align 8 + %not61 = icmp eq %Head* %91, null + br i1 %not61, label %if.then62, label %if.exit63 -if.then73: ; preds = %noerr_block69 - store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var58, align 8 - br label %guard_block75 +if.then62: ; preds = %noerr_block58 + store i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64), i64* %error_var47, align 8 + br label %guard_block64 -if.exit74: ; preds = %noerr_block69 - %108 = load %Head*, %Head** %temp70, align 8 - %109 = bitcast %Head* %108 to i8* - %110 = bitcast %Head* %value59 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %109, i8* align 8 %110, i32 8, i1 false) - br label %noerr_block76 +if.exit63: ; preds = %noerr_block58 + %92 = load %Head*, %Head** %temp59, align 8 + %93 = bitcast %Head* %92 to i8* + %94 = bitcast %Head* %value48 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %93, i8* align 8 %94, i32 8, i1 false) + br label %noerr_block65 -guard_block75: ; preds = %if.then73 - %111 = load i64, i64* %error_var58, align 8 - ret i64 %111 +guard_block64: ; preds = %if.then62 + %95 = load i64, i64* %error_var47, align 8 + ret i64 %95 -noerr_block76: ; preds = %if.exit74 - %112 = load %Head*, %Head** %temp70, align 8 - store %Head* %112, %Head** %89, align 8 - %113 = bitcast %Doc* %0 to i8* - %114 = bitcast %Doc* %literal57 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %113, i8* align 8 %114, i32 8, i1 false) +noerr_block65: ; preds = %if.exit63 + %96 = load %Head*, %Head** %temp59, align 8 + store %Head* %96, %Head** %73, align 8 + %97 = bitcast %Doc* %0 to i8* + %98 = bitcast %Doc* %literal46 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %97, i8* align 8 %98, i32 8, i1 false) ret i64 0 } @@ -635,38 +603,37 @@ entry: store i8* %0, i8** %2, align 8 %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 1 store i64 %1, i64* %3, align 8 - %4 = bitcast %"char[]"* %url to { i8*, i64 }* - %5 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 0 - %lo = load i8*, i8** %5, align 8 - %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 1 - %hi = load i64, i64* %6, align 8 - %7 = call i64 @test_readDoc(%Doc* %retparam, i8* %lo, i64 %hi) - %not_err = icmp eq i64 %7, 0 + %4 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %lo = load i8*, i8** %4, align 8 + %5 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %hi = load i64, i64* %5, align 8 + %6 = call i64 @test_readDoc(%Doc* %retparam, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %6, 0 br i1 %not_err, label %after_check, label %else_block after_check: ; preds = %entry - %8 = getelementptr inbounds %Doc, %Doc* %retparam, i32 0, i32 0 - %9 = load %Head*, %Head** %8, align 8 - %10 = call { %"char[]"*, i8 } @test_buildSummary(%Head* %9) - %11 = bitcast %Summary* %result to { %"char[]"*, i8 }* - store { %"char[]"*, i8 } %10, { %"char[]"*, i8 }* %11, align 8 - %12 = load %Summary, %Summary* %result, align 8 + %7 = getelementptr inbounds %Doc, %Doc* %retparam, i32 0, i32 0 + %8 = load %Head*, %Head** %7, align 8 + %9 = call { %"char[]"*, i8 } @test_buildSummary(%Head* %8) + %10 = bitcast %Summary* %result to { %"char[]"*, i8 }* + store { %"char[]"*, i8 } %9, { %"char[]"*, i8 }* %10, align 8 + %11 = load %Summary, %Summary* %result, align 8 br label %phi_block else_block: ; preds = %entry - %13 = getelementptr inbounds %Summary, %Summary* %literal, i32 0, i32 0 - store %"char[]"* null, %"char[]"** %13, align 8 - %14 = getelementptr inbounds %Summary, %Summary* %literal, i32 0, i32 1 - store i8 0, i8* %14, align 8 - %15 = load %Summary, %Summary* %literal, align 8 + %12 = getelementptr inbounds %Summary, %Summary* %literal, i32 0, i32 0 + store %"char[]"* null, %"char[]"** %12, align 8 + %13 = getelementptr inbounds %Summary, %Summary* %literal, i32 0, i32 1 + store i8 0, i8* %13, align 8 + %14 = load %Summary, %Summary* %literal, align 8 br label %phi_block phi_block: ; preds = %else_block, %after_check - %val = phi %Summary [ %12, %after_check ], [ %15, %else_block ] + %val = phi %Summary [ %11, %after_check ], [ %14, %else_block ] store %Summary %val, %Summary* %taddr, align 8 - %16 = bitcast %Summary* %taddr to { %"char[]"*, i8 }* - %17 = load { %"char[]"*, i8 }, { %"char[]"*, i8 }* %16, align 8 - ret { %"char[]"*, i8 } %17 + %15 = bitcast %Summary* %taddr to { %"char[]"*, i8 }* + %16 = load { %"char[]"*, i8 }, { %"char[]"*, i8 }* %15, align 8 + ret { %"char[]"*, i8 } %16 } ; Function Attrs: nounwind @@ -720,38 +687,37 @@ entry: store i8* %1, i8** %3, align 8 %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 1 store i64 %2, i64* %4, align 8 - %5 = bitcast %"char[]"* %url to { i8*, i64 }* - %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 0 - %lo = load i8*, i8** %6, align 8 - %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 1 - %hi = load i64, i64* %7, align 8 - %8 = call i64 @test_readDoc(%Doc* %retparam1, i8* %lo, i64 %hi) - %not_err = icmp eq i64 %8, 0 + %5 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %lo = load i8*, i8** %5, align 8 + %6 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %hi = load i64, i64* %6, align 8 + %7 = call i64 @test_readDoc(%Doc* %retparam1, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %7, 0 br i1 %not_err, label %after_check, label %assign_optional assign_optional: ; preds = %entry - store i64 %8, i64* %reterr, align 8 + store i64 %7, i64* %reterr, align 8 br label %err_retblock after_check: ; preds = %entry - %9 = getelementptr inbounds %Doc, %Doc* %retparam1, i32 0, i32 0 - %10 = load %Head*, %Head** %9, align 8 - %11 = call i64 @test_isTitleNonEmpty(i8* %retparam, %Head* %10) - %not_err2 = icmp eq i64 %11, 0 + %8 = getelementptr inbounds %Doc, %Doc* %retparam1, i32 0, i32 0 + %9 = load %Head*, %Head** %8, align 8 + %10 = call i64 @test_isTitleNonEmpty(i8* %retparam, %Head* %9) + %not_err2 = icmp eq i64 %10, 0 br i1 %not_err2, label %after_check4, label %assign_optional3 assign_optional3: ; preds = %after_check - store i64 %11, i64* %reterr, align 8 + store i64 %10, i64* %reterr, align 8 br label %err_retblock after_check4: ; preds = %after_check - %12 = load i8, i8* %retparam, align 1 - store i8 %12, i8* %0, align 1 + %11 = load i8, i8* %retparam, align 1 + store i8 %11, i8* %0, align 1 ret i64 0 err_retblock: ; preds = %assign_optional3, %assign_optional - %13 = load i64, i64* %reterr, align 8 - ret i64 %13 + %12 = load i64, i64* %reterr, align 8 + ret i64 %12 } ; Function Attrs: nounwind @@ -853,60 +819,58 @@ loop.body: ; preds = %loop.cond %19 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 %20 = load i8*, i8** %19, align 8 %21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.20, i32 0, i32 0), i32 %uisitrunc, i8* %20) - %22 = bitcast %"char[]"* %url to { i8*, i64 }* - %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0 - %lo = load i8*, i8** %23, align 8 - %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1 - %hi = load i64, i64* %24, align 8 - %25 = call { %"char[]"*, i8 } @test_readAndBuildSummary(i8* %lo, i64 %hi) - %26 = bitcast %Summary* %result to { %"char[]"*, i8 }* - store { %"char[]"*, i8 } %25, { %"char[]"*, i8 }* %26, align 8 - %27 = bitcast %Summary* %summary to i8* - %28 = bitcast %Summary* %result to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %27, i8* align 8 %28, i32 16, i1 false) - %29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.21, i32 0, i32 0)) - %30 = load i8*, i8** @__stdoutp, align 8 - call void @test_Summary_print(%Summary* %summary, i8* %30) - %31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i32 0, i32 0)) - %32 = getelementptr inbounds %Summary, %Summary* %summary, i32 0, i32 0 - %33 = load %"char[]"*, %"char[]"** %32, align 8 - %ptrbool = icmp ne %"char[]"* %33, null + %22 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %lo = load i8*, i8** %22, align 8 + %23 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %hi = load i64, i64* %23, align 8 + %24 = call { %"char[]"*, i8 } @test_readAndBuildSummary(i8* %lo, i64 %hi) + %25 = bitcast %Summary* %result to { %"char[]"*, i8 }* + store { %"char[]"*, i8 } %24, { %"char[]"*, i8 }* %25, align 8 + %26 = bitcast %Summary* %summary to i8* + %27 = bitcast %Summary* %result to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %26, i8* align 8 %27, i32 16, i1 false) + %28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.21, i32 0, i32 0)) + %29 = load i8*, i8** @__stdoutp, align 8 + call void @test_Summary_print(%Summary* %summary, i8* %29) + %30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i32 0, i32 0)) + %31 = getelementptr inbounds %Summary, %Summary* %summary, i32 0, i32 0 + %32 = load %"char[]"*, %"char[]"** %31, align 8 + %ptrbool = icmp ne %"char[]"* %32, null br i1 %ptrbool, label %cond.lhs, label %cond.rhs cond.lhs: ; preds = %loop.body - %34 = getelementptr inbounds %Summary, %Summary* %summary, i32 0, i32 0 - %35 = load %"char[]"*, %"char[]"** %34, align 8 - %36 = load %"char[]", %"char[]"* %35, align 8 + %33 = getelementptr inbounds %Summary, %Summary* %summary, i32 0, i32 0 + %34 = load %"char[]"*, %"char[]"** %33, align 8 + %35 = load %"char[]", %"char[]"* %34, align 8 br label %cond.phi cond.rhs: ; preds = %loop.body br label %cond.phi cond.phi: ; preds = %cond.rhs, %cond.lhs - %val = phi %"char[]" [ %36, %cond.lhs ], [ zeroinitializer, %cond.rhs ] + %val = phi %"char[]" [ %35, %cond.lhs ], [ zeroinitializer, %cond.rhs ] store %"char[]" %val, %"char[]"* %title_sure, align 8 - %37 = getelementptr inbounds %"char[]", %"char[]"* %title_sure, i32 0, i32 1 - %38 = load i64, i64* %37, align 8 - %uisitrunc2 = trunc i64 %38 to i32 - %39 = getelementptr inbounds %"char[]", %"char[]"* %title_sure, i32 0, i32 0 - %40 = load i8*, i8** %39, align 8 - %41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.24, i32 0, i32 0), i32 %uisitrunc2, i8* %40) - %42 = bitcast %"char[]"* %url to { i8*, i64 }* - %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %42, i32 0, i32 0 - %lo3 = load i8*, i8** %43, align 8 - %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %42, i32 0, i32 1 - %hi4 = load i64, i64* %44, align 8 - %45 = call i64 @test_readWhetherTitleNonEmpty(i8* %retparam, i8* %lo3, i64 %hi4) - %not_err = icmp eq i64 %45, 0 + %36 = getelementptr inbounds %"char[]", %"char[]"* %title_sure, i32 0, i32 1 + %37 = load i64, i64* %36, align 8 + %uisitrunc2 = trunc i64 %37 to i32 + %38 = getelementptr inbounds %"char[]", %"char[]"* %title_sure, i32 0, i32 0 + %39 = load i8*, i8** %38, align 8 + %40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.24, i32 0, i32 0), i32 %uisitrunc2, i8* %39) + %41 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %lo3 = load i8*, i8** %41, align 8 + %42 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %hi4 = load i64, i64* %42, align 8 + %43 = call i64 @test_readWhetherTitleNonEmpty(i8* %retparam, i8* %lo3, i64 %hi4) + %not_err = icmp eq i64 %43, 0 br i1 %not_err, label %after_check, label %assign_optional assign_optional: ; preds = %cond.phi - store i64 %45, i64* %has_title.f, align 8 + store i64 %43, i64* %has_title.f, align 8 br label %after_assign after_check: ; preds = %cond.phi - %46 = load i8, i8* %retparam, align 1 - store i8 %46, i8* %has_title, align 1 + %44 = load i8, i8* %retparam, align 1 + store i8 %44, i8* %has_title, align 1 store i64 0, i64* %has_title.f, align 8 br label %after_assign @@ -916,35 +880,35 @@ after_assign: ; preds = %after_check, %assig br i1 %not_err5, label %after_check6, label %else_block after_check6: ; preds = %after_assign - %47 = load i8, i8* %has_title, align 1 - %48 = call i8* @test_bool_to_string(i8 %47) + %45 = load i8, i8* %has_title, align 1 + %46 = call i8* @test_bool_to_string(i8 %45) br label %phi_block else_block: ; preds = %after_assign - %49 = load i64, i64* %has_title.f, align 8 - %50 = call i8* @test_nameFromError(i64 %49) + %47 = load i64, i64* %has_title.f, align 8 + %48 = call i8* @test_nameFromError(i64 %47) br label %phi_block phi_block: ; preds = %else_block, %after_check6 - %val7 = phi i8* [ %48, %after_check6 ], [ %50, %else_block ] + %val7 = phi i8* [ %46, %after_check6 ], [ %48, %else_block ] %optval8 = load i64, i64* %has_title.f, align 8 %not_err9 = icmp eq i64 %optval8, 0 br i1 %not_err9, label %after_check10, label %else_block11 after_check10: ; preds = %phi_block - %51 = load i8, i8* %has_title, align 1 - %52 = trunc i8 %51 to i1 + %49 = load i8, i8* %has_title, align 1 + %50 = trunc i8 %49 to i1 br label %phi_block12 else_block11: ; preds = %phi_block br label %phi_block12 phi_block12: ; preds = %else_block11, %after_check10 - %val13 = phi i1 [ %52, %after_check10 ], [ false, %else_block11 ] + %val13 = phi i1 [ %50, %after_check10 ], [ false, %else_block11 ] %ternary = select i1 %val13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.27, i32 0, i32 0) - %53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.25, i32 0, i32 0), i8* %val7, i8* %ternary) - %54 = load i64, i64* %.anon1, align 8 - %add = add i64 %54, 1 + %51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.25, i32 0, i32 0), i8* %val7, i8* %ternary) + %52 = load i64, i64* %.anon1, align 8 + %add = add i64 %52, 1 store i64 %add, i64* %.anon1, align 8 br label %loop.cond diff --git a/test/test_suite/errors/optional_chained_init.c3t b/test/test_suite/errors/optional_chained_init.c3t index fb9e69655..cd20b747a 100644 --- a/test/test_suite/errors/optional_chained_init.c3t +++ b/test/test_suite/errors/optional_chained_init.c3t @@ -55,22 +55,18 @@ entry: %b.f = alloca i64, align 8 %err = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %err5 = alloca i64, align 8 - %retparam14 = alloca i64, align 8 - %taddr15 = alloca %"char[]", align 8 - %vararg18 = alloca %"variant[]", align 8 - %varargslots19 = alloca [1 x %variant], align 16 - %retparam26 = alloca i64, align 8 - %taddr27 = alloca %"char[]", align 8 - %vararg30 = alloca %"variant[]", align 8 - %varargslots31 = alloca [1 x %variant], align 16 - %retparam40 = alloca i64, align 8 - %taddr41 = alloca %"char[]", align 8 - %vararg44 = alloca %"variant[]", align 8 - %varargslots45 = alloca [1 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 + %err3 = alloca i64, align 8 + %retparam12 = alloca i64, align 8 + %varargslots13 = alloca [1 x %variant], align 16 + %taddr14 = alloca %"variant[]", align 8 + %retparam21 = alloca i64, align 8 + %varargslots22 = alloca [1 x %variant], align 16 + %taddr26 = alloca %"variant[]", align 8 + %retparam32 = alloca i64, align 8 + %varargslots33 = alloca [1 x %variant], align 16 + %taddr37 = alloca %"variant[]", align 8 store i32 1, i32* %a, align 4 store i64 0, i64* %a.f, align 8 store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %a.f, align 8 @@ -99,159 +95,131 @@ end_block: ; preds = %after_check, %assig br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i32 0, i32 0), i64 13 }, %"char[]"* %taddr, align 8 - %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 - %lo = load i8*, i8** %2, align 8 - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 - %hi = load i64, i64* %3, align 8 - %4 = bitcast i64* %err to i8* - %5 = insertvalue %variant undef, i8* %4, 0 - %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %6, %variant* %7, align 16 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %8, align 8 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %10 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %10, %variant** %9, align 8 - %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 - %lo1 = load i8*, i8** %12, align 8 - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 - %hi2 = load i64, i64* %13, align 8 - %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) - %not_err3 = icmp eq i64 %14, 0 - br i1 %not_err3, label %after_check4, label %voiderr + %1 = bitcast i64* %err to i8* + %2 = insertvalue %variant undef, i8* %1, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %3, %variant* %4, align 16 + %5 = bitcast [1 x %variant]* %varargslots to %variant* + %6 = insertvalue %"variant[]" undef, %variant* %5, 0 + %7 = insertvalue %"variant[]" %6, i64 1, 1 + store %"variant[]" %7, %"variant[]"* %taddr, align 8 + %8 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 + %lo = load i8*, i8** %9, align 8 + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 + %hi = load i64, i64* %10, align 8 + %11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i32 0, i32 0), i64 13, i8* %lo, i64 %hi) + %not_err1 = icmp eq i64 %11, 0 + br i1 %not_err1, label %after_check2, label %voiderr -after_check4: ; preds = %if.then +after_check2: ; preds = %if.then br label %voiderr -voiderr: ; preds = %after_check4, %if.then +voiderr: ; preds = %after_check2, %if.then br label %if.exit if.exit: ; preds = %voiderr, %end_block - br label %testblock6 + br label %testblock4 -testblock6: ; preds = %if.exit - %optval7 = load i64, i64* %b.f, align 8 - %not_err8 = icmp eq i64 %optval7, 0 - br i1 %not_err8, label %after_check10, label %assign_optional9 +testblock4: ; preds = %if.exit + %optval5 = load i64, i64* %b.f, align 8 + %not_err6 = icmp eq i64 %optval5, 0 + br i1 %not_err6, label %after_check8, label %assign_optional7 -assign_optional9: ; preds = %testblock6 - store i64 %optval7, i64* %err5, align 8 - br label %end_block11 +assign_optional7: ; preds = %testblock4 + store i64 %optval5, i64* %err3, align 8 + br label %end_block9 -after_check10: ; preds = %testblock6 - store i64 0, i64* %err5, align 8 - br label %end_block11 +after_check8: ; preds = %testblock4 + store i64 0, i64* %err3, align 8 + br label %end_block9 -end_block11: ; preds = %after_check10, %assign_optional9 - %15 = load i64, i64* %err5, align 8 - %neq12 = icmp ne i64 %15, 0 - br i1 %neq12, label %if.then13, label %if.exit25 +end_block9: ; preds = %after_check8, %assign_optional7 + %12 = load i64, i64* %err3, align 8 + %neq10 = icmp ne i64 %12, 0 + br i1 %neq10, label %if.then11, label %if.exit20 -if.then13: ; preds = %end_block11 - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i32 0, i32 0), i64 13 }, %"char[]"* %taddr15, align 8 - %16 = bitcast %"char[]"* %taddr15 to { i8*, i64 }* - %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 0 - %lo16 = load i8*, i8** %17, align 8 - %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 1 - %hi17 = load i64, i64* %18, align 8 - %19 = bitcast i64* %err5 to i8* - %20 = insertvalue %variant undef, i8* %19, 0 - %21 = insertvalue %variant %20, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %22 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots19, i64 0, i64 0 - store %variant %21, %variant* %22, align 16 - %23 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg18, i32 0, i32 1 - store i64 1, i64* %23, align 8 - %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg18, i32 0, i32 0 - %25 = bitcast [1 x %variant]* %varargslots19 to %variant* - store %variant* %25, %variant** %24, align 8 - %26 = bitcast %"variant[]"* %vararg18 to { i8*, i64 }* - %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 0 - %lo20 = load i8*, i8** %27, align 8 - %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 1 - %hi21 = load i64, i64* %28, align 8 - %29 = call i64 @std_io_printfln(i64* %retparam14, i8* %lo16, i64 %hi17, i8* %lo20, i64 %hi21) - %not_err22 = icmp eq i64 %29, 0 - br i1 %not_err22, label %after_check23, label %voiderr24 +if.then11: ; preds = %end_block9 + %13 = bitcast i64* %err3 to i8* + %14 = insertvalue %variant undef, i8* %13, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %16 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots13, i64 0, i64 0 + store %variant %15, %variant* %16, align 16 + %17 = bitcast [1 x %variant]* %varargslots13 to %variant* + %18 = insertvalue %"variant[]" undef, %variant* %17, 0 + %19 = insertvalue %"variant[]" %18, i64 1, 1 + store %"variant[]" %19, %"variant[]"* %taddr14, align 8 + %20 = bitcast %"variant[]"* %taddr14 to { i8*, i64 }* + %21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 0 + %lo15 = load i8*, i8** %21, align 8 + %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 1 + %hi16 = load i64, i64* %22, align 8 + %23 = call i64 @std_io_printfln(i64* %retparam12, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i32 0, i32 0), i64 13, i8* %lo15, i64 %hi16) + %not_err17 = icmp eq i64 %23, 0 + br i1 %not_err17, label %after_check18, label %voiderr19 -after_check23: ; preds = %if.then13 - br label %voiderr24 +after_check18: ; preds = %if.then11 + br label %voiderr19 -voiderr24: ; preds = %after_check23, %if.then13 - br label %if.exit25 +voiderr19: ; preds = %after_check18, %if.then11 + br label %if.exit20 -if.exit25: ; preds = %voiderr24, %end_block11 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i64 9 }, %"char[]"* %taddr27, align 8 - %30 = bitcast %"char[]"* %taddr27 to { i8*, i64 }* - %31 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 0 - %lo28 = load i8*, i8** %31, align 8 - %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 1 - %hi29 = load i64, i64* %32, align 8 - %optval32 = load i64, i64* %a.f, align 8 - %not_err33 = icmp eq i64 %optval32, 0 - br i1 %not_err33, label %after_check34, label %voiderr39 +if.exit20: ; preds = %voiderr19, %end_block9 + %optval23 = load i64, i64* %a.f, align 8 + %not_err24 = icmp eq i64 %optval23, 0 + br i1 %not_err24, label %after_check25, label %voiderr31 -after_check34: ; preds = %if.exit25 - %33 = bitcast i32* %a to i8* - %34 = insertvalue %variant undef, i8* %33, 0 - %35 = insertvalue %variant %34, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %36 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots31, i64 0, i64 0 - store %variant %35, %variant* %36, align 16 - %37 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg30, i32 0, i32 1 - store i64 1, i64* %37, align 8 - %38 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg30, i32 0, i32 0 - %39 = bitcast [1 x %variant]* %varargslots31 to %variant* - store %variant* %39, %variant** %38, align 8 - %40 = bitcast %"variant[]"* %vararg30 to { i8*, i64 }* - %41 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %40, i32 0, i32 0 - %lo35 = load i8*, i8** %41, align 8 - %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %40, i32 0, i32 1 - %hi36 = load i64, i64* %42, align 8 - %43 = call i64 @std_io_printfln(i64* %retparam26, i8* %lo28, i64 %hi29, i8* %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %43, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 +after_check25: ; preds = %if.exit20 + %24 = bitcast i32* %a to i8* + %25 = insertvalue %variant undef, i8* %24, 0 + %26 = insertvalue %variant %25, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %27 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots22, i64 0, i64 0 + store %variant %26, %variant* %27, align 16 + %28 = bitcast [1 x %variant]* %varargslots22 to %variant* + %29 = insertvalue %"variant[]" undef, %variant* %28, 0 + %30 = insertvalue %"variant[]" %29, i64 1, 1 + store %"variant[]" %30, %"variant[]"* %taddr26, align 8 + %31 = bitcast %"variant[]"* %taddr26 to { i8*, i64 }* + %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 + %lo27 = load i8*, i8** %32, align 8 + %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 + %hi28 = load i64, i64* %33, align 8 + %34 = call i64 @std_io_printfln(i64* %retparam21, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i64 9, i8* %lo27, i64 %hi28) + %not_err29 = icmp eq i64 %34, 0 + br i1 %not_err29, label %after_check30, label %voiderr31 -after_check38: ; preds = %after_check34 - br label %voiderr39 +after_check30: ; preds = %after_check25 + br label %voiderr31 -voiderr39: ; preds = %after_check38, %after_check34, %if.exit25 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i32 0, i32 0), i64 9 }, %"char[]"* %taddr41, align 8 - %44 = bitcast %"char[]"* %taddr41 to { i8*, i64 }* - %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0 - %lo42 = load i8*, i8** %45, align 8 - %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1 - %hi43 = load i64, i64* %46, align 8 - %optval46 = load i64, i64* %b.f, align 8 - %not_err47 = icmp eq i64 %optval46, 0 - br i1 %not_err47, label %after_check48, label %voiderr53 +voiderr31: ; preds = %after_check30, %after_check25, %if.exit20 + %optval34 = load i64, i64* %b.f, align 8 + %not_err35 = icmp eq i64 %optval34, 0 + br i1 %not_err35, label %after_check36, label %voiderr42 -after_check48: ; preds = %voiderr39 - %47 = bitcast i32* %b to i8* - %48 = insertvalue %variant undef, i8* %47, 0 - %49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %50 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots45, i64 0, i64 0 - store %variant %49, %variant* %50, align 16 - %51 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 1 - store i64 1, i64* %51, align 8 - %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 0 - %53 = bitcast [1 x %variant]* %varargslots45 to %variant* - store %variant* %53, %variant** %52, align 8 - %54 = bitcast %"variant[]"* %vararg44 to { i8*, i64 }* - %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 0 - %lo49 = load i8*, i8** %55, align 8 - %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 1 - %hi50 = load i64, i64* %56, align 8 - %57 = call i64 @std_io_printfln(i64* %retparam40, i8* %lo42, i64 %hi43, i8* %lo49, i64 %hi50) - %not_err51 = icmp eq i64 %57, 0 - br i1 %not_err51, label %after_check52, label %voiderr53 +after_check36: ; preds = %voiderr31 + %35 = bitcast i32* %b to i8* + %36 = insertvalue %variant undef, i8* %35, 0 + %37 = insertvalue %variant %36, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %38 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots33, i64 0, i64 0 + store %variant %37, %variant* %38, align 16 + %39 = bitcast [1 x %variant]* %varargslots33 to %variant* + %40 = insertvalue %"variant[]" undef, %variant* %39, 0 + %41 = insertvalue %"variant[]" %40, i64 1, 1 + store %"variant[]" %41, %"variant[]"* %taddr37, align 8 + %42 = bitcast %"variant[]"* %taddr37 to { i8*, i64 }* + %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %42, i32 0, i32 0 + %lo38 = load i8*, i8** %43, align 8 + %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %42, i32 0, i32 1 + %hi39 = load i64, i64* %44, align 8 + %45 = call i64 @std_io_printfln(i64* %retparam32, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i32 0, i32 0), i64 9, i8* %lo38, i64 %hi39) + %not_err40 = icmp eq i64 %45, 0 + br i1 %not_err40, label %after_check41, label %voiderr42 -after_check52: ; preds = %after_check48 - br label %voiderr53 +after_check41: ; preds = %after_check36 + br label %voiderr42 -voiderr53: ; preds = %after_check52, %after_check48, %voiderr39 +voiderr42: ; preds = %after_check41, %after_check36, %voiderr31 ret void } @@ -266,22 +234,18 @@ entry: %b.f = alloca i64, align 8 %err = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %err10 = alloca i64, align 8 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 - %varargslots24 = alloca [1 x %variant], align 16 - %retparam31 = alloca i64, align 8 - %taddr32 = alloca %"char[]", align 8 - %vararg35 = alloca %"variant[]", align 8 - %varargslots36 = alloca [1 x %variant], align 16 - %retparam45 = alloca i64, align 8 - %taddr46 = alloca %"char[]", align 8 - %vararg49 = alloca %"variant[]", align 8 - %varargslots50 = alloca [1 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 + %err8 = alloca i64, align 8 + %retparam17 = alloca i64, align 8 + %varargslots18 = alloca [1 x %variant], align 16 + %taddr19 = alloca %"variant[]", align 8 + %retparam26 = alloca i64, align 8 + %varargslots27 = alloca [1 x %variant], align 16 + %taddr31 = alloca %"variant[]", align 8 + %retparam37 = alloca i64, align 8 + %varargslots38 = alloca [1 x %variant], align 16 + %taddr42 = alloca %"variant[]", align 8 store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %x.f, align 8 store i32 1, i32* %a, align 4 store i64 0, i64* %a.f, align 8 @@ -331,159 +295,131 @@ end_block: ; preds = %after_check5, %assi br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i32 0, i32 0), i64 13 }, %"char[]"* %taddr, align 8 - %2 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 0 - %lo = load i8*, i8** %3, align 8 - %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 1 - %hi = load i64, i64* %4, align 8 - %5 = bitcast i64* %err to i8* - %6 = insertvalue %variant undef, i8* %5, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %8 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %7, %variant* %8, align 16 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %9, align 8 - %10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %11 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %11, %variant** %10, align 8 - %12 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 0 - %lo6 = load i8*, i8** %13, align 8 - %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 1 - %hi7 = load i64, i64* %14, align 8 - %15 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo6, i64 %hi7) - %not_err8 = icmp eq i64 %15, 0 - br i1 %not_err8, label %after_check9, label %voiderr + %2 = bitcast i64* %err to i8* + %3 = insertvalue %variant undef, i8* %2, 0 + %4 = insertvalue %variant %3, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %5 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %4, %variant* %5, align 16 + %6 = bitcast [1 x %variant]* %varargslots to %variant* + %7 = insertvalue %"variant[]" undef, %variant* %6, 0 + %8 = insertvalue %"variant[]" %7, i64 1, 1 + store %"variant[]" %8, %"variant[]"* %taddr, align 8 + %9 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %9, i32 0, i32 0 + %lo = load i8*, i8** %10, align 8 + %11 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %9, i32 0, i32 1 + %hi = load i64, i64* %11, align 8 + %12 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i32 0, i32 0), i64 13, i8* %lo, i64 %hi) + %not_err6 = icmp eq i64 %12, 0 + br i1 %not_err6, label %after_check7, label %voiderr -after_check9: ; preds = %if.then +after_check7: ; preds = %if.then br label %voiderr -voiderr: ; preds = %after_check9, %if.then +voiderr: ; preds = %after_check7, %if.then br label %if.exit if.exit: ; preds = %voiderr, %end_block - br label %testblock11 + br label %testblock9 -testblock11: ; preds = %if.exit - %optval12 = load i64, i64* %b.f, align 8 - %not_err13 = icmp eq i64 %optval12, 0 - br i1 %not_err13, label %after_check15, label %assign_optional14 +testblock9: ; preds = %if.exit + %optval10 = load i64, i64* %b.f, align 8 + %not_err11 = icmp eq i64 %optval10, 0 + br i1 %not_err11, label %after_check13, label %assign_optional12 -assign_optional14: ; preds = %testblock11 - store i64 %optval12, i64* %err10, align 8 - br label %end_block16 +assign_optional12: ; preds = %testblock9 + store i64 %optval10, i64* %err8, align 8 + br label %end_block14 -after_check15: ; preds = %testblock11 - store i64 0, i64* %err10, align 8 - br label %end_block16 +after_check13: ; preds = %testblock9 + store i64 0, i64* %err8, align 8 + br label %end_block14 -end_block16: ; preds = %after_check15, %assign_optional14 - %16 = load i64, i64* %err10, align 8 - %neq17 = icmp ne i64 %16, 0 - br i1 %neq17, label %if.then18, label %if.exit30 +end_block14: ; preds = %after_check13, %assign_optional12 + %13 = load i64, i64* %err8, align 8 + %neq15 = icmp ne i64 %13, 0 + br i1 %neq15, label %if.then16, label %if.exit25 -if.then18: ; preds = %end_block16 - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i32 0, i32 0), i64 13 }, %"char[]"* %taddr20, align 8 - %17 = bitcast %"char[]"* %taddr20 to { i8*, i64 }* - %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 - %lo21 = load i8*, i8** %18, align 8 - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 - %hi22 = load i64, i64* %19, align 8 - %20 = bitcast i64* %err10 to i8* - %21 = insertvalue %variant undef, i8* %20, 0 - %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %23 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0 - store %variant %22, %variant* %23, align 16 - %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1 - store i64 1, i64* %24, align 8 - %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0 - %26 = bitcast [1 x %variant]* %varargslots24 to %variant* - store %variant* %26, %variant** %25, align 8 - %27 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }* - %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 - %lo25 = load i8*, i8** %28, align 8 - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 - %hi26 = load i64, i64* %29, align 8 - %30 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %30, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 +if.then16: ; preds = %end_block14 + %14 = bitcast i64* %err8 to i8* + %15 = insertvalue %variant undef, i8* %14, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %17 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots18, i64 0, i64 0 + store %variant %16, %variant* %17, align 16 + %18 = bitcast [1 x %variant]* %varargslots18 to %variant* + %19 = insertvalue %"variant[]" undef, %variant* %18, 0 + %20 = insertvalue %"variant[]" %19, i64 1, 1 + store %"variant[]" %20, %"variant[]"* %taddr19, align 8 + %21 = bitcast %"variant[]"* %taddr19 to { i8*, i64 }* + %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 0 + %lo20 = load i8*, i8** %22, align 8 + %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 1 + %hi21 = load i64, i64* %23, align 8 + %24 = call i64 @std_io_printfln(i64* %retparam17, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i32 0, i32 0), i64 13, i8* %lo20, i64 %hi21) + %not_err22 = icmp eq i64 %24, 0 + br i1 %not_err22, label %after_check23, label %voiderr24 -after_check28: ; preds = %if.then18 - br label %voiderr29 +after_check23: ; preds = %if.then16 + br label %voiderr24 -voiderr29: ; preds = %after_check28, %if.then18 - br label %if.exit30 +voiderr24: ; preds = %after_check23, %if.then16 + br label %if.exit25 -if.exit30: ; preds = %voiderr29, %end_block16 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0), i64 9 }, %"char[]"* %taddr32, align 8 - %31 = bitcast %"char[]"* %taddr32 to { i8*, i64 }* - %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 - %lo33 = load i8*, i8** %32, align 8 - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 - %hi34 = load i64, i64* %33, align 8 - %optval37 = load i64, i64* %a.f, align 8 - %not_err38 = icmp eq i64 %optval37, 0 - br i1 %not_err38, label %after_check39, label %voiderr44 +if.exit25: ; preds = %voiderr24, %end_block14 + %optval28 = load i64, i64* %a.f, align 8 + %not_err29 = icmp eq i64 %optval28, 0 + br i1 %not_err29, label %after_check30, label %voiderr36 -after_check39: ; preds = %if.exit30 - %34 = bitcast i32* %a to i8* - %35 = insertvalue %variant undef, i8* %34, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %37 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots36, i64 0, i64 0 - store %variant %36, %variant* %37, align 16 - %38 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg35, i32 0, i32 1 - store i64 1, i64* %38, align 8 - %39 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg35, i32 0, i32 0 - %40 = bitcast [1 x %variant]* %varargslots36 to %variant* - store %variant* %40, %variant** %39, align 8 - %41 = bitcast %"variant[]"* %vararg35 to { i8*, i64 }* - %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 - %lo40 = load i8*, i8** %42, align 8 - %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 - %hi41 = load i64, i64* %43, align 8 - %44 = call i64 @std_io_printfln(i64* %retparam31, i8* %lo33, i64 %hi34, i8* %lo40, i64 %hi41) - %not_err42 = icmp eq i64 %44, 0 - br i1 %not_err42, label %after_check43, label %voiderr44 +after_check30: ; preds = %if.exit25 + %25 = bitcast i32* %a to i8* + %26 = insertvalue %variant undef, i8* %25, 0 + %27 = insertvalue %variant %26, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %28 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots27, i64 0, i64 0 + store %variant %27, %variant* %28, align 16 + %29 = bitcast [1 x %variant]* %varargslots27 to %variant* + %30 = insertvalue %"variant[]" undef, %variant* %29, 0 + %31 = insertvalue %"variant[]" %30, i64 1, 1 + store %"variant[]" %31, %"variant[]"* %taddr31, align 8 + %32 = bitcast %"variant[]"* %taddr31 to { i8*, i64 }* + %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0 + %lo32 = load i8*, i8** %33, align 8 + %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1 + %hi33 = load i64, i64* %34, align 8 + %35 = call i64 @std_io_printfln(i64* %retparam26, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0), i64 9, i8* %lo32, i64 %hi33) + %not_err34 = icmp eq i64 %35, 0 + br i1 %not_err34, label %after_check35, label %voiderr36 -after_check43: ; preds = %after_check39 - br label %voiderr44 +after_check35: ; preds = %after_check30 + br label %voiderr36 -voiderr44: ; preds = %after_check43, %after_check39, %if.exit30 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i32 0, i32 0), i64 9 }, %"char[]"* %taddr46, align 8 - %45 = bitcast %"char[]"* %taddr46 to { i8*, i64 }* - %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 - %lo47 = load i8*, i8** %46, align 8 - %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 - %hi48 = load i64, i64* %47, align 8 - %optval51 = load i64, i64* %b.f, align 8 - %not_err52 = icmp eq i64 %optval51, 0 - br i1 %not_err52, label %after_check53, label %voiderr58 +voiderr36: ; preds = %after_check35, %after_check30, %if.exit25 + %optval39 = load i64, i64* %b.f, align 8 + %not_err40 = icmp eq i64 %optval39, 0 + br i1 %not_err40, label %after_check41, label %voiderr47 -after_check53: ; preds = %voiderr44 - %48 = bitcast i32* %b to i8* - %49 = insertvalue %variant undef, i8* %48, 0 - %50 = insertvalue %variant %49, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %51 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots50, i64 0, i64 0 - store %variant %50, %variant* %51, align 16 - %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg49, i32 0, i32 1 - store i64 1, i64* %52, align 8 - %53 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg49, i32 0, i32 0 - %54 = bitcast [1 x %variant]* %varargslots50 to %variant* - store %variant* %54, %variant** %53, align 8 - %55 = bitcast %"variant[]"* %vararg49 to { i8*, i64 }* - %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 0 - %lo54 = load i8*, i8** %56, align 8 - %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 1 - %hi55 = load i64, i64* %57, align 8 - %58 = call i64 @std_io_printfln(i64* %retparam45, i8* %lo47, i64 %hi48, i8* %lo54, i64 %hi55) - %not_err56 = icmp eq i64 %58, 0 - br i1 %not_err56, label %after_check57, label %voiderr58 +after_check41: ; preds = %voiderr36 + %36 = bitcast i32* %b to i8* + %37 = insertvalue %variant undef, i8* %36, 0 + %38 = insertvalue %variant %37, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %39 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots38, i64 0, i64 0 + store %variant %38, %variant* %39, align 16 + %40 = bitcast [1 x %variant]* %varargslots38 to %variant* + %41 = insertvalue %"variant[]" undef, %variant* %40, 0 + %42 = insertvalue %"variant[]" %41, i64 1, 1 + store %"variant[]" %42, %"variant[]"* %taddr42, align 8 + %43 = bitcast %"variant[]"* %taddr42 to { i8*, i64 }* + %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0 + %lo43 = load i8*, i8** %44, align 8 + %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1 + %hi44 = load i64, i64* %45, align 8 + %46 = call i64 @std_io_printfln(i64* %retparam37, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i32 0, i32 0), i64 9, i8* %lo43, i64 %hi44) + %not_err45 = icmp eq i64 %46, 0 + br i1 %not_err45, label %after_check46, label %voiderr47 -after_check57: ; preds = %after_check53 - br label %voiderr58 +after_check46: ; preds = %after_check41 + br label %voiderr47 -voiderr58: ; preds = %after_check57, %after_check53, %voiderr44 +voiderr47: ; preds = %after_check46, %after_check41, %voiderr36 ret void } @@ -498,22 +434,18 @@ entry: %b.f = alloca i64, align 8 %err = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %err10 = alloca i64, align 8 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 - %varargslots24 = alloca [1 x %variant], align 16 - %retparam31 = alloca i64, align 8 - %taddr32 = alloca %"char[]", align 8 - %vararg35 = alloca %"variant[]", align 8 - %varargslots36 = alloca [1 x %variant], align 16 - %retparam45 = alloca i64, align 8 - %taddr46 = alloca %"char[]", align 8 - %vararg49 = alloca %"variant[]", align 8 - %varargslots50 = alloca [1 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 + %err8 = alloca i64, align 8 + %retparam17 = alloca i64, align 8 + %varargslots18 = alloca [1 x %variant], align 16 + %taddr19 = alloca %"variant[]", align 8 + %retparam26 = alloca i64, align 8 + %varargslots27 = alloca [1 x %variant], align 16 + %taddr31 = alloca %"variant[]", align 8 + %retparam37 = alloca i64, align 8 + %varargslots38 = alloca [1 x %variant], align 16 + %taddr42 = alloca %"variant[]", align 8 store i32 23, i32* %x, align 4 store i64 0, i64* %x.f, align 8 store i32 1, i32* %a, align 4 @@ -564,158 +496,130 @@ end_block: ; preds = %after_check5, %assi br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i32 0, i32 0), i64 13 }, %"char[]"* %taddr, align 8 - %2 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 0 - %lo = load i8*, i8** %3, align 8 - %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 1 - %hi = load i64, i64* %4, align 8 - %5 = bitcast i64* %err to i8* - %6 = insertvalue %variant undef, i8* %5, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %8 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %7, %variant* %8, align 16 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %9, align 8 - %10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %11 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %11, %variant** %10, align 8 - %12 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 0 - %lo6 = load i8*, i8** %13, align 8 - %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 1 - %hi7 = load i64, i64* %14, align 8 - %15 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo6, i64 %hi7) - %not_err8 = icmp eq i64 %15, 0 - br i1 %not_err8, label %after_check9, label %voiderr + %2 = bitcast i64* %err to i8* + %3 = insertvalue %variant undef, i8* %2, 0 + %4 = insertvalue %variant %3, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %5 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %4, %variant* %5, align 16 + %6 = bitcast [1 x %variant]* %varargslots to %variant* + %7 = insertvalue %"variant[]" undef, %variant* %6, 0 + %8 = insertvalue %"variant[]" %7, i64 1, 1 + store %"variant[]" %8, %"variant[]"* %taddr, align 8 + %9 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %9, i32 0, i32 0 + %lo = load i8*, i8** %10, align 8 + %11 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %9, i32 0, i32 1 + %hi = load i64, i64* %11, align 8 + %12 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i32 0, i32 0), i64 13, i8* %lo, i64 %hi) + %not_err6 = icmp eq i64 %12, 0 + br i1 %not_err6, label %after_check7, label %voiderr -after_check9: ; preds = %if.then +after_check7: ; preds = %if.then br label %voiderr -voiderr: ; preds = %after_check9, %if.then +voiderr: ; preds = %after_check7, %if.then br label %if.exit if.exit: ; preds = %voiderr, %end_block - br label %testblock11 + br label %testblock9 -testblock11: ; preds = %if.exit - %optval12 = load i64, i64* %b.f, align 8 - %not_err13 = icmp eq i64 %optval12, 0 - br i1 %not_err13, label %after_check15, label %assign_optional14 +testblock9: ; preds = %if.exit + %optval10 = load i64, i64* %b.f, align 8 + %not_err11 = icmp eq i64 %optval10, 0 + br i1 %not_err11, label %after_check13, label %assign_optional12 -assign_optional14: ; preds = %testblock11 - store i64 %optval12, i64* %err10, align 8 - br label %end_block16 +assign_optional12: ; preds = %testblock9 + store i64 %optval10, i64* %err8, align 8 + br label %end_block14 -after_check15: ; preds = %testblock11 - store i64 0, i64* %err10, align 8 - br label %end_block16 +after_check13: ; preds = %testblock9 + store i64 0, i64* %err8, align 8 + br label %end_block14 -end_block16: ; preds = %after_check15, %assign_optional14 - %16 = load i64, i64* %err10, align 8 - %neq17 = icmp ne i64 %16, 0 - br i1 %neq17, label %if.then18, label %if.exit30 +end_block14: ; preds = %after_check13, %assign_optional12 + %13 = load i64, i64* %err8, align 8 + %neq15 = icmp ne i64 %13, 0 + br i1 %neq15, label %if.then16, label %if.exit25 -if.then18: ; preds = %end_block16 - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.9, i32 0, i32 0), i64 13 }, %"char[]"* %taddr20, align 8 - %17 = bitcast %"char[]"* %taddr20 to { i8*, i64 }* - %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 - %lo21 = load i8*, i8** %18, align 8 - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 - %hi22 = load i64, i64* %19, align 8 - %20 = bitcast i64* %err10 to i8* - %21 = insertvalue %variant undef, i8* %20, 0 - %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %23 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0 - store %variant %22, %variant* %23, align 16 - %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1 - store i64 1, i64* %24, align 8 - %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0 - %26 = bitcast [1 x %variant]* %varargslots24 to %variant* - store %variant* %26, %variant** %25, align 8 - %27 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }* - %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 - %lo25 = load i8*, i8** %28, align 8 - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 - %hi26 = load i64, i64* %29, align 8 - %30 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %30, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 +if.then16: ; preds = %end_block14 + %14 = bitcast i64* %err8 to i8* + %15 = insertvalue %variant undef, i8* %14, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %17 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots18, i64 0, i64 0 + store %variant %16, %variant* %17, align 16 + %18 = bitcast [1 x %variant]* %varargslots18 to %variant* + %19 = insertvalue %"variant[]" undef, %variant* %18, 0 + %20 = insertvalue %"variant[]" %19, i64 1, 1 + store %"variant[]" %20, %"variant[]"* %taddr19, align 8 + %21 = bitcast %"variant[]"* %taddr19 to { i8*, i64 }* + %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 0 + %lo20 = load i8*, i8** %22, align 8 + %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 1 + %hi21 = load i64, i64* %23, align 8 + %24 = call i64 @std_io_printfln(i64* %retparam17, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.9, i32 0, i32 0), i64 13, i8* %lo20, i64 %hi21) + %not_err22 = icmp eq i64 %24, 0 + br i1 %not_err22, label %after_check23, label %voiderr24 -after_check28: ; preds = %if.then18 - br label %voiderr29 +after_check23: ; preds = %if.then16 + br label %voiderr24 -voiderr29: ; preds = %after_check28, %if.then18 - br label %if.exit30 +voiderr24: ; preds = %after_check23, %if.then16 + br label %if.exit25 -if.exit30: ; preds = %voiderr29, %end_block16 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i32 0, i32 0), i64 9 }, %"char[]"* %taddr32, align 8 - %31 = bitcast %"char[]"* %taddr32 to { i8*, i64 }* - %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 - %lo33 = load i8*, i8** %32, align 8 - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 - %hi34 = load i64, i64* %33, align 8 - %optval37 = load i64, i64* %a.f, align 8 - %not_err38 = icmp eq i64 %optval37, 0 - br i1 %not_err38, label %after_check39, label %voiderr44 +if.exit25: ; preds = %voiderr24, %end_block14 + %optval28 = load i64, i64* %a.f, align 8 + %not_err29 = icmp eq i64 %optval28, 0 + br i1 %not_err29, label %after_check30, label %voiderr36 -after_check39: ; preds = %if.exit30 - %34 = bitcast i32* %a to i8* - %35 = insertvalue %variant undef, i8* %34, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %37 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots36, i64 0, i64 0 - store %variant %36, %variant* %37, align 16 - %38 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg35, i32 0, i32 1 - store i64 1, i64* %38, align 8 - %39 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg35, i32 0, i32 0 - %40 = bitcast [1 x %variant]* %varargslots36 to %variant* - store %variant* %40, %variant** %39, align 8 - %41 = bitcast %"variant[]"* %vararg35 to { i8*, i64 }* - %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 - %lo40 = load i8*, i8** %42, align 8 - %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 - %hi41 = load i64, i64* %43, align 8 - %44 = call i64 @std_io_printfln(i64* %retparam31, i8* %lo33, i64 %hi34, i8* %lo40, i64 %hi41) - %not_err42 = icmp eq i64 %44, 0 - br i1 %not_err42, label %after_check43, label %voiderr44 +after_check30: ; preds = %if.exit25 + %25 = bitcast i32* %a to i8* + %26 = insertvalue %variant undef, i8* %25, 0 + %27 = insertvalue %variant %26, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %28 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots27, i64 0, i64 0 + store %variant %27, %variant* %28, align 16 + %29 = bitcast [1 x %variant]* %varargslots27 to %variant* + %30 = insertvalue %"variant[]" undef, %variant* %29, 0 + %31 = insertvalue %"variant[]" %30, i64 1, 1 + store %"variant[]" %31, %"variant[]"* %taddr31, align 8 + %32 = bitcast %"variant[]"* %taddr31 to { i8*, i64 }* + %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0 + %lo32 = load i8*, i8** %33, align 8 + %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1 + %hi33 = load i64, i64* %34, align 8 + %35 = call i64 @std_io_printfln(i64* %retparam26, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i32 0, i32 0), i64 9, i8* %lo32, i64 %hi33) + %not_err34 = icmp eq i64 %35, 0 + br i1 %not_err34, label %after_check35, label %voiderr36 -after_check43: ; preds = %after_check39 - br label %voiderr44 +after_check35: ; preds = %after_check30 + br label %voiderr36 -voiderr44: ; preds = %after_check43, %after_check39, %if.exit30 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i32 0, i32 0), i64 9 }, %"char[]"* %taddr46, align 8 - %45 = bitcast %"char[]"* %taddr46 to { i8*, i64 }* - %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 - %lo47 = load i8*, i8** %46, align 8 - %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 - %hi48 = load i64, i64* %47, align 8 - %optval51 = load i64, i64* %b.f, align 8 - %not_err52 = icmp eq i64 %optval51, 0 - br i1 %not_err52, label %after_check53, label %voiderr58 +voiderr36: ; preds = %after_check35, %after_check30, %if.exit25 + %optval39 = load i64, i64* %b.f, align 8 + %not_err40 = icmp eq i64 %optval39, 0 + br i1 %not_err40, label %after_check41, label %voiderr47 -after_check53: ; preds = %voiderr44 - %48 = bitcast i32* %b to i8* - %49 = insertvalue %variant undef, i8* %48, 0 - %50 = insertvalue %variant %49, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %51 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots50, i64 0, i64 0 - store %variant %50, %variant* %51, align 16 - %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg49, i32 0, i32 1 - store i64 1, i64* %52, align 8 - %53 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg49, i32 0, i32 0 - %54 = bitcast [1 x %variant]* %varargslots50 to %variant* - store %variant* %54, %variant** %53, align 8 - %55 = bitcast %"variant[]"* %vararg49 to { i8*, i64 }* - %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 0 - %lo54 = load i8*, i8** %56, align 8 - %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 1 - %hi55 = load i64, i64* %57, align 8 - %58 = call i64 @std_io_printfln(i64* %retparam45, i8* %lo47, i64 %hi48, i8* %lo54, i64 %hi55) - %not_err56 = icmp eq i64 %58, 0 - br i1 %not_err56, label %after_check57, label %voiderr58 +after_check41: ; preds = %voiderr36 + %36 = bitcast i32* %b to i8* + %37 = insertvalue %variant undef, i8* %36, 0 + %38 = insertvalue %variant %37, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %39 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots38, i64 0, i64 0 + store %variant %38, %variant* %39, align 16 + %40 = bitcast [1 x %variant]* %varargslots38 to %variant* + %41 = insertvalue %"variant[]" undef, %variant* %40, 0 + %42 = insertvalue %"variant[]" %41, i64 1, 1 + store %"variant[]" %42, %"variant[]"* %taddr42, align 8 + %43 = bitcast %"variant[]"* %taddr42 to { i8*, i64 }* + %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0 + %lo43 = load i8*, i8** %44, align 8 + %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1 + %hi44 = load i64, i64* %45, align 8 + %46 = call i64 @std_io_printfln(i64* %retparam37, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i32 0, i32 0), i64 9, i8* %lo43, i64 %hi44) + %not_err45 = icmp eq i64 %46, 0 + br i1 %not_err45, label %after_check46, label %voiderr47 -after_check57: ; preds = %after_check53 - br label %voiderr58 +after_check46: ; preds = %after_check41 + br label %voiderr47 -voiderr58: ; preds = %after_check57, %after_check53, %voiderr44 +voiderr47: ; preds = %after_check46, %after_check41, %voiderr36 ret void } \ No newline at end of file diff --git a/test/test_suite/errors/optional_with_optional.c3t b/test/test_suite/errors/optional_with_optional.c3t index 58bb8b228..cca90482e 100644 --- a/test/test_suite/errors/optional_with_optional.c3t +++ b/test/test_suite/errors/optional_with_optional.c3t @@ -36,78 +36,64 @@ fn int! get_b(int x) define void @test_main() #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 %retparam1 = alloca i32, align 4 %retparam2 = alloca i32, align 4 - %taddr8 = alloca i32, align 4 - %retparam13 = alloca i64, align 8 - %taddr14 = alloca %"char[]", align 8 - %vararg17 = alloca %"variant[]", align 8 - %varargslots18 = alloca [1 x %variant], align 16 - %retparam19 = alloca i32, align 4 - %retparam23 = alloca i32, align 4 - %taddr31 = alloca i32, align 4 - %retparam37 = alloca i64, align 8 - %taddr38 = alloca %"char[]", align 8 - %vararg41 = alloca %"variant[]", align 8 - %varargslots42 = alloca [1 x %variant], align 16 - %retparam43 = alloca i32, align 4 - %retparam47 = alloca i32, align 4 - %taddr55 = alloca i32, align 4 - %retparam61 = alloca i64, align 8 - %taddr62 = alloca %"char[]", align 8 - %vararg65 = alloca %"variant[]", align 8 - %varargslots66 = alloca [1 x %variant], align 16 - %taddr67 = alloca i64, align 8 - %retparam73 = alloca i64, align 8 - %taddr74 = alloca %"char[]", align 8 - %vararg77 = alloca %"variant[]", align 8 - %varargslots78 = alloca [1 x %variant], align 16 - %taddr79 = alloca i32, align 4 - %retparam85 = alloca i64, align 8 - %taddr86 = alloca %"char[]", align 8 - %vararg89 = alloca %"variant[]", align 8 - %varargslots90 = alloca [1 x %variant], align 16 - %taddr91 = alloca i64, align 8 - %retparam97 = alloca i64, align 8 - %taddr98 = alloca %"char[]", align 8 - %vararg101 = alloca %"variant[]", align 8 - %varargslots102 = alloca [1 x %variant], align 16 + %taddr = alloca i32, align 4 + %taddr8 = alloca %"variant[]", align 8 + %retparam11 = alloca i64, align 8 + %varargslots12 = alloca [1 x %variant], align 16 + %retparam13 = alloca i32, align 4 + %retparam17 = alloca i32, align 4 + %taddr25 = alloca i32, align 4 + %taddr26 = alloca %"variant[]", align 8 + %retparam32 = alloca i64, align 8 + %varargslots33 = alloca [1 x %variant], align 16 + %retparam34 = alloca i32, align 4 + %retparam38 = alloca i32, align 4 + %taddr46 = alloca i32, align 4 + %taddr47 = alloca %"variant[]", align 8 + %retparam53 = alloca i64, align 8 + %varargslots54 = alloca [1 x %variant], align 16 + %taddr55 = alloca i64, align 8 + %taddr56 = alloca %"variant[]", align 8 + %retparam62 = alloca i64, align 8 + %varargslots63 = alloca [1 x %variant], align 16 + %taddr64 = alloca i32, align 4 + %taddr65 = alloca %"variant[]", align 8 + %retparam71 = alloca i64, align 8 + %varargslots72 = alloca [1 x %variant], align 16 + %taddr73 = alloca i64, align 8 + %taddr74 = alloca %"variant[]", align 8 + %retparam80 = alloca i64, align 8 + %varargslots81 = alloca [1 x %variant], align 16 %error_var = alloca i64, align 8 + %taddr84 = alloca %"variant[]", align 8 %x = alloca i64, align 8 - %retparam110 = alloca i64, align 8 - %taddr111 = alloca %"char[]", align 8 - %vararg114 = alloca %"variant[]", align 8 - %varargslots115 = alloca [1 x %variant], align 16 + %retparam90 = alloca i64, align 8 + %varargslots91 = alloca [1 x %variant], align 16 + %taddr92 = alloca %"variant[]", align 8 %xy = alloca i32, align 4 %xy.f = alloca i64, align 8 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0), i64 4 }, %"char[]"* %taddr, align 8 - %0 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %1 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 0 - %lo = load i8*, i8** %1, align 8 - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 1 - %hi = load i64, i64* %2, align 8 - %3 = call i64 @test_get_a(i32* %retparam1, i32 1) - %not_err = icmp eq i64 %3, 0 + %0 = call i64 @test_get_a(i32* %retparam1, i32 1) + %not_err = icmp eq i64 %0, 0 br i1 %not_err, label %after_check, label %else_block after_check: ; preds = %entry - %4 = load i32, i32* %retparam1, align 4 + %1 = load i32, i32* %retparam1, align 4 br label %phi_block else_block: ; preds = %entry - %5 = call i64 @test_get_b(i32* %retparam2, i32 4) - %not_err3 = icmp eq i64 %5, 0 + %2 = call i64 @test_get_b(i32* %retparam2, i32 4) + %not_err3 = icmp eq i64 %2, 0 br i1 %not_err3, label %after_check4, label %else_block5 after_check4: ; preds = %else_block - %6 = load i32, i32* %retparam2, align 4 + %3 = load i32, i32* %retparam2, align 4 br label %phi_block phi_block: ; preds = %after_check4, %after_check - %val = phi i32 [ %4, %after_check ], [ %6, %after_check4 ] + %val = phi i32 [ %1, %after_check ], [ %3, %after_check4 ] br label %phi_block6 else_block5: ; preds = %else_block @@ -115,298 +101,248 @@ else_block5: ; preds = %else_block phi_block6: ; preds = %else_block5, %phi_block %val7 = phi i32 [ %val, %phi_block ], [ -1, %else_block5 ] - store i32 %val7, i32* %taddr8, align 4 - %7 = bitcast i32* %taddr8 to i8* - %8 = insertvalue %variant undef, i8* %7, 0 - %9 = insertvalue %variant %8, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %10 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %9, %variant* %10, align 16 - %11 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %11, align 8 - %12 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %13 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %13, %variant** %12, align 8 - %14 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 0 - %lo9 = load i8*, i8** %15, align 8 - %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 1 - %hi10 = load i64, i64* %16, align 8 - %17 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo9, i64 %hi10) - %not_err11 = icmp eq i64 %17, 0 - br i1 %not_err11, label %after_check12, label %voiderr + store i32 %val7, i32* %taddr, align 4 + %4 = bitcast i32* %taddr to i8* + %5 = insertvalue %variant undef, i8* %4, 0 + %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %6, %variant* %7, align 16 + %8 = bitcast [1 x %variant]* %varargslots to %variant* + %9 = insertvalue %"variant[]" undef, %variant* %8, 0 + %10 = insertvalue %"variant[]" %9, i64 1, 1 + store %"variant[]" %10, %"variant[]"* %taddr8, align 8 + %11 = bitcast %"variant[]"* %taddr8 to { i8*, i64 }* + %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 + %lo = load i8*, i8** %12, align 8 + %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 + %hi = load i64, i64* %13, align 8 + %14 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0), i64 4, i8* %lo, i64 %hi) + %not_err9 = icmp eq i64 %14, 0 + br i1 %not_err9, label %after_check10, label %voiderr -after_check12: ; preds = %phi_block6 +after_check10: ; preds = %phi_block6 br label %voiderr -voiderr: ; preds = %after_check12, %phi_block6 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0), i64 4 }, %"char[]"* %taddr14, align 8 - %18 = bitcast %"char[]"* %taddr14 to { i8*, i64 }* - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 - %lo15 = load i8*, i8** %19, align 8 - %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 - %hi16 = load i64, i64* %20, align 8 - %21 = call i64 @test_get_a(i32* %retparam19, i32 2) - %not_err20 = icmp eq i64 %21, 0 - br i1 %not_err20, label %after_check21, label %else_block22 +voiderr: ; preds = %after_check10, %phi_block6 + %15 = call i64 @test_get_a(i32* %retparam13, i32 2) + %not_err14 = icmp eq i64 %15, 0 + br i1 %not_err14, label %after_check15, label %else_block16 -after_check21: ; preds = %voiderr - %22 = load i32, i32* %retparam19, align 4 - br label %phi_block26 +after_check15: ; preds = %voiderr + %16 = load i32, i32* %retparam13, align 4 + br label %phi_block20 -else_block22: ; preds = %voiderr - %23 = call i64 @test_get_b(i32* %retparam23, i32 4) - %not_err24 = icmp eq i64 %23, 0 - br i1 %not_err24, label %after_check25, label %else_block28 +else_block16: ; preds = %voiderr + %17 = call i64 @test_get_b(i32* %retparam17, i32 4) + %not_err18 = icmp eq i64 %17, 0 + br i1 %not_err18, label %after_check19, label %else_block22 -after_check25: ; preds = %else_block22 - %24 = load i32, i32* %retparam23, align 4 - br label %phi_block26 +after_check19: ; preds = %else_block16 + %18 = load i32, i32* %retparam17, align 4 + br label %phi_block20 -phi_block26: ; preds = %after_check25, %after_check21 - %val27 = phi i32 [ %22, %after_check21 ], [ %24, %after_check25 ] - br label %phi_block29 +phi_block20: ; preds = %after_check19, %after_check15 + %val21 = phi i32 [ %16, %after_check15 ], [ %18, %after_check19 ] + br label %phi_block23 -else_block28: ; preds = %else_block22 - br label %phi_block29 +else_block22: ; preds = %else_block16 + br label %phi_block23 -phi_block29: ; preds = %else_block28, %phi_block26 - %val30 = phi i32 [ %val27, %phi_block26 ], [ -1, %else_block28 ] - store i32 %val30, i32* %taddr31, align 4 - %25 = bitcast i32* %taddr31 to i8* - %26 = insertvalue %variant undef, i8* %25, 0 - %27 = insertvalue %variant %26, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %28 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots18, i64 0, i64 0 - store %variant %27, %variant* %28, align 16 - %29 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg17, i32 0, i32 1 - store i64 1, i64* %29, align 8 - %30 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg17, i32 0, i32 0 - %31 = bitcast [1 x %variant]* %varargslots18 to %variant* - store %variant* %31, %variant** %30, align 8 - %32 = bitcast %"variant[]"* %vararg17 to { i8*, i64 }* - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0 - %lo32 = load i8*, i8** %33, align 8 - %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1 - %hi33 = load i64, i64* %34, align 8 - %35 = call i64 @std_io_printfln(i64* %retparam13, i8* %lo15, i64 %hi16, i8* %lo32, i64 %hi33) - %not_err34 = icmp eq i64 %35, 0 - br i1 %not_err34, label %after_check35, label %voiderr36 +phi_block23: ; preds = %else_block22, %phi_block20 + %val24 = phi i32 [ %val21, %phi_block20 ], [ -1, %else_block22 ] + store i32 %val24, i32* %taddr25, align 4 + %19 = bitcast i32* %taddr25 to i8* + %20 = insertvalue %variant undef, i8* %19, 0 + %21 = insertvalue %variant %20, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %22 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots12, i64 0, i64 0 + store %variant %21, %variant* %22, align 16 + %23 = bitcast [1 x %variant]* %varargslots12 to %variant* + %24 = insertvalue %"variant[]" undef, %variant* %23, 0 + %25 = insertvalue %"variant[]" %24, i64 1, 1 + store %"variant[]" %25, %"variant[]"* %taddr26, align 8 + %26 = bitcast %"variant[]"* %taddr26 to { i8*, i64 }* + %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 0 + %lo27 = load i8*, i8** %27, align 8 + %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 1 + %hi28 = load i64, i64* %28, align 8 + %29 = call i64 @std_io_printfln(i64* %retparam11, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0), i64 4, i8* %lo27, i64 %hi28) + %not_err29 = icmp eq i64 %29, 0 + br i1 %not_err29, label %after_check30, label %voiderr31 -after_check35: ; preds = %phi_block29 - br label %voiderr36 +after_check30: ; preds = %phi_block23 + br label %voiderr31 -voiderr36: ; preds = %after_check35, %phi_block29 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i32 0, i32 0), i64 4 }, %"char[]"* %taddr38, align 8 - %36 = bitcast %"char[]"* %taddr38 to { i8*, i64 }* - %37 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 0 - %lo39 = load i8*, i8** %37, align 8 - %38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 1 - %hi40 = load i64, i64* %38, align 8 - %39 = call i64 @test_get_a(i32* %retparam43, i32 1) - %not_err44 = icmp eq i64 %39, 0 - br i1 %not_err44, label %after_check45, label %else_block46 +voiderr31: ; preds = %after_check30, %phi_block23 + %30 = call i64 @test_get_a(i32* %retparam34, i32 1) + %not_err35 = icmp eq i64 %30, 0 + br i1 %not_err35, label %after_check36, label %else_block37 -after_check45: ; preds = %voiderr36 - %40 = load i32, i32* %retparam43, align 4 - br label %phi_block50 +after_check36: ; preds = %voiderr31 + %31 = load i32, i32* %retparam34, align 4 + br label %phi_block41 -else_block46: ; preds = %voiderr36 - %41 = call i64 @test_get_b(i32* %retparam47, i32 5) - %not_err48 = icmp eq i64 %41, 0 - br i1 %not_err48, label %after_check49, label %else_block52 +else_block37: ; preds = %voiderr31 + %32 = call i64 @test_get_b(i32* %retparam38, i32 5) + %not_err39 = icmp eq i64 %32, 0 + br i1 %not_err39, label %after_check40, label %else_block43 -after_check49: ; preds = %else_block46 - %42 = load i32, i32* %retparam47, align 4 - br label %phi_block50 +after_check40: ; preds = %else_block37 + %33 = load i32, i32* %retparam38, align 4 + br label %phi_block41 -phi_block50: ; preds = %after_check49, %after_check45 - %val51 = phi i32 [ %40, %after_check45 ], [ %42, %after_check49 ] - br label %phi_block53 +phi_block41: ; preds = %after_check40, %after_check36 + %val42 = phi i32 [ %31, %after_check36 ], [ %33, %after_check40 ] + br label %phi_block44 -else_block52: ; preds = %else_block46 - br label %phi_block53 +else_block43: ; preds = %else_block37 + br label %phi_block44 -phi_block53: ; preds = %else_block52, %phi_block50 - %val54 = phi i32 [ %val51, %phi_block50 ], [ -1, %else_block52 ] - store i32 %val54, i32* %taddr55, align 4 - %43 = bitcast i32* %taddr55 to i8* - %44 = insertvalue %variant undef, i8* %43, 0 - %45 = insertvalue %variant %44, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %46 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots42, i64 0, i64 0 - store %variant %45, %variant* %46, align 16 - %47 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg41, i32 0, i32 1 - store i64 1, i64* %47, align 8 - %48 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg41, i32 0, i32 0 - %49 = bitcast [1 x %variant]* %varargslots42 to %variant* - store %variant* %49, %variant** %48, align 8 - %50 = bitcast %"variant[]"* %vararg41 to { i8*, i64 }* - %51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %50, i32 0, i32 0 - %lo56 = load i8*, i8** %51, align 8 - %52 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %50, i32 0, i32 1 - %hi57 = load i64, i64* %52, align 8 - %53 = call i64 @std_io_printfln(i64* %retparam37, i8* %lo39, i64 %hi40, i8* %lo56, i64 %hi57) - %not_err58 = icmp eq i64 %53, 0 - br i1 %not_err58, label %after_check59, label %voiderr60 +phi_block44: ; preds = %else_block43, %phi_block41 + %val45 = phi i32 [ %val42, %phi_block41 ], [ -1, %else_block43 ] + store i32 %val45, i32* %taddr46, align 4 + %34 = bitcast i32* %taddr46 to i8* + %35 = insertvalue %variant undef, i8* %34, 0 + %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %37 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots33, i64 0, i64 0 + store %variant %36, %variant* %37, align 16 + %38 = bitcast [1 x %variant]* %varargslots33 to %variant* + %39 = insertvalue %"variant[]" undef, %variant* %38, 0 + %40 = insertvalue %"variant[]" %39, i64 1, 1 + store %"variant[]" %40, %"variant[]"* %taddr47, align 8 + %41 = bitcast %"variant[]"* %taddr47 to { i8*, i64 }* + %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 + %lo48 = load i8*, i8** %42, align 8 + %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 + %hi49 = load i64, i64* %43, align 8 + %44 = call i64 @std_io_printfln(i64* %retparam32, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i32 0, i32 0), i64 4, i8* %lo48, i64 %hi49) + %not_err50 = icmp eq i64 %44, 0 + br i1 %not_err50, label %after_check51, label %voiderr52 -after_check59: ; preds = %phi_block53 - br label %voiderr60 +after_check51: ; preds = %phi_block44 + br label %voiderr52 -voiderr60: ; preds = %after_check59, %phi_block53 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i32 0, i32 0), i64 4 }, %"char[]"* %taddr62, align 8 - %54 = bitcast %"char[]"* %taddr62 to { i8*, i64 }* - %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 0 - %lo63 = load i8*, i8** %55, align 8 - %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 1 - %hi64 = load i64, i64* %56, align 8 - store i64 ptrtoint (%.fault* @"test_Foo$DEF" to i64), i64* %taddr67, align 8 - %57 = bitcast i64* %taddr67 to i8* - %58 = insertvalue %variant undef, i8* %57, 0 - %59 = insertvalue %variant %58, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %60 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots66, i64 0, i64 0 - store %variant %59, %variant* %60, align 16 - %61 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg65, i32 0, i32 1 - store i64 1, i64* %61, align 8 - %62 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg65, i32 0, i32 0 - %63 = bitcast [1 x %variant]* %varargslots66 to %variant* - store %variant* %63, %variant** %62, align 8 - %64 = bitcast %"variant[]"* %vararg65 to { i8*, i64 }* - %65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 0 - %lo68 = load i8*, i8** %65, align 8 - %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 1 - %hi69 = load i64, i64* %66, align 8 - %67 = call i64 @std_io_printfln(i64* %retparam61, i8* %lo63, i64 %hi64, i8* %lo68, i64 %hi69) - %not_err70 = icmp eq i64 %67, 0 - br i1 %not_err70, label %after_check71, label %voiderr72 +voiderr52: ; preds = %after_check51, %phi_block44 + store i64 ptrtoint (%.fault* @"test_Foo$DEF" to i64), i64* %taddr55, align 8 + %45 = bitcast i64* %taddr55 to i8* + %46 = insertvalue %variant undef, i8* %45, 0 + %47 = insertvalue %variant %46, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %48 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots54, i64 0, i64 0 + store %variant %47, %variant* %48, align 16 + %49 = bitcast [1 x %variant]* %varargslots54 to %variant* + %50 = insertvalue %"variant[]" undef, %variant* %49, 0 + %51 = insertvalue %"variant[]" %50, i64 1, 1 + store %"variant[]" %51, %"variant[]"* %taddr56, align 8 + %52 = bitcast %"variant[]"* %taddr56 to { i8*, i64 }* + %53 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %52, i32 0, i32 0 + %lo57 = load i8*, i8** %53, align 8 + %54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %52, i32 0, i32 1 + %hi58 = load i64, i64* %54, align 8 + %55 = call i64 @std_io_printfln(i64* %retparam53, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i32 0, i32 0), i64 4, i8* %lo57, i64 %hi58) + %not_err59 = icmp eq i64 %55, 0 + br i1 %not_err59, label %after_check60, label %voiderr61 -after_check71: ; preds = %voiderr60 - br label %voiderr72 +after_check60: ; preds = %voiderr52 + br label %voiderr61 -voiderr72: ; preds = %after_check71, %voiderr60 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i32 0, i32 0), i64 4 }, %"char[]"* %taddr74, align 8 - %68 = bitcast %"char[]"* %taddr74 to { i8*, i64 }* - %69 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %68, i32 0, i32 0 - %lo75 = load i8*, i8** %69, align 8 - %70 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %68, i32 0, i32 1 - %hi76 = load i64, i64* %70, align 8 - store i32 3, i32* %taddr79, align 4 - %71 = bitcast i32* %taddr79 to i8* - %72 = insertvalue %variant undef, i8* %71, 0 - %73 = insertvalue %variant %72, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %74 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots78, i64 0, i64 0 - store %variant %73, %variant* %74, align 16 - %75 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg77, i32 0, i32 1 - store i64 1, i64* %75, align 8 - %76 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg77, i32 0, i32 0 - %77 = bitcast [1 x %variant]* %varargslots78 to %variant* - store %variant* %77, %variant** %76, align 8 - %78 = bitcast %"variant[]"* %vararg77 to { i8*, i64 }* - %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0 - %lo80 = load i8*, i8** %79, align 8 - %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1 - %hi81 = load i64, i64* %80, align 8 - %81 = call i64 @std_io_printfln(i64* %retparam73, i8* %lo75, i64 %hi76, i8* %lo80, i64 %hi81) - %not_err82 = icmp eq i64 %81, 0 - br i1 %not_err82, label %after_check83, label %voiderr84 +voiderr61: ; preds = %after_check60, %voiderr52 + store i32 3, i32* %taddr64, align 4 + %56 = bitcast i32* %taddr64 to i8* + %57 = insertvalue %variant undef, i8* %56, 0 + %58 = insertvalue %variant %57, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %59 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots63, i64 0, i64 0 + store %variant %58, %variant* %59, align 16 + %60 = bitcast [1 x %variant]* %varargslots63 to %variant* + %61 = insertvalue %"variant[]" undef, %variant* %60, 0 + %62 = insertvalue %"variant[]" %61, i64 1, 1 + store %"variant[]" %62, %"variant[]"* %taddr65, align 8 + %63 = bitcast %"variant[]"* %taddr65 to { i8*, i64 }* + %64 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %63, i32 0, i32 0 + %lo66 = load i8*, i8** %64, align 8 + %65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %63, i32 0, i32 1 + %hi67 = load i64, i64* %65, align 8 + %66 = call i64 @std_io_printfln(i64* %retparam62, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i32 0, i32 0), i64 4, i8* %lo66, i64 %hi67) + %not_err68 = icmp eq i64 %66, 0 + br i1 %not_err68, label %after_check69, label %voiderr70 -after_check83: ; preds = %voiderr72 - br label %voiderr84 +after_check69: ; preds = %voiderr61 + br label %voiderr70 -voiderr84: ; preds = %after_check83, %voiderr72 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0), i64 4 }, %"char[]"* %taddr86, align 8 - %82 = bitcast %"char[]"* %taddr86 to { i8*, i64 }* - %83 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %82, i32 0, i32 0 - %lo87 = load i8*, i8** %83, align 8 - %84 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %82, i32 0, i32 1 - %hi88 = load i64, i64* %84, align 8 - store i64 ptrtoint (%.fault* @"test_Foo$DEF" to i64), i64* %taddr91, align 8 - %85 = bitcast i64* %taddr91 to i8* - %86 = insertvalue %variant undef, i8* %85, 0 - %87 = insertvalue %variant %86, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %88 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots90, i64 0, i64 0 - store %variant %87, %variant* %88, align 16 - %89 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg89, i32 0, i32 1 - store i64 1, i64* %89, align 8 - %90 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg89, i32 0, i32 0 - %91 = bitcast [1 x %variant]* %varargslots90 to %variant* - store %variant* %91, %variant** %90, align 8 - %92 = bitcast %"variant[]"* %vararg89 to { i8*, i64 }* - %93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 0 - %lo92 = load i8*, i8** %93, align 8 - %94 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 1 - %hi93 = load i64, i64* %94, align 8 - %95 = call i64 @std_io_printfln(i64* %retparam85, i8* %lo87, i64 %hi88, i8* %lo92, i64 %hi93) - %not_err94 = icmp eq i64 %95, 0 - br i1 %not_err94, label %after_check95, label %voiderr96 +voiderr70: ; preds = %after_check69, %voiderr61 + store i64 ptrtoint (%.fault* @"test_Foo$DEF" to i64), i64* %taddr73, align 8 + %67 = bitcast i64* %taddr73 to i8* + %68 = insertvalue %variant undef, i8* %67, 0 + %69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %70 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots72, i64 0, i64 0 + store %variant %69, %variant* %70, align 16 + %71 = bitcast [1 x %variant]* %varargslots72 to %variant* + %72 = insertvalue %"variant[]" undef, %variant* %71, 0 + %73 = insertvalue %"variant[]" %72, i64 1, 1 + store %"variant[]" %73, %"variant[]"* %taddr74, align 8 + %74 = bitcast %"variant[]"* %taddr74 to { i8*, i64 }* + %75 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 0 + %lo75 = load i8*, i8** %75, align 8 + %76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 1 + %hi76 = load i64, i64* %76, align 8 + %77 = call i64 @std_io_printfln(i64* %retparam71, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0), i64 4, i8* %lo75, i64 %hi76) + %not_err77 = icmp eq i64 %77, 0 + br i1 %not_err77, label %after_check78, label %voiderr79 -after_check95: ; preds = %voiderr84 - br label %voiderr96 +after_check78: ; preds = %voiderr70 + br label %voiderr79 -voiderr96: ; preds = %after_check95, %voiderr84 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i32 0, i32 0), i64 4 }, %"char[]"* %taddr98, align 8 - %96 = bitcast %"char[]"* %taddr98 to { i8*, i64 }* - %97 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %96, i32 0, i32 0 - %lo99 = load i8*, i8** %97, align 8 - %98 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %96, i32 0, i32 1 - %hi100 = load i64, i64* %98, align 8 +voiderr79: ; preds = %after_check78, %voiderr70 store i64 0, i64* %error_var, align 8 - br label %phi_block104 + br label %phi_block83 -phi_block104: ; preds = %voiderr96 +phi_block83: ; preds = %voiderr79 br label %noerr_block -noerr_block: ; preds = %phi_block104 - %99 = bitcast i64* %error_var to i8* - %100 = insertvalue %variant undef, i8* %99, 0 - %101 = insertvalue %variant %100, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %102 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots102, i64 0, i64 0 - store %variant %101, %variant* %102, align 16 - %103 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg101, i32 0, i32 1 - store i64 1, i64* %103, align 8 - %104 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg101, i32 0, i32 0 - %105 = bitcast [1 x %variant]* %varargslots102 to %variant* - store %variant* %105, %variant** %104, align 8 - %106 = bitcast %"variant[]"* %vararg101 to { i8*, i64 }* - %107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 0 - %lo105 = load i8*, i8** %107, align 8 - %108 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 1 - %hi106 = load i64, i64* %108, align 8 - %109 = call i64 @std_io_printfln(i64* %retparam97, i8* %lo99, i64 %hi100, i8* %lo105, i64 %hi106) - %not_err107 = icmp eq i64 %109, 0 - br i1 %not_err107, label %after_check108, label %voiderr109 +noerr_block: ; preds = %phi_block83 + %78 = bitcast i64* %error_var to i8* + %79 = insertvalue %variant undef, i8* %78, 0 + %80 = insertvalue %variant %79, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %81 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots81, i64 0, i64 0 + store %variant %80, %variant* %81, align 16 + %82 = bitcast [1 x %variant]* %varargslots81 to %variant* + %83 = insertvalue %"variant[]" undef, %variant* %82, 0 + %84 = insertvalue %"variant[]" %83, i64 1, 1 + store %"variant[]" %84, %"variant[]"* %taddr84, align 8 + %85 = bitcast %"variant[]"* %taddr84 to { i8*, i64 }* + %86 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %85, i32 0, i32 0 + %lo85 = load i8*, i8** %86, align 8 + %87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %85, i32 0, i32 1 + %hi86 = load i64, i64* %87, align 8 + %88 = call i64 @std_io_printfln(i64* %retparam80, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i32 0, i32 0), i64 4, i8* %lo85, i64 %hi86) + %not_err87 = icmp eq i64 %88, 0 + br i1 %not_err87, label %after_check88, label %voiderr89 -after_check108: ; preds = %noerr_block - br label %voiderr109 +after_check88: ; preds = %noerr_block + br label %voiderr89 -voiderr109: ; preds = %after_check108, %noerr_block +voiderr89: ; preds = %after_check88, %noerr_block store i64 3, i64* %x, align 8 - store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i32 0, i32 0), i64 4 }, %"char[]"* %taddr111, align 8 - %110 = bitcast %"char[]"* %taddr111 to { i8*, i64 }* - %111 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %110, i32 0, i32 0 - %lo112 = load i8*, i8** %111, align 8 - %112 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %110, i32 0, i32 1 - %hi113 = load i64, i64* %112, align 8 - %113 = bitcast i64* %x to i8* - %114 = insertvalue %variant undef, i8* %113, 0 - %115 = insertvalue %variant %114, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 - %116 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots115, i64 0, i64 0 - store %variant %115, %variant* %116, align 16 - %117 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg114, i32 0, i32 1 - store i64 1, i64* %117, align 8 - %118 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg114, i32 0, i32 0 - %119 = bitcast [1 x %variant]* %varargslots115 to %variant* - store %variant* %119, %variant** %118, align 8 - %120 = bitcast %"variant[]"* %vararg114 to { i8*, i64 }* - %121 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %120, i32 0, i32 0 - %lo116 = load i8*, i8** %121, align 8 - %122 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %120, i32 0, i32 1 - %hi117 = load i64, i64* %122, align 8 - %123 = call i64 @std_io_printfln(i64* %retparam110, i8* %lo112, i64 %hi113, i8* %lo116, i64 %hi117) - %not_err118 = icmp eq i64 %123, 0 - br i1 %not_err118, label %after_check119, label %voiderr120 + %89 = bitcast i64* %x to i8* + %90 = insertvalue %variant undef, i8* %89, 0 + %91 = insertvalue %variant %90, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1 + %92 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots91, i64 0, i64 0 + store %variant %91, %variant* %92, align 16 + %93 = bitcast [1 x %variant]* %varargslots91 to %variant* + %94 = insertvalue %"variant[]" undef, %variant* %93, 0 + %95 = insertvalue %"variant[]" %94, i64 1, 1 + store %"variant[]" %95, %"variant[]"* %taddr92, align 8 + %96 = bitcast %"variant[]"* %taddr92 to { i8*, i64 }* + %97 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %96, i32 0, i32 0 + %lo93 = load i8*, i8** %97, align 8 + %98 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %96, i32 0, i32 1 + %hi94 = load i64, i64* %98, align 8 + %99 = call i64 @std_io_printfln(i64* %retparam90, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i32 0, i32 0), i64 4, i8* %lo93, i64 %hi94) + %not_err95 = icmp eq i64 %99, 0 + br i1 %not_err95, label %after_check96, label %voiderr97 -after_check119: ; preds = %voiderr109 - br label %voiderr120 +after_check96: ; preds = %voiderr89 + br label %voiderr97 -voiderr120: ; preds = %after_check119, %voiderr109 +voiderr97: ; preds = %after_check96, %voiderr89 store i64 ptrtoint (%.fault* @"test_Foo$DEF" to i64), i64* %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 46e933c45..7eb743e17 100644 --- a/test/test_suite/errors/or_and_rethrow.c3t +++ b/test/test_suite/errors/or_and_rethrow.c3t @@ -42,39 +42,31 @@ fn void main() define i64 @foo_test(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 + %taddr = alloca i32, align 4 + %taddr1 = alloca %"variant[]", align 8 %error_var = alloca i64, align 8 %blockret = alloca i32, align 4 - %error_var4 = alloca i64, align 8 - %blockret5 = alloca i32, align 4 + %error_var2 = alloca i64, align 8 + %blockret3 = alloca i32, align 4 %reterr = alloca i64, align 8 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8 - %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 - %lo = load i8*, i8** %2, align 8 - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 - %hi = load i64, i64* %3, align 8 - store i32 %0, i32* %taddr1, align 4 - %4 = bitcast i32* %taddr1 to i8* - %5 = insertvalue %variant undef, i8* %4, 0 - %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %6, %variant* %7, align 16 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %8, align 8 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %10 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %10, %variant** %9, align 8 - %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 - %lo2 = load i8*, i8** %12, align 8 - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 - %hi3 = load i64, i64* %13, align 8 - %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %14, 0 + store i32 %0, i32* %taddr, align 4 + %1 = bitcast i32* %taddr to i8* + %2 = insertvalue %variant undef, i8* %1, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %3, %variant* %4, align 16 + %5 = bitcast [1 x %variant]* %varargslots to %variant* + %6 = insertvalue %"variant[]" undef, %variant* %5, 0 + %7 = insertvalue %"variant[]" %6, i64 1, 1 + store %"variant[]" %7, %"variant[]"* %taddr1, align 8 + %8 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 + %lo = load i8*, i8** %9, align 8 + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 + %hi = load i64, i64* %10, align 8 + %11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0), i64 8, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -93,70 +85,63 @@ opt_block_cleanup: ; preds = %or.rhs br label %guard_block guard_block: ; preds = %opt_block_cleanup - %15 = load i64, i64* %error_var, align 8 - ret i64 %15 + %12 = load i64, i64* %error_var, align 8 + ret i64 %12 or.phi: ; preds = %voiderr br label %if.then if.then: ; preds = %or.phi - %16 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0)) #1 + %13 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0)) #1 br label %if.exit if.exit: ; preds = %if.then - %17 = call i32 @std_io_println(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i32 0, i32 0)) #1 - store i64 ptrtoint (%.fault* @"foo_Foo$ABC" to i64), i64* %error_var4, align 8 - br label %opt_block_cleanup6 + %14 = call i32 @std_io_println(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i32 0, i32 0)) #1 + store i64 ptrtoint (%.fault* @"foo_Foo$ABC" to i64), i64* %error_var2, align 8 + br label %opt_block_cleanup4 -opt_block_cleanup6: ; preds = %if.exit +opt_block_cleanup4: ; preds = %if.exit call void @foo_blurb() - br label %guard_block7 + br label %guard_block5 -guard_block7: ; preds = %opt_block_cleanup6 - %18 = load i64, i64* %error_var4, align 8 - ret i64 %18 +guard_block5: ; preds = %opt_block_cleanup4 + %15 = load i64, i64* %error_var2, align 8 + ret i64 %15 -if.exit9: ; No predecessors! - %19 = call i32 @std_io_println(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i32 0, i32 0)) #1 +if.exit7: ; No predecessors! + %16 = call i32 @std_io_println(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i32 0, i32 0)) #1 ret i64 0 } +; Function Attrs: nounwind define i64 @foo_test2(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 + %taddr = alloca i32, align 4 + %taddr1 = alloca %"variant[]", align 8 %error_var = alloca i64, align 8 %blockret = alloca i32, align 4 - %error_var4 = alloca i64, align 8 - %blockret5 = alloca i32, align 4 + %error_var2 = alloca i64, align 8 + %blockret3 = alloca i32, align 4 %reterr = alloca i64, align 8 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0), i64 9 }, %"char[]"* %taddr, align 8 - %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 - %lo = load i8*, i8** %2, align 8 - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 - %hi = load i64, i64* %3, align 8 - store i32 %0, i32* %taddr1, align 4 - %4 = bitcast i32* %taddr1 to i8* - %5 = insertvalue %variant undef, i8* %4, 0 - %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %6, %variant* %7, align 16 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %8, align 8 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %10 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %10, %variant** %9, align 8 - %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 - %lo2 = load i8*, i8** %12, align 8 - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 - %hi3 = load i64, i64* %13, align 8 - %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %14, 0 + store i32 %0, i32* %taddr, align 4 + %1 = bitcast i32* %taddr to i8* + %2 = insertvalue %variant undef, i8* %1, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %3, %variant* %4, align 16 + %5 = bitcast [1 x %variant]* %varargslots to %variant* + %6 = insertvalue %"variant[]" undef, %variant* %5, 0 + %7 = insertvalue %"variant[]" %6, i64 1, 1 + store %"variant[]" %7, %"variant[]"* %taddr1, align 8 + %8 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 + %lo = load i8*, i8** %9, align 8 + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 + %hi = load i64, i64* %10, align 8 + %11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0), i64 9, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -175,26 +160,26 @@ opt_block_cleanup: ; preds = %and.rhs br label %guard_block guard_block: ; preds = %opt_block_cleanup - %15 = load i64, i64* %error_var, align 8 - ret i64 %15 + %12 = load i64, i64* %error_var, align 8 + ret i64 %12 and.phi: ; preds = %voiderr br label %if.exit if.exit: ; preds = %and.phi - %16 = call i32 @std_io_println(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i32 0, i32 0)) #1 - store i64 ptrtoint (%.fault* @"foo_Foo$ABC" to i64), i64* %error_var4, align 8 - br label %opt_block_cleanup6 + %13 = call i32 @std_io_println(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i32 0, i32 0)) #1 + store i64 ptrtoint (%.fault* @"foo_Foo$ABC" to i64), i64* %error_var2, align 8 + br label %opt_block_cleanup4 -opt_block_cleanup6: ; preds = %if.exit +opt_block_cleanup4: ; preds = %if.exit call void @foo_blurb() - br label %guard_block7 + br label %guard_block5 -guard_block7: ; preds = %opt_block_cleanup6 - %17 = load i64, i64* %error_var4, align 8 - ret i64 %17 +guard_block5: ; preds = %opt_block_cleanup4 + %14 = load i64, i64* %error_var2, align 8 + ret i64 %14 -if.exit8: ; No predecessors! - %18 = call i32 @std_io_println(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i32 0, i32 0)) #1 +if.exit6: ; No predecessors! + %15 = call i32 @std_io_println(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i32 0, i32 0)) #1 ret i64 0 } diff --git a/test/test_suite/errors/printing_errors.c3t b/test/test_suite/errors/printing_errors.c3t index 7cabe9ff2..df4a9c0e1 100644 --- a/test/test_suite/errors/printing_errors.c3t +++ b/test/test_suite/errors/printing_errors.c3t @@ -19,57 +19,49 @@ define void @test_main() #0 { entry: %x = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 - %taddr1 = alloca [5 x i8]*, align 8 + %taddr = alloca [5 x i8]*, align 8 %faultname_zero = alloca %"char[]", align 8 + %taddr1 = alloca %"variant[]", align 8 store i64 ptrtoint (%.fault* @"test_Cde$WORLD" to i64), i64* %x, align 8 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0), i64 6 }, %"char[]"* %taddr, align 8 - %0 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %1 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 0 - %lo = load i8*, i8** %1, align 8 - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 1 - %hi = load i64, i64* %2, align 8 - store [5 x i8]* bitcast ([6 x i8]* @.str.2 to [5 x i8]*), [5 x i8]** %taddr1, align 8 - %3 = bitcast [5 x i8]** %taddr1 to i8* - %4 = insertvalue %variant undef, i8* %3, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 - %6 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 - store %variant %5, %variant* %6, align 16 - %7 = load i64, i64* %x, align 8 - %eq = icmp eq i64 %7, 0 + store [5 x i8]* bitcast ([6 x i8]* @.str.2 to [5 x i8]*), [5 x i8]** %taddr, align 8 + %0 = bitcast [5 x i8]** %taddr to i8* + %1 = insertvalue %variant undef, i8* %0, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1 + %3 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 + store %variant %2, %variant* %3, align 16 + %4 = load i64, i64* %x, align 8 + %eq = icmp eq i64 %4, 0 br i1 %eq, label %faultname_no, label %faultname_ok faultname_no: ; preds = %entry - %8 = bitcast %"char[]"* %faultname_zero to i8* - call void @llvm.memset.p0i8.i64(i8* align 8 %8, i8 0, i64 16, i1 false) + %5 = bitcast %"char[]"* %faultname_zero to i8* + call void @llvm.memset.p0i8.i64(i8* align 8 %5, i8 0, i64 16, i1 false) br label %faultname_exit faultname_ok: ; preds = %entry - %9 = inttoptr i64 %7 to %.fault* - %10 = getelementptr inbounds %.fault, %.fault* %9, i32 0, i32 1 + %6 = inttoptr i64 %4 to %.fault* + %7 = getelementptr inbounds %.fault, %.fault* %6, i32 0, i32 1 br label %faultname_exit faultname_exit: ; preds = %faultname_ok, %faultname_no - %faultname = phi %"char[]"* [ %faultname_zero, %faultname_no ], [ %10, %faultname_ok ] - %11 = bitcast %"char[]"* %faultname to i8* - %12 = insertvalue %variant undef, i8* %11, 0 - %13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$sa$char" to i64), 1 - %14 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 - store %variant %13, %variant* %14, align 16 - %15 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 2, i64* %15, align 8 - %16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %17 = bitcast [2 x %variant]* %varargslots to %variant* - store %variant* %17, %variant** %16, align 8 - %18 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 - %lo2 = load i8*, i8** %19, align 8 - %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 - %hi3 = load i64, i64* %20, align 8 - %21 = call i64 @std_io_printf(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %21, 0 + %faultname = phi %"char[]"* [ %faultname_zero, %faultname_no ], [ %7, %faultname_ok ] + %8 = bitcast %"char[]"* %faultname to i8* + %9 = insertvalue %variant undef, i8* %8, 0 + %10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$sa$char" to i64), 1 + %11 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 + store %variant %10, %variant* %11, align 16 + %12 = bitcast [2 x %variant]* %varargslots to %variant* + %13 = insertvalue %"variant[]" undef, %variant* %12, 0 + %14 = insertvalue %"variant[]" %13, i64 2, 1 + store %"variant[]" %14, %"variant[]"* %taddr1, align 8 + %15 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 0 + %lo = load i8*, i8** %16, align 8 + %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 1 + %hi = load i64, i64* %17, align 8 + %18 = call i64 @std_io_printf(i64* %retparam, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0), i64 6, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %18, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %faultname_exit diff --git a/test/test_suite/expressions/optional_ternary.c3t b/test/test_suite/expressions/optional_ternary.c3t index e1dc71fb3..958d3e9d8 100644 --- a/test/test_suite/expressions/optional_ternary.c3t +++ b/test/test_suite/expressions/optional_ternary.c3t @@ -327,55 +327,58 @@ after_check: ; preds = %entry br label %noerr_block panic_block: ; preds = %assign_optional - call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.1, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.2, i64 0, i64 0), i32 51) + %2 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %2(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.panic_msg, i64 0, i64 0), i64 27, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.file, i64 0, i64 0), i64 19, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.func, i64 0, i64 0), i64 4, i32 51) unreachable noerr_block: ; preds = %after_check - %2 = call i64 @test_test7(i32* %retparam2, i32 0) - %not_err3 = icmp eq i64 %2, 0 + %3 = call i64 @test_test7(i32* %retparam2, i32 0) + %not_err3 = icmp eq i64 %3, 0 br i1 %not_err3, label %after_check5, label %assign_optional4 assign_optional4: ; preds = %noerr_block - store i64 %2, i64* %error_var1, align 8 + store i64 %3, i64* %error_var1, align 8 br label %panic_block6 after_check5: ; preds = %noerr_block - %3 = load i32, i32* %retparam2, align 4 + %4 = load i32, i32* %retparam2, align 4 br label %noerr_block7 panic_block6: ; preds = %assign_optional4 - call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.3, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.4, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.5, i64 0, i64 0), i32 52) + %5 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %5(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.panic_msg.1, i64 0, i64 0), i64 27, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.file.2, i64 0, i64 0), i64 19, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.func.3, i64 0, i64 0), i64 4, i32 52) unreachable noerr_block7: ; preds = %after_check5 - %4 = call i64 @test_test6(i32* %retparam9, i32 1) - %not_err10 = icmp eq i64 %4, 0 + %6 = call i64 @test_test6(i32* %retparam9, i32 1) + %not_err10 = icmp eq i64 %6, 0 br i1 %not_err10, label %after_check12, label %assign_optional11 assign_optional11: ; preds = %noerr_block7 - store i64 %4, i64* %error_var8, align 8 + store i64 %6, i64* %error_var8, align 8 br label %panic_block13 after_check12: ; preds = %noerr_block7 - %5 = load i32, i32* %retparam9, align 4 + %7 = load i32, i32* %retparam9, align 4 br label %noerr_block14 panic_block13: ; preds = %assign_optional11 - call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.6, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.7, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.8, i64 0, i64 0), i32 53) + %8 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %8(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.panic_msg.4, i64 0, i64 0), i64 27, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.file.5, i64 0, i64 0), i64 19, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.func.6, i64 0, i64 0), i64 4, i32 53) unreachable noerr_block14: ; preds = %after_check12 - %6 = call i64 @test_test2(i32* %retparam15, i32 3) - %not_err16 = icmp eq i64 %6, 0 + %9 = call i64 @test_test2(i32* %retparam15, i32 3) + %not_err16 = icmp eq i64 %9, 0 br i1 %not_err16, label %after_check18, label %assign_optional17 assign_optional17: ; preds = %noerr_block14 - store i64 %6, i64* %i.f, align 8 + store i64 %9, i64* %i.f, align 8 br label %after_assign after_check18: ; preds = %noerr_block14 - %7 = load i32, i32* %retparam15, align 4 - store i32 %7, i32* %i, align 4 + %10 = load i32, i32* %retparam15, align 4 + store i32 %10, i32* %i, align 4 store i64 0, i64* %i.f, align 8 br label %after_assign diff --git a/test/test_suite/expressions/type_support.c3t b/test/test_suite/expressions/type_support.c3t index 1002721e4..fdf530741 100644 --- a/test/test_suite/expressions/type_support.c3t +++ b/test/test_suite/expressions/type_support.c3t @@ -26,52 +26,52 @@ fn void main() /* #expect: test.ll - store i64 0 - store i64 1 - store i8 0 - store i8 -1 - store i16 0 - store i16 -1 - store i64 4 - store i64 2 - store i32 0 - store i32 -1 - store i64 8 - store i64 0 - store i64 -1 - store i64 8 - store i64 0 - store i64 -1 - store i64 8 - store i64 0 - store i64 -1 - store i64 8 - store i64 0 - store i64 -1 - store i64 1 - store i8 -128 - store i8 127 - store i64 2 - store i16 -32768 - store i16 32767 - store i64 4 - store i32 -2147483648 - store i32 2147483647 - store i64 8 - store i64 -9223372036854775808 - store i64 9223372036854775807 - store i64 8 - store i64 -9223372036854775808 - store i64 9223372036854775807 - store i64 8 - store i64 -9223372036854775808 - store i64 9223372036854775807 - store i64 8 - store i64 -9223372036854775808 - store i64 9223372036854775807 - store i64 4 - store float 0xC7EFFFFFE0000000 - store float 0x47EFFFFFE0000000 - store i64 8 - store double 0xFFEFFFFFFFFFFFFF - store double 0x7FEFFFFFFFFFFFFF \ No newline at end of file +i64 0 +i64 1 +i8 0 +i8 -1 +i16 0 +i16 -1 +i64 4 +i64 2 +i32 0 +i32 -1 +i64 8 +i64 0 +i64 -1 +i64 8 +i64 0 +i64 -1 +i64 8 +i64 0 +i64 -1 +i64 8 +i64 0 +i64 -1 +i64 1 +i8 -128 +i8 127 +i64 2 +i16 -32768 +i16 32767 +i64 4 +i32 -2147483648 +i32 2147483647 +i64 8 +i64 -9223372036854775808 +i64 9223372036854775807 +i64 8 +i64 -9223372036854775808 +i64 9223372036854775807 +i64 8 +i64 -9223372036854775808 +i64 9223372036854775807 +i64 8 +i64 -9223372036854775808 +i64 9223372036854775807 +i64 4 +float 0xC7EFFFFFE0000000 +float 0x47EFFFFFE0000000 +i64 8 +double 0xFFEFFFFFFFFFFFFF +double 0x7FEFFFFFFFFFFFFF \ No newline at end of file diff --git a/test/test_suite/from_docs/examples_forswitch.c3t b/test/test_suite/from_docs/examples_forswitch.c3t index b65436fac..446c24e63 100644 --- a/test/test_suite/from_docs/examples_forswitch.c3t +++ b/test/test_suite/from_docs/examples_forswitch.c3t @@ -109,7 +109,8 @@ loop.body: ; preds = %loop.cond br label %loop.cond loop.exit: ; preds = %loop.cond - call void @std_core_builtin_panic(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.zstr.1, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.zstr.2, i64 0, i64 0), i32 14) + %4 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %4(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.panic_msg, i64 0, i64 0), i64 19, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.file, i64 0, i64 0), i64 21, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.func, i64 0, i64 0), i64 11, i32 14) unreachable unreachable_block: ; No predecessors! @@ -138,11 +139,11 @@ switch.entry: ; preds = %entry ] switch.case: ; preds = %switch.entry, %switch.entry - %2 = call i32 @std_io_println(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0)) #1 + %2 = call i32 @std_io_println(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0)) #1 br label %switch.exit switch.case1: ; preds = %switch.entry - %3 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i32 0, i32 0)) #1 + %3 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0)) #1 br label %switch.exit switch.exit: ; preds = %switch.case1, %switch.case, %switch.entry @@ -158,11 +159,11 @@ switch.entry3: ; preds = %switch.exit ] switch.case4: ; preds = %switch.entry3, %switch.entry3 - %5 = call i32 @std_io_println(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i32 0, i32 0)) #1 + %5 = call i32 @std_io_println(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0)) #1 br label %switch.exit6 switch.case5: ; preds = %switch.entry3 - %6 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0)) #1 + %6 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i32 0, i32 0)) #1 br label %switch.exit6 switch.exit6: ; preds = %switch.case5, %switch.case4, %switch.entry3 @@ -181,7 +182,7 @@ switch.case9: ; preds = %switch.entry8 br label %switch.exit12 switch.case10: ; preds = %switch.entry8 - %8 = call i32 @std_io_println(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i32 0, i32 0)) #1 + %8 = call i32 @std_io_println(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i32 0, i32 0)) #1 br label %switch.exit12 switch.case11: ; preds = %switch.entry8 @@ -219,16 +220,16 @@ switch.entry18: ; preds = %switch.exit16 switch.case19: ; preds = %switch.entry18 store i32 1, i32* %a, align 4 - %11 = call i32 @std_io_println(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i32 0, i32 0)) #1 + %11 = call i32 @std_io_println(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i32 0, i32 0)) #1 br label %switch.case20 switch.case20: ; preds = %switch.entry18, %switch.case19 store i32 2, i32* %a21, align 4 - %12 = call i32 @std_io_println(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i32 0, i32 0)) #1 + %12 = call i32 @std_io_println(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i32 0, i32 0)) #1 br label %switch.case22 switch.case22: ; preds = %switch.entry18, %switch.case20 - %13 = call i32 @std_io_println(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i32 0, i32 0)) #1 + %13 = call i32 @std_io_println(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i32 0, i32 0)) #1 br label %switch.exit23 switch.exit23: ; preds = %switch.case22, %switch.entry18 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 80cdba4bb..c0219d41b 100644 --- a/test/test_suite/functions/func_ptr_conversions_and_names.c3t +++ b/test/test_suite/functions/func_ptr_conversions_and_names.c3t @@ -62,296 +62,232 @@ entry: %a = alloca i32 (i32)*, align 8 %b = alloca i32 (i32)*, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 - %taddr10 = alloca i32, align 4 + %taddr = alloca i32, align 4 + %taddr1 = alloca %"variant[]", align 8 + %retparam2 = alloca i64, align 8 + %varargslots3 = alloca [1 x %variant], align 16 + %taddr4 = alloca i32, align 4 + %taddr5 = alloca %"variant[]", align 8 %z = alloca i32 (i32)*, align 8 - %retparam16 = alloca i64, align 8 - %taddr17 = alloca %"char[]", align 8 - %vararg20 = alloca %"variant[]", align 8 + %retparam11 = alloca i64, align 8 + %varargslots12 = alloca [1 x %variant], align 16 + %taddr13 = alloca i32, align 4 + %taddr14 = alloca %"variant[]", align 8 + %retparam20 = alloca i64, align 8 %varargslots21 = alloca [1 x %variant], align 16 - %taddr22 = alloca i32, align 4 - %retparam28 = alloca i64, align 8 - %taddr29 = alloca %"char[]", align 8 - %vararg32 = alloca %"variant[]", align 8 - %varargslots33 = alloca [1 x %variant], align 16 - %taddr34 = alloca [12 x i8]*, align 8 - %retparam40 = alloca i64, align 8 - %taddr41 = alloca %"char[]", align 8 - %vararg44 = alloca %"variant[]", align 8 - %varargslots45 = alloca [1 x %variant], align 16 - %taddr46 = alloca [12 x i8]*, align 8 - %retparam52 = alloca i64, align 8 - %taddr53 = alloca %"char[]", align 8 - %vararg56 = alloca %"variant[]", align 8 + %taddr22 = alloca [12 x i8]*, align 8 + %taddr23 = alloca %"variant[]", align 8 + %retparam29 = alloca i64, align 8 + %varargslots30 = alloca [1 x %variant], align 16 + %taddr31 = alloca [12 x i8]*, align 8 + %taddr32 = alloca %"variant[]", align 8 + %retparam38 = alloca i64, align 8 + %varargslots39 = alloca [1 x %variant], align 16 + %taddr40 = alloca [12 x i8]*, align 8 + %taddr41 = alloca %"variant[]", align 8 + %retparam47 = alloca i64, align 8 + %varargslots48 = alloca [1 x %variant], align 16 + %taddr49 = alloca [6 x i8]*, align 8 + %taddr50 = alloca %"variant[]", align 8 + %retparam56 = alloca i64, align 8 %varargslots57 = alloca [1 x %variant], align 16 - %taddr58 = alloca [12 x i8]*, align 8 - %retparam64 = alloca i64, align 8 - %taddr65 = alloca %"char[]", align 8 - %vararg68 = alloca %"variant[]", align 8 - %varargslots69 = alloca [1 x %variant], align 16 - %taddr70 = alloca [6 x i8]*, align 8 - %retparam76 = alloca i64, align 8 - %taddr77 = alloca %"char[]", align 8 - %vararg80 = alloca %"variant[]", align 8 - %varargslots81 = alloca [1 x %variant], align 16 - %taddr82 = alloca [13 x i8]*, align 8 + %taddr58 = alloca [13 x i8]*, align 8 + %taddr59 = alloca %"variant[]", align 8 %y = alloca i32 (i32)*, align 8 %zfoke = alloca i64, align 8 store i32 (i32)* @test_test, i32 (i32)** %a, align 8 store i32 (i32)* @test_test2, i32 (i32)** %b, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2 }, %"char[]"* %taddr, align 8 - %0 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %1 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 0 - %lo = load i8*, i8** %1, align 8 - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 1 - %hi = load i64, i64* %2, align 8 - %3 = load i32 (i32)*, i32 (i32)** %a, align 8 - %4 = call i32 %3(i32 123) - store i32 %4, i32* %taddr1, align 4 - %5 = bitcast i32* %taddr1 to i8* - %6 = insertvalue %variant undef, i8* %5, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %8 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %7, %variant* %8, align 16 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %9, align 8 - %10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %11 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %11, %variant** %10, align 8 - %12 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 0 - %lo2 = load i8*, i8** %13, align 8 - %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 1 - %hi3 = load i64, i64* %14, align 8 - %15 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %15, 0 + %0 = load i32 (i32)*, i32 (i32)** %a, align 8 + %1 = call i32 %0(i32 123) + store i32 %1, i32* %taddr, align 4 + %2 = bitcast i32* %taddr to i8* + %3 = insertvalue %variant undef, i8* %2, 0 + %4 = insertvalue %variant %3, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %5 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %4, %variant* %5, align 16 + %6 = bitcast [1 x %variant]* %varargslots to %variant* + %7 = insertvalue %"variant[]" undef, %variant* %6, 0 + %8 = insertvalue %"variant[]" %7, i64 1, 1 + store %"variant[]" %8, %"variant[]"* %taddr1, align 8 + %9 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %9, i32 0, i32 0 + %lo = load i8*, i8** %10, align 8 + %11 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %9, i32 0, i32 1 + %hi = load i64, i64* %11, align 8 + %12 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %12, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i32 0, i32 0), i64 2 }, %"char[]"* %taddr5, align 8 - %16 = bitcast %"char[]"* %taddr5 to { i8*, i64 }* - %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 0 - %lo6 = load i8*, i8** %17, align 8 - %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 1 - %hi7 = load i64, i64* %18, align 8 - %19 = call i32 @test_test2(i32 3) - store i32 %19, i32* %taddr10, align 4 - %20 = bitcast i32* %taddr10 to i8* - %21 = insertvalue %variant undef, i8* %20, 0 - %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %23 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots9, i64 0, i64 0 - store %variant %22, %variant* %23, align 16 - %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 1 - store i64 1, i64* %24, align 8 - %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 0 - %26 = bitcast [1 x %variant]* %varargslots9 to %variant* - store %variant* %26, %variant** %25, align 8 - %27 = bitcast %"variant[]"* %vararg8 to { i8*, i64 }* - %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 - %lo11 = load i8*, i8** %28, align 8 - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 - %hi12 = load i64, i64* %29, align 8 - %30 = call i64 @std_io_printfln(i64* %retparam4, i8* %lo6, i64 %hi7, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %30, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %13 = call i32 @test_test2(i32 3) + store i32 %13, i32* %taddr4, align 4 + %14 = bitcast i32* %taddr4 to i8* + %15 = insertvalue %variant undef, i8* %14, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %17 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots3, i64 0, i64 0 + store %variant %16, %variant* %17, align 16 + %18 = bitcast [1 x %variant]* %varargslots3 to %variant* + %19 = insertvalue %"variant[]" undef, %variant* %18, 0 + %20 = insertvalue %"variant[]" %19, i64 1, 1 + store %"variant[]" %20, %"variant[]"* %taddr5, align 8 + %21 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }* + %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 0 + %lo6 = load i8*, i8** %22, align 8 + %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 1 + %hi7 = load i64, i64* %23, align 8 + %24 = call i64 @std_io_printfln(i64* %retparam2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i32 0, i32 0), i64 2, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %24, 0 + br i1 %not_err8, label %after_check9, label %voiderr10 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check9: ; preds = %voiderr + br label %voiderr10 -voiderr15: ; preds = %after_check14, %voiderr +voiderr10: ; preds = %after_check9, %voiderr store i32 (i32)* @test_test2, i32 (i32)** %z, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2 }, %"char[]"* %taddr17, align 8 - %31 = bitcast %"char[]"* %taddr17 to { i8*, i64 }* - %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 - %lo18 = load i8*, i8** %32, align 8 - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 - %hi19 = load i64, i64* %33, align 8 - %34 = load i32 (i32)*, i32 (i32)** %z, align 8 - %35 = call i32 %34(i32 444) - store i32 %35, i32* %taddr22, align 4 - %36 = bitcast i32* %taddr22 to i8* - %37 = insertvalue %variant undef, i8* %36, 0 - %38 = insertvalue %variant %37, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %39 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots21, i64 0, i64 0 - store %variant %38, %variant* %39, align 16 - %40 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 1 - store i64 1, i64* %40, align 8 - %41 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 0 + %25 = load i32 (i32)*, i32 (i32)** %z, align 8 + %26 = call i32 %25(i32 444) + store i32 %26, i32* %taddr13, align 4 + %27 = bitcast i32* %taddr13 to i8* + %28 = insertvalue %variant undef, i8* %27, 0 + %29 = insertvalue %variant %28, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %30 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots12, i64 0, i64 0 + store %variant %29, %variant* %30, align 16 + %31 = bitcast [1 x %variant]* %varargslots12 to %variant* + %32 = insertvalue %"variant[]" undef, %variant* %31, 0 + %33 = insertvalue %"variant[]" %32, i64 1, 1 + store %"variant[]" %33, %"variant[]"* %taddr14, align 8 + %34 = bitcast %"variant[]"* %taddr14 to { i8*, i64 }* + %35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %34, i32 0, i32 0 + %lo15 = load i8*, i8** %35, align 8 + %36 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %34, i32 0, i32 1 + %hi16 = load i64, i64* %36, align 8 + %37 = call i64 @std_io_printfln(i64* %retparam11, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2, i8* %lo15, i64 %hi16) + %not_err17 = icmp eq i64 %37, 0 + br i1 %not_err17, label %after_check18, label %voiderr19 + +after_check18: ; preds = %voiderr10 + br label %voiderr19 + +voiderr19: ; preds = %after_check18, %voiderr10 + store [12 x i8]* bitcast ([13 x i8]* @.str.4 to [12 x i8]*), [12 x i8]** %taddr22, align 8 + %38 = bitcast [12 x i8]** %taddr22 to i8* + %39 = insertvalue %variant undef, i8* %38, 0 + %40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$p$a12$char" to i64), 1 + %41 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots21, i64 0, i64 0 + store %variant %40, %variant* %41, align 16 %42 = bitcast [1 x %variant]* %varargslots21 to %variant* - store %variant* %42, %variant** %41, align 8 - %43 = bitcast %"variant[]"* %vararg20 to { i8*, i64 }* - %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0 - %lo23 = load i8*, i8** %44, align 8 - %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1 - %hi24 = load i64, i64* %45, align 8 - %46 = call i64 @std_io_printfln(i64* %retparam16, i8* %lo18, i64 %hi19, i8* %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %46, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 + %43 = insertvalue %"variant[]" undef, %variant* %42, 0 + %44 = insertvalue %"variant[]" %43, i64 1, 1 + store %"variant[]" %44, %"variant[]"* %taddr23, align 8 + %45 = bitcast %"variant[]"* %taddr23 to { i8*, i64 }* + %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 + %lo24 = load i8*, i8** %46, align 8 + %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 + %hi25 = load i64, i64* %47, align 8 + %48 = call i64 @std_io_printfln(i64* %retparam20, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2, i8* %lo24, i64 %hi25) + %not_err26 = icmp eq i64 %48, 0 + br i1 %not_err26, label %after_check27, label %voiderr28 -after_check26: ; preds = %voiderr15 - br label %voiderr27 +after_check27: ; preds = %voiderr19 + br label %voiderr28 -voiderr27: ; preds = %after_check26, %voiderr15 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2 }, %"char[]"* %taddr29, align 8 - %47 = bitcast %"char[]"* %taddr29 to { i8*, i64 }* - %48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 0 - %lo30 = load i8*, i8** %48, align 8 - %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 1 - %hi31 = load i64, i64* %49, align 8 - store [12 x i8]* bitcast ([13 x i8]* @.str.4 to [12 x i8]*), [12 x i8]** %taddr34, align 8 - %50 = bitcast [12 x i8]** %taddr34 to i8* - %51 = insertvalue %variant undef, i8* %50, 0 - %52 = insertvalue %variant %51, i64 ptrtoint (%.introspect* @"ct$p$a12$char" to i64), 1 - %53 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots33, i64 0, i64 0 - store %variant %52, %variant* %53, align 16 - %54 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 1 - store i64 1, i64* %54, align 8 - %55 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 0 - %56 = bitcast [1 x %variant]* %varargslots33 to %variant* - store %variant* %56, %variant** %55, align 8 - %57 = bitcast %"variant[]"* %vararg32 to { i8*, i64 }* - %58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %57, i32 0, i32 0 - %lo35 = load i8*, i8** %58, align 8 - %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %57, i32 0, i32 1 - %hi36 = load i64, i64* %59, align 8 - %60 = call i64 @std_io_printfln(i64* %retparam28, i8* %lo30, i64 %hi31, i8* %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %60, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 +voiderr28: ; preds = %after_check27, %voiderr19 + store [12 x i8]* bitcast ([13 x i8]* @.str.6 to [12 x i8]*), [12 x i8]** %taddr31, align 8 + %49 = bitcast [12 x i8]** %taddr31 to i8* + %50 = insertvalue %variant undef, i8* %49, 0 + %51 = insertvalue %variant %50, i64 ptrtoint (%.introspect* @"ct$p$a12$char" to i64), 1 + %52 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots30, i64 0, i64 0 + store %variant %51, %variant* %52, align 16 + %53 = bitcast [1 x %variant]* %varargslots30 to %variant* + %54 = insertvalue %"variant[]" undef, %variant* %53, 0 + %55 = insertvalue %"variant[]" %54, i64 1, 1 + store %"variant[]" %55, %"variant[]"* %taddr32, align 8 + %56 = bitcast %"variant[]"* %taddr32 to { i8*, i64 }* + %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 0 + %lo33 = load i8*, i8** %57, align 8 + %58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 1 + %hi34 = load i64, i64* %58, align 8 + %59 = call i64 @std_io_printfln(i64* %retparam29, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0), i64 2, i8* %lo33, i64 %hi34) + %not_err35 = icmp eq i64 %59, 0 + br i1 %not_err35, label %after_check36, label %voiderr37 -after_check38: ; preds = %voiderr27 - br label %voiderr39 +after_check36: ; preds = %voiderr28 + br label %voiderr37 -voiderr39: ; preds = %after_check38, %voiderr27 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0), i64 2 }, %"char[]"* %taddr41, align 8 - %61 = bitcast %"char[]"* %taddr41 to { i8*, i64 }* - %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %61, i32 0, i32 0 - %lo42 = load i8*, i8** %62, align 8 - %63 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %61, i32 0, i32 1 - %hi43 = load i64, i64* %63, align 8 - store [12 x i8]* bitcast ([13 x i8]* @.str.6 to [12 x i8]*), [12 x i8]** %taddr46, align 8 - %64 = bitcast [12 x i8]** %taddr46 to i8* - %65 = insertvalue %variant undef, i8* %64, 0 - %66 = insertvalue %variant %65, i64 ptrtoint (%.introspect* @"ct$p$a12$char" to i64), 1 - %67 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots45, i64 0, i64 0 - store %variant %66, %variant* %67, align 16 - %68 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 1 - store i64 1, i64* %68, align 8 - %69 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 0 - %70 = bitcast [1 x %variant]* %varargslots45 to %variant* - store %variant* %70, %variant** %69, align 8 - %71 = bitcast %"variant[]"* %vararg44 to { i8*, i64 }* - %72 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %71, i32 0, i32 0 - %lo47 = load i8*, i8** %72, align 8 - %73 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %71, i32 0, i32 1 - %hi48 = load i64, i64* %73, align 8 - %74 = call i64 @std_io_printfln(i64* %retparam40, i8* %lo42, i64 %hi43, i8* %lo47, i64 %hi48) - %not_err49 = icmp eq i64 %74, 0 - br i1 %not_err49, label %after_check50, label %voiderr51 +voiderr37: ; preds = %after_check36, %voiderr28 + store [12 x i8]* bitcast ([13 x i8]* @.str.8 to [12 x i8]*), [12 x i8]** %taddr40, align 8 + %60 = bitcast [12 x i8]** %taddr40 to i8* + %61 = insertvalue %variant undef, i8* %60, 0 + %62 = insertvalue %variant %61, i64 ptrtoint (%.introspect* @"ct$p$a12$char" to i64), 1 + %63 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots39, i64 0, i64 0 + store %variant %62, %variant* %63, align 16 + %64 = bitcast [1 x %variant]* %varargslots39 to %variant* + %65 = insertvalue %"variant[]" undef, %variant* %64, 0 + %66 = insertvalue %"variant[]" %65, i64 1, 1 + store %"variant[]" %66, %"variant[]"* %taddr41, align 8 + %67 = bitcast %"variant[]"* %taddr41 to { i8*, i64 }* + %68 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %67, i32 0, i32 0 + %lo42 = load i8*, i8** %68, align 8 + %69 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %67, i32 0, i32 1 + %hi43 = load i64, i64* %69, align 8 + %70 = call i64 @std_io_printfln(i64* %retparam38, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i32 0, i32 0), i64 2, i8* %lo42, i64 %hi43) + %not_err44 = icmp eq i64 %70, 0 + br i1 %not_err44, label %after_check45, label %voiderr46 -after_check50: ; preds = %voiderr39 - br label %voiderr51 +after_check45: ; preds = %voiderr37 + br label %voiderr46 -voiderr51: ; preds = %after_check50, %voiderr39 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i32 0, i32 0), i64 2 }, %"char[]"* %taddr53, align 8 - %75 = bitcast %"char[]"* %taddr53 to { i8*, i64 }* - %76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %75, i32 0, i32 0 - %lo54 = load i8*, i8** %76, align 8 - %77 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %75, i32 0, i32 1 - %hi55 = load i64, i64* %77, align 8 - store [12 x i8]* bitcast ([13 x i8]* @.str.8 to [12 x i8]*), [12 x i8]** %taddr58, align 8 - %78 = bitcast [12 x i8]** %taddr58 to i8* - %79 = insertvalue %variant undef, i8* %78, 0 - %80 = insertvalue %variant %79, i64 ptrtoint (%.introspect* @"ct$p$a12$char" to i64), 1 - %81 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots57, i64 0, i64 0 - store %variant %80, %variant* %81, align 16 - %82 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg56, i32 0, i32 1 - store i64 1, i64* %82, align 8 - %83 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg56, i32 0, i32 0 - %84 = bitcast [1 x %variant]* %varargslots57 to %variant* - store %variant* %84, %variant** %83, align 8 - %85 = bitcast %"variant[]"* %vararg56 to { i8*, i64 }* - %86 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %85, i32 0, i32 0 - %lo59 = load i8*, i8** %86, align 8 - %87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %85, i32 0, i32 1 - %hi60 = load i64, i64* %87, align 8 - %88 = call i64 @std_io_printfln(i64* %retparam52, i8* %lo54, i64 %hi55, i8* %lo59, i64 %hi60) - %not_err61 = icmp eq i64 %88, 0 - br i1 %not_err61, label %after_check62, label %voiderr63 +voiderr46: ; preds = %after_check45, %voiderr37 + store [6 x i8]* bitcast ([7 x i8]* @.str.10 to [6 x i8]*), [6 x i8]** %taddr49, align 8 + %71 = bitcast [6 x i8]** %taddr49 to i8* + %72 = insertvalue %variant undef, i8* %71, 0 + %73 = insertvalue %variant %72, i64 ptrtoint (%.introspect* @"ct$p$a6$char" to i64), 1 + %74 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots48, i64 0, i64 0 + store %variant %73, %variant* %74, align 16 + %75 = bitcast [1 x %variant]* %varargslots48 to %variant* + %76 = insertvalue %"variant[]" undef, %variant* %75, 0 + %77 = insertvalue %"variant[]" %76, i64 1, 1 + store %"variant[]" %77, %"variant[]"* %taddr50, align 8 + %78 = bitcast %"variant[]"* %taddr50 to { i8*, i64 }* + %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0 + %lo51 = load i8*, i8** %79, align 8 + %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1 + %hi52 = load i64, i64* %80, align 8 + %81 = call i64 @std_io_printfln(i64* %retparam47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i64 2, i8* %lo51, i64 %hi52) + %not_err53 = icmp eq i64 %81, 0 + br i1 %not_err53, label %after_check54, label %voiderr55 -after_check62: ; preds = %voiderr51 - br label %voiderr63 +after_check54: ; preds = %voiderr46 + br label %voiderr55 -voiderr63: ; preds = %after_check62, %voiderr51 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i64 2 }, %"char[]"* %taddr65, align 8 - %89 = bitcast %"char[]"* %taddr65 to { i8*, i64 }* +voiderr55: ; preds = %after_check54, %voiderr46 + store [13 x i8]* bitcast ([14 x i8]* @.str.12 to [13 x i8]*), [13 x i8]** %taddr58, align 8 + %82 = bitcast [13 x i8]** %taddr58 to i8* + %83 = insertvalue %variant undef, i8* %82, 0 + %84 = insertvalue %variant %83, i64 ptrtoint (%.introspect* @"ct$p$a13$char" to i64), 1 + %85 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots57, i64 0, i64 0 + store %variant %84, %variant* %85, align 16 + %86 = bitcast [1 x %variant]* %varargslots57 to %variant* + %87 = insertvalue %"variant[]" undef, %variant* %86, 0 + %88 = insertvalue %"variant[]" %87, i64 1, 1 + store %"variant[]" %88, %"variant[]"* %taddr59, align 8 + %89 = bitcast %"variant[]"* %taddr59 to { i8*, i64 }* %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %89, i32 0, i32 0 - %lo66 = load i8*, i8** %90, align 8 + %lo60 = load i8*, i8** %90, align 8 %91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %89, i32 0, i32 1 - %hi67 = load i64, i64* %91, align 8 - store [6 x i8]* bitcast ([7 x i8]* @.str.10 to [6 x i8]*), [6 x i8]** %taddr70, align 8 - %92 = bitcast [6 x i8]** %taddr70 to i8* - %93 = insertvalue %variant undef, i8* %92, 0 - %94 = insertvalue %variant %93, i64 ptrtoint (%.introspect* @"ct$p$a6$char" to i64), 1 - %95 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots69, i64 0, i64 0 - store %variant %94, %variant* %95, align 16 - %96 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg68, i32 0, i32 1 - store i64 1, i64* %96, align 8 - %97 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg68, i32 0, i32 0 - %98 = bitcast [1 x %variant]* %varargslots69 to %variant* - store %variant* %98, %variant** %97, align 8 - %99 = bitcast %"variant[]"* %vararg68 to { i8*, i64 }* - %100 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %99, i32 0, i32 0 - %lo71 = load i8*, i8** %100, align 8 - %101 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %99, i32 0, i32 1 - %hi72 = load i64, i64* %101, align 8 - %102 = call i64 @std_io_printfln(i64* %retparam64, i8* %lo66, i64 %hi67, i8* %lo71, i64 %hi72) - %not_err73 = icmp eq i64 %102, 0 - br i1 %not_err73, label %after_check74, label %voiderr75 + %hi61 = load i64, i64* %91, align 8 + %92 = call i64 @std_io_printfln(i64* %retparam56, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i32 0, i32 0), i64 2, i8* %lo60, i64 %hi61) + %not_err62 = icmp eq i64 %92, 0 + br i1 %not_err62, label %after_check63, label %voiderr64 -after_check74: ; preds = %voiderr63 - br label %voiderr75 +after_check63: ; preds = %voiderr55 + br label %voiderr64 -voiderr75: ; preds = %after_check74, %voiderr63 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i32 0, i32 0), i64 2 }, %"char[]"* %taddr77, align 8 - %103 = bitcast %"char[]"* %taddr77 to { i8*, i64 }* - %104 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %103, i32 0, i32 0 - %lo78 = load i8*, i8** %104, align 8 - %105 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %103, i32 0, i32 1 - %hi79 = load i64, i64* %105, align 8 - store [13 x i8]* bitcast ([14 x i8]* @.str.12 to [13 x i8]*), [13 x i8]** %taddr82, align 8 - %106 = bitcast [13 x i8]** %taddr82 to i8* - %107 = insertvalue %variant undef, i8* %106, 0 - %108 = insertvalue %variant %107, i64 ptrtoint (%.introspect* @"ct$p$a13$char" to i64), 1 - %109 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots81, i64 0, i64 0 - store %variant %108, %variant* %109, align 16 - %110 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg80, i32 0, i32 1 - store i64 1, i64* %110, align 8 - %111 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg80, i32 0, i32 0 - %112 = bitcast [1 x %variant]* %varargslots81 to %variant* - store %variant* %112, %variant** %111, align 8 - %113 = bitcast %"variant[]"* %vararg80 to { i8*, i64 }* - %114 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %113, i32 0, i32 0 - %lo83 = load i8*, i8** %114, align 8 - %115 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %113, i32 0, i32 1 - %hi84 = load i64, i64* %115, align 8 - %116 = call i64 @std_io_printfln(i64* %retparam76, i8* %lo78, i64 %hi79, i8* %lo83, i64 %hi84) - %not_err85 = icmp eq i64 %116, 0 - br i1 %not_err85, label %after_check86, label %voiderr87 - -after_check86: ; preds = %voiderr75 - br label %voiderr87 - -voiderr87: ; preds = %after_check86, %voiderr75 +voiderr64: ; preds = %after_check63, %voiderr55 store i32 (i32)* @test_test2, i32 (i32)** %y, align 8 store i64 ptrtoint (%.introspect* @"ct$p$fn$int$int$" to i64), i64* %zfoke, align 8 ret void diff --git a/test/test_suite/functions/splat.c3t b/test/test_suite/functions/splat.c3t index c12ef17d9..3a7bd0ddb 100644 --- a/test/test_suite/functions/splat.c3t +++ b/test/test_suite/functions/splat.c3t @@ -13,27 +13,25 @@ fn void test() sum_us(); } -// #expect: splat.ll +/* #expect: splat.ll - %vararg = alloca %"int[]", align 8 %varargslots = alloca [3 x i32], align 4 + %taddr = alloca %"int[]", align 8 %x = alloca [3 x i32], align 4 %z = alloca %"int[]", align 8 - %vararg1 = alloca %"int[]", align 8 - %vararg4 = alloca %"int[]", align 8 - %vararg7 = alloca %"int[]", align 8 + %taddr1 = alloca %"int[]", align 8 + %taddr6 = alloca %"int[]", align 8 %0 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 0 store i32 1, i32* %0, align 4 %1 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 1 store i32 2, i32* %1, align 4 %2 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 2 store i32 3, i32* %2, align 4 - %3 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1 - store i64 3, i64* %3, align 8 - %4 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0 - %5 = bitcast [3 x i32]* %varargslots to i32* - store i32* %5, i32** %4, align 8 - %6 = bitcast %"int[]"* %vararg to { i8*, i64 }* + %3 = bitcast [3 x i32]* %varargslots to i32* + %4 = insertvalue %"int[]" undef, i32* %3, 0 + %5 = insertvalue %"int[]" %4, i64 3, 1 + store %"int[]" %5, %"int[]"* %taddr, align 8 + %6 = bitcast %"int[]"* %taddr to { i8*, i64 }* %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 0 %lo = load i8*, i8** %7, align 8 %8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 1 @@ -45,31 +43,27 @@ fn void test() %12 = insertvalue %"int[]" undef, i32* %11, 0 %13 = insertvalue %"int[]" %12, i64 3, 1 store %"int[]" %13, %"int[]"* %z, align 8 - %14 = getelementptr inbounds %"int[]", %"int[]"* %vararg1, i32 0, i32 1 - %15 = getelementptr inbounds %"int[]", %"int[]"* %vararg1, i32 0, i32 0 - store i64 3, i64* %14, align 8 - %16 = bitcast [3 x i32]* %x to i32* - store i32* %16, i32** %15, align 8 - %17 = bitcast %"int[]"* %vararg1 to { i8*, i64 }* + %14 = bitcast [3 x i32]* %x to i32* + %15 = insertvalue %"int[]" undef, i32* %14, 0 + %16 = insertvalue %"int[]" %15, i64 3, 1 + store %"int[]" %16, %"int[]"* %taddr1, align 8 + %17 = bitcast %"int[]"* %taddr1 to { i8*, i64 }* %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 %lo2 = load i8*, i8** %18, align 8 %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 %hi3 = load i64, i64* %19, align 8 %20 = call i32 @sum_us(i8* %lo2, i64 %hi3) - %21 = getelementptr inbounds %"int[]", %"int[]"* %vararg4, i32 0, i32 1 - %22 = getelementptr inbounds %"int[]", %"int[]"* %vararg4, i32 0, i32 0 - %23 = bitcast %"int[]"* %z to { i8*, i64 }* - %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %23, i32 0, i32 0 - %lo5 = load i8*, i8** %24, align 8 - %25 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %23, i32 0, i32 1 - %hi6 = load i64, i64* %25, align 8 - %26 = call i32 @sum_us(i8* %lo5, i64 %hi6) - %27 = getelementptr inbounds %"int[]", %"int[]"* %vararg7, i32 0, i32 1 - store i64 0, i64* %27, align 8 - %28 = bitcast %"int[]"* %vararg7 to { i8*, i64 }* - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 0 - %lo8 = load i8*, i8** %29, align 8 - %30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 1 - %hi9 = load i64, i64* %30, align 8 - %31 = call i32 @sum_us(i8* %lo8, i64 %hi9) + %21 = bitcast %"int[]"* %z to { i8*, i64 }* + %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 0 + %lo4 = load i8*, i8** %22, align 8 + %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 1 + %hi5 = load i64, i64* %23, align 8 + %24 = call i32 @sum_us(i8* %lo4, i64 %hi5) + store %"int[]" zeroinitializer, %"int[]"* %taddr6, align 8 + %25 = bitcast %"int[]"* %taddr6 to { i8*, i64 }* + %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 0 + %lo7 = load i8*, i8** %26, align 8 + %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 1 + %hi8 = load i64, i64* %27, align 8 + %28 = call i32 @sum_us(i8* %lo7, i64 %hi8) ret void diff --git a/test/test_suite/functions/splat_aarch64.c3t b/test/test_suite/functions/splat_aarch64.c3t index c4f69cd43..42a088556 100644 --- a/test/test_suite/functions/splat_aarch64.c3t +++ b/test/test_suite/functions/splat_aarch64.c3t @@ -21,25 +21,23 @@ declare i32 @sum_us([2 x i64]) #0 define void @splat_test() #0 { entry: - %vararg = alloca %"int[]", align 8 %varargslots = alloca [3 x i32], align 4 + %taddr = alloca %"int[]", align 8 %x = alloca [3 x i32], align 4 %z = alloca %"int[]", align 8 - %vararg1 = alloca %"int[]", align 8 - %vararg2 = alloca %"int[]", align 8 - %vararg3 = alloca %"int[]", align 8 + %taddr1 = alloca %"int[]", align 8 + %taddr2 = alloca %"int[]", align 8 %0 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 0 store i32 1, i32* %0, align 4 %1 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 1 store i32 2, i32* %1, align 4 %2 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 2 store i32 3, i32* %2, align 4 - %3 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1 - store i64 3, i64* %3, align 8 - %4 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0 - %5 = bitcast [3 x i32]* %varargslots to i32* - store i32* %5, i32** %4, align 8 - %6 = bitcast %"int[]"* %vararg to [2 x i64]* + %3 = bitcast [3 x i32]* %varargslots to i32* + %4 = insertvalue %"int[]" undef, i32* %3, 0 + %5 = insertvalue %"int[]" %4, i64 3, 1 + store %"int[]" %5, %"int[]"* %taddr, align 8 + %6 = bitcast %"int[]"* %taddr to [2 x i64]* %7 = load [2 x i64], [2 x i64]* %6, align 8 %8 = call i32 @sum_us([2 x i64] %7) %9 = bitcast [3 x i32]* %x to i8* @@ -48,23 +46,19 @@ entry: %11 = insertvalue %"int[]" undef, i32* %10, 0 %12 = insertvalue %"int[]" %11, i64 3, 1 store %"int[]" %12, %"int[]"* %z, align 8 - %13 = getelementptr inbounds %"int[]", %"int[]"* %vararg1, i32 0, i32 1 - %14 = getelementptr inbounds %"int[]", %"int[]"* %vararg1, i32 0, i32 0 - store i64 3, i64* %13, align 8 - %15 = bitcast [3 x i32]* %x to i32* - store i32* %15, i32** %14, align 8 - %16 = bitcast %"int[]"* %vararg1 to [2 x i64]* + %13 = bitcast [3 x i32]* %x to i32* + %14 = insertvalue %"int[]" undef, i32* %13, 0 + %15 = insertvalue %"int[]" %14, i64 3, 1 + store %"int[]" %15, %"int[]"* %taddr1, align 8 + %16 = bitcast %"int[]"* %taddr1 to [2 x i64]* %17 = load [2 x i64], [2 x i64]* %16, align 8 %18 = call i32 @sum_us([2 x i64] %17) - %19 = getelementptr inbounds %"int[]", %"int[]"* %vararg2, i32 0, i32 1 - %20 = getelementptr inbounds %"int[]", %"int[]"* %vararg2, i32 0, i32 0 - %21 = bitcast %"int[]"* %z to [2 x i64]* - %22 = load [2 x i64], [2 x i64]* %21, align 8 - %23 = call i32 @sum_us([2 x i64] %22) - %24 = getelementptr inbounds %"int[]", %"int[]"* %vararg3, i32 0, i32 1 - store i64 0, i64* %24, align 8 - %25 = bitcast %"int[]"* %vararg3 to [2 x i64]* - %26 = load [2 x i64], [2 x i64]* %25, align 8 - %27 = call i32 @sum_us([2 x i64] %26) + %19 = bitcast %"int[]"* %z to [2 x i64]* + %20 = load [2 x i64], [2 x i64]* %19, align 8 + %21 = call i32 @sum_us([2 x i64] %20) + store %"int[]" zeroinitializer, %"int[]"* %taddr2, align 8 + %22 = bitcast %"int[]"* %taddr2 to [2 x i64]* + %23 = load [2 x i64], [2 x i64]* %22, align 8 + %24 = call i32 @sum_us([2 x i64] %23) ret void } diff --git a/test/test_suite/functions/splat_mingw.c3t b/test/test_suite/functions/splat_mingw.c3t index a88610122..2e630a581 100644 --- a/test/test_suite/functions/splat_mingw.c3t +++ b/test/test_suite/functions/splat_mingw.c3t @@ -13,59 +13,43 @@ fn void test() sum_us(); } -// #expect: splat.ll +/* #expect: splat.ll - %vararg = alloca %"int[]", align 8 - %varargslots = alloca [3 x i32], align 4 - %indirectarg = alloca %"int[]", align 8 - %x = alloca [3 x i32], align 4 - %z = alloca %"int[]", align 8 - %vararg1 = alloca %"int[]", align 8 - %indirectarg2 = alloca %"int[]", align 8 - %vararg3 = alloca %"int[]", align 8 - %indirectarg4 = alloca %"int[]", align 8 - %vararg5 = alloca %"int[]", align 8 - %indirectarg6 = alloca %"int[]", align 8 - %0 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 0 - store i32 1, i32* %0, align 4 - %1 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 1 - store i32 2, i32* %1, align 4 - %2 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 2 - store i32 3, i32* %2, align 4 - %3 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1 - store i64 3, i64* %3, align 8 - %4 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0 - %5 = bitcast [3 x i32]* %varargslots to i32* - store i32* %5, i32** %4, align 8 - %6 = bitcast %"int[]"* %indirectarg to i8* - %7 = bitcast %"int[]"* %vararg to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %6, i8* align 8 %7, i32 16, i1 false) - %8 = call i32 @sum_us(%"int[]"* align 8 %indirectarg) - %9 = bitcast [3 x i32]* %x to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %9, i8* align 4 bitcast ([3 x i32]* @.__const to i8*), i32 12, i1 false) - %10 = bitcast [3 x i32]* %x to i32* - %11 = insertvalue %"int[]" undef, i32* %10, 0 - %12 = insertvalue %"int[]" %11, i64 3, 1 - store %"int[]" %12, %"int[]"* %z, align 8 - %13 = getelementptr inbounds %"int[]", %"int[]"* %vararg1, i32 0, i32 1 - %14 = getelementptr inbounds %"int[]", %"int[]"* %vararg1, i32 0, i32 0 - store i64 3, i64* %13, align 8 - %15 = bitcast [3 x i32]* %x to i32* - store i32* %15, i32** %14, align 8 - %16 = bitcast %"int[]"* %indirectarg2 to i8* - %17 = bitcast %"int[]"* %vararg1 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %16, i8* align 8 %17, i32 16, i1 false) - %18 = call i32 @sum_us(%"int[]"* align 8 %indirectarg2) - %19 = getelementptr inbounds %"int[]", %"int[]"* %vararg3, i32 0, i32 1 - %20 = getelementptr inbounds %"int[]", %"int[]"* %vararg3, i32 0, i32 0 - %21 = bitcast %"int[]"* %indirectarg4 to i8* - %22 = bitcast %"int[]"* %z to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %21, i8* align 8 %22, i32 16, i1 false) - %23 = call i32 @sum_us(%"int[]"* align 8 %indirectarg4) - %24 = getelementptr inbounds %"int[]", %"int[]"* %vararg5, i32 0, i32 1 - store i64 0, i64* %24, align 8 - %25 = bitcast %"int[]"* %indirectarg6 to i8* - %26 = bitcast %"int[]"* %vararg5 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %25, i8* align 8 %26, i32 16, i1 false) - %27 = call i32 @sum_us(%"int[]"* align 8 %indirectarg6) - ret void +declare i32 @sum_us(%"int[]"* align 8) #0 + + %varargslots = alloca [3 x i32], align 4 + %indirectarg = alloca %"int[]", align 8 + %x = alloca [3 x i32], align 4 + %z = alloca %"int[]", align 8 + %indirectarg1 = alloca %"int[]", align 8 + %indirectarg2 = alloca %"int[]", align 8 + %indirectarg3 = alloca %"int[]", align 8 + %0 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 0 + store i32 1, i32* %0, align 4 + %1 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 1 + store i32 2, i32* %1, align 4 + %2 = getelementptr inbounds [3 x i32], [3 x i32]* %varargslots, i64 0, i64 2 + store i32 3, i32* %2, align 4 + %3 = bitcast [3 x i32]* %varargslots to i32* + %4 = insertvalue %"int[]" undef, i32* %3, 0 + %5 = insertvalue %"int[]" %4, i64 3, 1 + store %"int[]" %5, %"int[]"* %indirectarg, align 8 + %6 = call i32 @sum_us(%"int[]"* align 8 %indirectarg) + %7 = bitcast [3 x i32]* %x to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %7, i8* align 4 bitcast ([3 x i32]* @.__const to i8*), i32 12, i1 false) + %8 = bitcast [3 x i32]* %x to i32* + %9 = insertvalue %"int[]" undef, i32* %8, 0 + %10 = insertvalue %"int[]" %9, i64 3, 1 + store %"int[]" %10, %"int[]"* %z, align 8 + %11 = bitcast [3 x i32]* %x to i32* + %12 = insertvalue %"int[]" undef, i32* %11, 0 + %13 = insertvalue %"int[]" %12, i64 3, 1 + store %"int[]" %13, %"int[]"* %indirectarg1, align 8 + %14 = call i32 @sum_us(%"int[]"* align 8 %indirectarg1) + %15 = bitcast %"int[]"* %indirectarg2 to i8* + %16 = bitcast %"int[]"* %z to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %15, i8* align 8 %16, i32 16, i1 false) + %17 = call i32 @sum_us(%"int[]"* align 8 %indirectarg2) + store %"int[]" zeroinitializer, %"int[]"* %indirectarg3, align 8 + %18 = call i32 @sum_us(%"int[]"* align 8 %indirectarg3) + ret void diff --git a/test/test_suite/functions/test_regression.c3t b/test/test_suite/functions/test_regression.c3t index dbfb6d8bd..89b467cec 100644 --- a/test/test_suite/functions/test_regression.c3t +++ b/test/test_suite/functions/test_regression.c3t @@ -337,7 +337,6 @@ define i32 @test_sum_us(i8* %0, i64 %1) #0 { entry: %x = alloca %"int[]", align 8 %sum = alloca i32, align 4 - %vararg = alloca %"int[]", align 8 %taddr = alloca %"int[]", align 8 %pair = bitcast %"int[]"* %x to { i8*, i64 }* %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 0 @@ -368,20 +367,18 @@ if.exit: ; preds = %entry %ptroffset1 = getelementptr inbounds i32, i32* %11, i64 1 %14 = insertvalue %"int[]" undef, i32* %ptroffset1, 0 %15 = insertvalue %"int[]" %14, i64 %size, 1 - %16 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1 - %17 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0 store %"int[]" %15, %"int[]"* %taddr, align 8 - %18 = bitcast %"int[]"* %taddr to { i8*, i64 }* - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 - %lo = load i8*, i8** %19, align 8 - %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 - %hi = load i64, i64* %20, align 8 - %21 = call i32 @test_sum_us(i8* %lo, i64 %hi) - %add = add i32 %9, %21 + %16 = bitcast %"int[]"* %taddr to { i8*, i64 }* + %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 0 + %lo = load i8*, i8** %17, align 8 + %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 1 + %hi = load i64, i64* %18, align 8 + %19 = call i32 @test_sum_us(i8* %lo, i64 %hi) + %add = add i32 %9, %19 %add2 = add i32 %6, %add store i32 %add2, i32* %sum, align 4 - %22 = load i32, i32* %sum, align 4 - ret i32 %22 + %20 = load i32, i32* %sum, align 4 + ret i32 %20 } ; Function Attrs: nounwind @@ -442,16 +439,15 @@ entry: %ddx = alloca %Foo, align 4 %fro = alloca i32, align 4 %x = alloca [4 x i32], align 16 - %vararg = alloca %"int[]", align 8 + %taddr = alloca %"int[]", align 8 %z = alloca %"int[]", align 8 %de = alloca [3 x i32], align 4 - %vararg10 = alloca %"int[]", align 8 - %vararg13 = alloca %"int[]", align 8 - %vararg16 = alloca %"int[]", align 8 + %taddr10 = alloca %"int[]", align 8 %varargslots = alloca [4 x i32], align 16 - %vararg19 = alloca %"int[]", align 8 - %varargslots20 = alloca [1 x i32], align 4 - %vararg23 = alloca %"int[]", align 8 + %taddr15 = alloca %"int[]", align 8 + %varargslots18 = alloca [1 x i32], align 4 + %taddr19 = alloca %"int[]", align 8 + %taddr22 = alloca %"int[]", align 8 %a1 = alloca i32 (double, %Bobo*)*, align 8 %b2 = alloca i32 (double, %Bobo*)*, align 8 %0 = call i32 @test_test_static() @@ -544,12 +540,11 @@ loop.exit8: ; preds = %loop.cond2 %37 = bitcast [4 x i32]* %x to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %37, i8* align 16 bitcast ([4 x i32]* @.__const.12 to i8*), i32 16, i1 false) %38 = load i32, i32* %fro, align 4 - %39 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1 - %40 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0 - store i64 4, i64* %39, align 8 - %41 = bitcast [4 x i32]* %x to i32* - store i32* %41, i32** %40, align 8 - %42 = bitcast %"int[]"* %vararg to { i8*, i64 }* + %39 = bitcast [4 x i32]* %x to i32* + %40 = insertvalue %"int[]" undef, i32* %39, 0 + %41 = insertvalue %"int[]" %40, i64 4, 1 + store %"int[]" %41, %"int[]"* %taddr, align 8 + %42 = bitcast %"int[]"* %taddr to { i8*, i64 }* %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %42, i32 0, i32 0 %lo = load i8*, i8** %43, align 8 %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %42, i32 0, i32 1 @@ -566,70 +561,64 @@ loop.exit8: ; preds = %loop.cond2 store %"int[]" %51, %"int[]"* %z, align 8 %52 = bitcast [3 x i32]* %de to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %52, i8* align 4 bitcast ([3 x i32]* @.__const.15 to i8*), i32 12, i1 false) - %53 = getelementptr inbounds %"int[]", %"int[]"* %vararg10, i32 0, i32 1 - %54 = getelementptr inbounds %"int[]", %"int[]"* %vararg10, i32 0, i32 0 - store i64 4, i64* %53, align 8 - %55 = bitcast [4 x i32]* %x to i32* - store i32* %55, i32** %54, align 8 - %56 = bitcast %"int[]"* %vararg10 to { i8*, i64 }* + %53 = bitcast [4 x i32]* %x to i32* + %54 = insertvalue %"int[]" undef, i32* %53, 0 + %55 = insertvalue %"int[]" %54, i64 4, 1 + store %"int[]" %55, %"int[]"* %taddr10, align 8 + %56 = bitcast %"int[]"* %taddr10 to { i8*, i64 }* %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 0 %lo11 = load i8*, i8** %57, align 8 %58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 1 %hi12 = load i64, i64* %58, align 8 %59 = call i32 @test_sum_us(i8* %lo11, i64 %hi12) %60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.16, i32 0, i32 0), i32 %59) - %61 = getelementptr inbounds %"int[]", %"int[]"* %vararg13, i32 0, i32 1 - %62 = getelementptr inbounds %"int[]", %"int[]"* %vararg13, i32 0, i32 0 - %63 = bitcast %"int[]"* %z to { i8*, i64 }* - %64 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %63, i32 0, i32 0 - %lo14 = load i8*, i8** %64, align 8 - %65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %63, i32 0, i32 1 - %hi15 = load i64, i64* %65, align 8 - %66 = call i32 @test_sum_us(i8* %lo14, i64 %hi15) - %67 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, i32 0, i32 0), i32 %66) - %68 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 0 - store i32 1, i32* %68, align 4 - %69 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 1 - store i32 2, i32* %69, align 4 - %70 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 2 - store i32 4, i32* %70, align 4 - %71 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 3 - store i32 5, i32* %71, align 4 - %72 = getelementptr inbounds %"int[]", %"int[]"* %vararg16, i32 0, i32 1 - store i64 4, i64* %72, align 8 - %73 = getelementptr inbounds %"int[]", %"int[]"* %vararg16, i32 0, i32 0 - %74 = bitcast [4 x i32]* %varargslots to i32* - store i32* %74, i32** %73, align 8 - %75 = bitcast %"int[]"* %vararg16 to { i8*, i64 }* - %76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %75, i32 0, i32 0 - %lo17 = load i8*, i8** %76, align 8 - %77 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %75, i32 0, i32 1 - %hi18 = load i64, i64* %77, align 8 - %78 = call i32 @test_sum_us(i8* %lo17, i64 %hi18) - %79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %78) - %80 = getelementptr inbounds [1 x i32], [1 x i32]* %varargslots20, i64 0, i64 0 - store i32 1, i32* %80, align 4 - %81 = getelementptr inbounds %"int[]", %"int[]"* %vararg19, i32 0, i32 1 - store i64 1, i64* %81, align 8 - %82 = getelementptr inbounds %"int[]", %"int[]"* %vararg19, i32 0, i32 0 - %83 = bitcast [1 x i32]* %varargslots20 to i32* - store i32* %83, i32** %82, align 8 - %84 = bitcast %"int[]"* %vararg19 to { i8*, i64 }* - %85 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %84, i32 0, i32 0 - %lo21 = load i8*, i8** %85, align 8 - %86 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %84, i32 0, i32 1 - %hi22 = load i64, i64* %86, align 8 - %87 = call i32 @test_sum_us(i8* %lo21, i64 %hi22) - %88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %87) - %89 = getelementptr inbounds %"int[]", %"int[]"* %vararg23, i32 0, i32 1 - store i64 0, i64* %89, align 8 - %90 = bitcast %"int[]"* %vararg23 to { i8*, i64 }* - %91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 0 - %lo24 = load i8*, i8** %91, align 8 - %92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 1 - %hi25 = load i64, i64* %92, align 8 - %93 = call i32 @test_sum_us(i8* %lo24, i64 %hi25) - %94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i32 0, i32 0), i32 %93) + %61 = bitcast %"int[]"* %z to { i8*, i64 }* + %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %61, i32 0, i32 0 + %lo13 = load i8*, i8** %62, align 8 + %63 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %61, i32 0, i32 1 + %hi14 = load i64, i64* %63, align 8 + %64 = call i32 @test_sum_us(i8* %lo13, i64 %hi14) + %65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, i32 0, i32 0), i32 %64) + %66 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 0 + store i32 1, i32* %66, align 4 + %67 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 1 + store i32 2, i32* %67, align 4 + %68 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 2 + store i32 4, i32* %68, align 4 + %69 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 3 + store i32 5, i32* %69, align 4 + %70 = bitcast [4 x i32]* %varargslots to i32* + %71 = insertvalue %"int[]" undef, i32* %70, 0 + %72 = insertvalue %"int[]" %71, i64 4, 1 + store %"int[]" %72, %"int[]"* %taddr15, align 8 + %73 = bitcast %"int[]"* %taddr15 to { i8*, i64 }* + %74 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %73, i32 0, i32 0 + %lo16 = load i8*, i8** %74, align 8 + %75 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %73, i32 0, i32 1 + %hi17 = load i64, i64* %75, align 8 + %76 = call i32 @test_sum_us(i8* %lo16, i64 %hi17) + %77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %76) + %78 = getelementptr inbounds [1 x i32], [1 x i32]* %varargslots18, i64 0, i64 0 + store i32 1, i32* %78, align 4 + %79 = bitcast [1 x i32]* %varargslots18 to i32* + %80 = insertvalue %"int[]" undef, i32* %79, 0 + %81 = insertvalue %"int[]" %80, i64 1, 1 + store %"int[]" %81, %"int[]"* %taddr19, align 8 + %82 = bitcast %"int[]"* %taddr19 to { i8*, i64 }* + %83 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %82, i32 0, i32 0 + %lo20 = load i8*, i8** %83, align 8 + %84 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %82, i32 0, i32 1 + %hi21 = load i64, i64* %84, align 8 + %85 = call i32 @test_sum_us(i8* %lo20, i64 %hi21) + %86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %85) + store %"int[]" zeroinitializer, %"int[]"* %taddr22, align 8 + %87 = bitcast %"int[]"* %taddr22 to { i8*, i64 }* + %88 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %87, i32 0, i32 0 + %lo23 = load i8*, i8** %88, align 8 + %89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %87, i32 0, i32 1 + %hi24 = load i64, i64* %89, align 8 + %90 = call i32 @test_sum_us(i8* %lo23, i64 %hi24) + %91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i32 0, i32 0), i32 %90) store i32 (double, %Bobo*)* null, i32 (double, %Bobo*)** %a1, align 8 store i32 (double, %Bobo*)* null, i32 (double, %Bobo*)** %b2, align 8 ret void diff --git a/test/test_suite/functions/test_regression_mingw.c3t b/test/test_suite/functions/test_regression_mingw.c3t index f82faa658..35c13b155 100644 --- a/test/test_suite/functions/test_regression_mingw.c3t +++ b/test/test_suite/functions/test_regression_mingw.c3t @@ -377,7 +377,6 @@ if.exit: ; preds = %entry define i32 @test_sum_us(%"int[]"* align 8 %0) #0 { entry: %sum = alloca i32, align 4 - %vararg = alloca %"int[]", align 8 %indirectarg = alloca %"int[]", align 8 store i32 0, i32* %sum, align 4 %1 = getelementptr inbounds %"int[]", %"int[]"* %0, i32 0, i32 1 @@ -403,15 +402,13 @@ if.exit: ; preds = %entry %ptroffset1 = getelementptr inbounds i32, i32* %8, i64 1 %11 = insertvalue %"int[]" undef, i32* %ptroffset1, 0 %12 = insertvalue %"int[]" %11, i64 %size, 1 - %13 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1 - %14 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0 store %"int[]" %12, %"int[]"* %indirectarg, align 8 - %15 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg) - %add = add i32 %6, %15 + %13 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg) + %add = add i32 %6, %13 %add2 = add i32 %3, %add store i32 %add2, i32* %sum, align 4 - %16 = load i32, i32* %sum, align 4 - ret i32 %16 + %14 = load i32, i32* %sum, align 4 + ret i32 %14 } ; Function Attrs: nounwind @@ -466,22 +463,16 @@ entry: %ddx = alloca %Foo, align 4 %fro = alloca i32, align 4 %x = alloca [4 x i32], align 16 - %vararg = alloca %"int[]", align 8 %indirectarg = alloca %"int[]", align 8 %z = alloca %"int[]", align 8 %de = alloca [3 x i32], align 4 - %vararg10 = alloca %"int[]", align 8 + %indirectarg10 = alloca %"int[]", align 8 %indirectarg11 = alloca %"int[]", align 8 - %vararg12 = alloca %"int[]", align 8 - %indirectarg13 = alloca %"int[]", align 8 - %vararg14 = alloca %"int[]", align 8 %varargslots = alloca [4 x i32], align 16 + %indirectarg12 = alloca %"int[]", align 8 + %varargslots13 = alloca [1 x i32], align 4 + %indirectarg14 = alloca %"int[]", align 8 %indirectarg15 = alloca %"int[]", align 8 - %vararg16 = alloca %"int[]", align 8 - %varargslots17 = alloca [1 x i32], align 4 - %indirectarg18 = alloca %"int[]", align 8 - %vararg19 = alloca %"int[]", align 8 - %indirectarg20 = alloca %"int[]", align 8 %a1 = alloca i32 (double, %Bobo*)*, align 8 %b2 = alloca i32 (double, %Bobo*)*, align 8 %0 = call i32 @test_test_static() @@ -575,80 +566,58 @@ loop.exit8: ; preds = %loop.cond2 %38 = bitcast [4 x i32]* %x to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %38, i8* align 16 bitcast ([4 x i32]* @.__const.12 to i8*), i32 16, i1 false) %39 = load i32, i32* %fro, align 4 - %40 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1 - %41 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0 - store i64 4, i64* %40, align 8 - %42 = bitcast [4 x i32]* %x to i32* - store i32* %42, i32** %41, align 8 - %43 = bitcast %"int[]"* %indirectarg to i8* - %44 = bitcast %"int[]"* %vararg to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %43, i8* align 8 %44, i32 16, i1 false) - %45 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg) - %46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.13, i32 0, i32 0), i32 %45) - %add9 = add i32 %39, %46 + %40 = bitcast [4 x i32]* %x to i32* + %41 = insertvalue %"int[]" undef, i32* %40, 0 + %42 = insertvalue %"int[]" %41, i64 4, 1 + store %"int[]" %42, %"int[]"* %indirectarg, align 8 + %43 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg) + %44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.13, i32 0, i32 0), i32 %43) + %add9 = add i32 %39, %44 store i32 %add9, i32* %fro, align 4 - %47 = load i32, i32* %fro, align 4 - %48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i32 0, i32 0), i32 %47) - %49 = bitcast [4 x i32]* %x to i32* - %50 = insertvalue %"int[]" undef, i32* %49, 0 - %51 = insertvalue %"int[]" %50, i64 4, 1 - store %"int[]" %51, %"int[]"* %z, align 8 - %52 = bitcast [3 x i32]* %de to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %52, i8* align 4 bitcast ([3 x i32]* @.__const.15 to i8*), i32 12, i1 false) - %53 = getelementptr inbounds %"int[]", %"int[]"* %vararg10, i32 0, i32 1 - %54 = getelementptr inbounds %"int[]", %"int[]"* %vararg10, i32 0, i32 0 - store i64 4, i64* %53, align 8 - %55 = bitcast [4 x i32]* %x to i32* - store i32* %55, i32** %54, align 8 + %45 = load i32, i32* %fro, align 4 + %46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i32 0, i32 0), i32 %45) + %47 = bitcast [4 x i32]* %x to i32* + %48 = insertvalue %"int[]" undef, i32* %47, 0 + %49 = insertvalue %"int[]" %48, i64 4, 1 + store %"int[]" %49, %"int[]"* %z, align 8 + %50 = bitcast [3 x i32]* %de to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %50, i8* align 4 bitcast ([3 x i32]* @.__const.15 to i8*), i32 12, i1 false) + %51 = bitcast [4 x i32]* %x to i32* + %52 = insertvalue %"int[]" undef, i32* %51, 0 + %53 = insertvalue %"int[]" %52, i64 4, 1 + store %"int[]" %53, %"int[]"* %indirectarg10, align 8 + %54 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg10) + %55 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.16, i32 0, i32 0), i32 %54) %56 = bitcast %"int[]"* %indirectarg11 to i8* - %57 = bitcast %"int[]"* %vararg10 to i8* + %57 = bitcast %"int[]"* %z to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %56, i8* align 8 %57, i32 16, i1 false) %58 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg11) - %59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.16, i32 0, i32 0), i32 %58) - %60 = getelementptr inbounds %"int[]", %"int[]"* %vararg12, i32 0, i32 1 - %61 = getelementptr inbounds %"int[]", %"int[]"* %vararg12, i32 0, i32 0 - %62 = bitcast %"int[]"* %indirectarg13 to i8* - %63 = bitcast %"int[]"* %z to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %62, i8* align 8 %63, i32 16, i1 false) - %64 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg13) - %65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, i32 0, i32 0), i32 %64) - %66 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 0 - store i32 1, i32* %66, align 4 - %67 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 1 - store i32 2, i32* %67, align 4 - %68 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 2 - store i32 4, i32* %68, align 4 - %69 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 3 - store i32 5, i32* %69, align 4 - %70 = getelementptr inbounds %"int[]", %"int[]"* %vararg14, i32 0, i32 1 - store i64 4, i64* %70, align 8 - %71 = getelementptr inbounds %"int[]", %"int[]"* %vararg14, i32 0, i32 0 - %72 = bitcast [4 x i32]* %varargslots to i32* - store i32* %72, i32** %71, align 8 - %73 = bitcast %"int[]"* %indirectarg15 to i8* - %74 = bitcast %"int[]"* %vararg14 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %73, i8* align 8 %74, i32 16, i1 false) + %59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, i32 0, i32 0), i32 %58) + %60 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 0 + store i32 1, i32* %60, align 4 + %61 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 1 + store i32 2, i32* %61, align 4 + %62 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 2 + store i32 4, i32* %62, align 4 + %63 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 3 + store i32 5, i32* %63, align 4 + %64 = bitcast [4 x i32]* %varargslots to i32* + %65 = insertvalue %"int[]" undef, i32* %64, 0 + %66 = insertvalue %"int[]" %65, i64 4, 1 + store %"int[]" %66, %"int[]"* %indirectarg12, align 8 + %67 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg12) + %68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %67) + %69 = getelementptr inbounds [1 x i32], [1 x i32]* %varargslots13, i64 0, i64 0 + store i32 1, i32* %69, align 4 + %70 = bitcast [1 x i32]* %varargslots13 to i32* + %71 = insertvalue %"int[]" undef, i32* %70, 0 + %72 = insertvalue %"int[]" %71, i64 1, 1 + store %"int[]" %72, %"int[]"* %indirectarg14, align 8 + %73 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg14) + %74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %73) + store %"int[]" zeroinitializer, %"int[]"* %indirectarg15, align 8 %75 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg15) - %76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %75) - %77 = getelementptr inbounds [1 x i32], [1 x i32]* %varargslots17, i64 0, i64 0 - store i32 1, i32* %77, align 4 - %78 = getelementptr inbounds %"int[]", %"int[]"* %vararg16, i32 0, i32 1 - store i64 1, i64* %78, align 8 - %79 = getelementptr inbounds %"int[]", %"int[]"* %vararg16, i32 0, i32 0 - %80 = bitcast [1 x i32]* %varargslots17 to i32* - store i32* %80, i32** %79, align 8 - %81 = bitcast %"int[]"* %indirectarg18 to i8* - %82 = bitcast %"int[]"* %vararg16 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %81, i8* align 8 %82, i32 16, i1 false) - %83 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg18) - %84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %83) - %85 = getelementptr inbounds %"int[]", %"int[]"* %vararg19, i32 0, i32 1 - store i64 0, i64* %85, align 8 - %86 = bitcast %"int[]"* %indirectarg20 to i8* - %87 = bitcast %"int[]"* %vararg19 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %86, i8* align 8 %87, i32 16, i1 false) - %88 = call i32 @test_sum_us(%"int[]"* align 8 %indirectarg20) - %89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i32 0, i32 0), i32 %88) + %76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i32 0, i32 0), i32 %75) store i32 (double, %Bobo*)* null, i32 (double, %Bobo*)** %a1, align 8 store i32 (double, %Bobo*)* null, i32 (double, %Bobo*)** %b2, align 8 ret void diff --git a/test/test_suite/functions/typeless_varargs.c3t b/test/test_suite/functions/typeless_varargs.c3t index 203d0611f..39019d43c 100644 --- a/test/test_suite/functions/typeless_varargs.c3t +++ b/test/test_suite/functions/typeless_varargs.c3t @@ -25,19 +25,16 @@ fn int main() define void @test_retest(i8* %0, i64 %1) #0 { entry: %foo = alloca %"variant[]", align 8 - %vararg = alloca %"variant[]", align 8 %pair = bitcast %"variant[]"* %foo to { i8*, i64 }* %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 0 store i8* %0, i8** %2, align 8 %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 1 store i64 %1, i64* %3, align 8 - %4 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - %5 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %6 = bitcast %"variant[]"* %foo to { i8*, i64 }* - %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 0 - %lo = load i8*, i8** %7, align 8 - %8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 1 - %hi = load i64, i64* %8, align 8 + %4 = bitcast %"variant[]"* %foo to { i8*, i64 }* + %5 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 0 + %lo = load i8*, i8** %5, align 8 + %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 1 + %hi = load i64, i64* %6, align 8 call void @test_test(i8* %lo, i64 %hi) ret void } @@ -66,12 +63,12 @@ entry: define i32 @main() #0 { entry: %i = alloca i32, align 4 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 %taddr = alloca i32, align 4 - %vararg1 = alloca %"variant[]", align 8 + %taddr1 = alloca %"variant[]", align 8 %varargslots2 = alloca [1 x %variant], align 16 %taddr3 = alloca i32, align 4 + %taddr4 = alloca %"variant[]", align 8 store i32 1, i32* %i, align 4 store i32 1, i32* %taddr, align 4 %0 = bitcast i32* %taddr to i8* @@ -79,12 +76,11 @@ entry: %2 = insertvalue %variant %1, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 %3 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 store %variant %2, %variant* %3, align 16 - %4 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %4, align 8 - %5 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %6 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %6, %variant** %5, align 8 - %7 = bitcast %"variant[]"* %vararg to { i8*, i64 }* + %4 = bitcast [1 x %variant]* %varargslots to %variant* + %5 = insertvalue %"variant[]" undef, %variant* %4, 0 + %6 = insertvalue %"variant[]" %5, i64 1, 1 + store %"variant[]" %6, %"variant[]"* %taddr1, align 8 + %7 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* %8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %7, i32 0, i32 0 %lo = load i8*, i8** %8, align 8 %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %7, i32 0, i32 1 @@ -96,16 +92,15 @@ entry: %12 = insertvalue %variant %11, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 %13 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots2, i64 0, i64 0 store %variant %12, %variant* %13, align 16 - %14 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg1, i32 0, i32 1 - store i64 1, i64* %14, align 8 - %15 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg1, i32 0, i32 0 - %16 = bitcast [1 x %variant]* %varargslots2 to %variant* - store %variant* %16, %variant** %15, align 8 - %17 = bitcast %"variant[]"* %vararg1 to { i8*, i64 }* + %14 = bitcast [1 x %variant]* %varargslots2 to %variant* + %15 = insertvalue %"variant[]" undef, %variant* %14, 0 + %16 = insertvalue %"variant[]" %15, i64 1, 1 + store %"variant[]" %16, %"variant[]"* %taddr4, align 8 + %17 = bitcast %"variant[]"* %taddr4 to { i8*, i64 }* %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 - %lo4 = load i8*, i8** %18, align 8 + %lo5 = load i8*, i8** %18, align 8 %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 - %hi5 = load i64, i64* %19, align 8 - call void @test_retest(i8* %lo4, i64 %hi5) + %hi6 = load i64, i64* %19, align 8 + call void @test_retest(i8* %lo5, i64 %hi6) ret i32 1 -} \ No newline at end of file +} diff --git a/test/test_suite/functions/varargs_followed_by_named.c3t b/test/test_suite/functions/varargs_followed_by_named.c3t index a5515e295..fdb21d683 100644 --- a/test/test_suite/functions/varargs_followed_by_named.c3t +++ b/test/test_suite/functions/varargs_followed_by_named.c3t @@ -59,71 +59,68 @@ entry: define void @foo_main() #0 { entry: - %vararg = alloca %"int[]", align 8 %varargslots = alloca [2 x i32], align 4 - %vararg1 = alloca %"variant[]", align 8 - %varargslots2 = alloca [2 x %variant], align 16 - %taddr = alloca i32, align 4 + %taddr = alloca %"int[]", align 8 + %varargslots1 = alloca [2 x %variant], align 16 + %taddr2 = alloca i32, align 4 %taddr3 = alloca i32, align 4 - %vararg6 = alloca %"int[]", align 8 + %taddr4 = alloca %"variant[]", align 8 %varargslots7 = alloca [2 x i32], align 4 - %vararg10 = alloca %"variant[]", align 8 + %taddr8 = alloca %"int[]", align 8 %varargslots11 = alloca [2 x %variant], align 16 %taddr12 = alloca i32, align 4 %taddr13 = alloca i32, align 4 + %taddr14 = alloca %"variant[]", align 8 %0 = getelementptr inbounds [2 x i32], [2 x i32]* %varargslots, i64 0, i64 0 store i32 4, i32* %0, align 4 %1 = getelementptr inbounds [2 x i32], [2 x i32]* %varargslots, i64 0, i64 1 store i32 5, i32* %1, align 4 - %2 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1 - store i64 2, i64* %2, align 8 - %3 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0 - %4 = bitcast [2 x i32]* %varargslots to i32* - store i32* %4, i32** %3, align 8 - %5 = bitcast %"int[]"* %vararg to { i8*, i64 }* + %2 = bitcast [2 x i32]* %varargslots to i32* + %3 = insertvalue %"int[]" undef, i32* %2, 0 + %4 = insertvalue %"int[]" %3, i64 2, 1 + store %"int[]" %4, %"int[]"* %taddr, align 8 + %5 = bitcast %"int[]"* %taddr to { i8*, i64 }* %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 0 %lo = load i8*, i8** %6, align 8 %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 1 %hi = load i64, i64* %7, align 8 call void @foo_test(i32 3, i8* %lo, i64 %hi, i32 123) - store i32 4, i32* %taddr, align 4 - %8 = bitcast i32* %taddr to i8* + store i32 4, i32* %taddr2, align 4 + %8 = bitcast i32* %taddr2 to i8* %9 = insertvalue %variant undef, i8* %8, 0 %10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %11 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots2, i64 0, i64 0 + %11 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots1, i64 0, i64 0 store %variant %10, %variant* %11, align 16 store i32 5, i32* %taddr3, align 4 %12 = bitcast i32* %taddr3 to i8* %13 = insertvalue %variant undef, i8* %12, 0 %14 = insertvalue %variant %13, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %15 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots2, i64 0, i64 1 + %15 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots1, i64 0, i64 1 store %variant %14, %variant* %15, align 16 - %16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg1, i32 0, i32 1 - store i64 2, i64* %16, align 8 - %17 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg1, i32 0, i32 0 - %18 = bitcast [2 x %variant]* %varargslots2 to %variant* - store %variant* %18, %variant** %17, align 8 - %19 = bitcast %"variant[]"* %vararg1 to { i8*, i64 }* + %16 = bitcast [2 x %variant]* %varargslots1 to %variant* + %17 = insertvalue %"variant[]" undef, %variant* %16, 0 + %18 = insertvalue %"variant[]" %17, i64 2, 1 + store %"variant[]" %18, %"variant[]"* %taddr4, align 8 + %19 = bitcast %"variant[]"* %taddr4 to { i8*, i64 }* %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %19, i32 0, i32 0 - %lo4 = load i8*, i8** %20, align 8 + %lo5 = load i8*, i8** %20, align 8 %21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %19, i32 0, i32 1 - %hi5 = load i64, i64* %21, align 8 - call void @foo_test2(i32 3, i8* %lo4, i64 %hi5, i32 123) + %hi6 = load i64, i64* %21, align 8 + call void @foo_test2(i32 3, i8* %lo5, i64 %hi6, i32 123) %22 = getelementptr inbounds [2 x i32], [2 x i32]* %varargslots7, i64 0, i64 0 store i32 4, i32* %22, align 4 %23 = getelementptr inbounds [2 x i32], [2 x i32]* %varargslots7, i64 0, i64 1 store i32 5, i32* %23, align 4 - %24 = getelementptr inbounds %"int[]", %"int[]"* %vararg6, i32 0, i32 1 - store i64 2, i64* %24, align 8 - %25 = getelementptr inbounds %"int[]", %"int[]"* %vararg6, i32 0, i32 0 - %26 = bitcast [2 x i32]* %varargslots7 to i32* - store i32* %26, i32** %25, align 8 - %27 = bitcast %"int[]"* %vararg6 to { i8*, i64 }* + %24 = bitcast [2 x i32]* %varargslots7 to i32* + %25 = insertvalue %"int[]" undef, i32* %24, 0 + %26 = insertvalue %"int[]" %25, i64 2, 1 + store %"int[]" %26, %"int[]"* %taddr8, align 8 + %27 = bitcast %"int[]"* %taddr8 to { i8*, i64 }* %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 - %lo8 = load i8*, i8** %28, align 8 + %lo9 = load i8*, i8** %28, align 8 %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 - %hi9 = load i64, i64* %29, align 8 - call void @foo_test(i32 3, i8* %lo8, i64 %hi9, i32 2) + %hi10 = load i64, i64* %29, align 8 + call void @foo_test(i32 3, i8* %lo9, i64 %hi10, i32 2) store i32 4, i32* %taddr12, align 4 %30 = bitcast i32* %taddr12 to i8* %31 = insertvalue %variant undef, i8* %30, 0 @@ -136,17 +133,16 @@ entry: %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 %37 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots11, i64 0, i64 1 store %variant %36, %variant* %37, align 16 - %38 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg10, i32 0, i32 1 - store i64 2, i64* %38, align 8 - %39 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg10, i32 0, i32 0 - %40 = bitcast [2 x %variant]* %varargslots11 to %variant* - store %variant* %40, %variant** %39, align 8 - %41 = bitcast %"variant[]"* %vararg10 to { i8*, i64 }* + %38 = bitcast [2 x %variant]* %varargslots11 to %variant* + %39 = insertvalue %"variant[]" undef, %variant* %38, 0 + %40 = insertvalue %"variant[]" %39, i64 2, 1 + store %"variant[]" %40, %"variant[]"* %taddr14, align 8 + %41 = bitcast %"variant[]"* %taddr14 to { i8*, i64 }* %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 - %lo14 = load i8*, i8** %42, align 8 + %lo15 = load i8*, i8** %42, align 8 %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 - %hi15 = load i64, i64* %43, align 8 - call void @foo_test2(i32 3, i8* %lo14, i64 %hi15, i32 2) + %hi16 = load i64, i64* %43, align 8 + call void @foo_test2(i32 3, i8* %lo15, i64 %hi16, i32 2) ret void } diff --git a/test/test_suite/generic/enum_set_test.c3t b/test/test_suite/generic/enum_set_test.c3t index 3cb4a96cb..f42e7993b 100644 --- a/test/test_suite/generic/enum_set_test.c3t +++ b/test/test_suite/generic/enum_set_test.c3t @@ -31,56 +31,44 @@ define void @test_main() #0 { entry: %set = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i8, align 1 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 - %taddr10 = alloca i8, align 1 - %retparam16 = alloca i64, align 8 - %taddr17 = alloca %"char[]", align 8 - %vararg20 = alloca %"variant[]", align 8 + %taddr = alloca i8, align 1 + %taddr1 = alloca %"variant[]", align 8 + %retparam2 = alloca i64, align 8 + %varargslots3 = alloca [1 x %variant], align 16 + %taddr4 = alloca i8, align 1 + %taddr5 = alloca %"variant[]", align 8 + %retparam11 = alloca i64, align 8 + %varargslots12 = alloca [1 x %variant], align 16 + %taddr13 = alloca i8, align 1 + %taddr14 = alloca %"variant[]", align 8 + %set2 = alloca i32, align 4 + %retparam20 = alloca i64, align 8 %varargslots21 = alloca [1 x %variant], align 16 %taddr22 = alloca i8, align 1 - %set2 = alloca i32, align 4 - %retparam28 = alloca i64, align 8 - %taddr29 = alloca %"char[]", align 8 - %vararg32 = alloca %"variant[]", align 8 - %varargslots33 = alloca [1 x %variant], align 16 - %taddr34 = alloca i8, align 1 - %retparam40 = alloca i64, align 8 - %taddr41 = alloca %"char[]", align 8 - %vararg44 = alloca %"variant[]", align 8 - %varargslots45 = alloca [1 x %variant], align 16 - %taddr46 = alloca i8, align 1 + %taddr23 = alloca %"variant[]", align 8 + %retparam29 = alloca i64, align 8 + %varargslots30 = alloca [1 x %variant], align 16 + %taddr31 = alloca i8, align 1 + %taddr32 = alloca %"variant[]", align 8 store i32 0, i32* %set, align 4 - store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i32 0, i32 0), i64 14 }, %"char[]"* %taddr, align 8 - %0 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %1 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 0 - %lo = load i8*, i8** %1, align 8 - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 1 - %hi = load i64, i64* %2, align 8 - %3 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1) - store i8 %3, i8* %taddr1, align 1 - %4 = insertvalue %variant undef, i8* %taddr1, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %6 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %5, %variant* %6, align 16 - %7 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %7, align 8 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %9 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %9, %variant** %8, align 8 - %10 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %11 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %10, i32 0, i32 0 - %lo2 = load i8*, i8** %11, align 8 - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %10, i32 0, i32 1 - %hi3 = load i64, i64* %12, align 8 - %13 = call i64 @std_io_printf(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %13, 0 + %0 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1) + store i8 %0, i8* %taddr, align 1 + %1 = insertvalue %variant undef, i8* %taddr, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %2, %variant* %3, align 16 + %4 = bitcast [1 x %variant]* %varargslots to %variant* + %5 = insertvalue %"variant[]" undef, %variant* %4, 0 + %6 = insertvalue %"variant[]" %5, i64 1, 1 + store %"variant[]" %6, %"variant[]"* %taddr1, align 8 + %7 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %7, i32 0, i32 0 + %lo = load i8*, i8** %8, align 8 + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %7, i32 0, i32 1 + %hi = load i64, i64* %9, align 8 + %10 = call i64 @std_io_printf(i64* %retparam, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i32 0, i32 0), i64 14, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %10, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -88,131 +76,103 @@ after_check: ; preds = %entry voiderr: ; preds = %after_check, %entry call void @"std_enumset$$test_Abc_EnumSet_add"(i32* %set, i32 0) - store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i32 0, i32 0), i64 14 }, %"char[]"* %taddr5, align 8 - %14 = bitcast %"char[]"* %taddr5 to { i8*, i64 }* - %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 0 - %lo6 = load i8*, i8** %15, align 8 - %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 1 - %hi7 = load i64, i64* %16, align 8 - %17 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1) - store i8 %17, i8* %taddr10, align 1 - %18 = insertvalue %variant undef, i8* %taddr10, 0 - %19 = insertvalue %variant %18, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %20 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots9, i64 0, i64 0 - store %variant %19, %variant* %20, align 16 - %21 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 1 - store i64 1, i64* %21, align 8 - %22 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 0 - %23 = bitcast [1 x %variant]* %varargslots9 to %variant* - store %variant* %23, %variant** %22, align 8 - %24 = bitcast %"variant[]"* %vararg8 to { i8*, i64 }* - %25 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 0 - %lo11 = load i8*, i8** %25, align 8 - %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 1 - %hi12 = load i64, i64* %26, align 8 - %27 = call i64 @std_io_printf(i64* %retparam4, i8* %lo6, i64 %hi7, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %27, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %11 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1) + store i8 %11, i8* %taddr4, align 1 + %12 = insertvalue %variant undef, i8* %taddr4, 0 + %13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %14 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots3, i64 0, i64 0 + store %variant %13, %variant* %14, align 16 + %15 = bitcast [1 x %variant]* %varargslots3 to %variant* + %16 = insertvalue %"variant[]" undef, %variant* %15, 0 + %17 = insertvalue %"variant[]" %16, i64 1, 1 + store %"variant[]" %17, %"variant[]"* %taddr5, align 8 + %18 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }* + %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 + %lo6 = load i8*, i8** %19, align 8 + %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 + %hi7 = load i64, i64* %20, align 8 + %21 = call i64 @std_io_printf(i64* %retparam2, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i32 0, i32 0), i64 14, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %21, 0 + br i1 %not_err8, label %after_check9, label %voiderr10 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check9: ; preds = %voiderr + br label %voiderr10 -voiderr15: ; preds = %after_check14, %voiderr +voiderr10: ; preds = %after_check9, %voiderr call void @"std_enumset$$test_Abc_EnumSet_add"(i32* %set, i32 1) - store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i32 0, i32 0), i64 14 }, %"char[]"* %taddr17, align 8 - %28 = bitcast %"char[]"* %taddr17 to { i8*, i64 }* - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 0 - %lo18 = load i8*, i8** %29, align 8 - %30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 1 - %hi19 = load i64, i64* %30, align 8 - %31 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1) - store i8 %31, i8* %taddr22, align 1 - %32 = insertvalue %variant undef, i8* %taddr22, 0 - %33 = insertvalue %variant %32, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %34 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots21, i64 0, i64 0 - store %variant %33, %variant* %34, align 16 - %35 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 1 - store i64 1, i64* %35, align 8 - %36 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 0 - %37 = bitcast [1 x %variant]* %varargslots21 to %variant* - store %variant* %37, %variant** %36, align 8 - %38 = bitcast %"variant[]"* %vararg20 to { i8*, i64 }* - %39 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %38, i32 0, i32 0 - %lo23 = load i8*, i8** %39, align 8 - %40 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %38, i32 0, i32 1 - %hi24 = load i64, i64* %40, align 8 - %41 = call i64 @std_io_printf(i64* %retparam16, i8* %lo18, i64 %hi19, i8* %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %41, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 + %22 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1) + store i8 %22, i8* %taddr13, align 1 + %23 = insertvalue %variant undef, i8* %taddr13, 0 + %24 = insertvalue %variant %23, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %25 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots12, i64 0, i64 0 + store %variant %24, %variant* %25, align 16 + %26 = bitcast [1 x %variant]* %varargslots12 to %variant* + %27 = insertvalue %"variant[]" undef, %variant* %26, 0 + %28 = insertvalue %"variant[]" %27, i64 1, 1 + store %"variant[]" %28, %"variant[]"* %taddr14, align 8 + %29 = bitcast %"variant[]"* %taddr14 to { i8*, i64 }* + %30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %29, i32 0, i32 0 + %lo15 = load i8*, i8** %30, align 8 + %31 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %29, i32 0, i32 1 + %hi16 = load i64, i64* %31, align 8 + %32 = call i64 @std_io_printf(i64* %retparam11, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i32 0, i32 0), i64 14, i8* %lo15, i64 %hi16) + %not_err17 = icmp eq i64 %32, 0 + br i1 %not_err17, label %after_check18, label %voiderr19 -after_check26: ; preds = %voiderr15 - br label %voiderr27 +after_check18: ; preds = %voiderr10 + br label %voiderr19 -voiderr27: ; preds = %after_check26, %voiderr15 +voiderr19: ; preds = %after_check18, %voiderr10 store i32 0, i32* %set2, align 4 - %42 = load i32, i32* %set, align 4 - call void @"std_enumset$$test_Abc_EnumSet_add_all"(i32* %set2, i32 %42) - store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i32 0, i32 0), i64 14 }, %"char[]"* %taddr29, align 8 - %43 = bitcast %"char[]"* %taddr29 to { i8*, i64 }* - %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0 - %lo30 = load i8*, i8** %44, align 8 - %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1 - %hi31 = load i64, i64* %45, align 8 - %46 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set2, i32 1) - store i8 %46, i8* %taddr34, align 1 - %47 = insertvalue %variant undef, i8* %taddr34, 0 + %33 = load i32, i32* %set, align 4 + call void @"std_enumset$$test_Abc_EnumSet_add_all"(i32* %set2, i32 %33) + %34 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set2, i32 1) + store i8 %34, i8* %taddr22, align 1 + %35 = insertvalue %variant undef, i8* %taddr22, 0 + %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %37 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots21, i64 0, i64 0 + store %variant %36, %variant* %37, align 16 + %38 = bitcast [1 x %variant]* %varargslots21 to %variant* + %39 = insertvalue %"variant[]" undef, %variant* %38, 0 + %40 = insertvalue %"variant[]" %39, i64 1, 1 + store %"variant[]" %40, %"variant[]"* %taddr23, align 8 + %41 = bitcast %"variant[]"* %taddr23 to { i8*, i64 }* + %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 + %lo24 = load i8*, i8** %42, align 8 + %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 + %hi25 = load i64, i64* %43, align 8 + %44 = call i64 @std_io_printf(i64* %retparam20, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i32 0, i32 0), i64 14, i8* %lo24, i64 %hi25) + %not_err26 = icmp eq i64 %44, 0 + br i1 %not_err26, label %after_check27, label %voiderr28 + +after_check27: ; preds = %voiderr19 + br label %voiderr28 + +voiderr28: ; preds = %after_check27, %voiderr19 + %45 = load i32, i32* %set2, align 4 + call void @"std_enumset$$test_Abc_EnumSet_remove_all"(i32* %set, i32 %45) + %46 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1) + store i8 %46, i8* %taddr31, align 1 + %47 = insertvalue %variant undef, i8* %taddr31, 0 %48 = insertvalue %variant %47, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %49 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots33, i64 0, i64 0 + %49 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots30, i64 0, i64 0 store %variant %48, %variant* %49, align 16 - %50 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 1 - store i64 1, i64* %50, align 8 - %51 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 0 - %52 = bitcast [1 x %variant]* %varargslots33 to %variant* - store %variant* %52, %variant** %51, align 8 - %53 = bitcast %"variant[]"* %vararg32 to { i8*, i64 }* + %50 = bitcast [1 x %variant]* %varargslots30 to %variant* + %51 = insertvalue %"variant[]" undef, %variant* %50, 0 + %52 = insertvalue %"variant[]" %51, i64 1, 1 + store %"variant[]" %52, %"variant[]"* %taddr32, align 8 + %53 = bitcast %"variant[]"* %taddr32 to { i8*, i64 }* %54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 0 - %lo35 = load i8*, i8** %54, align 8 + %lo33 = load i8*, i8** %54, align 8 %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 1 - %hi36 = load i64, i64* %55, align 8 - %56 = call i64 @std_io_printf(i64* %retparam28, i8* %lo30, i64 %hi31, i8* %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %56, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 + %hi34 = load i64, i64* %55, align 8 + %56 = call i64 @std_io_printf(i64* %retparam29, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i32 0, i32 0), i64 14, i8* %lo33, i64 %hi34) + %not_err35 = icmp eq i64 %56, 0 + br i1 %not_err35, label %after_check36, label %voiderr37 -after_check38: ; preds = %voiderr27 - br label %voiderr39 +after_check36: ; preds = %voiderr28 + br label %voiderr37 -voiderr39: ; preds = %after_check38, %voiderr27 - %57 = load i32, i32* %set2, align 4 - call void @"std_enumset$$test_Abc_EnumSet_remove_all"(i32* %set, i32 %57) - store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i32 0, i32 0), i64 14 }, %"char[]"* %taddr41, align 8 - %58 = bitcast %"char[]"* %taddr41 to { i8*, i64 }* - %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0 - %lo42 = load i8*, i8** %59, align 8 - %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1 - %hi43 = load i64, i64* %60, align 8 - %61 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1) - store i8 %61, i8* %taddr46, align 1 - %62 = insertvalue %variant undef, i8* %taddr46, 0 - %63 = insertvalue %variant %62, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %64 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots45, i64 0, i64 0 - store %variant %63, %variant* %64, align 16 - %65 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 1 - store i64 1, i64* %65, align 8 - %66 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 0 - %67 = bitcast [1 x %variant]* %varargslots45 to %variant* - store %variant* %67, %variant** %66, align 8 - %68 = bitcast %"variant[]"* %vararg44 to { i8*, i64 }* - %69 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %68, i32 0, i32 0 - %lo47 = load i8*, i8** %69, align 8 - %70 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %68, i32 0, i32 1 - %hi48 = load i64, i64* %70, align 8 - %71 = call i64 @std_io_printf(i64* %retparam40, i8* %lo42, i64 %hi43, i8* %lo47, i64 %hi48) - %not_err49 = icmp eq i64 %71, 0 - br i1 %not_err49, label %after_check50, label %voiderr51 - -after_check50: ; preds = %voiderr39 - br label %voiderr51 - -voiderr51: ; preds = %after_check50, %voiderr39 +voiderr37: ; preds = %after_check36, %voiderr28 ret void } diff --git a/test/test_suite/generic/generic_num.c3t b/test/test_suite/generic/generic_num.c3t index 5238618a3..86e498a98 100644 --- a/test/test_suite/generic/generic_num.c3t +++ b/test/test_suite/generic/generic_num.c3t @@ -22,35 +22,27 @@ fn void main() define void @test_main() #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2 }, %"char[]"* %taddr, align 8 - %0 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %1 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 0 - %lo = load i8*, i8** %1, align 8 - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 1 - %hi = load i64, i64* %2, align 8 - %3 = call i32 @"hello$$int._123_x"(i32 4) - store i32 %3, i32* %taddr1, align 4 - %4 = bitcast i32* %taddr1 to i8* - %5 = insertvalue %variant undef, i8* %4, 0 - %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %6, %variant* %7, align 16 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %8, align 8 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %10 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %10, %variant** %9, align 8 - %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 - %lo2 = load i8*, i8** %12, align 8 - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 - %hi3 = load i64, i64* %13, align 8 - %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %14, 0 + %taddr = alloca i32, align 4 + %taddr1 = alloca %"variant[]", align 8 + %0 = call i32 @"hello$$int._123_x"(i32 4) + store i32 %0, i32* %taddr, align 4 + %1 = bitcast i32* %taddr to i8* + %2 = insertvalue %variant undef, i8* %1, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %3, %variant* %4, align 16 + %5 = bitcast [1 x %variant]* %varargslots to %variant* + %6 = insertvalue %"variant[]" undef, %variant* %5, 0 + %7 = insertvalue %"variant[]" %6, i64 1, 1 + store %"variant[]" %7, %"variant[]"* %taddr1, align 8 + %8 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 + %lo = load i8*, i8** %9, align 8 + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 + %hi = load i64, i64* %10, align 8 + %11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry diff --git a/test/test_suite/initializer_lists/fasta.c3t b/test/test_suite/initializer_lists/fasta.c3t index 016a18b64..f35c4ea19 100644 --- a/test/test_suite/initializer_lists/fasta.c3t +++ b/test/test_suite/initializer_lists/fasta.c3t @@ -345,22 +345,22 @@ if.then: ; preds = %entry if.exit: ; preds = %if.then, %entry %4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.14, i32 0, i32 0)) - %lo = load i8*, i8** getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"char[]"* @fasta_alu to { i8*, i64 }*), i32 0, i32 0), align 8 - %hi = load i64, i64* getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"char[]"* @fasta_alu to { i8*, i64 }*), i32 0, i32 1), align 8 + %lo = load i8*, i8** getelementptr inbounds (%"char[]", %"char[]"* @fasta_alu, i32 0, i32 0), align 8 + %hi = load i64, i64* getelementptr inbounds (%"char[]", %"char[]"* @fasta_alu, i32 0, i32 1), align 8 %5 = load i32, i32* %n, align 4 %mul = mul i32 %5, 2 call void @fasta_repeat_fasta(i8* %lo, i64 %hi, i32 %mul) %6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.15, i32 0, i32 0)) - %lo1 = load i8*, i8** getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"char[]"* @fasta_iub to { i8*, i64 }*), i32 0, i32 0), align 8 - %hi2 = load i64, i64* getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"char[]"* @fasta_iub to { i8*, i64 }*), i32 0, i32 1), align 8 + %lo1 = load i8*, i8** getelementptr inbounds (%"char[]", %"char[]"* @fasta_iub, i32 0, i32 0), align 8 + %hi2 = load i64, i64* getelementptr inbounds (%"char[]", %"char[]"* @fasta_iub, i32 0, i32 1), align 8 %lo3 = load i8*, i8** getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"double[]"* @fasta_iub_p to { i8*, i64 }*), i32 0, i32 0), align 8 %hi4 = load i64, i64* getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"double[]"* @fasta_iub_p to { i8*, i64 }*), i32 0, i32 1), align 8 %7 = load i32, i32* %n, align 4 %mul5 = mul i32 %7, 3 call void @fasta_random_fasta(i8* %lo1, i64 %hi2, i8* %lo3, i64 %hi4, i32 %mul5) %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.16, i32 0, i32 0)) - %lo6 = load i8*, i8** getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"char[]"* @fasta_homosapiens to { i8*, i64 }*), i32 0, i32 0), align 8 - %hi7 = load i64, i64* getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"char[]"* @fasta_homosapiens to { i8*, i64 }*), i32 0, i32 1), align 8 + %lo6 = load i8*, i8** getelementptr inbounds (%"char[]", %"char[]"* @fasta_homosapiens, i32 0, i32 0), align 8 + %hi7 = load i64, i64* getelementptr inbounds (%"char[]", %"char[]"* @fasta_homosapiens, i32 0, i32 1), align 8 %lo8 = load i8*, i8** getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"double[]"* @fasta_homosapiens_p to { i8*, i64 }*), i32 0, i32 0), align 8 %hi9 = load i64, i64* getelementptr inbounds ({ i8*, i64 }, { i8*, i64 }* bitcast (%"double[]"* @fasta_homosapiens_p to { i8*, i64 }*), i32 0, i32 1), align 8 %9 = load i32, i32* %n, align 4 diff --git a/test/test_suite/literals/bin_literal.c3t b/test/test_suite/literals/bin_literal.c3t index a76d59103..8aac74286 100644 --- a/test/test_suite/literals/bin_literal.c3t +++ b/test/test_suite/literals/bin_literal.c3t @@ -22,20 +22,18 @@ entry: %c = alloca i32, align 4 %d = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 %z = alloca i8, align 1 - %retparam3 = alloca i64, align 8 - %taddr4 = alloca %"char[]", align 8 - %vararg7 = alloca %"variant[]", align 8 - %varargslots8 = alloca [3 x %variant], align 16 + %retparam1 = alloca i64, align 8 + %varargslots2 = alloca [3 x %variant], align 16 %i = alloca i8, align 1 %shift = alloca i8, align 1 - %taddr9 = alloca i8, align 1 - %i10 = alloca i8, align 1 - %shift11 = alloca i8, align 1 - %taddr12 = alloca i8, align 1 + %taddr3 = alloca i8, align 1 + %i4 = alloca i8, align 1 + %shift5 = alloca i8, align 1 + %taddr6 = alloca i8, align 1 + %taddr7 = alloca %"variant[]", align 8 store i32 123, i32* %a, align 4 store i32 -23, i32* %b, align 4 %0 = load i32, i32* %a, align 4 @@ -46,34 +44,27 @@ entry: %4 = load i32, i32* %b, align 4 %5 = call i32 @llvm.smax.i32(i32 %3, i32 %4) store i32 %5, i32* %d, align 4 - store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5 }, %"char[]"* %taddr, align 8 - %6 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 0 - %lo = load i8*, i8** %7, align 8 - %8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 1 - %hi = load i64, i64* %8, align 8 - %9 = bitcast i32* %c to i8* - %10 = insertvalue %variant undef, i8* %9, 0 - %11 = insertvalue %variant %10, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %12 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 - store %variant %11, %variant* %12, align 16 - %13 = bitcast i32* %d to i8* - %14 = insertvalue %variant undef, i8* %13, 0 - %15 = insertvalue %variant %14, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %16 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 - store %variant %15, %variant* %16, align 16 - %17 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 2, i64* %17, align 8 - %18 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %19 = bitcast [2 x %variant]* %varargslots to %variant* - store %variant* %19, %variant** %18, align 8 - %20 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 0 - %lo1 = load i8*, i8** %21, align 8 - %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 1 - %hi2 = load i64, i64* %22, align 8 - %23 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) - %not_err = icmp eq i64 %23, 0 + %6 = bitcast i32* %c to i8* + %7 = insertvalue %variant undef, i8* %6, 0 + %8 = insertvalue %variant %7, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %9 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 + store %variant %8, %variant* %9, align 16 + %10 = bitcast i32* %d to i8* + %11 = insertvalue %variant undef, i8* %10, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %13 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 + store %variant %12, %variant* %13, align 16 + %14 = bitcast [2 x %variant]* %varargslots to %variant* + %15 = insertvalue %"variant[]" undef, %variant* %14, 0 + %16 = insertvalue %"variant[]" %15, i64 2, 1 + store %"variant[]" %16, %"variant[]"* %taddr, align 8 + %17 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 + %lo = load i8*, i8** %18, align 8 + %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 + %hi = load i64, i64* %19, align 8 + %20 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %20, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -81,57 +72,50 @@ after_check: ; preds = %entry voiderr: ; preds = %after_check, %entry store i8 -35, i8* %z, align 1 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0), i64 8 }, %"char[]"* %taddr4, align 8 - %24 = bitcast %"char[]"* %taddr4 to { i8*, i64 }* - %25 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 0 - %lo5 = load i8*, i8** %25, align 8 - %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 1 - %hi6 = load i64, i64* %26, align 8 - %27 = insertvalue %variant undef, i8* %z, 0 - %28 = insertvalue %variant %27, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 - %29 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots8, i64 0, i64 0 - store %variant %28, %variant* %29, align 16 - %30 = load i8, i8* %z, align 1 - store i8 %30, i8* %i, align 1 + %21 = insertvalue %variant undef, i8* %z, 0 + %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 + %23 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots2, i64 0, i64 0 + store %variant %22, %variant* %23, align 16 + %24 = load i8, i8* %z, align 1 + store i8 %24, i8* %i, align 1 store i8 1, i8* %shift, align 1 - %31 = load i8, i8* %i, align 1 - %32 = load i8, i8* %i, align 1 - %33 = load i8, i8* %shift, align 1 - %34 = call i8 @llvm.fshr.i8(i8 %31, i8 %32, i8 %33) - store i8 %34, i8* %taddr9, align 1 - %35 = insertvalue %variant undef, i8* %taddr9, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 - %37 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots8, i64 0, i64 1 - store %variant %36, %variant* %37, align 16 - %38 = load i8, i8* %z, align 1 - store i8 %38, i8* %i10, align 1 - store i8 1, i8* %shift11, align 1 - %39 = load i8, i8* %i10, align 1 - %40 = load i8, i8* %i10, align 1 - %41 = load i8, i8* %shift11, align 1 - %42 = call i8 @llvm.fshl.i8(i8 %39, i8 %40, i8 %41) - store i8 %42, i8* %taddr12, align 1 - %43 = insertvalue %variant undef, i8* %taddr12, 0 - %44 = insertvalue %variant %43, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 - %45 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots8, i64 0, i64 2 - store %variant %44, %variant* %45, align 16 - %46 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg7, i32 0, i32 1 - store i64 3, i64* %46, align 8 - %47 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg7, i32 0, i32 0 - %48 = bitcast [3 x %variant]* %varargslots8 to %variant* - store %variant* %48, %variant** %47, align 8 - %49 = bitcast %"variant[]"* %vararg7 to { i8*, i64 }* - %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 0 - %lo13 = load i8*, i8** %50, align 8 - %51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 1 - %hi14 = load i64, i64* %51, align 8 - %52 = call i64 @std_io_printfln(i64* %retparam3, i8* %lo5, i64 %hi6, i8* %lo13, i64 %hi14) - %not_err15 = icmp eq i64 %52, 0 - br i1 %not_err15, label %after_check16, label %voiderr17 + %25 = load i8, i8* %i, align 1 + %26 = load i8, i8* %i, align 1 + %27 = load i8, i8* %shift, align 1 + %28 = call i8 @llvm.fshr.i8(i8 %25, i8 %26, i8 %27) + store i8 %28, i8* %taddr3, align 1 + %29 = insertvalue %variant undef, i8* %taddr3, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 + %31 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots2, i64 0, i64 1 + store %variant %30, %variant* %31, align 16 + %32 = load i8, i8* %z, align 1 + store i8 %32, i8* %i4, align 1 + store i8 1, i8* %shift5, align 1 + %33 = load i8, i8* %i4, align 1 + %34 = load i8, i8* %i4, align 1 + %35 = load i8, i8* %shift5, align 1 + %36 = call i8 @llvm.fshl.i8(i8 %33, i8 %34, i8 %35) + store i8 %36, i8* %taddr6, align 1 + %37 = insertvalue %variant undef, i8* %taddr6, 0 + %38 = insertvalue %variant %37, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1 + %39 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots2, i64 0, i64 2 + store %variant %38, %variant* %39, align 16 + %40 = bitcast [3 x %variant]* %varargslots2 to %variant* + %41 = insertvalue %"variant[]" undef, %variant* %40, 0 + %42 = insertvalue %"variant[]" %41, i64 3, 1 + store %"variant[]" %42, %"variant[]"* %taddr7, align 8 + %43 = bitcast %"variant[]"* %taddr7 to { i8*, i64 }* + %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0 + %lo8 = load i8*, i8** %44, align 8 + %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1 + %hi9 = load i64, i64* %45, align 8 + %46 = call i64 @std_io_printfln(i64* %retparam1, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0), i64 8, i8* %lo8, i64 %hi9) + %not_err10 = icmp eq i64 %46, 0 + br i1 %not_err10, label %after_check11, label %voiderr12 -after_check16: ; preds = %voiderr - br label %voiderr17 +after_check11: ; preds = %voiderr + br label %voiderr12 -voiderr17: ; preds = %after_check16, %voiderr +voiderr12: ; preds = %after_check11, %voiderr ret void } diff --git a/test/test_suite/macros/macro_typed_varargs.c3t b/test/test_suite/macros/macro_typed_varargs.c3t index 5d27a6511..a67da50df 100644 --- a/test/test_suite/macros/macro_typed_varargs.c3t +++ b/test/test_suite/macros/macro_typed_varargs.c3t @@ -37,22 +37,20 @@ entry: %.anon1 = alloca i64, align 8 %i = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %x4 = alloca %"variant[]", align 8 - %literal5 = alloca [4 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 + %x2 = alloca %"variant[]", align 8 + %literal3 = alloca [4 x %variant], align 16 + %taddr4 = alloca i32, align 4 + %taddr5 = alloca i32, align 4 %taddr6 = alloca i32, align 4 %taddr7 = alloca i32, align 4 - %taddr8 = alloca i32, align 4 - %taddr9 = alloca i32, align 4 - %.anon10 = alloca i64, align 8 - %.anon11 = alloca i64, align 8 - %i15 = alloca %variant, align 8 - %retparam17 = alloca i64, align 8 - %taddr18 = alloca %"char[]", align 8 - %vararg21 = alloca %"variant[]", align 8 - %varargslots22 = alloca [1 x %variant], align 16 + %.anon8 = alloca i64, align 8 + %.anon9 = alloca i64, align 8 + %i13 = alloca %variant, align 8 + %retparam15 = alloca i64, align 8 + %varargslots16 = alloca [1 x %variant], align 16 + %taddr17 = alloca %"variant[]", align 8 %0 = getelementptr inbounds [4 x i32], [4 x i32]* %literal, i64 0, i64 0 store i32 1, i32* %0, align 4 %1 = getelementptr inbounds [4 x i32], [4 x i32]* %literal, i64 0, i64 1 @@ -84,127 +82,113 @@ loop.body: ; preds = %loop.cond %ptroffset = getelementptr inbounds i32, i32* %12, i64 %13 %14 = load i32, i32* %ptroffset, align 4 store i32 %14, i32* %i, align 4 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2 }, %"char[]"* %taddr, align 8 - %15 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 0 - %lo = load i8*, i8** %16, align 8 - %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 1 - %hi = load i64, i64* %17, align 8 - %18 = bitcast i32* %i to i8* - %19 = insertvalue %variant undef, i8* %18, 0 - %20 = insertvalue %variant %19, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %21 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %20, %variant* %21, align 16 - %22 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %22, align 8 - %23 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %24 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %24, %variant** %23, align 8 - %25 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 0 - %lo2 = load i8*, i8** %26, align 8 - %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 1 - %hi3 = load i64, i64* %27, align 8 - %28 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %28, 0 + %15 = bitcast i32* %i to i8* + %16 = insertvalue %variant undef, i8* %15, 0 + %17 = insertvalue %variant %16, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %18 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %17, %variant* %18, align 16 + %19 = bitcast [1 x %variant]* %varargslots to %variant* + %20 = insertvalue %"variant[]" undef, %variant* %19, 0 + %21 = insertvalue %"variant[]" %20, i64 1, 1 + store %"variant[]" %21, %"variant[]"* %taddr, align 8 + %22 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0 + %lo = load i8*, i8** %23, align 8 + %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1 + %hi = load i64, i64* %24, align 8 + %25 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %25, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %loop.body br label %voiderr voiderr: ; preds = %after_check, %loop.body - %29 = load i64, i64* %.anon1, align 8 - %add = add i64 %29, 1 + %26 = load i64, i64* %.anon1, align 8 + %add = add i64 %26, 1 store i64 %add, i64* %.anon1, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - %30 = getelementptr inbounds [4 x %variant], [4 x %variant]* %literal5, i64 0, i64 0 - store i32 1, i32* %taddr6, align 4 - %31 = bitcast i32* %taddr6 to i8* - %32 = insertvalue %variant undef, i8* %31, 0 - %33 = insertvalue %variant %32, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - store %variant %33, %variant* %30, align 8 - %34 = getelementptr inbounds [4 x %variant], [4 x %variant]* %literal5, i64 0, i64 1 - store i32 -1, i32* %taddr7, align 4 - %35 = bitcast i32* %taddr7 to i8* - %36 = insertvalue %variant undef, i8* %35, 0 - %37 = insertvalue %variant %36, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - store %variant %37, %variant* %34, align 8 - %38 = getelementptr inbounds [4 x %variant], [4 x %variant]* %literal5, i64 0, i64 2 - store i32 3141, i32* %taddr8, align 4 - %39 = bitcast i32* %taddr8 to i8* - %40 = insertvalue %variant undef, i8* %39, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - store %variant %41, %variant* %38, align 8 - %42 = getelementptr inbounds [4 x %variant], [4 x %variant]* %literal5, i64 0, i64 3 - store i32 1000, i32* %taddr9, align 4 - %43 = bitcast i32* %taddr9 to i8* - %44 = insertvalue %variant undef, i8* %43, 0 - %45 = insertvalue %variant %44, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - store %variant %45, %variant* %42, align 8 - %46 = bitcast [4 x %variant]* %literal5 to %variant* - %47 = insertvalue %"variant[]" undef, %variant* %46, 0 - %48 = insertvalue %"variant[]" %47, i64 4, 1 - store %"variant[]" %48, %"variant[]"* %x4, align 8 - %49 = getelementptr inbounds %"variant[]", %"variant[]"* %x4, i32 0, i32 1 - %50 = load i64, i64* %49, align 8 - store i64 %50, i64* %.anon10, align 8 - store i64 0, i64* %.anon11, align 8 - br label %loop.cond12 + %27 = getelementptr inbounds [4 x %variant], [4 x %variant]* %literal3, i64 0, i64 0 + store i32 1, i32* %taddr4, align 4 + %28 = bitcast i32* %taddr4 to i8* + %29 = insertvalue %variant undef, i8* %28, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + store %variant %30, %variant* %27, align 8 + %31 = getelementptr inbounds [4 x %variant], [4 x %variant]* %literal3, i64 0, i64 1 + store i32 -1, i32* %taddr5, align 4 + %32 = bitcast i32* %taddr5 to i8* + %33 = insertvalue %variant undef, i8* %32, 0 + %34 = insertvalue %variant %33, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + store %variant %34, %variant* %31, align 8 + %35 = getelementptr inbounds [4 x %variant], [4 x %variant]* %literal3, i64 0, i64 2 + store i32 3141, i32* %taddr6, align 4 + %36 = bitcast i32* %taddr6 to i8* + %37 = insertvalue %variant undef, i8* %36, 0 + %38 = insertvalue %variant %37, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + store %variant %38, %variant* %35, align 8 + %39 = getelementptr inbounds [4 x %variant], [4 x %variant]* %literal3, i64 0, i64 3 + store i32 1000, i32* %taddr7, align 4 + %40 = bitcast i32* %taddr7 to i8* + %41 = insertvalue %variant undef, i8* %40, 0 + %42 = insertvalue %variant %41, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + store %variant %42, %variant* %39, align 8 + %43 = bitcast [4 x %variant]* %literal3 to %variant* + %44 = insertvalue %"variant[]" undef, %variant* %43, 0 + %45 = insertvalue %"variant[]" %44, i64 4, 1 + store %"variant[]" %45, %"variant[]"* %x2, align 8 + %46 = getelementptr inbounds %"variant[]", %"variant[]"* %x2, i32 0, i32 1 + %47 = load i64, i64* %46, align 8 + store i64 %47, i64* %.anon8, align 8 + store i64 0, i64* %.anon9, align 8 + br label %loop.cond10 -loop.cond12: ; preds = %voiderr27, %loop.exit - %51 = load i64, i64* %.anon11, align 8 - %52 = load i64, i64* %.anon10, align 8 - %lt13 = icmp ult i64 %51, %52 - br i1 %lt13, label %loop.body14, label %loop.exit29 +loop.cond10: ; preds = %voiderr22, %loop.exit + %48 = load i64, i64* %.anon9, align 8 + %49 = load i64, i64* %.anon8, align 8 + %lt11 = icmp ult i64 %48, %49 + br i1 %lt11, label %loop.body12, label %loop.exit24 -loop.body14: ; preds = %loop.cond12 - %53 = getelementptr inbounds %"variant[]", %"variant[]"* %x4, i32 0, i32 0 - %54 = load %variant*, %variant** %53, align 8 - %55 = load i64, i64* %.anon11, align 8 - %ptroffset16 = getelementptr inbounds %variant, %variant* %54, i64 %55 - %56 = bitcast %variant* %i15 to i8* - %57 = bitcast %variant* %ptroffset16 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %56, i8* align 8 %57, i32 16, i1 false) - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i32 0, i32 0), i64 2 }, %"char[]"* %taddr18, align 8 - %58 = bitcast %"char[]"* %taddr18 to { i8*, i64 }* - %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0 - %lo19 = load i8*, i8** %59, align 8 - %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1 - %hi20 = load i64, i64* %60, align 8 - %61 = getelementptr inbounds %variant, %variant* %i15, i32 0, i32 0 - %62 = bitcast i8** %61 to i32** - %63 = load i32*, i32** %62, align 8 - %64 = bitcast i32* %63 to i8* - %65 = insertvalue %variant undef, i8* %64, 0 - %66 = insertvalue %variant %65, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %67 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots22, i64 0, i64 0 - store %variant %66, %variant* %67, align 16 - %68 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg21, i32 0, i32 1 - store i64 1, i64* %68, align 8 - %69 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg21, i32 0, i32 0 - %70 = bitcast [1 x %variant]* %varargslots22 to %variant* - store %variant* %70, %variant** %69, align 8 - %71 = bitcast %"variant[]"* %vararg21 to { i8*, i64 }* - %72 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %71, i32 0, i32 0 - %lo23 = load i8*, i8** %72, align 8 - %73 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %71, i32 0, i32 1 - %hi24 = load i64, i64* %73, align 8 - %74 = call i64 @std_io_printfln(i64* %retparam17, i8* %lo19, i64 %hi20, i8* %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %74, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 +loop.body12: ; preds = %loop.cond10 + %50 = getelementptr inbounds %"variant[]", %"variant[]"* %x2, i32 0, i32 0 + %51 = load %variant*, %variant** %50, align 8 + %52 = load i64, i64* %.anon9, align 8 + %ptroffset14 = getelementptr inbounds %variant, %variant* %51, i64 %52 + %53 = bitcast %variant* %i13 to i8* + %54 = bitcast %variant* %ptroffset14 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %53, i8* align 8 %54, i32 16, i1 false) + %55 = getelementptr inbounds %variant, %variant* %i13, i32 0, i32 0 + %56 = bitcast i8** %55 to i32** + %57 = load i32*, i32** %56, align 8 + %58 = bitcast i32* %57 to i8* + %59 = insertvalue %variant undef, i8* %58, 0 + %60 = insertvalue %variant %59, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %61 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots16, i64 0, i64 0 + store %variant %60, %variant* %61, align 16 + %62 = bitcast [1 x %variant]* %varargslots16 to %variant* + %63 = insertvalue %"variant[]" undef, %variant* %62, 0 + %64 = insertvalue %"variant[]" %63, i64 1, 1 + store %"variant[]" %64, %"variant[]"* %taddr17, align 8 + %65 = bitcast %"variant[]"* %taddr17 to { i8*, i64 }* + %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 0 + %lo18 = load i8*, i8** %66, align 8 + %67 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 1 + %hi19 = load i64, i64* %67, align 8 + %68 = call i64 @std_io_printfln(i64* %retparam15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i32 0, i32 0), i64 2, i8* %lo18, i64 %hi19) + %not_err20 = icmp eq i64 %68, 0 + br i1 %not_err20, label %after_check21, label %voiderr22 -after_check26: ; preds = %loop.body14 - br label %voiderr27 +after_check21: ; preds = %loop.body12 + br label %voiderr22 -voiderr27: ; preds = %after_check26, %loop.body14 - %75 = load i64, i64* %.anon11, align 8 - %add28 = add i64 %75, 1 - store i64 %add28, i64* %.anon11, align 8 - br label %loop.cond12 +voiderr22: ; preds = %after_check21, %loop.body12 + %69 = load i64, i64* %.anon9, align 8 + %add23 = add i64 %69, 1 + store i64 %add23, i64* %.anon9, align 8 + br label %loop.cond10 -loop.exit29: ; preds = %loop.cond12 +loop.exit24: ; preds = %loop.cond10 ret void } diff --git a/test/test_suite/macros/macro_untyped_varargs_2.c3t b/test/test_suite/macros/macro_untyped_varargs_2.c3t index dc09ed66b..d64333fe1 100644 --- a/test/test_suite/macros/macro_untyped_varargs_2.c3t +++ b/test/test_suite/macros/macro_untyped_varargs_2.c3t @@ -63,34 +63,26 @@ fn void main() define i32 @test_ping(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8 - %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 - %lo = load i8*, i8** %2, align 8 - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 - %hi = load i64, i64* %3, align 8 - store i32 %0, i32* %taddr1, align 4 - %4 = bitcast i32* %taddr1 to i8* - %5 = insertvalue %variant undef, i8* %4, 0 - %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %6, %variant* %7, align 16 - %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %8, align 8 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %10 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %10, %variant** %9, align 8 - %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 - %lo2 = load i8*, i8** %12, align 8 - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 - %hi3 = load i64, i64* %13, align 8 - %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %14, 0 + %taddr = alloca i32, align 4 + %taddr1 = alloca %"variant[]", align 8 + store i32 %0, i32* %taddr, align 4 + %1 = bitcast i32* %taddr to i8* + %2 = insertvalue %variant undef, i8* %1, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %3, %variant* %4, align 16 + %5 = bitcast [1 x %variant]* %varargslots to %variant* + %6 = insertvalue %"variant[]" undef, %variant* %5, 0 + %7 = insertvalue %"variant[]" %6, i64 1, 1 + store %"variant[]" %7, %"variant[]"* %taddr1, align 8 + %8 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 + %lo = load i8*, i8** %9, align 8 + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 + %hi = load i64, i64* %10, align 8 + %11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -100,6 +92,7 @@ voiderr: ; preds = %after_check, %entry ret i32 %0 } +; Function Attrs: nounwind define void @test_main() #0 { entry: %.anon = alloca i32, align 4 @@ -109,50 +102,41 @@ entry: %i = alloca i32, align 4 %j = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %retparam7 = alloca i64, align 8 - %taddr8 = alloca %"char[]", align 8 - %vararg11 = alloca %"variant[]", align 8 - %varargslots12 = alloca [1 x %variant], align 16 - %retparam18 = alloca i64, align 8 - %taddr19 = alloca %"char[]", align 8 - %vararg22 = alloca %"variant[]", align 8 - %varargslots23 = alloca [1 x %variant], align 16 - %retparam29 = alloca i64, align 8 - %taddr30 = alloca %"char[]", align 8 - %vararg33 = alloca %"variant[]", align 8 - %varargslots34 = alloca [1 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 + %retparam5 = alloca i64, align 8 + %varargslots6 = alloca [1 x %variant], align 16 + %taddr7 = alloca %"variant[]", align 8 + %retparam13 = alloca i64, align 8 + %varargslots14 = alloca [1 x %variant], align 16 + %taddr15 = alloca %"variant[]", align 8 + %retparam21 = alloca i64, align 8 + %varargslots22 = alloca [1 x %variant], align 16 + %taddr23 = alloca %"variant[]", align 8 %x = alloca i32, align 4 - %retparam40 = alloca i64, align 8 - %taddr41 = alloca %"char[]", align 8 - %vararg44 = alloca %"variant[]", align 8 - %varargslots45 = alloca [1 x %variant], align 16 - %taddr46 = alloca [3 x i8]*, align 8 - %x52 = alloca double, align 8 - %retparam53 = alloca i64, align 8 - %taddr54 = alloca %"char[]", align 8 - %vararg57 = alloca %"variant[]", align 8 - %varargslots58 = alloca [1 x %variant], align 16 - %taddr59 = alloca [6 x i8]*, align 8 - %retparam65 = alloca i64, align 8 - %taddr66 = alloca %"char[]", align 8 - %vararg69 = alloca %"variant[]", align 8 - %varargslots70 = alloca [1 x %variant], align 16 - %taddr71 = alloca i32, align 4 - %x77 = alloca i32, align 4 + %retparam29 = alloca i64, align 8 + %varargslots30 = alloca [1 x %variant], align 16 + %taddr31 = alloca [3 x i8]*, align 8 + %taddr32 = alloca %"variant[]", align 8 + %x38 = alloca double, align 8 + %retparam39 = alloca i64, align 8 + %varargslots40 = alloca [1 x %variant], align 16 + %taddr41 = alloca [6 x i8]*, align 8 + %taddr42 = alloca %"variant[]", align 8 + %retparam48 = alloca i64, align 8 + %varargslots49 = alloca [1 x %variant], align 16 + %taddr50 = alloca i32, align 4 + %taddr51 = alloca %"variant[]", align 8 + %x57 = alloca i32, align 4 %y = alloca i32, align 4 %a = alloca i32, align 4 - %retparam78 = alloca i64, align 8 - %taddr79 = alloca %"char[]", align 8 - %vararg82 = alloca %"variant[]", align 8 - %varargslots83 = alloca [2 x %variant], align 16 - %a89 = alloca i32, align 4 - %retparam90 = alloca i64, align 8 - %taddr91 = alloca %"char[]", align 8 - %vararg94 = alloca %"variant[]", align 8 - %varargslots95 = alloca [2 x %variant], align 16 + %retparam58 = alloca i64, align 8 + %varargslots59 = alloca [2 x %variant], align 16 + %taddr60 = alloca %"variant[]", align 8 + %a66 = alloca i32, align 4 + %retparam67 = alloca i64, align 8 + %varargslots68 = alloca [2 x %variant], align 16 + %taddr69 = alloca %"variant[]", align 8 %0 = call i32 @test_ping(i32 -1) store i32 %0, i32* %.anon, align 4 %1 = call i32 @test_ping(i32 1) @@ -169,295 +153,232 @@ entry: %7 = call i32 @test_ping(i32 3141) %add4 = add i32 %6, %7 store i32 %add4, i32* %j, align 4 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i32 0, i32 0), i64 2 }, %"char[]"* %taddr, align 8 - %8 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0 - %lo = load i8*, i8** %9, align 8 - %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1 - %hi = load i64, i64* %10, align 8 - %11 = bitcast i32* %.anon1 to i8* - %12 = insertvalue %variant undef, i8* %11, 0 - %13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %14 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %13, %variant* %14, align 16 - %15 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %15, align 8 - %16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %17 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %17, %variant** %16, align 8 - %18 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 - %lo5 = load i8*, i8** %19, align 8 - %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 - %hi6 = load i64, i64* %20, align 8 - %21 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo5, i64 %hi6) - %not_err = icmp eq i64 %21, 0 + %8 = bitcast i32* %.anon1 to i8* + %9 = insertvalue %variant undef, i8* %8, 0 + %10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %11 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %10, %variant* %11, align 16 + %12 = bitcast [1 x %variant]* %varargslots to %variant* + %13 = insertvalue %"variant[]" undef, %variant* %12, 0 + %14 = insertvalue %"variant[]" %13, i64 1, 1 + store %"variant[]" %14, %"variant[]"* %taddr, align 8 + %15 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 0 + %lo = load i8*, i8** %16, align 8 + %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 1 + %hi = load i64, i64* %17, align 8 + %18 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i32 0, i32 0), i64 2, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %18, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2 }, %"char[]"* %taddr8, align 8 - %22 = bitcast %"char[]"* %taddr8 to { i8*, i64 }* - %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0 - %lo9 = load i8*, i8** %23, align 8 - %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1 - %hi10 = load i64, i64* %24, align 8 - %25 = bitcast i32* %.anon to i8* - %26 = insertvalue %variant undef, i8* %25, 0 - %27 = insertvalue %variant %26, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %28 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots12, i64 0, i64 0 - store %variant %27, %variant* %28, align 16 - %29 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg11, i32 0, i32 1 - store i64 1, i64* %29, align 8 - %30 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg11, i32 0, i32 0 - %31 = bitcast [1 x %variant]* %varargslots12 to %variant* - store %variant* %31, %variant** %30, align 8 - %32 = bitcast %"variant[]"* %vararg11 to { i8*, i64 }* - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0 - %lo13 = load i8*, i8** %33, align 8 - %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1 - %hi14 = load i64, i64* %34, align 8 - %35 = call i64 @std_io_printfln(i64* %retparam7, i8* %lo9, i64 %hi10, i8* %lo13, i64 %hi14) - %not_err15 = icmp eq i64 %35, 0 - br i1 %not_err15, label %after_check16, label %voiderr17 + %19 = bitcast i32* %.anon to i8* + %20 = insertvalue %variant undef, i8* %19, 0 + %21 = insertvalue %variant %20, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %22 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots6, i64 0, i64 0 + store %variant %21, %variant* %22, align 16 + %23 = bitcast [1 x %variant]* %varargslots6 to %variant* + %24 = insertvalue %"variant[]" undef, %variant* %23, 0 + %25 = insertvalue %"variant[]" %24, i64 1, 1 + store %"variant[]" %25, %"variant[]"* %taddr7, align 8 + %26 = bitcast %"variant[]"* %taddr7 to { i8*, i64 }* + %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 0 + %lo8 = load i8*, i8** %27, align 8 + %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 1 + %hi9 = load i64, i64* %28, align 8 + %29 = call i64 @std_io_printfln(i64* %retparam5, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2, i8* %lo8, i64 %hi9) + %not_err10 = icmp eq i64 %29, 0 + br i1 %not_err10, label %after_check11, label %voiderr12 -after_check16: ; preds = %voiderr - br label %voiderr17 +after_check11: ; preds = %voiderr + br label %voiderr12 -voiderr17: ; preds = %after_check16, %voiderr - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2 }, %"char[]"* %taddr19, align 8 - %36 = bitcast %"char[]"* %taddr19 to { i8*, i64 }* - %37 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 0 - %lo20 = load i8*, i8** %37, align 8 - %38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 1 - %hi21 = load i64, i64* %38, align 8 - %39 = bitcast i32* %.anon2 to i8* - %40 = insertvalue %variant undef, i8* %39, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %42 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots23, i64 0, i64 0 - store %variant %41, %variant* %42, align 16 - %43 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg22, i32 0, i32 1 - store i64 1, i64* %43, align 8 - %44 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg22, i32 0, i32 0 - %45 = bitcast [1 x %variant]* %varargslots23 to %variant* - store %variant* %45, %variant** %44, align 8 - %46 = bitcast %"variant[]"* %vararg22 to { i8*, i64 }* - %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 0 - %lo24 = load i8*, i8** %47, align 8 - %48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 1 - %hi25 = load i64, i64* %48, align 8 - %49 = call i64 @std_io_printfln(i64* %retparam18, i8* %lo20, i64 %hi21, i8* %lo24, i64 %hi25) - %not_err26 = icmp eq i64 %49, 0 +voiderr12: ; preds = %after_check11, %voiderr + %30 = bitcast i32* %.anon2 to i8* + %31 = insertvalue %variant undef, i8* %30, 0 + %32 = insertvalue %variant %31, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %33 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots14, i64 0, i64 0 + store %variant %32, %variant* %33, align 16 + %34 = bitcast [1 x %variant]* %varargslots14 to %variant* + %35 = insertvalue %"variant[]" undef, %variant* %34, 0 + %36 = insertvalue %"variant[]" %35, i64 1, 1 + store %"variant[]" %36, %"variant[]"* %taddr15, align 8 + %37 = bitcast %"variant[]"* %taddr15 to { i8*, i64 }* + %38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %37, i32 0, i32 0 + %lo16 = load i8*, i8** %38, align 8 + %39 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %37, i32 0, i32 1 + %hi17 = load i64, i64* %39, align 8 + %40 = call i64 @std_io_printfln(i64* %retparam13, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2, i8* %lo16, i64 %hi17) + %not_err18 = icmp eq i64 %40, 0 + br i1 %not_err18, label %after_check19, label %voiderr20 + +after_check19: ; preds = %voiderr12 + br label %voiderr20 + +voiderr20: ; preds = %after_check19, %voiderr12 + %41 = bitcast i32* %.anon3 to i8* + %42 = insertvalue %variant undef, i8* %41, 0 + %43 = insertvalue %variant %42, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %44 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots22, i64 0, i64 0 + store %variant %43, %variant* %44, align 16 + %45 = bitcast [1 x %variant]* %varargslots22 to %variant* + %46 = insertvalue %"variant[]" undef, %variant* %45, 0 + %47 = insertvalue %"variant[]" %46, i64 1, 1 + store %"variant[]" %47, %"variant[]"* %taddr23, align 8 + %48 = bitcast %"variant[]"* %taddr23 to { i8*, i64 }* + %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 0 + %lo24 = load i8*, i8** %49, align 8 + %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 1 + %hi25 = load i64, i64* %50, align 8 + %51 = call i64 @std_io_printfln(i64* %retparam21, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2, i8* %lo24, i64 %hi25) + %not_err26 = icmp eq i64 %51, 0 br i1 %not_err26, label %after_check27, label %voiderr28 -after_check27: ; preds = %voiderr17 +after_check27: ; preds = %voiderr20 br label %voiderr28 -voiderr28: ; preds = %after_check27, %voiderr17 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2 }, %"char[]"* %taddr30, align 8 - %50 = bitcast %"char[]"* %taddr30 to { i8*, i64 }* - %51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %50, i32 0, i32 0 - %lo31 = load i8*, i8** %51, align 8 - %52 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %50, i32 0, i32 1 - %hi32 = load i64, i64* %52, align 8 - %53 = bitcast i32* %.anon3 to i8* - %54 = insertvalue %variant undef, i8* %53, 0 - %55 = insertvalue %variant %54, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %56 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots34, i64 0, i64 0 - store %variant %55, %variant* %56, align 16 - %57 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg33, i32 0, i32 1 - store i64 1, i64* %57, align 8 - %58 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg33, i32 0, i32 0 - %59 = bitcast [1 x %variant]* %varargslots34 to %variant* - store %variant* %59, %variant** %58, align 8 - %60 = bitcast %"variant[]"* %vararg33 to { i8*, i64 }* - %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0 - %lo35 = load i8*, i8** %61, align 8 - %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1 - %hi36 = load i64, i64* %62, align 8 - %63 = call i64 @std_io_printfln(i64* %retparam29, i8* %lo31, i64 %hi32, i8* %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %63, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 - -after_check38: ; preds = %voiderr28 - br label %voiderr39 - -voiderr39: ; preds = %after_check38, %voiderr28 +voiderr28: ; preds = %after_check27, %voiderr20 store i32 0, i32* %x, align 4 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0), i64 2 }, %"char[]"* %taddr41, align 8 - %64 = bitcast %"char[]"* %taddr41 to { i8*, i64 }* - %65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 0 - %lo42 = load i8*, i8** %65, align 8 - %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 1 - %hi43 = load i64, i64* %66, align 8 - store [3 x i8]* bitcast ([4 x i8]* @.str.6 to [3 x i8]*), [3 x i8]** %taddr46, align 8 - %67 = bitcast [3 x i8]** %taddr46 to i8* - %68 = insertvalue %variant undef, i8* %67, 0 - %69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %70 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots45, i64 0, i64 0 - store %variant %69, %variant* %70, align 16 - %71 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 1 - store i64 1, i64* %71, align 8 - %72 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 0 - %73 = bitcast [1 x %variant]* %varargslots45 to %variant* - store %variant* %73, %variant** %72, align 8 - %74 = bitcast %"variant[]"* %vararg44 to { i8*, i64 }* - %75 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 0 - %lo47 = load i8*, i8** %75, align 8 - %76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 1 - %hi48 = load i64, i64* %76, align 8 - %77 = call i64 @std_io_printfln(i64* %retparam40, i8* %lo42, i64 %hi43, i8* %lo47, i64 %hi48) - %not_err49 = icmp eq i64 %77, 0 - br i1 %not_err49, label %after_check50, label %voiderr51 + store [3 x i8]* bitcast ([4 x i8]* @.str.6 to [3 x i8]*), [3 x i8]** %taddr31, align 8 + %52 = bitcast [3 x i8]** %taddr31 to i8* + %53 = insertvalue %variant undef, i8* %52, 0 + %54 = insertvalue %variant %53, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 + %55 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots30, i64 0, i64 0 + store %variant %54, %variant* %55, align 16 + %56 = bitcast [1 x %variant]* %varargslots30 to %variant* + %57 = insertvalue %"variant[]" undef, %variant* %56, 0 + %58 = insertvalue %"variant[]" %57, i64 1, 1 + store %"variant[]" %58, %"variant[]"* %taddr32, align 8 + %59 = bitcast %"variant[]"* %taddr32 to { i8*, i64 }* + %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %59, i32 0, i32 0 + %lo33 = load i8*, i8** %60, align 8 + %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %59, i32 0, i32 1 + %hi34 = load i64, i64* %61, align 8 + %62 = call i64 @std_io_printfln(i64* %retparam29, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0), i64 2, i8* %lo33, i64 %hi34) + %not_err35 = icmp eq i64 %62, 0 + br i1 %not_err35, label %after_check36, label %voiderr37 -after_check50: ; preds = %voiderr39 - br label %voiderr51 +after_check36: ; preds = %voiderr28 + br label %voiderr37 -voiderr51: ; preds = %after_check50, %voiderr39 - store double 0.000000e+00, double* %x52, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i32 0, i32 0), i64 2 }, %"char[]"* %taddr54, align 8 - %78 = bitcast %"char[]"* %taddr54 to { i8*, i64 }* - %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0 - %lo55 = load i8*, i8** %79, align 8 - %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1 - %hi56 = load i64, i64* %80, align 8 - store [6 x i8]* bitcast ([7 x i8]* @.str.8 to [6 x i8]*), [6 x i8]** %taddr59, align 8 - %81 = bitcast [6 x i8]** %taddr59 to i8* - %82 = insertvalue %variant undef, i8* %81, 0 - %83 = insertvalue %variant %82, i64 ptrtoint (%.introspect* @"ct$p$a6$char" to i64), 1 - %84 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots58, i64 0, i64 0 - store %variant %83, %variant* %84, align 16 - %85 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg57, i32 0, i32 1 - store i64 1, i64* %85, align 8 - %86 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg57, i32 0, i32 0 - %87 = bitcast [1 x %variant]* %varargslots58 to %variant* - store %variant* %87, %variant** %86, align 8 - %88 = bitcast %"variant[]"* %vararg57 to { i8*, i64 }* - %89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 0 - %lo60 = load i8*, i8** %89, align 8 - %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 1 - %hi61 = load i64, i64* %90, align 8 - %91 = call i64 @std_io_printfln(i64* %retparam53, i8* %lo55, i64 %hi56, i8* %lo60, i64 %hi61) - %not_err62 = icmp eq i64 %91, 0 - br i1 %not_err62, label %after_check63, label %voiderr64 +voiderr37: ; preds = %after_check36, %voiderr28 + store double 0.000000e+00, double* %x38, align 8 + store [6 x i8]* bitcast ([7 x i8]* @.str.8 to [6 x i8]*), [6 x i8]** %taddr41, align 8 + %63 = bitcast [6 x i8]** %taddr41 to i8* + %64 = insertvalue %variant undef, i8* %63, 0 + %65 = insertvalue %variant %64, i64 ptrtoint (%.introspect* @"ct$p$a6$char" to i64), 1 + %66 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots40, i64 0, i64 0 + store %variant %65, %variant* %66, align 16 + %67 = bitcast [1 x %variant]* %varargslots40 to %variant* + %68 = insertvalue %"variant[]" undef, %variant* %67, 0 + %69 = insertvalue %"variant[]" %68, i64 1, 1 + store %"variant[]" %69, %"variant[]"* %taddr42, align 8 + %70 = bitcast %"variant[]"* %taddr42 to { i8*, i64 }* + %71 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 0 + %lo43 = load i8*, i8** %71, align 8 + %72 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 1 + %hi44 = load i64, i64* %72, align 8 + %73 = call i64 @std_io_printfln(i64* %retparam39, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i32 0, i32 0), i64 2, i8* %lo43, i64 %hi44) + %not_err45 = icmp eq i64 %73, 0 + br i1 %not_err45, label %after_check46, label %voiderr47 -after_check63: ; preds = %voiderr51 - br label %voiderr64 +after_check46: ; preds = %voiderr37 + br label %voiderr47 -voiderr64: ; preds = %after_check63, %voiderr51 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i64 2 }, %"char[]"* %taddr66, align 8 - %92 = bitcast %"char[]"* %taddr66 to { i8*, i64 }* - %93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 0 - %lo67 = load i8*, i8** %93, align 8 - %94 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 1 - %hi68 = load i64, i64* %94, align 8 - store i32 105, i32* %taddr71, align 4 - %95 = bitcast i32* %taddr71 to i8* - %96 = insertvalue %variant undef, i8* %95, 0 - %97 = insertvalue %variant %96, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %98 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots70, i64 0, i64 0 - store %variant %97, %variant* %98, align 16 - %99 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg69, i32 0, i32 1 - store i64 1, i64* %99, align 8 - %100 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg69, i32 0, i32 0 - %101 = bitcast [1 x %variant]* %varargslots70 to %variant* - store %variant* %101, %variant** %100, align 8 - %102 = bitcast %"variant[]"* %vararg69 to { i8*, i64 }* - %103 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %102, i32 0, i32 0 - %lo72 = load i8*, i8** %103, align 8 - %104 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %102, i32 0, i32 1 - %hi73 = load i64, i64* %104, align 8 - %105 = call i64 @std_io_printfln(i64* %retparam65, i8* %lo67, i64 %hi68, i8* %lo72, i64 %hi73) - %not_err74 = icmp eq i64 %105, 0 - br i1 %not_err74, label %after_check75, label %voiderr76 +voiderr47: ; preds = %after_check46, %voiderr37 + store i32 105, i32* %taddr50, align 4 + %74 = bitcast i32* %taddr50 to i8* + %75 = insertvalue %variant undef, i8* %74, 0 + %76 = insertvalue %variant %75, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %77 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots49, i64 0, i64 0 + store %variant %76, %variant* %77, align 16 + %78 = bitcast [1 x %variant]* %varargslots49 to %variant* + %79 = insertvalue %"variant[]" undef, %variant* %78, 0 + %80 = insertvalue %"variant[]" %79, i64 1, 1 + store %"variant[]" %80, %"variant[]"* %taddr51, align 8 + %81 = bitcast %"variant[]"* %taddr51 to { i8*, i64 }* + %82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %81, i32 0, i32 0 + %lo52 = load i8*, i8** %82, align 8 + %83 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %81, i32 0, i32 1 + %hi53 = load i64, i64* %83, align 8 + %84 = call i64 @std_io_printfln(i64* %retparam48, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i64 2, i8* %lo52, i64 %hi53) + %not_err54 = icmp eq i64 %84, 0 + br i1 %not_err54, label %after_check55, label %voiderr56 -after_check75: ; preds = %voiderr64 - br label %voiderr76 +after_check55: ; preds = %voiderr47 + br label %voiderr56 -voiderr76: ; preds = %after_check75, %voiderr64 - store i32 123, i32* %x77, align 4 +voiderr56: ; preds = %after_check55, %voiderr47 + store i32 123, i32* %x57, align 4 store i32 33, i32* %y, align 4 - %106 = load i32, i32* %x77, align 4 - store i32 %106, i32* %a, align 4 - %107 = load i32, i32* %y, align 4 - store i32 %107, i32* %x77, align 4 - %108 = load i32, i32* %a, align 4 - store i32 %108, i32* %y, align 4 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.10, i32 0, i32 0), i64 6 }, %"char[]"* %taddr79, align 8 - %109 = bitcast %"char[]"* %taddr79 to { i8*, i64 }* - %110 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %109, i32 0, i32 0 - %lo80 = load i8*, i8** %110, align 8 - %111 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %109, i32 0, i32 1 - %hi81 = load i64, i64* %111, align 8 - %112 = bitcast i32* %x77 to i8* - %113 = insertvalue %variant undef, i8* %112, 0 - %114 = insertvalue %variant %113, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %115 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots83, i64 0, i64 0 - store %variant %114, %variant* %115, align 16 - %116 = bitcast i32* %y to i8* - %117 = insertvalue %variant undef, i8* %116, 0 - %118 = insertvalue %variant %117, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %119 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots83, i64 0, i64 1 - store %variant %118, %variant* %119, align 16 - %120 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg82, i32 0, i32 1 - store i64 2, i64* %120, align 8 - %121 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg82, i32 0, i32 0 - %122 = bitcast [2 x %variant]* %varargslots83 to %variant* - store %variant* %122, %variant** %121, align 8 - %123 = bitcast %"variant[]"* %vararg82 to { i8*, i64 }* - %124 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 0 - %lo84 = load i8*, i8** %124, align 8 - %125 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 1 - %hi85 = load i64, i64* %125, align 8 - %126 = call i64 @std_io_printfln(i64* %retparam78, i8* %lo80, i64 %hi81, i8* %lo84, i64 %hi85) - %not_err86 = icmp eq i64 %126, 0 - br i1 %not_err86, label %after_check87, label %voiderr88 + %85 = load i32, i32* %x57, align 4 + store i32 %85, i32* %a, align 4 + %86 = load i32, i32* %y, align 4 + store i32 %86, i32* %x57, align 4 + %87 = load i32, i32* %a, align 4 + store i32 %87, i32* %y, align 4 + %88 = bitcast i32* %x57 to i8* + %89 = insertvalue %variant undef, i8* %88, 0 + %90 = insertvalue %variant %89, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %91 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots59, i64 0, i64 0 + store %variant %90, %variant* %91, align 16 + %92 = bitcast i32* %y to i8* + %93 = insertvalue %variant undef, i8* %92, 0 + %94 = insertvalue %variant %93, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %95 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots59, i64 0, i64 1 + store %variant %94, %variant* %95, align 16 + %96 = bitcast [2 x %variant]* %varargslots59 to %variant* + %97 = insertvalue %"variant[]" undef, %variant* %96, 0 + %98 = insertvalue %"variant[]" %97, i64 2, 1 + store %"variant[]" %98, %"variant[]"* %taddr60, align 8 + %99 = bitcast %"variant[]"* %taddr60 to { i8*, i64 }* + %100 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %99, i32 0, i32 0 + %lo61 = load i8*, i8** %100, align 8 + %101 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %99, i32 0, i32 1 + %hi62 = load i64, i64* %101, align 8 + %102 = call i64 @std_io_printfln(i64* %retparam58, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.10, i32 0, i32 0), i64 6, i8* %lo61, i64 %hi62) + %not_err63 = icmp eq i64 %102, 0 + br i1 %not_err63, label %after_check64, label %voiderr65 -after_check87: ; preds = %voiderr76 - br label %voiderr88 +after_check64: ; preds = %voiderr56 + br label %voiderr65 -voiderr88: ; preds = %after_check87, %voiderr76 - %127 = load i32, i32* %x77, align 4 - store i32 %127, i32* %a89, align 4 - %128 = load i32, i32* %y, align 4 - store i32 %128, i32* %x77, align 4 - %129 = load i32, i32* %a89, align 4 - store i32 %129, i32* %y, align 4 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.11, i32 0, i32 0), i64 6 }, %"char[]"* %taddr91, align 8 - %130 = bitcast %"char[]"* %taddr91 to { i8*, i64 }* - %131 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %130, i32 0, i32 0 - %lo92 = load i8*, i8** %131, align 8 - %132 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %130, i32 0, i32 1 - %hi93 = load i64, i64* %132, align 8 - %133 = bitcast i32* %x77 to i8* - %134 = insertvalue %variant undef, i8* %133, 0 - %135 = insertvalue %variant %134, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %136 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots95, i64 0, i64 0 - store %variant %135, %variant* %136, align 16 - %137 = bitcast i32* %y to i8* - %138 = insertvalue %variant undef, i8* %137, 0 - %139 = insertvalue %variant %138, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %140 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots95, i64 0, i64 1 - store %variant %139, %variant* %140, align 16 - %141 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg94, i32 0, i32 1 - store i64 2, i64* %141, align 8 - %142 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg94, i32 0, i32 0 - %143 = bitcast [2 x %variant]* %varargslots95 to %variant* - store %variant* %143, %variant** %142, align 8 - %144 = bitcast %"variant[]"* %vararg94 to { i8*, i64 }* - %145 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %144, i32 0, i32 0 - %lo96 = load i8*, i8** %145, align 8 - %146 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %144, i32 0, i32 1 - %hi97 = load i64, i64* %146, align 8 - %147 = call i64 @std_io_printfln(i64* %retparam90, i8* %lo92, i64 %hi93, i8* %lo96, i64 %hi97) - %not_err98 = icmp eq i64 %147, 0 - br i1 %not_err98, label %after_check99, label %voiderr100 +voiderr65: ; preds = %after_check64, %voiderr56 + %103 = load i32, i32* %x57, align 4 + store i32 %103, i32* %a66, align 4 + %104 = load i32, i32* %y, align 4 + store i32 %104, i32* %x57, align 4 + %105 = load i32, i32* %a66, align 4 + store i32 %105, i32* %y, align 4 + %106 = bitcast i32* %x57 to i8* + %107 = insertvalue %variant undef, i8* %106, 0 + %108 = insertvalue %variant %107, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %109 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots68, i64 0, i64 0 + store %variant %108, %variant* %109, align 16 + %110 = bitcast i32* %y to i8* + %111 = insertvalue %variant undef, i8* %110, 0 + %112 = insertvalue %variant %111, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %113 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots68, i64 0, i64 1 + store %variant %112, %variant* %113, align 16 + %114 = bitcast [2 x %variant]* %varargslots68 to %variant* + %115 = insertvalue %"variant[]" undef, %variant* %114, 0 + %116 = insertvalue %"variant[]" %115, i64 2, 1 + store %"variant[]" %116, %"variant[]"* %taddr69, align 8 + %117 = bitcast %"variant[]"* %taddr69 to { i8*, i64 }* + %118 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %117, i32 0, i32 0 + %lo70 = load i8*, i8** %118, align 8 + %119 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %117, i32 0, i32 1 + %hi71 = load i64, i64* %119, align 8 + %120 = call i64 @std_io_printfln(i64* %retparam67, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.11, i32 0, i32 0), i64 6, i8* %lo70, i64 %hi71) + %not_err72 = icmp eq i64 %120, 0 + br i1 %not_err72, label %after_check73, label %voiderr74 -after_check99: ; preds = %voiderr88 - br label %voiderr100 +after_check73: ; preds = %voiderr65 + br label %voiderr74 -voiderr100: ; preds = %after_check99, %voiderr88 +voiderr74: ; preds = %after_check73, %voiderr65 ret void } diff --git a/test/test_suite/macros/macro_vasplat.c3t b/test/test_suite/macros/macro_vasplat.c3t index a3eb1268c..5bc8188b9 100644 --- a/test/test_suite/macros/macro_vasplat.c3t +++ b/test/test_suite/macros/macro_vasplat.c3t @@ -69,105 +69,95 @@ entry: %i = alloca i64, align 8 %x = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 - %a3 = alloca [1 x i32], align 4 - %.anon4 = alloca i64, align 8 - %i8 = alloca i64, align 8 - %x9 = alloca i32, align 4 - %retparam10 = alloca i64, align 8 - %taddr11 = alloca %"char[]", align 8 - %vararg14 = alloca %"variant[]", align 8 - %varargslots15 = alloca [2 x %variant], align 16 - %a23 = alloca [4 x i32], align 16 - %.anon24 = alloca i64, align 8 - %i28 = alloca i64, align 8 - %x29 = alloca i32, align 4 - %retparam30 = alloca i64, align 8 - %taddr31 = alloca %"char[]", align 8 - %vararg34 = alloca %"variant[]", align 8 - %varargslots35 = alloca [2 x %variant], align 16 - %a43 = alloca [2 x i32], align 4 - %.anon44 = alloca i64, align 8 - %i48 = alloca i64, align 8 - %x49 = alloca i32, align 4 - %retparam50 = alloca i64, align 8 - %taddr51 = alloca %"char[]", align 8 - %vararg54 = alloca %"variant[]", align 8 - %varargslots55 = alloca [2 x %variant], align 16 - %a63 = alloca [3 x i32], align 4 - %.anon64 = alloca i64, align 8 - %i68 = alloca i64, align 8 - %x69 = alloca i32, align 4 - %retparam70 = alloca i64, align 8 - %taddr71 = alloca %"char[]", align 8 - %vararg74 = alloca %"variant[]", align 8 - %varargslots75 = alloca [2 x %variant], align 16 - %a83 = alloca [1 x i32], align 4 - %.anon84 = alloca i64, align 8 - %i88 = alloca i64, align 8 - %x89 = alloca i32, align 4 - %retparam90 = alloca i64, align 8 - %taddr91 = alloca %"char[]", align 8 - %vararg94 = alloca %"variant[]", align 8 - %varargslots95 = alloca [2 x %variant], align 16 - %a103 = alloca [2 x i32], align 4 + %taddr = alloca %"variant[]", 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 %variant], align 16 + %taddr10 = alloca %"variant[]", align 8 + %a18 = alloca [4 x i32], align 16 + %.anon19 = alloca i64, align 8 + %i23 = alloca i64, align 8 + %x24 = alloca i32, align 4 + %retparam25 = alloca i64, align 8 + %varargslots26 = alloca [2 x %variant], align 16 + %taddr27 = alloca %"variant[]", align 8 + %a35 = alloca [2 x i32], align 4 + %.anon36 = alloca i64, align 8 + %i40 = alloca i64, align 8 + %x41 = alloca i32, align 4 + %retparam42 = alloca i64, align 8 + %varargslots43 = alloca [2 x %variant], align 16 + %taddr44 = alloca %"variant[]", align 8 + %a52 = alloca [3 x i32], align 4 + %.anon53 = alloca i64, align 8 + %i57 = alloca i64, align 8 + %x58 = alloca i32, align 4 + %retparam59 = alloca i64, align 8 + %varargslots60 = alloca [2 x %variant], align 16 + %taddr61 = alloca %"variant[]", align 8 + %a69 = alloca [1 x i32], align 4 + %.anon70 = alloca i64, align 8 + %i74 = alloca i64, align 8 + %x75 = alloca i32, align 4 + %retparam76 = alloca i64, align 8 + %varargslots77 = alloca [2 x %variant], align 16 + %taddr78 = alloca %"variant[]", align 8 + %a86 = alloca [2 x i32], align 4 + %.anon87 = alloca i64, align 8 + %i91 = alloca i64, align 8 + %x92 = alloca i32, align 4 + %retparam93 = alloca i64, align 8 + %varargslots94 = alloca [2 x %variant], align 16 + %taddr95 = alloca %"variant[]", align 8 + %a103 = alloca [5 x i32], align 16 %.anon104 = alloca i64, align 8 %i108 = alloca i64, align 8 %x109 = alloca i32, align 4 %retparam110 = alloca i64, align 8 - %taddr111 = alloca %"char[]", align 8 - %vararg114 = alloca %"variant[]", align 8 - %varargslots115 = alloca [2 x %variant], align 16 - %a123 = alloca [5 x i32], align 16 - %.anon124 = alloca i64, align 8 - %i128 = alloca i64, align 8 - %x129 = alloca i32, align 4 - %retparam130 = alloca i64, align 8 - %taddr131 = alloca %"char[]", align 8 - %vararg134 = alloca %"variant[]", align 8 - %varargslots135 = alloca [2 x %variant], align 16 - %a143 = alloca [8 x i32], align 16 - %.anon144 = alloca i64, align 8 - %i148 = alloca i64, align 8 - %x149 = alloca i32, align 4 - %retparam150 = alloca i64, align 8 - %taddr151 = alloca %"char[]", align 8 - %vararg154 = alloca %"variant[]", align 8 - %varargslots155 = alloca [2 x %variant], align 16 + %varargslots111 = alloca [2 x %variant], align 16 + %taddr112 = alloca %"variant[]", align 8 + %a120 = alloca [8 x i32], align 16 + %.anon121 = alloca i64, align 8 + %i125 = alloca i64, align 8 + %x126 = alloca i32, align 4 + %retparam127 = alloca i64, align 8 + %varargslots128 = alloca [2 x %variant], align 16 + %taddr129 = alloca %"variant[]", align 8 %b = alloca [7 x i32], align 16 - %.anon163 = alloca i64, align 8 - %i167 = alloca i64, align 8 - %x168 = alloca i32, align 4 - %retparam169 = alloca i64, align 8 - %taddr170 = alloca %"char[]", align 8 - %vararg173 = alloca %"variant[]", align 8 - %varargslots174 = alloca [2 x %variant], align 16 + %.anon137 = alloca i64, align 8 + %i141 = alloca i64, align 8 + %x142 = alloca i32, align 4 + %retparam143 = alloca i64, align 8 + %varargslots144 = alloca [2 x %variant], align 16 + %taddr145 = alloca %"variant[]", align 8 %c = alloca [8 x i32], align 16 - %.anon182 = alloca i64, align 8 - %i186 = alloca i64, align 8 - %x187 = alloca i32, align 4 - %retparam188 = alloca i64, align 8 - %taddr189 = alloca %"char[]", align 8 - %vararg192 = alloca %"variant[]", align 8 - %varargslots193 = alloca [2 x %variant], align 16 - %a201 = alloca [6 x i32], align 16 - %.anon202 = alloca i64, align 8 - %i206 = alloca i64, align 8 - %x207 = alloca i32, align 4 - %retparam208 = alloca i64, align 8 - %taddr209 = alloca %"char[]", align 8 - %vararg212 = alloca %"variant[]", align 8 - %varargslots213 = alloca [2 x %variant], align 16 + %.anon153 = alloca i64, align 8 + %i157 = alloca i64, align 8 + %x158 = alloca i32, align 4 + %retparam159 = alloca i64, align 8 + %varargslots160 = alloca [2 x %variant], align 16 + %taddr161 = alloca %"variant[]", align 8 + %a169 = alloca [6 x i32], align 16 + %.anon170 = alloca i64, align 8 + %i174 = alloca i64, align 8 + %x175 = alloca i32, align 4 + %retparam176 = alloca i64, align 8 + %varargslots177 = alloca [2 x %variant], align 16 + %taddr178 = alloca %"variant[]", align 8 %0 = bitcast [3 x i32]* %a to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([3 x i32]* @.__const to i8*), i32 12, i1 false) store i64 0, i64* %.anon, align 8 br label %loop.cond + loop.cond: ; preds = %voiderr, %entry %1 = load i64, i64* %.anon, align 8 %gt = icmp ugt i64 3, %1 br i1 %gt, label %loop.body, label %loop.exit + loop.body: ; preds = %loop.cond %2 = load i64, i64* %.anon, align 8 store i64 %2, i64* %i, align 8 @@ -175,615 +165,589 @@ loop.body: ; preds = %loop.cond %4 = getelementptr inbounds [3 x i32], [3 x i32]* %a, i64 0, i64 %3 %5 = load i32, i32* %4, align 4 store i32 %5, i32* %x, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8 - %6 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 0 - %lo = load i8*, i8** %7, align 8 - %8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 1 - %hi = load i64, i64* %8, align 8 - %9 = bitcast i64* %i to i8* - %10 = insertvalue %variant undef, i8* %9, 0 - %11 = insertvalue %variant %10, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %12 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 - store %variant %11, %variant* %12, align 16 - %13 = bitcast i32* %x to i8* - %14 = insertvalue %variant undef, i8* %13, 0 - %15 = insertvalue %variant %14, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %16 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 - store %variant %15, %variant* %16, align 16 - %17 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 2, i64* %17, align 8 - %18 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %19 = bitcast [2 x %variant]* %varargslots to %variant* - store %variant* %19, %variant** %18, align 8 - %20 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 0 - %lo1 = load i8*, i8** %21, align 8 - %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 1 - %hi2 = load i64, i64* %22, align 8 - %23 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) - %not_err = icmp eq i64 %23, 0 + %6 = bitcast i64* %i to i8* + %7 = insertvalue %variant undef, i8* %6, 0 + %8 = insertvalue %variant %7, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %9 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 + store %variant %8, %variant* %9, align 16 + %10 = bitcast i32* %x to i8* + %11 = insertvalue %variant undef, i8* %10, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %13 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 + store %variant %12, %variant* %13, align 16 + %14 = bitcast [2 x %variant]* %varargslots to %variant* + %15 = insertvalue %"variant[]" undef, %variant* %14, 0 + %16 = insertvalue %"variant[]" %15, i64 2, 1 + store %"variant[]" %16, %"variant[]"* %taddr, align 8 + %17 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 + %lo = load i8*, i8** %18, align 8 + %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 + %hi = load i64, i64* %19, align 8 + %20 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %20, 0 br i1 %not_err, label %after_check, label %voiderr + after_check: ; preds = %loop.body br label %voiderr + voiderr: ; preds = %after_check, %loop.body - %24 = load i64, i64* %.anon, align 8 - %add = add i64 %24, 1 + %21 = load i64, i64* %.anon, align 8 + %add = add i64 %21, 1 store i64 %add, i64* %.anon, align 8 br label %loop.cond + loop.exit: ; preds = %loop.cond - %25 = bitcast [1 x i32]* %a3 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %25, i8* align 4 bitcast ([1 x i32]* @.__const.1 to i8*), i32 4, i1 false) - store i64 0, i64* %.anon4, align 8 - br label %loop.cond5 -loop.cond5: ; preds = %voiderr20, %loop.exit - %26 = load i64, i64* %.anon4, align 8 - %gt6 = icmp ugt i64 1, %26 - br i1 %gt6, label %loop.body7, label %loop.exit22 -loop.body7: ; preds = %loop.cond5 - %27 = load i64, i64* %.anon4, align 8 - store i64 %27, i64* %i8, align 8 - %28 = load i64, i64* %.anon4, align 8 - %29 = getelementptr inbounds [1 x i32], [1 x i32]* %a3, i64 0, i64 %28 - %30 = load i32, i32* %29, align 4 - store i32 %30, i32* %x9, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8 }, %"char[]"* %taddr11, align 8 - %31 = bitcast %"char[]"* %taddr11 to { i8*, i64 }* - %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 - %lo12 = load i8*, i8** %32, align 8 - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 - %hi13 = load i64, i64* %33, align 8 - %34 = bitcast i64* %i8 to i8* - %35 = insertvalue %variant undef, i8* %34, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %37 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots15, i64 0, i64 0 - store %variant %36, %variant* %37, align 16 - %38 = bitcast i32* %x9 to i8* - %39 = insertvalue %variant undef, i8* %38, 0 - %40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %41 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots15, i64 0, i64 1 - store %variant %40, %variant* %41, align 16 - %42 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg14, i32 0, i32 1 - store i64 2, i64* %42, align 8 - %43 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg14, i32 0, i32 0 - %44 = bitcast [2 x %variant]* %varargslots15 to %variant* - store %variant* %44, %variant** %43, align 8 - %45 = bitcast %"variant[]"* %vararg14 to { i8*, i64 }* - %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 - %lo16 = load i8*, i8** %46, align 8 - %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 - %hi17 = load i64, i64* %47, align 8 - %48 = call i64 @std_io_printfln(i64* %retparam10, i8* %lo12, i64 %hi13, i8* %lo16, i64 %hi17) - %not_err18 = icmp eq i64 %48, 0 - br i1 %not_err18, label %after_check19, label %voiderr20 -after_check19: ; preds = %loop.body7 - br label %voiderr20 -voiderr20: ; preds = %after_check19, %loop.body7 - %49 = load i64, i64* %.anon4, align 8 - %add21 = add i64 %49, 1 - store i64 %add21, i64* %.anon4, align 8 - br label %loop.cond5 -loop.exit22: ; preds = %loop.cond5 - %50 = bitcast [4 x i32]* %a23 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %50, i8* align 16 bitcast ([4 x i32]* @.__const.3 to i8*), i32 16, i1 false) - store i64 0, i64* %.anon24, align 8 - br label %loop.cond25 -loop.cond25: ; preds = %voiderr40, %loop.exit22 - %51 = load i64, i64* %.anon24, align 8 - %gt26 = icmp ugt i64 4, %51 - br i1 %gt26, label %loop.body27, label %loop.exit42 -loop.body27: ; preds = %loop.cond25 - %52 = load i64, i64* %.anon24, align 8 - store i64 %52, i64* %i28, align 8 - %53 = load i64, i64* %.anon24, align 8 - %54 = getelementptr inbounds [4 x i32], [4 x i32]* %a23, i64 0, i64 %53 - %55 = load i32, i32* %54, align 4 - store i32 %55, i32* %x29, align 4 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i32 0, i32 0), i64 6 }, %"char[]"* %taddr31, align 8 - %56 = bitcast %"char[]"* %taddr31 to { i8*, i64 }* - %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 0 - %lo32 = load i8*, i8** %57, align 8 - %58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 1 - %hi33 = load i64, i64* %58, align 8 - %59 = bitcast i64* %i28 to i8* - %60 = insertvalue %variant undef, i8* %59, 0 - %61 = insertvalue %variant %60, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %62 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots35, i64 0, i64 0 - store %variant %61, %variant* %62, align 16 - %63 = bitcast i32* %x29 to i8* - %64 = insertvalue %variant undef, i8* %63, 0 - %65 = insertvalue %variant %64, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %66 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots35, i64 0, i64 1 - store %variant %65, %variant* %66, align 16 - %67 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 1 - store i64 2, i64* %67, align 8 - %68 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 0 - %69 = bitcast [2 x %variant]* %varargslots35 to %variant* - store %variant* %69, %variant** %68, align 8 - %70 = bitcast %"variant[]"* %vararg34 to { i8*, i64 }* - %71 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 0 - %lo36 = load i8*, i8** %71, align 8 - %72 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 1 - %hi37 = load i64, i64* %72, align 8 - %73 = call i64 @std_io_printfln(i64* %retparam30, i8* %lo32, i64 %hi33, i8* %lo36, i64 %hi37) - %not_err38 = icmp eq i64 %73, 0 - br i1 %not_err38, label %after_check39, label %voiderr40 -after_check39: ; preds = %loop.body27 - br label %voiderr40 -voiderr40: ; preds = %after_check39, %loop.body27 - %74 = load i64, i64* %.anon24, align 8 - %add41 = add i64 %74, 1 - store i64 %add41, i64* %.anon24, align 8 - br label %loop.cond25 -loop.exit42: ; preds = %loop.cond25 - %75 = bitcast [2 x i32]* %a43 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %75, i8* align 4 bitcast ([2 x i32]* @.__const.5 to i8*), i32 8, i1 false) - store i64 0, i64* %.anon44, align 8 - br label %loop.cond45 -loop.cond45: ; preds = %voiderr60, %loop.exit42 - %76 = load i64, i64* %.anon44, align 8 - %gt46 = icmp ugt i64 2, %76 - br i1 %gt46, label %loop.body47, label %loop.exit62 -loop.body47: ; preds = %loop.cond45 - %77 = load i64, i64* %.anon44, align 8 - store i64 %77, i64* %i48, align 8 - %78 = load i64, i64* %.anon44, align 8 - %79 = getelementptr inbounds [2 x i32], [2 x i32]* %a43, i64 0, i64 %78 - %80 = load i32, i32* %79, align 4 - store i32 %80, i32* %x49, align 4 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i64 6 }, %"char[]"* %taddr51, align 8 - %81 = bitcast %"char[]"* %taddr51 to { i8*, i64 }* - %82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %81, i32 0, i32 0 - %lo52 = load i8*, i8** %82, align 8 - %83 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %81, i32 0, i32 1 - %hi53 = load i64, i64* %83, align 8 - %84 = bitcast i64* %i48 to i8* - %85 = insertvalue %variant undef, i8* %84, 0 - %86 = insertvalue %variant %85, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %87 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots55, i64 0, i64 0 - store %variant %86, %variant* %87, align 16 - %88 = bitcast i32* %x49 to i8* - %89 = insertvalue %variant undef, i8* %88, 0 - %90 = insertvalue %variant %89, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %91 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots55, i64 0, i64 1 - store %variant %90, %variant* %91, align 16 - %92 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg54, i32 0, i32 1 - store i64 2, i64* %92, align 8 - %93 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg54, i32 0, i32 0 - %94 = bitcast [2 x %variant]* %varargslots55 to %variant* - store %variant* %94, %variant** %93, align 8 - %95 = bitcast %"variant[]"* %vararg54 to { i8*, i64 }* - %96 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %95, i32 0, i32 0 - %lo56 = load i8*, i8** %96, align 8 - %97 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %95, i32 0, i32 1 - %hi57 = load i64, i64* %97, align 8 - %98 = call i64 @std_io_printfln(i64* %retparam50, i8* %lo52, i64 %hi53, i8* %lo56, i64 %hi57) - %not_err58 = icmp eq i64 %98, 0 - br i1 %not_err58, label %after_check59, label %voiderr60 -after_check59: ; preds = %loop.body47 - br label %voiderr60 -voiderr60: ; preds = %after_check59, %loop.body47 - %99 = load i64, i64* %.anon44, align 8 - %add61 = add i64 %99, 1 - store i64 %add61, i64* %.anon44, align 8 - br label %loop.cond45 -loop.exit62: ; preds = %loop.cond45 - %100 = bitcast [3 x i32]* %a63 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %100, i8* align 4 bitcast ([3 x i32]* @.__const.7 to i8*), i32 12, i1 false) - store i64 0, i64* %.anon64, align 8 - br label %loop.cond65 -loop.cond65: ; preds = %voiderr80, %loop.exit62 - %101 = load i64, i64* %.anon64, align 8 - %gt66 = icmp ugt i64 3, %101 - br i1 %gt66, label %loop.body67, label %loop.exit82 -loop.body67: ; preds = %loop.cond65 - %102 = load i64, i64* %.anon64, align 8 - store i64 %102, i64* %i68, align 8 - %103 = load i64, i64* %.anon64, align 8 - %104 = getelementptr inbounds [3 x i32], [3 x i32]* %a63, i64 0, i64 %103 - %105 = load i32, i32* %104, align 4 - store i32 %105, i32* %x69, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i32 0, i32 0), i64 8 }, %"char[]"* %taddr71, align 8 - %106 = bitcast %"char[]"* %taddr71 to { i8*, i64 }* - %107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 0 - %lo72 = load i8*, i8** %107, align 8 - %108 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 1 - %hi73 = load i64, i64* %108, align 8 - %109 = bitcast i64* %i68 to i8* - %110 = insertvalue %variant undef, i8* %109, 0 - %111 = insertvalue %variant %110, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %112 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots75, i64 0, i64 0 - store %variant %111, %variant* %112, align 16 - %113 = bitcast i32* %x69 to i8* - %114 = insertvalue %variant undef, i8* %113, 0 - %115 = insertvalue %variant %114, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %116 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots75, i64 0, i64 1 - store %variant %115, %variant* %116, align 16 - %117 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg74, i32 0, i32 1 - store i64 2, i64* %117, align 8 - %118 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg74, i32 0, i32 0 - %119 = bitcast [2 x %variant]* %varargslots75 to %variant* - store %variant* %119, %variant** %118, align 8 - %120 = bitcast %"variant[]"* %vararg74 to { i8*, i64 }* - %121 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %120, i32 0, i32 0 - %lo76 = load i8*, i8** %121, align 8 - %122 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %120, i32 0, i32 1 - %hi77 = load i64, i64* %122, align 8 - %123 = call i64 @std_io_printfln(i64* %retparam70, i8* %lo72, i64 %hi73, i8* %lo76, i64 %hi77) - %not_err78 = icmp eq i64 %123, 0 - br i1 %not_err78, label %after_check79, label %voiderr80 -after_check79: ; preds = %loop.body67 - br label %voiderr80 -voiderr80: ; preds = %after_check79, %loop.body67 - %124 = load i64, i64* %.anon64, align 8 - %add81 = add i64 %124, 1 - store i64 %add81, i64* %.anon64, align 8 - br label %loop.cond65 -loop.exit82: ; preds = %loop.cond65 - %125 = bitcast [1 x i32]* %a83 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %125, i8* align 4 bitcast ([1 x i32]* @.__const.9 to i8*), i32 4, i1 false) - store i64 0, i64* %.anon84, align 8 - br label %loop.cond85 -loop.cond85: ; preds = %voiderr100, %loop.exit82 - %126 = load i64, i64* %.anon84, align 8 - %gt86 = icmp ugt i64 1, %126 - br i1 %gt86, label %loop.body87, label %loop.exit102 -loop.body87: ; preds = %loop.cond85 - %127 = load i64, i64* %.anon84, align 8 - store i64 %127, i64* %i88, align 8 - %128 = load i64, i64* %.anon84, align 8 - %129 = getelementptr inbounds [1 x i32], [1 x i32]* %a83, i64 0, i64 %128 - %130 = load i32, i32* %129, align 4 - store i32 %130, i32* %x89, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i32 0, i32 0), i64 8 }, %"char[]"* %taddr91, align 8 - %131 = bitcast %"char[]"* %taddr91 to { i8*, i64 }* - %132 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %131, i32 0, i32 0 - %lo92 = load i8*, i8** %132, align 8 - %133 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %131, i32 0, i32 1 - %hi93 = load i64, i64* %133, align 8 - %134 = bitcast i64* %i88 to i8* - %135 = insertvalue %variant undef, i8* %134, 0 - %136 = insertvalue %variant %135, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %137 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots95, i64 0, i64 0 - store %variant %136, %variant* %137, align 16 - %138 = bitcast i32* %x89 to i8* + %22 = bitcast [1 x i32]* %a1 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %22, i8* align 4 bitcast ([1 x i32]* @.__const.1 to i8*), i32 4, i1 false) + store i64 0, i64* %.anon2, align 8 + br label %loop.cond3 + +loop.cond3: ; preds = %voiderr15, %loop.exit + %23 = load i64, i64* %.anon2, align 8 + %gt4 = icmp ugt i64 1, %23 + br i1 %gt4, label %loop.body5, label %loop.exit17 + +loop.body5: ; preds = %loop.cond3 + %24 = load i64, i64* %.anon2, align 8 + store i64 %24, i64* %i6, align 8 + %25 = load i64, i64* %.anon2, align 8 + %26 = getelementptr inbounds [1 x i32], [1 x i32]* %a1, i64 0, i64 %25 + %27 = load i32, i32* %26, align 4 + store i32 %27, i32* %x7, align 4 + %28 = bitcast i64* %i6 to i8* + %29 = insertvalue %variant undef, i8* %28, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %31 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots9, i64 0, i64 0 + store %variant %30, %variant* %31, align 16 + %32 = bitcast i32* %x7 to i8* + %33 = insertvalue %variant undef, i8* %32, 0 + %34 = insertvalue %variant %33, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %35 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots9, i64 0, i64 1 + store %variant %34, %variant* %35, align 16 + %36 = bitcast [2 x %variant]* %varargslots9 to %variant* + %37 = insertvalue %"variant[]" undef, %variant* %36, 0 + %38 = insertvalue %"variant[]" %37, i64 2, 1 + store %"variant[]" %38, %"variant[]"* %taddr10, align 8 + %39 = bitcast %"variant[]"* %taddr10 to { i8*, i64 }* + %40 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %39, i32 0, i32 0 + %lo11 = load i8*, i8** %40, align 8 + %41 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %39, i32 0, i32 1 + %hi12 = load i64, i64* %41, align 8 + %42 = call i64 @std_io_printfln(i64* %retparam8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8, i8* %lo11, i64 %hi12) + %not_err13 = icmp eq i64 %42, 0 + br i1 %not_err13, label %after_check14, label %voiderr15 + +after_check14: ; preds = %loop.body5 + br label %voiderr15 + +voiderr15: ; preds = %after_check14, %loop.body5 + %43 = load i64, i64* %.anon2, align 8 + %add16 = add i64 %43, 1 + store i64 %add16, i64* %.anon2, align 8 + br label %loop.cond3 + +loop.exit17: ; preds = %loop.cond3 + %44 = bitcast [4 x i32]* %a18 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %44, i8* align 16 bitcast ([4 x i32]* @.__const.3 to i8*), i32 16, i1 false) + store i64 0, i64* %.anon19, align 8 + br label %loop.cond20 + +loop.cond20: ; preds = %voiderr32, %loop.exit17 + %45 = load i64, i64* %.anon19, align 8 + %gt21 = icmp ugt i64 4, %45 + br i1 %gt21, label %loop.body22, label %loop.exit34 + +loop.body22: ; preds = %loop.cond20 + %46 = load i64, i64* %.anon19, align 8 + store i64 %46, i64* %i23, align 8 + %47 = load i64, i64* %.anon19, align 8 + %48 = getelementptr inbounds [4 x i32], [4 x i32]* %a18, i64 0, i64 %47 + %49 = load i32, i32* %48, align 4 + store i32 %49, i32* %x24, align 4 + %50 = bitcast i64* %i23 to i8* + %51 = insertvalue %variant undef, i8* %50, 0 + %52 = insertvalue %variant %51, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %53 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots26, i64 0, i64 0 + store %variant %52, %variant* %53, align 16 + %54 = bitcast i32* %x24 to i8* + %55 = insertvalue %variant undef, i8* %54, 0 + %56 = insertvalue %variant %55, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %57 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots26, i64 0, i64 1 + store %variant %56, %variant* %57, align 16 + %58 = bitcast [2 x %variant]* %varargslots26 to %variant* + %59 = insertvalue %"variant[]" undef, %variant* %58, 0 + %60 = insertvalue %"variant[]" %59, i64 2, 1 + store %"variant[]" %60, %"variant[]"* %taddr27, align 8 + %61 = bitcast %"variant[]"* %taddr27 to { i8*, i64 }* + %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %61, i32 0, i32 0 + %lo28 = load i8*, i8** %62, align 8 + %63 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %61, i32 0, i32 1 + %hi29 = load i64, i64* %63, align 8 + %64 = call i64 @std_io_printfln(i64* %retparam25, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i32 0, i32 0), i64 6, i8* %lo28, i64 %hi29) + %not_err30 = icmp eq i64 %64, 0 + br i1 %not_err30, label %after_check31, label %voiderr32 + +after_check31: ; preds = %loop.body22 + br label %voiderr32 + +voiderr32: ; preds = %after_check31, %loop.body22 + %65 = load i64, i64* %.anon19, align 8 + %add33 = add i64 %65, 1 + store i64 %add33, i64* %.anon19, align 8 + br label %loop.cond20 + +loop.exit34: ; preds = %loop.cond20 + %66 = bitcast [2 x i32]* %a35 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %66, i8* align 4 bitcast ([2 x i32]* @.__const.5 to i8*), i32 8, i1 false) + store i64 0, i64* %.anon36, align 8 + br label %loop.cond37 + +loop.cond37: ; preds = %voiderr49, %loop.exit34 + %67 = load i64, i64* %.anon36, align 8 + %gt38 = icmp ugt i64 2, %67 + br i1 %gt38, label %loop.body39, label %loop.exit51 + +loop.body39: ; preds = %loop.cond37 + %68 = load i64, i64* %.anon36, align 8 + store i64 %68, i64* %i40, align 8 + %69 = load i64, i64* %.anon36, align 8 + %70 = getelementptr inbounds [2 x i32], [2 x i32]* %a35, i64 0, i64 %69 + %71 = load i32, i32* %70, align 4 + store i32 %71, i32* %x41, align 4 + %72 = bitcast i64* %i40 to i8* + %73 = insertvalue %variant undef, i8* %72, 0 + %74 = insertvalue %variant %73, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %75 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots43, i64 0, i64 0 + store %variant %74, %variant* %75, align 16 + %76 = bitcast i32* %x41 to i8* + %77 = insertvalue %variant undef, i8* %76, 0 + %78 = insertvalue %variant %77, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %79 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots43, i64 0, i64 1 + store %variant %78, %variant* %79, align 16 + %80 = bitcast [2 x %variant]* %varargslots43 to %variant* + %81 = insertvalue %"variant[]" undef, %variant* %80, 0 + %82 = insertvalue %"variant[]" %81, i64 2, 1 + store %"variant[]" %82, %"variant[]"* %taddr44, align 8 + %83 = bitcast %"variant[]"* %taddr44 to { i8*, i64 }* + %84 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %83, i32 0, i32 0 + %lo45 = load i8*, i8** %84, align 8 + %85 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %83, i32 0, i32 1 + %hi46 = load i64, i64* %85, align 8 + %86 = call i64 @std_io_printfln(i64* %retparam42, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i64 6, i8* %lo45, i64 %hi46) + %not_err47 = icmp eq i64 %86, 0 + br i1 %not_err47, label %after_check48, label %voiderr49 + +after_check48: ; preds = %loop.body39 + br label %voiderr49 + +voiderr49: ; preds = %after_check48, %loop.body39 + %87 = load i64, i64* %.anon36, align 8 + %add50 = add i64 %87, 1 + store i64 %add50, i64* %.anon36, align 8 + br label %loop.cond37 + +loop.exit51: ; preds = %loop.cond37 + %88 = bitcast [3 x i32]* %a52 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %88, i8* align 4 bitcast ([3 x i32]* @.__const.7 to i8*), i32 12, i1 false) + store i64 0, i64* %.anon53, align 8 + br label %loop.cond54 + +loop.cond54: ; preds = %voiderr66, %loop.exit51 + %89 = load i64, i64* %.anon53, align 8 + %gt55 = icmp ugt i64 3, %89 + br i1 %gt55, label %loop.body56, label %loop.exit68 + +loop.body56: ; preds = %loop.cond54 + %90 = load i64, i64* %.anon53, align 8 + store i64 %90, i64* %i57, align 8 + %91 = load i64, i64* %.anon53, align 8 + %92 = getelementptr inbounds [3 x i32], [3 x i32]* %a52, i64 0, i64 %91 + %93 = load i32, i32* %92, align 4 + store i32 %93, i32* %x58, align 4 + %94 = bitcast i64* %i57 to i8* + %95 = insertvalue %variant undef, i8* %94, 0 + %96 = insertvalue %variant %95, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %97 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots60, i64 0, i64 0 + store %variant %96, %variant* %97, align 16 + %98 = bitcast i32* %x58 to i8* + %99 = insertvalue %variant undef, i8* %98, 0 + %100 = insertvalue %variant %99, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %101 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots60, i64 0, i64 1 + store %variant %100, %variant* %101, align 16 + %102 = bitcast [2 x %variant]* %varargslots60 to %variant* + %103 = insertvalue %"variant[]" undef, %variant* %102, 0 + %104 = insertvalue %"variant[]" %103, i64 2, 1 + store %"variant[]" %104, %"variant[]"* %taddr61, align 8 + %105 = bitcast %"variant[]"* %taddr61 to { i8*, i64 }* + %106 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %105, i32 0, i32 0 + %lo62 = load i8*, i8** %106, align 8 + %107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %105, i32 0, i32 1 + %hi63 = load i64, i64* %107, align 8 + %108 = call i64 @std_io_printfln(i64* %retparam59, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i32 0, i32 0), i64 8, i8* %lo62, i64 %hi63) + %not_err64 = icmp eq i64 %108, 0 + br i1 %not_err64, label %after_check65, label %voiderr66 + +after_check65: ; preds = %loop.body56 + br label %voiderr66 + +voiderr66: ; preds = %after_check65, %loop.body56 + %109 = load i64, i64* %.anon53, align 8 + %add67 = add i64 %109, 1 + store i64 %add67, i64* %.anon53, align 8 + br label %loop.cond54 + +loop.exit68: ; preds = %loop.cond54 + %110 = bitcast [1 x i32]* %a69 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %110, i8* align 4 bitcast ([1 x i32]* @.__const.9 to i8*), i32 4, i1 false) + store i64 0, i64* %.anon70, align 8 + br label %loop.cond71 + +loop.cond71: ; preds = %voiderr83, %loop.exit68 + %111 = load i64, i64* %.anon70, align 8 + %gt72 = icmp ugt i64 1, %111 + br i1 %gt72, label %loop.body73, label %loop.exit85 + +loop.body73: ; preds = %loop.cond71 + %112 = load i64, i64* %.anon70, align 8 + store i64 %112, i64* %i74, align 8 + %113 = load i64, i64* %.anon70, align 8 + %114 = getelementptr inbounds [1 x i32], [1 x i32]* %a69, i64 0, i64 %113 + %115 = load i32, i32* %114, align 4 + store i32 %115, i32* %x75, align 4 + %116 = bitcast i64* %i74 to i8* + %117 = insertvalue %variant undef, i8* %116, 0 + %118 = insertvalue %variant %117, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %119 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots77, i64 0, i64 0 + store %variant %118, %variant* %119, align 16 + %120 = bitcast i32* %x75 to i8* + %121 = insertvalue %variant undef, i8* %120, 0 + %122 = insertvalue %variant %121, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %123 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots77, i64 0, i64 1 + store %variant %122, %variant* %123, align 16 + %124 = bitcast [2 x %variant]* %varargslots77 to %variant* + %125 = insertvalue %"variant[]" undef, %variant* %124, 0 + %126 = insertvalue %"variant[]" %125, i64 2, 1 + store %"variant[]" %126, %"variant[]"* %taddr78, align 8 + %127 = bitcast %"variant[]"* %taddr78 to { i8*, i64 }* + %128 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %127, i32 0, i32 0 + %lo79 = load i8*, i8** %128, align 8 + %129 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %127, i32 0, i32 1 + %hi80 = load i64, i64* %129, align 8 + %130 = call i64 @std_io_printfln(i64* %retparam76, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i32 0, i32 0), i64 8, i8* %lo79, i64 %hi80) + %not_err81 = icmp eq i64 %130, 0 + br i1 %not_err81, label %after_check82, label %voiderr83 + +after_check82: ; preds = %loop.body73 + br label %voiderr83 + +voiderr83: ; preds = %after_check82, %loop.body73 + %131 = load i64, i64* %.anon70, align 8 + %add84 = add i64 %131, 1 + store i64 %add84, i64* %.anon70, align 8 + br label %loop.cond71 + +loop.exit85: ; preds = %loop.cond71 + %132 = bitcast [2 x i32]* %a86 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %132, i8* align 4 bitcast ([2 x i32]* @.__const.11 to i8*), i32 8, i1 false) + store i64 0, i64* %.anon87, align 8 + br label %loop.cond88 + +loop.cond88: ; preds = %voiderr100, %loop.exit85 + %133 = load i64, i64* %.anon87, align 8 + %gt89 = icmp ugt i64 2, %133 + br i1 %gt89, label %loop.body90, label %loop.exit102 + +loop.body90: ; preds = %loop.cond88 + %134 = load i64, i64* %.anon87, align 8 + store i64 %134, i64* %i91, align 8 + %135 = load i64, i64* %.anon87, align 8 + %136 = getelementptr inbounds [2 x i32], [2 x i32]* %a86, i64 0, i64 %135 + %137 = load i32, i32* %136, align 4 + store i32 %137, i32* %x92, align 4 + %138 = bitcast i64* %i91 to i8* %139 = insertvalue %variant undef, i8* %138, 0 - %140 = insertvalue %variant %139, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %141 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots95, i64 0, i64 1 + %140 = insertvalue %variant %139, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %141 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots94, i64 0, i64 0 store %variant %140, %variant* %141, align 16 - %142 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg94, i32 0, i32 1 - store i64 2, i64* %142, align 8 - %143 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg94, i32 0, i32 0 - %144 = bitcast [2 x %variant]* %varargslots95 to %variant* - store %variant* %144, %variant** %143, align 8 - %145 = bitcast %"variant[]"* %vararg94 to { i8*, i64 }* - %146 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %145, i32 0, i32 0 - %lo96 = load i8*, i8** %146, align 8 - %147 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %145, i32 0, i32 1 - %hi97 = load i64, i64* %147, align 8 - %148 = call i64 @std_io_printfln(i64* %retparam90, i8* %lo92, i64 %hi93, i8* %lo96, i64 %hi97) - %not_err98 = icmp eq i64 %148, 0 + %142 = bitcast i32* %x92 to i8* + %143 = insertvalue %variant undef, i8* %142, 0 + %144 = insertvalue %variant %143, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %145 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots94, i64 0, i64 1 + store %variant %144, %variant* %145, align 16 + %146 = bitcast [2 x %variant]* %varargslots94 to %variant* + %147 = insertvalue %"variant[]" undef, %variant* %146, 0 + %148 = insertvalue %"variant[]" %147, i64 2, 1 + store %"variant[]" %148, %"variant[]"* %taddr95, align 8 + %149 = bitcast %"variant[]"* %taddr95 to { i8*, i64 }* + %150 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %149, i32 0, i32 0 + %lo96 = load i8*, i8** %150, align 8 + %151 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %149, i32 0, i32 1 + %hi97 = load i64, i64* %151, align 8 + %152 = call i64 @std_io_printfln(i64* %retparam93, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i32 0, i32 0), i64 8, i8* %lo96, i64 %hi97) + %not_err98 = icmp eq i64 %152, 0 br i1 %not_err98, label %after_check99, label %voiderr100 -after_check99: ; preds = %loop.body87 + +after_check99: ; preds = %loop.body90 br label %voiderr100 -voiderr100: ; preds = %after_check99, %loop.body87 - %149 = load i64, i64* %.anon84, align 8 - %add101 = add i64 %149, 1 - store i64 %add101, i64* %.anon84, align 8 - br label %loop.cond85 -loop.exit102: ; preds = %loop.cond85 - %150 = bitcast [2 x i32]* %a103 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %150, i8* align 4 bitcast ([2 x i32]* @.__const.11 to i8*), i32 8, i1 false) + +voiderr100: ; preds = %after_check99, %loop.body90 + %153 = load i64, i64* %.anon87, align 8 + %add101 = add i64 %153, 1 + store i64 %add101, i64* %.anon87, align 8 + br label %loop.cond88 + +loop.exit102: ; preds = %loop.cond88 + %154 = bitcast [5 x i32]* %a103 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %154, i8* align 16 bitcast ([5 x i32]* @.__const.13 to i8*), i32 20, i1 false) store i64 0, i64* %.anon104, align 8 br label %loop.cond105 -loop.cond105: ; preds = %voiderr120, %loop.exit102 - %151 = load i64, i64* %.anon104, align 8 - %gt106 = icmp ugt i64 2, %151 - br i1 %gt106, label %loop.body107, label %loop.exit122 + +loop.cond105: ; preds = %voiderr117, %loop.exit102 + %155 = load i64, i64* %.anon104, align 8 + %gt106 = icmp ugt i64 5, %155 + br i1 %gt106, label %loop.body107, label %loop.exit119 + loop.body107: ; preds = %loop.cond105 - %152 = load i64, i64* %.anon104, align 8 - store i64 %152, i64* %i108, align 8 - %153 = load i64, i64* %.anon104, align 8 - %154 = getelementptr inbounds [2 x i32], [2 x i32]* %a103, i64 0, i64 %153 - %155 = load i32, i32* %154, align 4 - store i32 %155, i32* %x109, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i32 0, i32 0), i64 8 }, %"char[]"* %taddr111, align 8 - %156 = bitcast %"char[]"* %taddr111 to { i8*, i64 }* - %157 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %156, i32 0, i32 0 - %lo112 = load i8*, i8** %157, align 8 - %158 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %156, i32 0, i32 1 - %hi113 = load i64, i64* %158, align 8 - %159 = bitcast i64* %i108 to i8* - %160 = insertvalue %variant undef, i8* %159, 0 - %161 = insertvalue %variant %160, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %162 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots115, i64 0, i64 0 - store %variant %161, %variant* %162, align 16 - %163 = bitcast i32* %x109 to i8* - %164 = insertvalue %variant undef, i8* %163, 0 - %165 = insertvalue %variant %164, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %166 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots115, i64 0, i64 1 - store %variant %165, %variant* %166, align 16 - %167 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg114, i32 0, i32 1 - store i64 2, i64* %167, align 8 - %168 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg114, i32 0, i32 0 - %169 = bitcast [2 x %variant]* %varargslots115 to %variant* - store %variant* %169, %variant** %168, align 8 - %170 = bitcast %"variant[]"* %vararg114 to { i8*, i64 }* - %171 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %170, i32 0, i32 0 - %lo116 = load i8*, i8** %171, align 8 - %172 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %170, i32 0, i32 1 - %hi117 = load i64, i64* %172, align 8 - %173 = call i64 @std_io_printfln(i64* %retparam110, i8* %lo112, i64 %hi113, i8* %lo116, i64 %hi117) - %not_err118 = icmp eq i64 %173, 0 - br i1 %not_err118, label %after_check119, label %voiderr120 -after_check119: ; preds = %loop.body107 - br label %voiderr120 -voiderr120: ; preds = %after_check119, %loop.body107 - %174 = load i64, i64* %.anon104, align 8 - %add121 = add i64 %174, 1 - store i64 %add121, i64* %.anon104, align 8 + %156 = load i64, i64* %.anon104, align 8 + store i64 %156, i64* %i108, align 8 + %157 = load i64, i64* %.anon104, align 8 + %158 = getelementptr inbounds [5 x i32], [5 x i32]* %a103, i64 0, i64 %157 + %159 = load i32, i32* %158, align 4 + store i32 %159, i32* %x109, align 4 + %160 = bitcast i64* %i108 to i8* + %161 = insertvalue %variant undef, i8* %160, 0 + %162 = insertvalue %variant %161, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %163 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots111, i64 0, i64 0 + store %variant %162, %variant* %163, align 16 + %164 = bitcast i32* %x109 to i8* + %165 = insertvalue %variant undef, i8* %164, 0 + %166 = insertvalue %variant %165, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %167 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots111, i64 0, i64 1 + store %variant %166, %variant* %167, align 16 + %168 = bitcast [2 x %variant]* %varargslots111 to %variant* + %169 = insertvalue %"variant[]" undef, %variant* %168, 0 + %170 = insertvalue %"variant[]" %169, i64 2, 1 + store %"variant[]" %170, %"variant[]"* %taddr112, align 8 + %171 = bitcast %"variant[]"* %taddr112 to { i8*, i64 }* + %172 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %171, i32 0, i32 0 + %lo113 = load i8*, i8** %172, align 8 + %173 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %171, i32 0, i32 1 + %hi114 = load i64, i64* %173, align 8 + %174 = call i64 @std_io_printfln(i64* %retparam110, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i32 0, i32 0), i64 8, i8* %lo113, i64 %hi114) + %not_err115 = icmp eq i64 %174, 0 + br i1 %not_err115, label %after_check116, label %voiderr117 + +after_check116: ; preds = %loop.body107 + br label %voiderr117 + +voiderr117: ; preds = %after_check116, %loop.body107 + %175 = load i64, i64* %.anon104, align 8 + %add118 = add i64 %175, 1 + store i64 %add118, i64* %.anon104, align 8 br label %loop.cond105 -loop.exit122: ; preds = %loop.cond105 - %175 = bitcast [5 x i32]* %a123 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %175, i8* align 16 bitcast ([5 x i32]* @.__const.13 to i8*), i32 20, i1 false) - store i64 0, i64* %.anon124, align 8 - br label %loop.cond125 -loop.cond125: ; preds = %voiderr140, %loop.exit122 - %176 = load i64, i64* %.anon124, align 8 - %gt126 = icmp ugt i64 5, %176 - br i1 %gt126, label %loop.body127, label %loop.exit142 -loop.body127: ; preds = %loop.cond125 - %177 = load i64, i64* %.anon124, align 8 - store i64 %177, i64* %i128, align 8 - %178 = load i64, i64* %.anon124, align 8 - %179 = getelementptr inbounds [5 x i32], [5 x i32]* %a123, i64 0, i64 %178 - %180 = load i32, i32* %179, align 4 - store i32 %180, i32* %x129, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i32 0, i32 0), i64 8 }, %"char[]"* %taddr131, align 8 - %181 = bitcast %"char[]"* %taddr131 to { i8*, i64 }* - %182 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %181, i32 0, i32 0 - %lo132 = load i8*, i8** %182, align 8 - %183 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %181, i32 0, i32 1 - %hi133 = load i64, i64* %183, align 8 - %184 = bitcast i64* %i128 to i8* - %185 = insertvalue %variant undef, i8* %184, 0 - %186 = insertvalue %variant %185, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %187 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots135, i64 0, i64 0 - store %variant %186, %variant* %187, align 16 - %188 = bitcast i32* %x129 to i8* - %189 = insertvalue %variant undef, i8* %188, 0 - %190 = insertvalue %variant %189, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %191 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots135, i64 0, i64 1 - store %variant %190, %variant* %191, align 16 - %192 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg134, i32 0, i32 1 - store i64 2, i64* %192, align 8 - %193 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg134, i32 0, i32 0 - %194 = bitcast [2 x %variant]* %varargslots135 to %variant* - store %variant* %194, %variant** %193, align 8 - %195 = bitcast %"variant[]"* %vararg134 to { i8*, i64 }* - %196 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %195, i32 0, i32 0 - %lo136 = load i8*, i8** %196, align 8 - %197 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %195, i32 0, i32 1 - %hi137 = load i64, i64* %197, align 8 - %198 = call i64 @std_io_printfln(i64* %retparam130, i8* %lo132, i64 %hi133, i8* %lo136, i64 %hi137) - %not_err138 = icmp eq i64 %198, 0 - br i1 %not_err138, label %after_check139, label %voiderr140 -after_check139: ; preds = %loop.body127 - br label %voiderr140 -voiderr140: ; preds = %after_check139, %loop.body127 - %199 = load i64, i64* %.anon124, align 8 - %add141 = add i64 %199, 1 - store i64 %add141, i64* %.anon124, align 8 - br label %loop.cond125 -loop.exit142: ; preds = %loop.cond125 - %200 = bitcast [8 x i32]* %a143 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %200, i8* align 16 bitcast ([8 x i32]* @.__const.15 to i8*), i32 32, i1 false) - store i64 0, i64* %.anon144, align 8 - br label %loop.cond145 -loop.cond145: ; preds = %voiderr160, %loop.exit142 - %201 = load i64, i64* %.anon144, align 8 - %gt146 = icmp ugt i64 8, %201 - br i1 %gt146, label %loop.body147, label %loop.exit162 -loop.body147: ; preds = %loop.cond145 - %202 = load i64, i64* %.anon144, align 8 - store i64 %202, i64* %i148, align 8 - %203 = load i64, i64* %.anon144, align 8 - %204 = getelementptr inbounds [8 x i32], [8 x i32]* %a143, i64 0, i64 %203 - %205 = load i32, i32* %204, align 4 - store i32 %205, i32* %x149, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.16, i32 0, i32 0), i64 8 }, %"char[]"* %taddr151, align 8 - %206 = bitcast %"char[]"* %taddr151 to { i8*, i64 }* - %207 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %206, i32 0, i32 0 - %lo152 = load i8*, i8** %207, align 8 - %208 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %206, i32 0, i32 1 - %hi153 = load i64, i64* %208, align 8 - %209 = bitcast i64* %i148 to i8* - %210 = insertvalue %variant undef, i8* %209, 0 - %211 = insertvalue %variant %210, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %212 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots155, i64 0, i64 0 - store %variant %211, %variant* %212, align 16 - %213 = bitcast i32* %x149 to i8* - %214 = insertvalue %variant undef, i8* %213, 0 - %215 = insertvalue %variant %214, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %216 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots155, i64 0, i64 1 - store %variant %215, %variant* %216, align 16 - %217 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg154, i32 0, i32 1 - store i64 2, i64* %217, align 8 - %218 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg154, i32 0, i32 0 - %219 = bitcast [2 x %variant]* %varargslots155 to %variant* - store %variant* %219, %variant** %218, align 8 - %220 = bitcast %"variant[]"* %vararg154 to { i8*, i64 }* - %221 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %220, i32 0, i32 0 - %lo156 = load i8*, i8** %221, align 8 - %222 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %220, i32 0, i32 1 - %hi157 = load i64, i64* %222, align 8 - %223 = call i64 @std_io_printfln(i64* %retparam150, i8* %lo152, i64 %hi153, i8* %lo156, i64 %hi157) - %not_err158 = icmp eq i64 %223, 0 - br i1 %not_err158, label %after_check159, label %voiderr160 -after_check159: ; preds = %loop.body147 - br label %voiderr160 -voiderr160: ; preds = %after_check159, %loop.body147 - %224 = load i64, i64* %.anon144, align 8 - %add161 = add i64 %224, 1 - store i64 %add161, i64* %.anon144, align 8 - br label %loop.cond145 -loop.exit162: ; preds = %loop.cond145 - %225 = bitcast [7 x i32]* %b to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %225, i8* align 16 bitcast ([7 x i32]* @.__const.17 to i8*), i32 28, i1 false) - store i64 0, i64* %.anon163, align 8 - br label %loop.cond164 -loop.cond164: ; preds = %voiderr179, %loop.exit162 - %226 = load i64, i64* %.anon163, align 8 - %gt165 = icmp ugt i64 7, %226 - br i1 %gt165, label %loop.body166, label %loop.exit181 -loop.body166: ; preds = %loop.cond164 - %227 = load i64, i64* %.anon163, align 8 - store i64 %227, i64* %i167, align 8 - %228 = load i64, i64* %.anon163, align 8 - %229 = getelementptr inbounds [7 x i32], [7 x i32]* %b, i64 0, i64 %228 - %230 = load i32, i32* %229, align 4 - store i32 %230, i32* %x168, align 4 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.18, i32 0, i32 0), i64 8 }, %"char[]"* %taddr170, align 8 - %231 = bitcast %"char[]"* %taddr170 to { i8*, i64 }* - %232 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %231, i32 0, i32 0 - %lo171 = load i8*, i8** %232, align 8 - %233 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %231, i32 0, i32 1 - %hi172 = load i64, i64* %233, align 8 - %234 = bitcast i64* %i167 to i8* - %235 = insertvalue %variant undef, i8* %234, 0 - %236 = insertvalue %variant %235, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %237 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots174, i64 0, i64 0 - store %variant %236, %variant* %237, align 16 - %238 = bitcast i32* %x168 to i8* - %239 = insertvalue %variant undef, i8* %238, 0 - %240 = insertvalue %variant %239, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %241 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots174, i64 0, i64 1 - store %variant %240, %variant* %241, align 16 - %242 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg173, i32 0, i32 1 - store i64 2, i64* %242, align 8 - %243 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg173, i32 0, i32 0 - %244 = bitcast [2 x %variant]* %varargslots174 to %variant* - store %variant* %244, %variant** %243, align 8 - %245 = bitcast %"variant[]"* %vararg173 to { i8*, i64 }* - %246 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %245, i32 0, i32 0 - %lo175 = load i8*, i8** %246, align 8 - %247 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %245, i32 0, i32 1 - %hi176 = load i64, i64* %247, align 8 - %248 = call i64 @std_io_printfln(i64* %retparam169, i8* %lo171, i64 %hi172, i8* %lo175, i64 %hi176) - %not_err177 = icmp eq i64 %248, 0 - br i1 %not_err177, label %after_check178, label %voiderr179 -after_check178: ; preds = %loop.body166 - br label %voiderr179 -voiderr179: ; preds = %after_check178, %loop.body166 - %249 = load i64, i64* %.anon163, align 8 - %add180 = add i64 %249, 1 - store i64 %add180, i64* %.anon163, align 8 - br label %loop.cond164 -loop.exit181: ; preds = %loop.cond164 - %250 = bitcast [8 x i32]* %c to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %250, i8* align 16 bitcast ([8 x i32]* @.__const.19 to i8*), i32 32, i1 false) - store i64 0, i64* %.anon182, align 8 - br label %loop.cond183 -loop.cond183: ; preds = %voiderr198, %loop.exit181 - %251 = load i64, i64* %.anon182, align 8 - %gt184 = icmp ugt i64 8, %251 - br i1 %gt184, label %loop.body185, label %loop.exit200 -loop.body185: ; preds = %loop.cond183 - %252 = load i64, i64* %.anon182, align 8 - store i64 %252, i64* %i186, align 8 - %253 = load i64, i64* %.anon182, align 8 - %254 = getelementptr inbounds [8 x i32], [8 x i32]* %c, i64 0, i64 %253 - %255 = load i32, i32* %254, align 4 - store i32 %255, i32* %x187, align 4 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.20, i32 0, i32 0), i64 9 }, %"char[]"* %taddr189, align 8 - %256 = bitcast %"char[]"* %taddr189 to { i8*, i64 }* - %257 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %256, i32 0, i32 0 - %lo190 = load i8*, i8** %257, align 8 - %258 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %256, i32 0, i32 1 - %hi191 = load i64, i64* %258, align 8 - %259 = bitcast i64* %i186 to i8* - %260 = insertvalue %variant undef, i8* %259, 0 - %261 = insertvalue %variant %260, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %262 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots193, i64 0, i64 0 - store %variant %261, %variant* %262, align 16 - %263 = bitcast i32* %x187 to i8* - %264 = insertvalue %variant undef, i8* %263, 0 - %265 = insertvalue %variant %264, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %266 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots193, i64 0, i64 1 - store %variant %265, %variant* %266, align 16 - %267 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg192, i32 0, i32 1 - store i64 2, i64* %267, align 8 - %268 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg192, i32 0, i32 0 - %269 = bitcast [2 x %variant]* %varargslots193 to %variant* - store %variant* %269, %variant** %268, align 8 - %270 = bitcast %"variant[]"* %vararg192 to { i8*, i64 }* - %271 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 0 - %lo194 = load i8*, i8** %271, align 8 - %272 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 1 - %hi195 = load i64, i64* %272, align 8 - %273 = call i64 @std_io_printfln(i64* %retparam188, i8* %lo190, i64 %hi191, i8* %lo194, i64 %hi195) - %not_err196 = icmp eq i64 %273, 0 - br i1 %not_err196, label %after_check197, label %voiderr198 -after_check197: ; preds = %loop.body185 - br label %voiderr198 -voiderr198: ; preds = %after_check197, %loop.body185 - %274 = load i64, i64* %.anon182, align 8 - %add199 = add i64 %274, 1 - store i64 %add199, i64* %.anon182, align 8 - br label %loop.cond183 -loop.exit200: ; preds = %loop.cond183 - %275 = bitcast [6 x i32]* %a201 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %275, i8* align 16 bitcast ([6 x i32]* @.__const.21 to i8*), i32 24, i1 false) - store i64 0, i64* %.anon202, align 8 - br label %loop.cond203 -loop.cond203: ; preds = %voiderr218, %loop.exit200 - %276 = load i64, i64* %.anon202, align 8 - %gt204 = icmp ugt i64 6, %276 - br i1 %gt204, label %loop.body205, label %loop.exit220 -loop.body205: ; preds = %loop.cond203 - %277 = load i64, i64* %.anon202, align 8 - store i64 %277, i64* %i206, align 8 - %278 = load i64, i64* %.anon202, align 8 - %279 = getelementptr inbounds [6 x i32], [6 x i32]* %a201, i64 0, i64 %278 - %280 = load i32, i32* %279, align 4 - store i32 %280, i32* %x207, align 4 - store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i32 0, i32 0), i64 6 }, %"char[]"* %taddr209, align 8 - %281 = bitcast %"char[]"* %taddr209 to { i8*, i64 }* - %282 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %281, i32 0, i32 0 - %lo210 = load i8*, i8** %282, align 8 - %283 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %281, i32 0, i32 1 - %hi211 = load i64, i64* %283, align 8 - %284 = bitcast i64* %i206 to i8* - %285 = insertvalue %variant undef, i8* %284, 0 - %286 = insertvalue %variant %285, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 - %287 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots213, i64 0, i64 0 - store %variant %286, %variant* %287, align 16 - %288 = bitcast i32* %x207 to i8* - %289 = insertvalue %variant undef, i8* %288, 0 - %290 = insertvalue %variant %289, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %291 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots213, i64 0, i64 1 - store %variant %290, %variant* %291, align 16 - %292 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg212, i32 0, i32 1 - store i64 2, i64* %292, align 8 - %293 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg212, i32 0, i32 0 - %294 = bitcast [2 x %variant]* %varargslots213 to %variant* - store %variant* %294, %variant** %293, align 8 - %295 = bitcast %"variant[]"* %vararg212 to { i8*, i64 }* - %296 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %295, i32 0, i32 0 - %lo214 = load i8*, i8** %296, align 8 - %297 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %295, i32 0, i32 1 - %hi215 = load i64, i64* %297, align 8 - %298 = call i64 @std_io_printfln(i64* %retparam208, i8* %lo210, i64 %hi211, i8* %lo214, i64 %hi215) - %not_err216 = icmp eq i64 %298, 0 - br i1 %not_err216, label %after_check217, label %voiderr218 -after_check217: ; preds = %loop.body205 - br label %voiderr218 -voiderr218: ; preds = %after_check217, %loop.body205 - %299 = load i64, i64* %.anon202, align 8 - %add219 = add i64 %299, 1 - store i64 %add219, i64* %.anon202, align 8 - br label %loop.cond203 -loop.exit220: ; preds = %loop.cond203 + +loop.exit119: ; preds = %loop.cond105 + %176 = bitcast [8 x i32]* %a120 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %176, i8* align 16 bitcast ([8 x i32]* @.__const.15 to i8*), i32 32, i1 false) + store i64 0, i64* %.anon121, align 8 + br label %loop.cond122 + +loop.cond122: ; preds = %voiderr134, %loop.exit119 + %177 = load i64, i64* %.anon121, align 8 + %gt123 = icmp ugt i64 8, %177 + br i1 %gt123, label %loop.body124, label %loop.exit136 + +loop.body124: ; preds = %loop.cond122 + %178 = load i64, i64* %.anon121, align 8 + store i64 %178, i64* %i125, align 8 + %179 = load i64, i64* %.anon121, align 8 + %180 = getelementptr inbounds [8 x i32], [8 x i32]* %a120, i64 0, i64 %179 + %181 = load i32, i32* %180, align 4 + store i32 %181, i32* %x126, align 4 + %182 = bitcast i64* %i125 to i8* + %183 = insertvalue %variant undef, i8* %182, 0 + %184 = insertvalue %variant %183, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %185 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots128, i64 0, i64 0 + store %variant %184, %variant* %185, align 16 + %186 = bitcast i32* %x126 to i8* + %187 = insertvalue %variant undef, i8* %186, 0 + %188 = insertvalue %variant %187, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %189 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots128, i64 0, i64 1 + store %variant %188, %variant* %189, align 16 + %190 = bitcast [2 x %variant]* %varargslots128 to %variant* + %191 = insertvalue %"variant[]" undef, %variant* %190, 0 + %192 = insertvalue %"variant[]" %191, i64 2, 1 + store %"variant[]" %192, %"variant[]"* %taddr129, align 8 + %193 = bitcast %"variant[]"* %taddr129 to { i8*, i64 }* + %194 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %193, i32 0, i32 0 + %lo130 = load i8*, i8** %194, align 8 + %195 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %193, i32 0, i32 1 + %hi131 = load i64, i64* %195, align 8 + %196 = call i64 @std_io_printfln(i64* %retparam127, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.16, i32 0, i32 0), i64 8, i8* %lo130, i64 %hi131) + %not_err132 = icmp eq i64 %196, 0 + br i1 %not_err132, label %after_check133, label %voiderr134 + +after_check133: ; preds = %loop.body124 + br label %voiderr134 + +voiderr134: ; preds = %after_check133, %loop.body124 + %197 = load i64, i64* %.anon121, align 8 + %add135 = add i64 %197, 1 + store i64 %add135, i64* %.anon121, align 8 + br label %loop.cond122 + +loop.exit136: ; preds = %loop.cond122 + %198 = bitcast [7 x i32]* %b to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %198, i8* align 16 bitcast ([7 x i32]* @.__const.17 to i8*), i32 28, i1 false) + store i64 0, i64* %.anon137, align 8 + br label %loop.cond138 + +loop.cond138: ; preds = %voiderr150, %loop.exit136 + %199 = load i64, i64* %.anon137, align 8 + %gt139 = icmp ugt i64 7, %199 + br i1 %gt139, label %loop.body140, label %loop.exit152 + +loop.body140: ; preds = %loop.cond138 + %200 = load i64, i64* %.anon137, align 8 + store i64 %200, i64* %i141, align 8 + %201 = load i64, i64* %.anon137, align 8 + %202 = getelementptr inbounds [7 x i32], [7 x i32]* %b, i64 0, i64 %201 + %203 = load i32, i32* %202, align 4 + store i32 %203, i32* %x142, align 4 + %204 = bitcast i64* %i141 to i8* + %205 = insertvalue %variant undef, i8* %204, 0 + %206 = insertvalue %variant %205, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %207 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots144, i64 0, i64 0 + store %variant %206, %variant* %207, align 16 + %208 = bitcast i32* %x142 to i8* + %209 = insertvalue %variant undef, i8* %208, 0 + %210 = insertvalue %variant %209, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %211 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots144, i64 0, i64 1 + store %variant %210, %variant* %211, align 16 + %212 = bitcast [2 x %variant]* %varargslots144 to %variant* + %213 = insertvalue %"variant[]" undef, %variant* %212, 0 + %214 = insertvalue %"variant[]" %213, i64 2, 1 + store %"variant[]" %214, %"variant[]"* %taddr145, align 8 + %215 = bitcast %"variant[]"* %taddr145 to { i8*, i64 }* + %216 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %215, i32 0, i32 0 + %lo146 = load i8*, i8** %216, align 8 + %217 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %215, i32 0, i32 1 + %hi147 = load i64, i64* %217, align 8 + %218 = call i64 @std_io_printfln(i64* %retparam143, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.18, i32 0, i32 0), i64 8, i8* %lo146, i64 %hi147) + %not_err148 = icmp eq i64 %218, 0 + br i1 %not_err148, label %after_check149, label %voiderr150 + +after_check149: ; preds = %loop.body140 + br label %voiderr150 + +voiderr150: ; preds = %after_check149, %loop.body140 + %219 = load i64, i64* %.anon137, align 8 + %add151 = add i64 %219, 1 + store i64 %add151, i64* %.anon137, align 8 + br label %loop.cond138 + +loop.exit152: ; preds = %loop.cond138 + %220 = bitcast [8 x i32]* %c to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %220, i8* align 16 bitcast ([8 x i32]* @.__const.19 to i8*), i32 32, i1 false) + store i64 0, i64* %.anon153, align 8 + br label %loop.cond154 + +loop.cond154: ; preds = %voiderr166, %loop.exit152 + %221 = load i64, i64* %.anon153, align 8 + %gt155 = icmp ugt i64 8, %221 + br i1 %gt155, label %loop.body156, label %loop.exit168 + +loop.body156: ; preds = %loop.cond154 + %222 = load i64, i64* %.anon153, align 8 + store i64 %222, i64* %i157, align 8 + %223 = load i64, i64* %.anon153, align 8 + %224 = getelementptr inbounds [8 x i32], [8 x i32]* %c, i64 0, i64 %223 + %225 = load i32, i32* %224, align 4 + store i32 %225, i32* %x158, align 4 + %226 = bitcast i64* %i157 to i8* + %227 = insertvalue %variant undef, i8* %226, 0 + %228 = insertvalue %variant %227, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %229 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots160, i64 0, i64 0 + store %variant %228, %variant* %229, align 16 + %230 = bitcast i32* %x158 to i8* + %231 = insertvalue %variant undef, i8* %230, 0 + %232 = insertvalue %variant %231, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %233 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots160, i64 0, i64 1 + store %variant %232, %variant* %233, align 16 + %234 = bitcast [2 x %variant]* %varargslots160 to %variant* + %235 = insertvalue %"variant[]" undef, %variant* %234, 0 + %236 = insertvalue %"variant[]" %235, i64 2, 1 + store %"variant[]" %236, %"variant[]"* %taddr161, align 8 + %237 = bitcast %"variant[]"* %taddr161 to { i8*, i64 }* + %238 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %237, i32 0, i32 0 + %lo162 = load i8*, i8** %238, align 8 + %239 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %237, i32 0, i32 1 + %hi163 = load i64, i64* %239, align 8 + %240 = call i64 @std_io_printfln(i64* %retparam159, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.20, i32 0, i32 0), i64 9, i8* %lo162, i64 %hi163) + %not_err164 = icmp eq i64 %240, 0 + br i1 %not_err164, label %after_check165, label %voiderr166 + +after_check165: ; preds = %loop.body156 + br label %voiderr166 + +voiderr166: ; preds = %after_check165, %loop.body156 + %241 = load i64, i64* %.anon153, align 8 + %add167 = add i64 %241, 1 + store i64 %add167, i64* %.anon153, align 8 + br label %loop.cond154 + +loop.exit168: ; preds = %loop.cond154 + %242 = bitcast [6 x i32]* %a169 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %242, i8* align 16 bitcast ([6 x i32]* @.__const.21 to i8*), i32 24, i1 false) + store i64 0, i64* %.anon170, align 8 + br label %loop.cond171 + +loop.cond171: ; preds = %voiderr183, %loop.exit168 + %243 = load i64, i64* %.anon170, align 8 + %gt172 = icmp ugt i64 6, %243 + br i1 %gt172, label %loop.body173, label %loop.exit185 + +loop.body173: ; preds = %loop.cond171 + %244 = load i64, i64* %.anon170, align 8 + store i64 %244, i64* %i174, align 8 + %245 = load i64, i64* %.anon170, align 8 + %246 = getelementptr inbounds [6 x i32], [6 x i32]* %a169, i64 0, i64 %245 + %247 = load i32, i32* %246, align 4 + store i32 %247, i32* %x175, align 4 + %248 = bitcast i64* %i174 to i8* + %249 = insertvalue %variant undef, i8* %248, 0 + %250 = insertvalue %variant %249, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1 + %251 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots177, i64 0, i64 0 + store %variant %250, %variant* %251, align 16 + %252 = bitcast i32* %x175 to i8* + %253 = insertvalue %variant undef, i8* %252, 0 + %254 = insertvalue %variant %253, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %255 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots177, i64 0, i64 1 + store %variant %254, %variant* %255, align 16 + %256 = bitcast [2 x %variant]* %varargslots177 to %variant* + %257 = insertvalue %"variant[]" undef, %variant* %256, 0 + %258 = insertvalue %"variant[]" %257, i64 2, 1 + store %"variant[]" %258, %"variant[]"* %taddr178, align 8 + %259 = bitcast %"variant[]"* %taddr178 to { i8*, i64 }* + %260 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %259, i32 0, i32 0 + %lo179 = load i8*, i8** %260, align 8 + %261 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %259, i32 0, i32 1 + %hi180 = load i64, i64* %261, align 8 + %262 = call i64 @std_io_printfln(i64* %retparam176, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i32 0, i32 0), i64 6, i8* %lo179, i64 %hi180) + %not_err181 = icmp eq i64 %262, 0 + br i1 %not_err181, label %after_check182, label %voiderr183 + +after_check182: ; preds = %loop.body173 + br label %voiderr183 + +voiderr183: ; preds = %after_check182, %loop.body173 + %263 = load i64, i64* %.anon170, align 8 + %add184 = add i64 %263, 1 + store i64 %add184, i64* %.anon170, align 8 + br label %loop.cond171 + +loop.exit185: ; preds = %loop.cond171 ret void } diff --git a/test/test_suite/overloading/set_overload.c3t b/test/test_suite/overloading/set_overload.c3t index c18610fcf..88d086303 100644 --- a/test/test_suite/overloading/set_overload.c3t +++ b/test/test_suite/overloading/set_overload.c3t @@ -17,23 +17,9 @@ fn void main() define void @test_main() #0 { entry: %map = alloca %HashMap, align 8 - %taddr = alloca %"char[]", align 8 - %taddr1 = alloca %"char[]", align 8 %0 = bitcast %HashMap* %map to i8* call void @llvm.memset.p0i8.i64(i8* align 8 %0, i8 0, i64 40, i1 false) - store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5 }, %"char[]"* %taddr, align 8 - %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 - %lo = load i8*, i8** %2, align 8 - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 - %hi = load i64, i64* %3, align 8 - %4 = call i8 @"std_map$$sa$char.int_HashMap_set"(%HashMap* %map, i8* %lo, i64 %hi, i32 4) - store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3 }, %"char[]"* %taddr1, align 8 - %5 = bitcast %"char[]"* %taddr1 to { i8*, i64 }* - %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 0 - %lo2 = load i8*, i8** %6, align 8 - %7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %5, i32 0, i32 1 - %hi3 = load i64, i64* %7, align 8 - %8 = call i8 @"std_map$$sa$char.int_HashMap_set"(%HashMap* %map, i8* %lo2, i64 %hi3, i32 5) + %1 = call i8 @"std_map$$sa$char.int_HashMap_set"(%HashMap* %map, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5, i32 4) + %2 = call i8 @"std_map$$sa$char.int_HashMap_set"(%HashMap* %map, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3, i32 5) ret void } diff --git a/test/test_suite/safe/deref.c3t b/test/test_suite/safe/deref.c3t index 8f9f67faa..8929aa549 100644 --- a/test/test_suite/safe/deref.c3t +++ b/test/test_suite/safe/deref.c3t @@ -1,4 +1,5 @@ // #safe: yes +// #target: macos-x64 module foo; fn void main() @@ -19,11 +20,12 @@ entry: br i1 %checknull, label %panic, label %checkok panic: ; preds = %entry - call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.zstr.1, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.2, i64 0, i64 0), i32 6) + %1 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %1(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.panic_msg, i64 0, i64 0), i64 27, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.file, i64 0, i64 0), i64 8, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.func, i64 0, i64 0), i64 4, i32 6) br label %checkok checkok: ; preds = %panic, %entry - %1 = load i32, i32* %0, align 8 - store i32 %1, i32* %y, align 4 + %2 = load i32, i32* %0, align 8 + store i32 %2, i32* %y, align 4 ret void } diff --git a/test/test_suite/slices/slice_to_slice_assign.c3t b/test/test_suite/slices/slice_to_slice_assign.c3t index 3685be98f..ffe3bbf3e 100644 --- a/test/test_suite/slices/slice_to_slice_assign.c3t +++ b/test/test_suite/slices/slice_to_slice_assign.c3t @@ -26,33 +26,28 @@ entry: %y = alloca [6 x i32], align 16 %taddr = alloca %"int[]", align 8 %retparam = alloca i64, align 8 - %taddr1 = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 - %taddr4 = alloca %"int[]", align 8 - %retparam5 = alloca i64, align 8 - %taddr6 = alloca %"char[]", align 8 - %vararg9 = alloca %"variant[]", align 8 - %varargslots10 = alloca [2 x %variant], align 16 + %taddr1 = alloca %"variant[]", align 8 + %taddr2 = alloca %"int[]", align 8 + %retparam3 = alloca i64, align 8 + %varargslots4 = alloca [2 x %variant], align 16 + %taddr5 = alloca %"variant[]", align 8 %a = alloca %"int[][]", align 8 %literal = alloca [1 x %"int[]"], align 16 - %literal16 = alloca [1 x i32], align 4 + %literal11 = alloca [1 x i32], align 4 %b = alloca %"int[][]", align 8 - %literal17 = alloca [1 x %"int[]"], align 16 - %literal18 = alloca [1 x i32], align 4 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 - %varargslots24 = alloca [1 x %variant], align 16 - %taddr31 = alloca %"int[][]", align 8 - %retparam32 = alloca i64, align 8 - %taddr33 = alloca %"char[]", align 8 - %vararg36 = alloca %"variant[]", align 8 - %varargslots37 = alloca [1 x %variant], align 16 - %retparam44 = alloca i64, align 8 - %taddr45 = alloca %"char[]", align 8 - %vararg48 = alloca %"variant[]", align 8 - %varargslots49 = alloca [1 x %variant], align 16 + %literal12 = alloca [1 x %"int[]"], align 16 + %literal13 = alloca [1 x i32], align 4 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [1 x %variant], align 16 + %taddr16 = alloca %"variant[]", align 8 + %taddr23 = alloca %"int[][]", align 8 + %retparam24 = alloca i64, align 8 + %varargslots25 = alloca [1 x %variant], align 16 + %taddr26 = alloca %"variant[]", align 8 + %retparam33 = alloca i64, align 8 + %varargslots34 = alloca [1 x %variant], align 16 + %taddr35 = alloca %"variant[]", align 8 %0 = bitcast [7 x i32]* %z to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %0, i8* align 16 bitcast ([7 x i32]* @.__const to i8*), i32 28, i1 false) %1 = bitcast [6 x i32]* %y to i8* @@ -72,223 +67,188 @@ entry: %13 = bitcast i32* %8 to i8* %14 = bitcast i32* %9 to i8* call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %13, i8* align 4 %14, i64 %12, i1 false) - store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5 }, %"char[]"* %taddr1, align 8 - %15 = bitcast %"char[]"* %taddr1 to { i8*, i64 }* - %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 0 - %lo = load i8*, i8** %16, align 8 - %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 1 - %hi = load i64, i64* %17, align 8 - %18 = bitcast [6 x i32]* %y to i8* - %19 = insertvalue %variant undef, i8* %18, 0 - %20 = insertvalue %variant %19, i64 ptrtoint (%.introspect* @"ct$a6$int" to i64), 1 - %21 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 - store %variant %20, %variant* %21, align 16 - %22 = bitcast [7 x i32]* %z to i8* - %23 = insertvalue %variant undef, i8* %22, 0 - %24 = insertvalue %variant %23, i64 ptrtoint (%.introspect* @"ct$a7$int" to i64), 1 - %25 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 - store %variant %24, %variant* %25, align 16 - %26 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 2, i64* %26, align 8 - %27 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %28 = bitcast [2 x %variant]* %varargslots to %variant* - store %variant* %28, %variant** %27, align 8 - %29 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %29, i32 0, i32 0 - %lo2 = load i8*, i8** %30, align 8 - %31 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %29, i32 0, i32 1 - %hi3 = load i64, i64* %31, align 8 - %32 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %32, 0 + %15 = bitcast [6 x i32]* %y to i8* + %16 = insertvalue %variant undef, i8* %15, 0 + %17 = insertvalue %variant %16, i64 ptrtoint (%.introspect* @"ct$a6$int" to i64), 1 + %18 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 + store %variant %17, %variant* %18, align 16 + %19 = bitcast [7 x i32]* %z to i8* + %20 = insertvalue %variant undef, i8* %19, 0 + %21 = insertvalue %variant %20, i64 ptrtoint (%.introspect* @"ct$a7$int" to i64), 1 + %22 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 + store %variant %21, %variant* %22, align 16 + %23 = bitcast [2 x %variant]* %varargslots to %variant* + %24 = insertvalue %"variant[]" undef, %variant* %23, 0 + %25 = insertvalue %"variant[]" %24, i64 2, 1 + store %"variant[]" %25, %"variant[]"* %taddr1, align 8 + %26 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 0 + %lo = load i8*, i8** %27, align 8 + %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 1 + %hi = load i64, i64* %28, align 8 + %29 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %29, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %33 = getelementptr inbounds [7 x i32], [7 x i32]* %z, i64 0, i64 5 + %30 = getelementptr inbounds [7 x i32], [7 x i32]* %z, i64 0, i64 5 + %31 = insertvalue %"int[]" undef, i32* %30, 0 + %32 = insertvalue %"int[]" %31, i64 2, 1 + %33 = getelementptr inbounds [6 x i32], [6 x i32]* %y, i64 0, i64 4 %34 = insertvalue %"int[]" undef, i32* %33, 0 %35 = insertvalue %"int[]" %34, i64 2, 1 - %36 = getelementptr inbounds [6 x i32], [6 x i32]* %y, i64 0, i64 4 - %37 = insertvalue %"int[]" undef, i32* %36, 0 - %38 = insertvalue %"int[]" %37, i64 2, 1 - %39 = extractvalue %"int[]" %38, 0 - %40 = extractvalue %"int[]" %35, 0 - store %"int[]" %35, %"int[]"* %taddr4, align 8 - %41 = getelementptr inbounds %"int[]", %"int[]"* %taddr4, i32 0, i32 1 - %42 = load i64, i64* %41, align 8 - %43 = mul i64 %42, 4 - %44 = bitcast i32* %39 to i8* - %45 = bitcast i32* %40 to i8* - call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %44, i8* align 4 %45, i64 %43, i1 false) - store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i64 5 }, %"char[]"* %taddr6, align 8 - %46 = bitcast %"char[]"* %taddr6 to { i8*, i64 }* - %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 0 - %lo7 = load i8*, i8** %47, align 8 - %48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 1 - %hi8 = load i64, i64* %48, align 8 - %49 = bitcast [6 x i32]* %y to i8* - %50 = insertvalue %variant undef, i8* %49, 0 - %51 = insertvalue %variant %50, i64 ptrtoint (%.introspect* @"ct$a6$int" to i64), 1 - %52 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots10, i64 0, i64 0 - store %variant %51, %variant* %52, align 16 - %53 = bitcast [7 x i32]* %z to i8* - %54 = insertvalue %variant undef, i8* %53, 0 - %55 = insertvalue %variant %54, i64 ptrtoint (%.introspect* @"ct$a7$int" to i64), 1 - %56 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots10, i64 0, i64 1 - store %variant %55, %variant* %56, align 16 - %57 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 1 - store i64 2, i64* %57, align 8 - %58 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 0 - %59 = bitcast [2 x %variant]* %varargslots10 to %variant* - store %variant* %59, %variant** %58, align 8 - %60 = bitcast %"variant[]"* %vararg9 to { i8*, i64 }* - %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0 - %lo11 = load i8*, i8** %61, align 8 - %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1 - %hi12 = load i64, i64* %62, align 8 - %63 = call i64 @std_io_printfln(i64* %retparam5, i8* %lo7, i64 %hi8, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %63, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %36 = extractvalue %"int[]" %35, 0 + %37 = extractvalue %"int[]" %32, 0 + store %"int[]" %32, %"int[]"* %taddr2, align 8 + %38 = getelementptr inbounds %"int[]", %"int[]"* %taddr2, i32 0, i32 1 + %39 = load i64, i64* %38, align 8 + %40 = mul i64 %39, 4 + %41 = bitcast i32* %36 to i8* + %42 = bitcast i32* %37 to i8* + call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %41, i8* align 4 %42, i64 %40, i1 false) + %43 = bitcast [6 x i32]* %y to i8* + %44 = insertvalue %variant undef, i8* %43, 0 + %45 = insertvalue %variant %44, i64 ptrtoint (%.introspect* @"ct$a6$int" to i64), 1 + %46 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots4, i64 0, i64 0 + store %variant %45, %variant* %46, align 16 + %47 = bitcast [7 x i32]* %z to i8* + %48 = insertvalue %variant undef, i8* %47, 0 + %49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$a7$int" to i64), 1 + %50 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots4, i64 0, i64 1 + store %variant %49, %variant* %50, align 16 + %51 = bitcast [2 x %variant]* %varargslots4 to %variant* + %52 = insertvalue %"variant[]" undef, %variant* %51, 0 + %53 = insertvalue %"variant[]" %52, i64 2, 1 + store %"variant[]" %53, %"variant[]"* %taddr5, align 8 + %54 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }* + %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 0 + %lo6 = load i8*, i8** %55, align 8 + %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 1 + %hi7 = load i64, i64* %56, align 8 + %57 = call i64 @std_io_printfln(i64* %retparam3, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i64 5, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %57, 0 + br i1 %not_err8, label %after_check9, label %voiderr10 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check9: ; preds = %voiderr + br label %voiderr10 -voiderr15: ; preds = %after_check14, %voiderr - %64 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal, i64 0, i64 0 - %65 = getelementptr inbounds [1 x i32], [1 x i32]* %literal16, i64 0, i64 0 - store i32 1, i32* %65, align 4 - %66 = bitcast [1 x i32]* %literal16 to i32* - %67 = insertvalue %"int[]" undef, i32* %66, 0 - %68 = insertvalue %"int[]" %67, i64 1, 1 - store %"int[]" %68, %"int[]"* %64, align 8 - %69 = bitcast [1 x %"int[]"]* %literal to %"int[]"* - %70 = insertvalue %"int[][]" undef, %"int[]"* %69, 0 - %71 = insertvalue %"int[][]" %70, i64 1, 1 - store %"int[][]" %71, %"int[][]"* %a, align 8 - %72 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal17, i64 0, i64 0 - %73 = getelementptr inbounds [1 x i32], [1 x i32]* %literal18, i64 0, i64 0 - store i32 2, i32* %73, align 4 - %74 = bitcast [1 x i32]* %literal18 to i32* - %75 = insertvalue %"int[]" undef, i32* %74, 0 - %76 = insertvalue %"int[]" %75, i64 1, 1 - store %"int[]" %76, %"int[]"* %72, align 8 - %77 = bitcast [1 x %"int[]"]* %literal17 to %"int[]"* - %78 = insertvalue %"int[][]" undef, %"int[]"* %77, 0 - %79 = insertvalue %"int[][]" %78, i64 1, 1 - store %"int[][]" %79, %"int[][]"* %b, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2 }, %"char[]"* %taddr20, align 8 - %80 = bitcast %"char[]"* %taddr20 to { i8*, i64 }* - %81 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 0 - %lo21 = load i8*, i8** %81, align 8 - %82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 1 - %hi22 = load i64, i64* %82, align 8 - %83 = bitcast %"int[][]"* %a to i8* - %84 = insertvalue %variant undef, i8* %83, 0 - %85 = insertvalue %variant %84, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 - %86 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0 - store %variant %85, %variant* %86, align 16 - %87 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1 - store i64 1, i64* %87, align 8 - %88 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0 - %89 = bitcast [1 x %variant]* %varargslots24 to %variant* - store %variant* %89, %variant** %88, align 8 - %90 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }* - %91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 0 - %lo25 = load i8*, i8** %91, align 8 - %92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 1 - %hi26 = load i64, i64* %92, align 8 - %93 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %93, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 +voiderr10: ; preds = %after_check9, %voiderr + %58 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal, i64 0, i64 0 + %59 = getelementptr inbounds [1 x i32], [1 x i32]* %literal11, i64 0, i64 0 + store i32 1, i32* %59, align 4 + %60 = bitcast [1 x i32]* %literal11 to i32* + %61 = insertvalue %"int[]" undef, i32* %60, 0 + %62 = insertvalue %"int[]" %61, i64 1, 1 + store %"int[]" %62, %"int[]"* %58, align 8 + %63 = bitcast [1 x %"int[]"]* %literal to %"int[]"* + %64 = insertvalue %"int[][]" undef, %"int[]"* %63, 0 + %65 = insertvalue %"int[][]" %64, i64 1, 1 + store %"int[][]" %65, %"int[][]"* %a, align 8 + %66 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal12, i64 0, i64 0 + %67 = getelementptr inbounds [1 x i32], [1 x i32]* %literal13, i64 0, i64 0 + store i32 2, i32* %67, align 4 + %68 = bitcast [1 x i32]* %literal13 to i32* + %69 = insertvalue %"int[]" undef, i32* %68, 0 + %70 = insertvalue %"int[]" %69, i64 1, 1 + store %"int[]" %70, %"int[]"* %66, align 8 + %71 = bitcast [1 x %"int[]"]* %literal12 to %"int[]"* + %72 = insertvalue %"int[][]" undef, %"int[]"* %71, 0 + %73 = insertvalue %"int[][]" %72, i64 1, 1 + store %"int[][]" %73, %"int[][]"* %b, align 8 + %74 = bitcast %"int[][]"* %a to i8* + %75 = insertvalue %variant undef, i8* %74, 0 + %76 = insertvalue %variant %75, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 + %77 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots15, i64 0, i64 0 + store %variant %76, %variant* %77, align 16 + %78 = bitcast [1 x %variant]* %varargslots15 to %variant* + %79 = insertvalue %"variant[]" undef, %variant* %78, 0 + %80 = insertvalue %"variant[]" %79, i64 1, 1 + store %"variant[]" %80, %"variant[]"* %taddr16, align 8 + %81 = bitcast %"variant[]"* %taddr16 to { i8*, i64 }* + %82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %81, i32 0, i32 0 + %lo17 = load i8*, i8** %82, align 8 + %83 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %81, i32 0, i32 1 + %hi18 = load i64, i64* %83, align 8 + %84 = call i64 @std_io_printfln(i64* %retparam14, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2, i8* %lo17, i64 %hi18) + %not_err19 = icmp eq i64 %84, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 -after_check28: ; preds = %voiderr15 - br label %voiderr29 +after_check20: ; preds = %voiderr10 + br label %voiderr21 -voiderr29: ; preds = %after_check28, %voiderr15 - %94 = load %"int[][]", %"int[][]"* %b, align 8 - %95 = extractvalue %"int[][]" %94, 0 - %ptroffset = getelementptr inbounds %"int[]", %"int[]"* %95, i64 0 - %96 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset, 0 - %97 = insertvalue %"int[][]" %96, i64 1, 1 - %98 = load %"int[][]", %"int[][]"* %a, align 8 - %99 = extractvalue %"int[][]" %98, 0 - %ptroffset30 = getelementptr inbounds %"int[]", %"int[]"* %99, i64 0 - %100 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset30, 0 - %101 = insertvalue %"int[][]" %100, i64 1, 1 - %102 = extractvalue %"int[][]" %101, 0 - %103 = extractvalue %"int[][]" %97, 0 - store %"int[][]" %97, %"int[][]"* %taddr31, align 8 - %104 = getelementptr inbounds %"int[][]", %"int[][]"* %taddr31, i32 0, i32 1 - %105 = load i64, i64* %104, align 8 - %106 = mul i64 %105, 16 - %107 = bitcast %"int[]"* %102 to i8* - %108 = bitcast %"int[]"* %103 to i8* - call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %107, i8* align 8 %108, i64 %106, i1 false) - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2 }, %"char[]"* %taddr33, align 8 - %109 = bitcast %"char[]"* %taddr33 to { i8*, i64 }* - %110 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %109, i32 0, i32 0 - %lo34 = load i8*, i8** %110, align 8 - %111 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %109, i32 0, i32 1 - %hi35 = load i64, i64* %111, align 8 - %112 = bitcast %"int[][]"* %a to i8* - %113 = insertvalue %variant undef, i8* %112, 0 - %114 = insertvalue %variant %113, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 - %115 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots37, i64 0, i64 0 - store %variant %114, %variant* %115, align 16 - %116 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg36, i32 0, i32 1 - store i64 1, i64* %116, align 8 - %117 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg36, i32 0, i32 0 - %118 = bitcast [1 x %variant]* %varargslots37 to %variant* - store %variant* %118, %variant** %117, align 8 - %119 = bitcast %"variant[]"* %vararg36 to { i8*, i64 }* - %120 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %119, i32 0, i32 0 - %lo38 = load i8*, i8** %120, align 8 - %121 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %119, i32 0, i32 1 - %hi39 = load i64, i64* %121, align 8 - %122 = call i64 @std_io_printfln(i64* %retparam32, i8* %lo34, i64 %hi35, i8* %lo38, i64 %hi39) - %not_err40 = icmp eq i64 %122, 0 - br i1 %not_err40, label %after_check41, label %voiderr42 +voiderr21: ; preds = %after_check20, %voiderr10 + %85 = load %"int[][]", %"int[][]"* %b, align 8 + %86 = extractvalue %"int[][]" %85, 0 + %ptroffset = getelementptr inbounds %"int[]", %"int[]"* %86, i64 0 + %87 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset, 0 + %88 = insertvalue %"int[][]" %87, i64 1, 1 + %89 = load %"int[][]", %"int[][]"* %a, align 8 + %90 = extractvalue %"int[][]" %89, 0 + %ptroffset22 = getelementptr inbounds %"int[]", %"int[]"* %90, i64 0 + %91 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset22, 0 + %92 = insertvalue %"int[][]" %91, i64 1, 1 + %93 = extractvalue %"int[][]" %92, 0 + %94 = extractvalue %"int[][]" %88, 0 + store %"int[][]" %88, %"int[][]"* %taddr23, align 8 + %95 = getelementptr inbounds %"int[][]", %"int[][]"* %taddr23, i32 0, i32 1 + %96 = load i64, i64* %95, align 8 + %97 = mul i64 %96, 16 + %98 = bitcast %"int[]"* %93 to i8* + %99 = bitcast %"int[]"* %94 to i8* + call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %98, i8* align 8 %99, i64 %97, i1 false) + %100 = bitcast %"int[][]"* %a to i8* + %101 = insertvalue %variant undef, i8* %100, 0 + %102 = insertvalue %variant %101, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 + %103 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots25, i64 0, i64 0 + store %variant %102, %variant* %103, align 16 + %104 = bitcast [1 x %variant]* %varargslots25 to %variant* + %105 = insertvalue %"variant[]" undef, %variant* %104, 0 + %106 = insertvalue %"variant[]" %105, i64 1, 1 + store %"variant[]" %106, %"variant[]"* %taddr26, align 8 + %107 = bitcast %"variant[]"* %taddr26 to { i8*, i64 }* + %108 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %107, i32 0, i32 0 + %lo27 = load i8*, i8** %108, align 8 + %109 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %107, i32 0, i32 1 + %hi28 = load i64, i64* %109, align 8 + %110 = call i64 @std_io_printfln(i64* %retparam24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2, i8* %lo27, i64 %hi28) + %not_err29 = icmp eq i64 %110, 0 + br i1 %not_err29, label %after_check30, label %voiderr31 -after_check41: ; preds = %voiderr29 - br label %voiderr42 +after_check30: ; preds = %voiderr21 + br label %voiderr31 -voiderr42: ; preds = %after_check41, %voiderr29 - %123 = getelementptr inbounds [6 x i32], [6 x i32]* %y, i64 0, i64 2 - %124 = insertvalue %"int[]" undef, i32* %123, 0 - %125 = insertvalue %"int[]" %124, i64 3, 1 - %126 = load %"int[][]", %"int[][]"* %a, align 8 - %127 = extractvalue %"int[][]" %126, 0 - %ptroffset43 = getelementptr inbounds %"int[]", %"int[]"* %127, i64 0 - store %"int[]" %125, %"int[]"* %ptroffset43, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2 }, %"char[]"* %taddr45, align 8 - %128 = bitcast %"char[]"* %taddr45 to { i8*, i64 }* - %129 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %128, i32 0, i32 0 - %lo46 = load i8*, i8** %129, align 8 - %130 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %128, i32 0, i32 1 - %hi47 = load i64, i64* %130, align 8 - %131 = bitcast %"int[][]"* %a to i8* - %132 = insertvalue %variant undef, i8* %131, 0 - %133 = insertvalue %variant %132, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 - %134 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots49, i64 0, i64 0 - store %variant %133, %variant* %134, align 16 - %135 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 1 - store i64 1, i64* %135, align 8 - %136 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 0 - %137 = bitcast [1 x %variant]* %varargslots49 to %variant* - store %variant* %137, %variant** %136, align 8 - %138 = bitcast %"variant[]"* %vararg48 to { i8*, i64 }* - %139 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %138, i32 0, i32 0 - %lo50 = load i8*, i8** %139, align 8 - %140 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %138, i32 0, i32 1 - %hi51 = load i64, i64* %140, align 8 - %141 = call i64 @std_io_printfln(i64* %retparam44, i8* %lo46, i64 %hi47, i8* %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %141, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 +voiderr31: ; preds = %after_check30, %voiderr21 + %111 = getelementptr inbounds [6 x i32], [6 x i32]* %y, i64 0, i64 2 + %112 = insertvalue %"int[]" undef, i32* %111, 0 + %113 = insertvalue %"int[]" %112, i64 3, 1 + %114 = load %"int[][]", %"int[][]"* %a, align 8 + %115 = extractvalue %"int[][]" %114, 0 + %ptroffset32 = getelementptr inbounds %"int[]", %"int[]"* %115, i64 0 + store %"int[]" %113, %"int[]"* %ptroffset32, align 8 + %116 = bitcast %"int[][]"* %a to i8* + %117 = insertvalue %variant undef, i8* %116, 0 + %118 = insertvalue %variant %117, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 + %119 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots34, i64 0, i64 0 + store %variant %118, %variant* %119, align 16 + %120 = bitcast [1 x %variant]* %varargslots34 to %variant* + %121 = insertvalue %"variant[]" undef, %variant* %120, 0 + %122 = insertvalue %"variant[]" %121, i64 1, 1 + store %"variant[]" %122, %"variant[]"* %taddr35, align 8 + %123 = bitcast %"variant[]"* %taddr35 to { i8*, i64 }* + %124 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 0 + %lo36 = load i8*, i8** %124, align 8 + %125 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 1 + %hi37 = load i64, i64* %125, align 8 + %126 = call i64 @std_io_printfln(i64* %retparam33, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2, i8* %lo36, i64 %hi37) + %not_err38 = icmp eq i64 %126, 0 + br i1 %not_err38, label %after_check39, label %voiderr40 -after_check53: ; preds = %voiderr42 - br label %voiderr54 +after_check39: ; preds = %voiderr31 + br label %voiderr40 -voiderr54: ; preds = %after_check53, %voiderr42 +voiderr40: ; preds = %after_check39, %voiderr31 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 2db09a602..2c2654f3a 100644 --- a/test/test_suite/slices/slice_to_slice_vector_assign.c3t +++ b/test/test_suite/slices/slice_to_slice_vector_assign.c3t @@ -26,33 +26,28 @@ entry: %y = alloca <6 x i32>, align 32 %taddr = alloca %"int[]", align 8 %retparam = alloca i64, align 8 - %taddr1 = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 - %taddr4 = alloca %"int[]", align 8 - %retparam5 = alloca i64, align 8 - %taddr6 = alloca %"char[]", align 8 - %vararg9 = alloca %"variant[]", align 8 - %varargslots10 = alloca [2 x %variant], align 16 + %taddr1 = alloca %"variant[]", align 8 + %taddr2 = alloca %"int[]", align 8 + %retparam3 = alloca i64, align 8 + %varargslots4 = alloca [2 x %variant], align 16 + %taddr5 = alloca %"variant[]", align 8 %a = alloca %"int[][]", align 8 %literal = alloca [1 x %"int[]"], align 16 - %literal16 = alloca [1 x i32], align 4 + %literal11 = alloca [1 x i32], align 4 %b = alloca %"int[][]", align 8 - %literal17 = alloca [1 x %"int[]"], align 16 - %literal18 = alloca [1 x i32], align 4 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 - %varargslots24 = alloca [1 x %variant], align 16 - %taddr31 = alloca %"int[][]", align 8 - %retparam32 = alloca i64, align 8 - %taddr33 = alloca %"char[]", align 8 - %vararg36 = alloca %"variant[]", align 8 - %varargslots37 = alloca [1 x %variant], align 16 - %retparam44 = alloca i64, align 8 - %taddr45 = alloca %"char[]", align 8 - %vararg48 = alloca %"variant[]", align 8 - %varargslots49 = alloca [1 x %variant], align 16 + %literal12 = alloca [1 x %"int[]"], align 16 + %literal13 = alloca [1 x i32], align 4 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [1 x %variant], align 16 + %taddr16 = alloca %"variant[]", align 8 + %taddr23 = alloca %"int[][]", align 8 + %retparam24 = alloca i64, align 8 + %varargslots25 = alloca [1 x %variant], align 16 + %taddr26 = alloca %"variant[]", align 8 + %retparam33 = alloca i64, align 8 + %varargslots34 = alloca [1 x %variant], align 16 + %taddr35 = alloca %"variant[]", align 8 store <7 x i32> , <7 x i32>* %z, align 32 store <6 x i32> zeroinitializer, <6 x i32>* %y, align 32 %0 = getelementptr inbounds <7 x i32>, <7 x i32>* %z, i64 0, i64 3 @@ -70,223 +65,188 @@ entry: %11 = bitcast i32* %6 to i8* %12 = bitcast i32* %7 to i8* call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %11, i8* align 4 %12, i64 %10, i1 false) - store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5 }, %"char[]"* %taddr1, align 8 - %13 = bitcast %"char[]"* %taddr1 to { i8*, i64 }* - %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 0 - %lo = load i8*, i8** %14, align 8 - %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 1 - %hi = load i64, i64* %15, align 8 - %16 = bitcast <6 x i32>* %y to i8* - %17 = insertvalue %variant undef, i8* %16, 0 - %18 = insertvalue %variant %17, i64 ptrtoint (%.introspect* @"ct$v6$int" to i64), 1 - %19 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 - store %variant %18, %variant* %19, align 16 - %20 = bitcast <7 x i32>* %z to i8* - %21 = insertvalue %variant undef, i8* %20, 0 - %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$v7$int" to i64), 1 - %23 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 - store %variant %22, %variant* %23, align 16 - %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 2, i64* %24, align 8 - %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %26 = bitcast [2 x %variant]* %varargslots to %variant* - store %variant* %26, %variant** %25, align 8 - %27 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 - %lo2 = load i8*, i8** %28, align 8 - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 - %hi3 = load i64, i64* %29, align 8 - %30 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3) - %not_err = icmp eq i64 %30, 0 + %13 = bitcast <6 x i32>* %y to i8* + %14 = insertvalue %variant undef, i8* %13, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (%.introspect* @"ct$v6$int" to i64), 1 + %16 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 + store %variant %15, %variant* %16, align 16 + %17 = bitcast <7 x i32>* %z to i8* + %18 = insertvalue %variant undef, i8* %17, 0 + %19 = insertvalue %variant %18, i64 ptrtoint (%.introspect* @"ct$v7$int" to i64), 1 + %20 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 + store %variant %19, %variant* %20, align 16 + %21 = bitcast [2 x %variant]* %varargslots to %variant* + %22 = insertvalue %"variant[]" undef, %variant* %21, 0 + %23 = insertvalue %"variant[]" %22, i64 2, 1 + store %"variant[]" %23, %"variant[]"* %taddr1, align 8 + %24 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }* + %25 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 0 + %lo = load i8*, i8** %25, align 8 + %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 1 + %hi = load i64, i64* %26, align 8 + %27 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %27, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %31 = getelementptr inbounds <7 x i32>, <7 x i32>* %z, i64 0, i64 5 + %28 = getelementptr inbounds <7 x i32>, <7 x i32>* %z, i64 0, i64 5 + %29 = insertvalue %"int[]" undef, i32* %28, 0 + %30 = insertvalue %"int[]" %29, i64 2, 1 + %31 = getelementptr inbounds <6 x i32>, <6 x i32>* %y, i64 0, i64 4 %32 = insertvalue %"int[]" undef, i32* %31, 0 %33 = insertvalue %"int[]" %32, i64 2, 1 - %34 = getelementptr inbounds <6 x i32>, <6 x i32>* %y, i64 0, i64 4 - %35 = insertvalue %"int[]" undef, i32* %34, 0 - %36 = insertvalue %"int[]" %35, i64 2, 1 - %37 = extractvalue %"int[]" %36, 0 - %38 = extractvalue %"int[]" %33, 0 - store %"int[]" %33, %"int[]"* %taddr4, align 8 - %39 = getelementptr inbounds %"int[]", %"int[]"* %taddr4, i32 0, i32 1 - %40 = load i64, i64* %39, align 8 - %41 = mul i64 %40, 4 - %42 = bitcast i32* %37 to i8* - %43 = bitcast i32* %38 to i8* - call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %42, i8* align 4 %43, i64 %41, i1 false) - store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i64 5 }, %"char[]"* %taddr6, align 8 - %44 = bitcast %"char[]"* %taddr6 to { i8*, i64 }* - %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0 - %lo7 = load i8*, i8** %45, align 8 - %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1 - %hi8 = load i64, i64* %46, align 8 - %47 = bitcast <6 x i32>* %y to i8* - %48 = insertvalue %variant undef, i8* %47, 0 - %49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$v6$int" to i64), 1 - %50 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots10, i64 0, i64 0 - store %variant %49, %variant* %50, align 16 - %51 = bitcast <7 x i32>* %z to i8* - %52 = insertvalue %variant undef, i8* %51, 0 - %53 = insertvalue %variant %52, i64 ptrtoint (%.introspect* @"ct$v7$int" to i64), 1 - %54 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots10, i64 0, i64 1 - store %variant %53, %variant* %54, align 16 - %55 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 1 - store i64 2, i64* %55, align 8 - %56 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 0 - %57 = bitcast [2 x %variant]* %varargslots10 to %variant* - store %variant* %57, %variant** %56, align 8 - %58 = bitcast %"variant[]"* %vararg9 to { i8*, i64 }* - %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0 - %lo11 = load i8*, i8** %59, align 8 - %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1 - %hi12 = load i64, i64* %60, align 8 - %61 = call i64 @std_io_printfln(i64* %retparam5, i8* %lo7, i64 %hi8, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %61, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %34 = extractvalue %"int[]" %33, 0 + %35 = extractvalue %"int[]" %30, 0 + store %"int[]" %30, %"int[]"* %taddr2, align 8 + %36 = getelementptr inbounds %"int[]", %"int[]"* %taddr2, i32 0, i32 1 + %37 = load i64, i64* %36, align 8 + %38 = mul i64 %37, 4 + %39 = bitcast i32* %34 to i8* + %40 = bitcast i32* %35 to i8* + call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %39, i8* align 4 %40, i64 %38, i1 false) + %41 = bitcast <6 x i32>* %y to i8* + %42 = insertvalue %variant undef, i8* %41, 0 + %43 = insertvalue %variant %42, i64 ptrtoint (%.introspect* @"ct$v6$int" to i64), 1 + %44 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots4, i64 0, i64 0 + store %variant %43, %variant* %44, align 16 + %45 = bitcast <7 x i32>* %z to i8* + %46 = insertvalue %variant undef, i8* %45, 0 + %47 = insertvalue %variant %46, i64 ptrtoint (%.introspect* @"ct$v7$int" to i64), 1 + %48 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots4, i64 0, i64 1 + store %variant %47, %variant* %48, align 16 + %49 = bitcast [2 x %variant]* %varargslots4 to %variant* + %50 = insertvalue %"variant[]" undef, %variant* %49, 0 + %51 = insertvalue %"variant[]" %50, i64 2, 1 + store %"variant[]" %51, %"variant[]"* %taddr5, align 8 + %52 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }* + %53 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %52, i32 0, i32 0 + %lo6 = load i8*, i8** %53, align 8 + %54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %52, i32 0, i32 1 + %hi7 = load i64, i64* %54, align 8 + %55 = call i64 @std_io_printfln(i64* %retparam3, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i64 5, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %55, 0 + br i1 %not_err8, label %after_check9, label %voiderr10 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check9: ; preds = %voiderr + br label %voiderr10 -voiderr15: ; preds = %after_check14, %voiderr - %62 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal, i64 0, i64 0 - %63 = getelementptr inbounds [1 x i32], [1 x i32]* %literal16, i64 0, i64 0 - store i32 1, i32* %63, align 4 - %64 = bitcast [1 x i32]* %literal16 to i32* - %65 = insertvalue %"int[]" undef, i32* %64, 0 - %66 = insertvalue %"int[]" %65, i64 1, 1 - store %"int[]" %66, %"int[]"* %62, align 8 - %67 = bitcast [1 x %"int[]"]* %literal to %"int[]"* - %68 = insertvalue %"int[][]" undef, %"int[]"* %67, 0 - %69 = insertvalue %"int[][]" %68, i64 1, 1 - store %"int[][]" %69, %"int[][]"* %a, align 8 - %70 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal17, i64 0, i64 0 - %71 = getelementptr inbounds [1 x i32], [1 x i32]* %literal18, i64 0, i64 0 - store i32 2, i32* %71, align 4 - %72 = bitcast [1 x i32]* %literal18 to i32* - %73 = insertvalue %"int[]" undef, i32* %72, 0 - %74 = insertvalue %"int[]" %73, i64 1, 1 - store %"int[]" %74, %"int[]"* %70, align 8 - %75 = bitcast [1 x %"int[]"]* %literal17 to %"int[]"* - %76 = insertvalue %"int[][]" undef, %"int[]"* %75, 0 - %77 = insertvalue %"int[][]" %76, i64 1, 1 - store %"int[][]" %77, %"int[][]"* %b, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2 }, %"char[]"* %taddr20, align 8 - %78 = bitcast %"char[]"* %taddr20 to { i8*, i64 }* - %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0 - %lo21 = load i8*, i8** %79, align 8 - %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1 - %hi22 = load i64, i64* %80, align 8 - %81 = bitcast %"int[][]"* %a to i8* - %82 = insertvalue %variant undef, i8* %81, 0 - %83 = insertvalue %variant %82, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 - %84 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0 - store %variant %83, %variant* %84, align 16 - %85 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1 - store i64 1, i64* %85, align 8 - %86 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0 - %87 = bitcast [1 x %variant]* %varargslots24 to %variant* - store %variant* %87, %variant** %86, align 8 - %88 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }* - %89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 0 - %lo25 = load i8*, i8** %89, align 8 - %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 1 - %hi26 = load i64, i64* %90, align 8 - %91 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %91, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 +voiderr10: ; preds = %after_check9, %voiderr + %56 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal, i64 0, i64 0 + %57 = getelementptr inbounds [1 x i32], [1 x i32]* %literal11, i64 0, i64 0 + store i32 1, i32* %57, align 4 + %58 = bitcast [1 x i32]* %literal11 to i32* + %59 = insertvalue %"int[]" undef, i32* %58, 0 + %60 = insertvalue %"int[]" %59, i64 1, 1 + store %"int[]" %60, %"int[]"* %56, align 8 + %61 = bitcast [1 x %"int[]"]* %literal to %"int[]"* + %62 = insertvalue %"int[][]" undef, %"int[]"* %61, 0 + %63 = insertvalue %"int[][]" %62, i64 1, 1 + store %"int[][]" %63, %"int[][]"* %a, align 8 + %64 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal12, i64 0, i64 0 + %65 = getelementptr inbounds [1 x i32], [1 x i32]* %literal13, i64 0, i64 0 + store i32 2, i32* %65, align 4 + %66 = bitcast [1 x i32]* %literal13 to i32* + %67 = insertvalue %"int[]" undef, i32* %66, 0 + %68 = insertvalue %"int[]" %67, i64 1, 1 + store %"int[]" %68, %"int[]"* %64, align 8 + %69 = bitcast [1 x %"int[]"]* %literal12 to %"int[]"* + %70 = insertvalue %"int[][]" undef, %"int[]"* %69, 0 + %71 = insertvalue %"int[][]" %70, i64 1, 1 + store %"int[][]" %71, %"int[][]"* %b, align 8 + %72 = bitcast %"int[][]"* %a to i8* + %73 = insertvalue %variant undef, i8* %72, 0 + %74 = insertvalue %variant %73, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 + %75 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots15, i64 0, i64 0 + store %variant %74, %variant* %75, align 16 + %76 = bitcast [1 x %variant]* %varargslots15 to %variant* + %77 = insertvalue %"variant[]" undef, %variant* %76, 0 + %78 = insertvalue %"variant[]" %77, i64 1, 1 + store %"variant[]" %78, %"variant[]"* %taddr16, align 8 + %79 = bitcast %"variant[]"* %taddr16 to { i8*, i64 }* + %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %79, i32 0, i32 0 + %lo17 = load i8*, i8** %80, align 8 + %81 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %79, i32 0, i32 1 + %hi18 = load i64, i64* %81, align 8 + %82 = call i64 @std_io_printfln(i64* %retparam14, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2, i8* %lo17, i64 %hi18) + %not_err19 = icmp eq i64 %82, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 -after_check28: ; preds = %voiderr15 - br label %voiderr29 +after_check20: ; preds = %voiderr10 + br label %voiderr21 -voiderr29: ; preds = %after_check28, %voiderr15 - %92 = load %"int[][]", %"int[][]"* %b, align 8 - %93 = extractvalue %"int[][]" %92, 0 - %ptroffset = getelementptr inbounds %"int[]", %"int[]"* %93, i64 0 - %94 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset, 0 - %95 = insertvalue %"int[][]" %94, i64 1, 1 - %96 = load %"int[][]", %"int[][]"* %a, align 8 - %97 = extractvalue %"int[][]" %96, 0 - %ptroffset30 = getelementptr inbounds %"int[]", %"int[]"* %97, i64 0 - %98 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset30, 0 - %99 = insertvalue %"int[][]" %98, i64 1, 1 - %100 = extractvalue %"int[][]" %99, 0 - %101 = extractvalue %"int[][]" %95, 0 - store %"int[][]" %95, %"int[][]"* %taddr31, align 8 - %102 = getelementptr inbounds %"int[][]", %"int[][]"* %taddr31, i32 0, i32 1 - %103 = load i64, i64* %102, align 8 - %104 = mul i64 %103, 16 - %105 = bitcast %"int[]"* %100 to i8* - %106 = bitcast %"int[]"* %101 to i8* - call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %105, i8* align 8 %106, i64 %104, i1 false) - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2 }, %"char[]"* %taddr33, align 8 - %107 = bitcast %"char[]"* %taddr33 to { i8*, i64 }* - %108 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %107, i32 0, i32 0 - %lo34 = load i8*, i8** %108, align 8 - %109 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %107, i32 0, i32 1 - %hi35 = load i64, i64* %109, align 8 - %110 = bitcast %"int[][]"* %a to i8* - %111 = insertvalue %variant undef, i8* %110, 0 - %112 = insertvalue %variant %111, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 - %113 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots37, i64 0, i64 0 - store %variant %112, %variant* %113, align 16 - %114 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg36, i32 0, i32 1 - store i64 1, i64* %114, align 8 - %115 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg36, i32 0, i32 0 - %116 = bitcast [1 x %variant]* %varargslots37 to %variant* - store %variant* %116, %variant** %115, align 8 - %117 = bitcast %"variant[]"* %vararg36 to { i8*, i64 }* - %118 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %117, i32 0, i32 0 - %lo38 = load i8*, i8** %118, align 8 - %119 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %117, i32 0, i32 1 - %hi39 = load i64, i64* %119, align 8 - %120 = call i64 @std_io_printfln(i64* %retparam32, i8* %lo34, i64 %hi35, i8* %lo38, i64 %hi39) - %not_err40 = icmp eq i64 %120, 0 - br i1 %not_err40, label %after_check41, label %voiderr42 +voiderr21: ; preds = %after_check20, %voiderr10 + %83 = load %"int[][]", %"int[][]"* %b, align 8 + %84 = extractvalue %"int[][]" %83, 0 + %ptroffset = getelementptr inbounds %"int[]", %"int[]"* %84, i64 0 + %85 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset, 0 + %86 = insertvalue %"int[][]" %85, i64 1, 1 + %87 = load %"int[][]", %"int[][]"* %a, align 8 + %88 = extractvalue %"int[][]" %87, 0 + %ptroffset22 = getelementptr inbounds %"int[]", %"int[]"* %88, i64 0 + %89 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset22, 0 + %90 = insertvalue %"int[][]" %89, i64 1, 1 + %91 = extractvalue %"int[][]" %90, 0 + %92 = extractvalue %"int[][]" %86, 0 + store %"int[][]" %86, %"int[][]"* %taddr23, align 8 + %93 = getelementptr inbounds %"int[][]", %"int[][]"* %taddr23, i32 0, i32 1 + %94 = load i64, i64* %93, align 8 + %95 = mul i64 %94, 16 + %96 = bitcast %"int[]"* %91 to i8* + %97 = bitcast %"int[]"* %92 to i8* + call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %96, i8* align 8 %97, i64 %95, i1 false) + %98 = bitcast %"int[][]"* %a to i8* + %99 = insertvalue %variant undef, i8* %98, 0 + %100 = insertvalue %variant %99, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 + %101 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots25, i64 0, i64 0 + store %variant %100, %variant* %101, align 16 + %102 = bitcast [1 x %variant]* %varargslots25 to %variant* + %103 = insertvalue %"variant[]" undef, %variant* %102, 0 + %104 = insertvalue %"variant[]" %103, i64 1, 1 + store %"variant[]" %104, %"variant[]"* %taddr26, align 8 + %105 = bitcast %"variant[]"* %taddr26 to { i8*, i64 }* + %106 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %105, i32 0, i32 0 + %lo27 = load i8*, i8** %106, align 8 + %107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %105, i32 0, i32 1 + %hi28 = load i64, i64* %107, align 8 + %108 = call i64 @std_io_printfln(i64* %retparam24, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2, i8* %lo27, i64 %hi28) + %not_err29 = icmp eq i64 %108, 0 + br i1 %not_err29, label %after_check30, label %voiderr31 -after_check41: ; preds = %voiderr29 - br label %voiderr42 +after_check30: ; preds = %voiderr21 + br label %voiderr31 -voiderr42: ; preds = %after_check41, %voiderr29 - %121 = getelementptr inbounds <6 x i32>, <6 x i32>* %y, i64 0, i64 2 - %122 = insertvalue %"int[]" undef, i32* %121, 0 - %123 = insertvalue %"int[]" %122, i64 3, 1 - %124 = load %"int[][]", %"int[][]"* %a, align 8 - %125 = extractvalue %"int[][]" %124, 0 - %ptroffset43 = getelementptr inbounds %"int[]", %"int[]"* %125, i64 0 - store %"int[]" %123, %"int[]"* %ptroffset43, align 8 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2 }, %"char[]"* %taddr45, align 8 - %126 = bitcast %"char[]"* %taddr45 to { i8*, i64 }* - %127 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %126, i32 0, i32 0 - %lo46 = load i8*, i8** %127, align 8 - %128 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %126, i32 0, i32 1 - %hi47 = load i64, i64* %128, align 8 - %129 = bitcast %"int[][]"* %a to i8* - %130 = insertvalue %variant undef, i8* %129, 0 - %131 = insertvalue %variant %130, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 - %132 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots49, i64 0, i64 0 - store %variant %131, %variant* %132, align 16 - %133 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 1 - store i64 1, i64* %133, align 8 - %134 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 0 - %135 = bitcast [1 x %variant]* %varargslots49 to %variant* - store %variant* %135, %variant** %134, align 8 - %136 = bitcast %"variant[]"* %vararg48 to { i8*, i64 }* - %137 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %136, i32 0, i32 0 - %lo50 = load i8*, i8** %137, align 8 - %138 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %136, i32 0, i32 1 - %hi51 = load i64, i64* %138, align 8 - %139 = call i64 @std_io_printfln(i64* %retparam44, i8* %lo46, i64 %hi47, i8* %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %139, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 +voiderr31: ; preds = %after_check30, %voiderr21 + %109 = getelementptr inbounds <6 x i32>, <6 x i32>* %y, i64 0, i64 2 + %110 = insertvalue %"int[]" undef, i32* %109, 0 + %111 = insertvalue %"int[]" %110, i64 3, 1 + %112 = load %"int[][]", %"int[][]"* %a, align 8 + %113 = extractvalue %"int[][]" %112, 0 + %ptroffset32 = getelementptr inbounds %"int[]", %"int[]"* %113, i64 0 + store %"int[]" %111, %"int[]"* %ptroffset32, align 8 + %114 = bitcast %"int[][]"* %a to i8* + %115 = insertvalue %variant undef, i8* %114, 0 + %116 = insertvalue %variant %115, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1 + %117 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots34, i64 0, i64 0 + store %variant %116, %variant* %117, align 16 + %118 = bitcast [1 x %variant]* %varargslots34 to %variant* + %119 = insertvalue %"variant[]" undef, %variant* %118, 0 + %120 = insertvalue %"variant[]" %119, i64 1, 1 + store %"variant[]" %120, %"variant[]"* %taddr35, align 8 + %121 = bitcast %"variant[]"* %taddr35 to { i8*, i64 }* + %122 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %121, i32 0, i32 0 + %lo36 = load i8*, i8** %122, align 8 + %123 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %121, i32 0, i32 1 + %hi37 = load i64, i64* %123, align 8 + %124 = call i64 @std_io_printfln(i64* %retparam33, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2, i8* %lo36, i64 %hi37) + %not_err38 = icmp eq i64 %124, 0 + br i1 %not_err38, label %after_check39, label %voiderr40 -after_check53: ; preds = %voiderr42 - br label %voiderr54 +after_check39: ; preds = %voiderr31 + br label %voiderr40 -voiderr54: ; preds = %after_check53, %voiderr42 +voiderr40: ; preds = %after_check39, %voiderr31 ret void } diff --git a/test/test_suite/statements/foreach_more_implementations.c3t b/test/test_suite/statements/foreach_more_implementations.c3t index bbc629b2a..ae21391d5 100644 --- a/test/test_suite/statements/foreach_more_implementations.c3t +++ b/test/test_suite/statements/foreach_more_implementations.c3t @@ -51,19 +51,17 @@ entry: %vector2 = alloca %Vector*, align 8 %element = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 + %.anon4 = alloca i64, align 8 + %vector5 = alloca %Vector, align 8 %.anon6 = alloca i64, align 8 - %vector7 = alloca %Vector, align 8 - %.anon8 = alloca i64, align 8 %i = alloca i32, align 4 - %vector12 = alloca %Vector*, align 8 - %element13 = alloca i64, align 8 - %retparam15 = alloca i64, align 8 - %taddr16 = alloca %"char[]", align 8 - %vararg19 = alloca %"variant[]", align 8 - %varargslots20 = alloca [1 x %variant], align 16 + %vector10 = alloca %Vector*, align 8 + %element11 = alloca i64, align 8 + %retparam13 = alloca i64, align 8 + %varargslots14 = alloca [1 x %variant], align 16 + %taddr15 = alloca %"variant[]", align 8 %0 = bitcast [2 x i32]* %x to i8* call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([2 x i32]* @.__const to i8*), i32 8, i1 false) %1 = getelementptr inbounds %Vector, %Vector* %v, i32 0, i32 0 @@ -96,106 +94,92 @@ loop.body: ; preds = %loop.cond %13 = load i64, i64* %element, align 8 %ptroffset = getelementptr inbounds i32, i32* %12, i64 %13 store i32* %ptroffset, i32** %ref, align 8 - store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 3 }, %"char[]"* %taddr, align 8 - %14 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 0 - %lo = load i8*, i8** %15, align 8 - %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 1 - %hi = load i64, i64* %16, align 8 - %17 = load i32*, i32** %ref, align 8 - %18 = bitcast i32* %17 to i8* - %19 = insertvalue %variant undef, i8* %18, 0 - %20 = insertvalue %variant %19, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %21 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %20, %variant* %21, align 16 - %22 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %22, align 8 - %23 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %24 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %24, %variant** %23, align 8 - %25 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 0 - %lo3 = load i8*, i8** %26, align 8 - %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 1 - %hi4 = load i64, i64* %27, align 8 - %28 = call i64 @std_io_printf(i64* %retparam, i8* %lo, i64 %hi, i8* %lo3, i64 %hi4) - %not_err = icmp eq i64 %28, 0 + %14 = load i32*, i32** %ref, align 8 + %15 = bitcast i32* %14 to i8* + %16 = insertvalue %variant undef, i8* %15, 0 + %17 = insertvalue %variant %16, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %18 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %17, %variant* %18, align 16 + %19 = bitcast [1 x %variant]* %varargslots to %variant* + %20 = insertvalue %"variant[]" undef, %variant* %19, 0 + %21 = insertvalue %"variant[]" %20, i64 1, 1 + store %"variant[]" %21, %"variant[]"* %taddr, align 8 + %22 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0 + %lo = load i8*, i8** %23, align 8 + %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1 + %hi = load i64, i64* %24, align 8 + %25 = call i64 @std_io_printf(i64* %retparam, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 3, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %25, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %loop.body br label %voiderr voiderr: ; preds = %after_check, %loop.body - %29 = load i32*, i32** %ref, align 8 - %30 = load i32, i32* %29, align 8 - %add = add i32 %30, 2 - store i32 %add, i32* %29, align 8 - %31 = load i64, i64* %.anon1, align 8 - %add5 = add i64 %31, 1 - store i64 %add5, i64* %.anon1, align 8 + %26 = load i32*, i32** %ref, align 8 + %27 = load i32, i32* %26, align 8 + %add = add i32 %27, 2 + store i32 %add, i32* %26, align 8 + %28 = load i64, i64* %.anon1, align 8 + %add3 = add i64 %28, 1 + store i64 %add3, i64* %.anon1, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - %32 = bitcast %Vector* %vector7 to i8* - %33 = bitcast %Vector* %v to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %32, i8* align 8 %33, i32 16, i1 false) - %34 = getelementptr inbounds %Vector, %Vector* %vector7, i32 0, i32 0 - %35 = load i64, i64* %34, align 8 - store i64 %35, i64* %.anon6, align 8 - store i64 0, i64* %.anon8, align 8 - br label %loop.cond9 + %29 = bitcast %Vector* %vector5 to i8* + %30 = bitcast %Vector* %v to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %29, i8* align 8 %30, i32 16, i1 false) + %31 = getelementptr inbounds %Vector, %Vector* %vector5, i32 0, i32 0 + %32 = load i64, i64* %31, align 8 + store i64 %32, i64* %.anon4, align 8 + store i64 0, i64* %.anon6, align 8 + br label %loop.cond7 -loop.cond9: ; preds = %voiderr25, %loop.exit - %36 = load i64, i64* %.anon8, align 8 - %37 = load i64, i64* %.anon6, align 8 - %lt10 = icmp ult i64 %36, %37 - br i1 %lt10, label %loop.body11, label %loop.exit27 +loop.cond7: ; preds = %voiderr20, %loop.exit + %33 = load i64, i64* %.anon6, align 8 + %34 = load i64, i64* %.anon4, align 8 + %lt8 = icmp ult i64 %33, %34 + br i1 %lt8, label %loop.body9, label %loop.exit22 -loop.body11: ; preds = %loop.cond9 - store %Vector* %v, %Vector** %vector12, align 8 - %38 = load i64, i64* %.anon8, align 8 - store i64 %38, i64* %element13, align 8 - %39 = load %Vector*, %Vector** %vector12, align 8 - %40 = getelementptr inbounds %Vector, %Vector* %39, i32 0, i32 1 - %41 = load i32*, i32** %40, align 8 - %42 = load i64, i64* %element13, align 8 - %ptroffset14 = getelementptr inbounds i32, i32* %41, i64 %42 - %43 = load i32, i32* %ptroffset14, align 4 - store i32 %43, i32* %i, align 4 - store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3 }, %"char[]"* %taddr16, align 8 - %44 = bitcast %"char[]"* %taddr16 to { i8*, i64 }* - %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0 - %lo17 = load i8*, i8** %45, align 8 - %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1 - %hi18 = load i64, i64* %46, align 8 - %47 = bitcast i32* %i to i8* - %48 = insertvalue %variant undef, i8* %47, 0 - %49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %50 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots20, i64 0, i64 0 - store %variant %49, %variant* %50, align 16 - %51 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg19, i32 0, i32 1 - store i64 1, i64* %51, align 8 - %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg19, i32 0, i32 0 - %53 = bitcast [1 x %variant]* %varargslots20 to %variant* - store %variant* %53, %variant** %52, align 8 - %54 = bitcast %"variant[]"* %vararg19 to { i8*, i64 }* - %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 0 - %lo21 = load i8*, i8** %55, align 8 - %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 1 - %hi22 = load i64, i64* %56, align 8 - %57 = call i64 @std_io_printf(i64* %retparam15, i8* %lo17, i64 %hi18, i8* %lo21, i64 %hi22) - %not_err23 = icmp eq i64 %57, 0 - br i1 %not_err23, label %after_check24, label %voiderr25 +loop.body9: ; preds = %loop.cond7 + store %Vector* %v, %Vector** %vector10, align 8 + %35 = load i64, i64* %.anon6, align 8 + store i64 %35, i64* %element11, align 8 + %36 = load %Vector*, %Vector** %vector10, align 8 + %37 = getelementptr inbounds %Vector, %Vector* %36, i32 0, i32 1 + %38 = load i32*, i32** %37, align 8 + %39 = load i64, i64* %element11, align 8 + %ptroffset12 = getelementptr inbounds i32, i32* %38, i64 %39 + %40 = load i32, i32* %ptroffset12, align 4 + store i32 %40, i32* %i, align 4 + %41 = bitcast i32* %i to i8* + %42 = insertvalue %variant undef, i8* %41, 0 + %43 = insertvalue %variant %42, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %44 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots14, i64 0, i64 0 + store %variant %43, %variant* %44, align 16 + %45 = bitcast [1 x %variant]* %varargslots14 to %variant* + %46 = insertvalue %"variant[]" undef, %variant* %45, 0 + %47 = insertvalue %"variant[]" %46, i64 1, 1 + store %"variant[]" %47, %"variant[]"* %taddr15, align 8 + %48 = bitcast %"variant[]"* %taddr15 to { i8*, i64 }* + %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 0 + %lo16 = load i8*, i8** %49, align 8 + %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 1 + %hi17 = load i64, i64* %50, align 8 + %51 = call i64 @std_io_printf(i64* %retparam13, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3, i8* %lo16, i64 %hi17) + %not_err18 = icmp eq i64 %51, 0 + br i1 %not_err18, label %after_check19, label %voiderr20 -after_check24: ; preds = %loop.body11 - br label %voiderr25 +after_check19: ; preds = %loop.body9 + br label %voiderr20 -voiderr25: ; preds = %after_check24, %loop.body11 - %58 = load i64, i64* %.anon8, align 8 - %add26 = add i64 %58, 1 - store i64 %add26, i64* %.anon8, align 8 - br label %loop.cond9 +voiderr20: ; preds = %after_check19, %loop.body9 + %52 = load i64, i64* %.anon6, align 8 + %add21 = add i64 %52, 1 + store i64 %add21, i64* %.anon6, align 8 + br label %loop.cond7 -loop.exit27: ; preds = %loop.cond9 +loop.exit22: ; preds = %loop.cond7 ret void } \ No newline at end of file diff --git a/test/test_suite/stdlib/map.c3t b/test/test_suite/stdlib/map.c3t index 1572a3dd0..974fa9b39 100644 --- a/test/test_suite/stdlib/map.c3t +++ b/test/test_suite/stdlib/map.c3t @@ -74,59 +74,56 @@ if.exit: ; preds = %if.then, %entry ret void } +declare void @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_init"(%HashMap*, i32, float, %Allocator*) + +declare i8 @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_set"(%HashMap*, i64, { i8*, i64 } (i8*, %Allocator*)*) + +; Function Attrs: nounwind define { i8*, i64 } @test_Foo_to_string(%Foo* %0, %Allocator* %1) #0 { entry: %s = alloca i8*, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 %result = alloca %"char[]", align 8 %2 = call i8* @std_core_string_new_with_capacity(i64 128, %Allocator* %1) store i8* %2, i8** %s, align 8 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8 - %3 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %3, i32 0, i32 0 - %lo = load i8*, i8** %4, align 8 - %5 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %3, i32 0, i32 1 - %hi = load i64, i64* %5, align 8 - %6 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 0 - %7 = bitcast i32* %6 to i8* - %8 = insertvalue %variant undef, i8* %7, 0 - %9 = insertvalue %variant %8, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %10 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 - store %variant %9, %variant* %10, align 16 - %11 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 1 - %12 = bitcast i8** %11 to i8* - %13 = insertvalue %variant undef, i8* %12, 0 - %14 = insertvalue %variant %13, i64 ptrtoint (%.introspect* @"ct$p$void" to i64), 1 - %15 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 - store %variant %14, %variant* %15, align 16 - %16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 2, i64* %16, align 8 - %17 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %18 = bitcast [2 x %variant]* %varargslots to %variant* - store %variant* %18, %variant** %17, align 8 - %19 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %19, i32 0, i32 0 - %lo1 = load i8*, i8** %20, align 8 - %21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %19, i32 0, i32 1 - %hi2 = load i64, i64* %21, align 8 - %22 = call i64 @std_core_string_String_printf(i64* %retparam, i8** %s, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) - %not_err = icmp eq i64 %22, 0 + %3 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 0 + %4 = bitcast i32* %3 to i8* + %5 = insertvalue %variant undef, i8* %4, 0 + %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %7 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0 + store %variant %6, %variant* %7, align 16 + %8 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 1 + %9 = bitcast i8** %8 to i8* + %10 = insertvalue %variant undef, i8* %9, 0 + %11 = insertvalue %variant %10, i64 ptrtoint (%.introspect* @"ct$p$void" to i64), 1 + %12 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1 + store %variant %11, %variant* %12, align 16 + %13 = bitcast [2 x %variant]* %varargslots to %variant* + %14 = insertvalue %"variant[]" undef, %variant* %13, 0 + %15 = insertvalue %"variant[]" %14, i64 2, 1 + store %"variant[]" %15, %"variant[]"* %taddr, align 8 + %16 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 0 + %lo = load i8*, i8** %17, align 8 + %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 1 + %hi = load i64, i64* %18, align 8 + %19 = call i64 @std_core_string_String_printf(i64* %retparam, i8** %s, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i32 0, i32 0), i64 8, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %19, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %23 = load i8*, i8** %s, align 8 - %24 = call { i8*, i64 } @std_core_string_String_str(i8* %23) - %25 = bitcast %"char[]"* %result to { i8*, i64 }* - store { i8*, i64 } %24, { i8*, i64 }* %25, align 8 - %26 = bitcast %"char[]"* %result to { i8*, i64 }* - %27 = load { i8*, i64 }, { i8*, i64 }* %26, align 8 - ret { i8*, i64 } %27 + %20 = load i8*, i8** %s, align 8 + %21 = call { i8*, i64 } @std_core_string_String_str(i8* %20) + %22 = bitcast %"char[]"* %result to { i8*, i64 }* + store { i8*, i64 } %21, { i8*, i64 }* %22, align 8 + %23 = bitcast %"char[]"* %result to { i8*, i64 }* + %24 = load { i8*, i64 }, { i8*, i64 }* %23, align 8 + ret { i8*, i64 } %24 } ; Function Attrs: nounwind @@ -134,527 +131,432 @@ define void @test_main() #0 { entry: %map = alloca %HashMap.0, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 + %taddr = alloca %"variant[]", align 8 %literal = alloca %Foo, align 8 - %retparam5 = alloca i64, align 8 - %taddr6 = alloca %"char[]", align 8 - %vararg9 = alloca %"variant[]", align 8 - %varargslots10 = alloca [1 x %variant], align 16 - %literal16 = alloca %Foo, align 8 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 - %varargslots24 = alloca [1 x %variant], align 16 - %retparam30 = alloca i64, align 8 - %taddr31 = alloca %"char[]", align 8 - %vararg34 = alloca %"variant[]", align 8 - %varargslots35 = alloca [1 x %variant], align 16 - %retparam36 = alloca %Foo, align 8 - %retparam44 = alloca i64, align 8 - %taddr45 = alloca %"char[]", align 8 - %vararg48 = alloca %"variant[]", align 8 - %varargslots49 = alloca [1 x %variant], align 16 - %taddr50 = alloca i8, align 1 - %retparam56 = alloca i64, align 8 - %taddr57 = alloca %"char[]", align 8 - %vararg60 = alloca %"variant[]", align 8 - %varargslots61 = alloca [1 x %variant], align 16 - %taddr62 = alloca i8, align 1 - %literal68 = alloca %Foo, align 8 - %retparam71 = alloca i64, align 8 - %taddr72 = alloca %"char[]", align 8 - %vararg75 = alloca %"variant[]", align 8 - %varargslots76 = alloca [1 x %variant], align 16 + %retparam3 = alloca i64, align 8 + %varargslots4 = alloca [1 x %variant], align 16 + %taddr5 = alloca %"variant[]", align 8 + %literal11 = alloca %Foo, align 8 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [1 x %variant], align 16 + %taddr16 = alloca %"variant[]", align 8 + %retparam22 = alloca i64, align 8 + %varargslots23 = alloca [1 x %variant], align 16 + %retparam24 = alloca %Foo, align 8 + %taddr27 = alloca %"variant[]", align 8 + %retparam33 = alloca i64, align 8 + %varargslots34 = alloca [1 x %variant], align 16 + %taddr35 = alloca i8, align 1 + %taddr36 = alloca %"variant[]", align 8 + %retparam42 = alloca i64, align 8 + %varargslots43 = alloca [1 x %variant], align 16 + %taddr44 = alloca i8, align 1 + %taddr45 = alloca %"variant[]", align 8 + %literal51 = alloca %Foo, align 8 + %retparam54 = alloca i64, align 8 + %varargslots55 = alloca [1 x %variant], align 16 %result = alloca %"Foo[]", align 8 + %taddr56 = alloca %"variant[]", align 8 %map2 = alloca %HashMap.3, align 8 - %retparam82 = alloca i64, align 8 - %taddr83 = alloca %"char[]", align 8 - %vararg86 = alloca %"variant[]", align 8 - %varargslots87 = alloca [1 x %variant], align 16 - %taddr88 = alloca i8, align 1 - %retparam94 = alloca i64, align 8 - %taddr95 = alloca %"char[]", align 8 - %vararg98 = alloca %"variant[]", align 8 - %varargslots99 = alloca [1 x %variant], align 16 - %taddr100 = alloca i8, align 1 - %retparam106 = alloca i64, align 8 - %taddr107 = alloca %"char[]", align 8 - %vararg110 = alloca %"variant[]", align 8 - %varargslots111 = alloca [1 x %variant], align 16 - %result112 = alloca %"int[]", align 8 - %retparam118 = alloca i64, align 8 - %taddr119 = alloca %"char[]", align 8 - %vararg122 = alloca %"variant[]", align 8 - %varargslots123 = alloca [1 x %variant], align 16 - %result124 = alloca %"double[]", align 8 + %retparam62 = alloca i64, align 8 + %varargslots63 = alloca [1 x %variant], align 16 + %taddr64 = alloca i8, align 1 + %taddr65 = alloca %"variant[]", align 8 + %retparam71 = alloca i64, align 8 + %varargslots72 = alloca [1 x %variant], align 16 + %taddr73 = alloca i8, align 1 + %taddr74 = alloca %"variant[]", align 8 + %retparam80 = alloca i64, align 8 + %varargslots81 = alloca [1 x %variant], align 16 + %result82 = alloca %"int[]", align 8 + %taddr83 = alloca %"variant[]", align 8 + %retparam89 = alloca i64, align 8 + %varargslots90 = alloca [1 x %variant], align 16 + %result91 = alloca %"double[]", align 8 + %taddr92 = alloca %"variant[]", align 8 %temp = alloca %TempAllocator*, align 8 %error_var = alloca i64, align 8 - %retparam130 = alloca %TempAllocator*, align 8 + %retparam98 = alloca %TempAllocator*, align 8 %mark = alloca i64, align 8 %map3 = alloca %HashMap.3, align 8 - %retparam133 = alloca i64, align 8 - %taddr134 = alloca %"char[]", align 8 - %vararg137 = alloca %"variant[]", align 8 - %varargslots138 = alloca [1 x %variant], align 16 - %result139 = alloca %"int[]", align 8 + %retparam101 = alloca i64, align 8 + %varargslots102 = alloca [1 x %variant], align 16 + %result103 = alloca %"int[]", align 8 + %taddr104 = alloca %"variant[]", align 8 %0 = bitcast %HashMap.0* %map to i8* call void @llvm.memset.p0i8.i64(i8* align 8 %0, i8 0, i64 40, i1 false) call void @"std_map$$int.test_Foo_HashMap_tinit"(%HashMap.0* %map, i32 16, float 7.500000e-01) - store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0), i64 12 }, %"char[]"* %taddr, align 8 - %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 - %lo = load i8*, i8** %2, align 8 - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 - %hi = load i64, i64* %3, align 8 - %4 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2 - %5 = bitcast i32* %4 to i8* - %6 = insertvalue %variant undef, i8* %5, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %8 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %7, %variant* %8, align 16 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %9, align 8 - %10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %11 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %11, %variant** %10, align 8 - %12 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 0 - %lo1 = load i8*, i8** %13, align 8 - %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 1 - %hi2 = load i64, i64* %14, align 8 - %15 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) - %not_err = icmp eq i64 %15, 0 + %1 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2 + %2 = bitcast i32* %1 to i8* + %3 = insertvalue %variant undef, i8* %2, 0 + %4 = insertvalue %variant %3, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %5 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %4, %variant* %5, align 16 + %6 = bitcast [1 x %variant]* %varargslots to %variant* + %7 = insertvalue %"variant[]" undef, %variant* %6, 0 + %8 = insertvalue %"variant[]" %7, i64 1, 1 + store %"variant[]" %8, %"variant[]"* %taddr, align 8 + %9 = bitcast %"variant[]"* %taddr to { i8*, i64 }* + %10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %9, i32 0, i32 0 + %lo = load i8*, i8** %10, align 8 + %11 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %9, i32 0, i32 1 + %hi = load i64, i64* %11, align 8 + %12 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0), i64 12, i8* %lo, i64 %hi) + %not_err = icmp eq i64 %12, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %16 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0 - store i32 1, i32* %16, align 8 - %17 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1 - store i8* null, i8** %17, align 8 - %18 = bitcast %Foo* %literal to { i64, i8* }* - %19 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %18, i32 0, i32 0 - %lo3 = load i64, i64* %19, align 8 - %20 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %18, i32 0, i32 1 - %hi4 = load i8*, i8** %20, align 8 - %21 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo3, i8* %hi4) - store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i32 0, i32 0), i64 12 }, %"char[]"* %taddr6, align 8 - %22 = bitcast %"char[]"* %taddr6 to { i8*, i64 }* - %23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0 - %lo7 = load i8*, i8** %23, align 8 - %24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1 - %hi8 = load i64, i64* %24, align 8 - %25 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2 - %26 = bitcast i32* %25 to i8* - %27 = insertvalue %variant undef, i8* %26, 0 - %28 = insertvalue %variant %27, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %29 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots10, i64 0, i64 0 - store %variant %28, %variant* %29, align 16 - %30 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 1 - store i64 1, i64* %30, align 8 - %31 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 0 - %32 = bitcast [1 x %variant]* %varargslots10 to %variant* - store %variant* %32, %variant** %31, align 8 - %33 = bitcast %"variant[]"* %vararg9 to { i8*, i64 }* - %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 0 - %lo11 = load i8*, i8** %34, align 8 - %35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 1 - %hi12 = load i64, i64* %35, align 8 - %36 = call i64 @std_io_printfln(i64* %retparam5, i8* %lo7, i64 %hi8, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %36, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %13 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0 + store i32 1, i32* %13, align 8 + %14 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1 + store i8* null, i8** %14, align 8 + %15 = bitcast %Foo* %literal to { i64, i8* }* + %16 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %15, i32 0, i32 0 + %lo1 = load i64, i64* %16, align 8 + %17 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %15, i32 0, i32 1 + %hi2 = load i8*, i8** %17, align 8 + %18 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo1, i8* %hi2) + %19 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2 + %20 = bitcast i32* %19 to i8* + %21 = insertvalue %variant undef, i8* %20, 0 + %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %23 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots4, i64 0, i64 0 + store %variant %22, %variant* %23, align 16 + %24 = bitcast [1 x %variant]* %varargslots4 to %variant* + %25 = insertvalue %"variant[]" undef, %variant* %24, 0 + %26 = insertvalue %"variant[]" %25, i64 1, 1 + store %"variant[]" %26, %"variant[]"* %taddr5, align 8 + %27 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }* + %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 + %lo6 = load i8*, i8** %28, align 8 + %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 + %hi7 = load i64, i64* %29, align 8 + %30 = call i64 @std_io_printfln(i64* %retparam3, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i32 0, i32 0), i64 12, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %30, 0 + br i1 %not_err8, label %after_check9, label %voiderr10 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check9: ; preds = %voiderr + br label %voiderr10 -voiderr15: ; preds = %after_check14, %voiderr - %37 = getelementptr inbounds %Foo, %Foo* %literal16, i32 0, i32 0 - store i32 2, i32* %37, align 8 - %38 = getelementptr inbounds %Foo, %Foo* %literal16, i32 0, i32 1 - store i8* null, i8** %38, align 8 - %39 = bitcast %Foo* %literal16 to { i64, i8* }* - %40 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %39, i32 0, i32 0 - %lo17 = load i64, i64* %40, align 8 - %41 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %39, i32 0, i32 1 - %hi18 = load i8*, i8** %41, align 8 - %42 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo17, i8* %hi18) - store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i32 0, i32 0), i64 12 }, %"char[]"* %taddr20, align 8 - %43 = bitcast %"char[]"* %taddr20 to { i8*, i64 }* - %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0 - %lo21 = load i8*, i8** %44, align 8 - %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1 - %hi22 = load i64, i64* %45, align 8 - %46 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2 - %47 = bitcast i32* %46 to i8* - %48 = insertvalue %variant undef, i8* %47, 0 - %49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 - %50 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0 - store %variant %49, %variant* %50, align 16 - %51 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1 - store i64 1, i64* %51, align 8 - %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0 - %53 = bitcast [1 x %variant]* %varargslots24 to %variant* - store %variant* %53, %variant** %52, align 8 - %54 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }* - %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 0 - %lo25 = load i8*, i8** %55, align 8 - %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 1 - %hi26 = load i64, i64* %56, align 8 - %57 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %57, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 +voiderr10: ; preds = %after_check9, %voiderr + %31 = getelementptr inbounds %Foo, %Foo* %literal11, i32 0, i32 0 + store i32 2, i32* %31, align 8 + %32 = getelementptr inbounds %Foo, %Foo* %literal11, i32 0, i32 1 + store i8* null, i8** %32, align 8 + %33 = bitcast %Foo* %literal11 to { i64, i8* }* + %34 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %33, i32 0, i32 0 + %lo12 = load i64, i64* %34, align 8 + %35 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %33, i32 0, i32 1 + %hi13 = load i8*, i8** %35, align 8 + %36 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo12, i8* %hi13) + %37 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2 + %38 = bitcast i32* %37 to i8* + %39 = insertvalue %variant undef, i8* %38, 0 + %40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1 + %41 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots15, i64 0, i64 0 + store %variant %40, %variant* %41, align 16 + %42 = bitcast [1 x %variant]* %varargslots15 to %variant* + %43 = insertvalue %"variant[]" undef, %variant* %42, 0 + %44 = insertvalue %"variant[]" %43, i64 1, 1 + store %"variant[]" %44, %"variant[]"* %taddr16, align 8 + %45 = bitcast %"variant[]"* %taddr16 to { i8*, i64 }* + %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 + %lo17 = load i8*, i8** %46, align 8 + %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 + %hi18 = load i64, i64* %47, align 8 + %48 = call i64 @std_io_printfln(i64* %retparam14, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i32 0, i32 0), i64 12, i8* %lo17, i64 %hi18) + %not_err19 = icmp eq i64 %48, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 -after_check28: ; preds = %voiderr15 - br label %voiderr29 +after_check20: ; preds = %voiderr10 + br label %voiderr21 -voiderr29: ; preds = %after_check28, %voiderr15 - store %"char[]" { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i32 0, i32 0), i64 7 }, %"char[]"* %taddr31, align 8 - %58 = bitcast %"char[]"* %taddr31 to { i8*, i64 }* +voiderr21: ; preds = %after_check20, %voiderr10 + %49 = call i64 @"std_map$$int.test_Foo_HashMap_get"(%Foo* %retparam24, %HashMap.0* %map, i32 1) + %not_err25 = icmp eq i64 %49, 0 + br i1 %not_err25, label %after_check26, label %voiderr32 + +after_check26: ; preds = %voiderr21 + %50 = getelementptr inbounds %Foo, %Foo* %retparam24, i32 0, i32 0 + %51 = bitcast i32* %50 to i8* + %52 = insertvalue %variant undef, i8* %51, 0 + %53 = insertvalue %variant %52, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %54 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots23, i64 0, i64 0 + store %variant %53, %variant* %54, align 16 + %55 = bitcast [1 x %variant]* %varargslots23 to %variant* + %56 = insertvalue %"variant[]" undef, %variant* %55, 0 + %57 = insertvalue %"variant[]" %56, i64 1, 1 + store %"variant[]" %57, %"variant[]"* %taddr27, align 8 + %58 = bitcast %"variant[]"* %taddr27 to { i8*, i64 }* %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0 - %lo32 = load i8*, i8** %59, align 8 + %lo28 = load i8*, i8** %59, align 8 %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1 - %hi33 = load i64, i64* %60, align 8 - %61 = call i64 @"std_map$$int.test_Foo_HashMap_get"(%Foo* %retparam36, %HashMap.0* %map, i32 1) - %not_err37 = icmp eq i64 %61, 0 - br i1 %not_err37, label %after_check38, label %voiderr43 + %hi29 = load i64, i64* %60, align 8 + %61 = call i64 @std_io_printfln(i64* %retparam22, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i32 0, i32 0), i64 7, i8* %lo28, i64 %hi29) + %not_err30 = icmp eq i64 %61, 0 + br i1 %not_err30, label %after_check31, label %voiderr32 -after_check38: ; preds = %voiderr29 - %62 = getelementptr inbounds %Foo, %Foo* %retparam36, i32 0, i32 0 - %63 = bitcast i32* %62 to i8* - %64 = insertvalue %variant undef, i8* %63, 0 - %65 = insertvalue %variant %64, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %66 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots35, i64 0, i64 0 - store %variant %65, %variant* %66, align 16 - %67 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 1 - store i64 1, i64* %67, align 8 - %68 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 0 - %69 = bitcast [1 x %variant]* %varargslots35 to %variant* - store %variant* %69, %variant** %68, align 8 - %70 = bitcast %"variant[]"* %vararg34 to { i8*, i64 }* - %71 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 0 - %lo39 = load i8*, i8** %71, align 8 - %72 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 1 - %hi40 = load i64, i64* %72, align 8 - %73 = call i64 @std_io_printfln(i64* %retparam30, i8* %lo32, i64 %hi33, i8* %lo39, i64 %hi40) - %not_err41 = icmp eq i64 %73, 0 - br i1 %not_err41, label %after_check42, label %voiderr43 +after_check31: ; preds = %after_check26 + br label %voiderr32 -after_check42: ; preds = %after_check38 - br label %voiderr43 +voiderr32: ; preds = %after_check31, %after_check26, %voiderr21 + %62 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 1) + store i8 %62, i8* %taddr35, align 1 + %63 = insertvalue %variant undef, i8* %taddr35, 0 + %64 = insertvalue %variant %63, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %65 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots34, i64 0, i64 0 + store %variant %64, %variant* %65, align 16 + %66 = bitcast [1 x %variant]* %varargslots34 to %variant* + %67 = insertvalue %"variant[]" undef, %variant* %66, 0 + %68 = insertvalue %"variant[]" %67, i64 1, 1 + store %"variant[]" %68, %"variant[]"* %taddr36, align 8 + %69 = bitcast %"variant[]"* %taddr36 to { i8*, i64 }* + %70 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %69, i32 0, i32 0 + %lo37 = load i8*, i8** %70, align 8 + %71 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %69, i32 0, i32 1 + %hi38 = load i64, i64* %71, align 8 + %72 = call i64 @std_io_printfln(i64* %retparam33, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i32 0, i32 0), i64 9, i8* %lo37, i64 %hi38) + %not_err39 = icmp eq i64 %72, 0 + br i1 %not_err39, label %after_check40, label %voiderr41 -voiderr43: ; preds = %after_check42, %after_check38, %voiderr29 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i32 0, i32 0), i64 9 }, %"char[]"* %taddr45, align 8 - %74 = bitcast %"char[]"* %taddr45 to { i8*, i64 }* - %75 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 0 - %lo46 = load i8*, i8** %75, align 8 - %76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 1 - %hi47 = load i64, i64* %76, align 8 - %77 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 1) - store i8 %77, i8* %taddr50, align 1 - %78 = insertvalue %variant undef, i8* %taddr50, 0 - %79 = insertvalue %variant %78, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %80 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots49, i64 0, i64 0 - store %variant %79, %variant* %80, align 16 - %81 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 1 - store i64 1, i64* %81, align 8 - %82 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 0 - %83 = bitcast [1 x %variant]* %varargslots49 to %variant* - store %variant* %83, %variant** %82, align 8 - %84 = bitcast %"variant[]"* %vararg48 to { i8*, i64 }* - %85 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %84, i32 0, i32 0 - %lo51 = load i8*, i8** %85, align 8 - %86 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %84, i32 0, i32 1 - %hi52 = load i64, i64* %86, align 8 - %87 = call i64 @std_io_printfln(i64* %retparam44, i8* %lo46, i64 %hi47, i8* %lo51, i64 %hi52) - %not_err53 = icmp eq i64 %87, 0 - br i1 %not_err53, label %after_check54, label %voiderr55 +after_check40: ; preds = %voiderr32 + br label %voiderr41 -after_check54: ; preds = %voiderr43 - br label %voiderr55 +voiderr41: ; preds = %after_check40, %voiderr32 + %73 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 2) + store i8 %73, i8* %taddr44, align 1 + %74 = insertvalue %variant undef, i8* %taddr44, 0 + %75 = insertvalue %variant %74, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %76 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots43, i64 0, i64 0 + store %variant %75, %variant* %76, align 16 + %77 = bitcast [1 x %variant]* %varargslots43 to %variant* + %78 = insertvalue %"variant[]" undef, %variant* %77, 0 + %79 = insertvalue %"variant[]" %78, i64 1, 1 + store %"variant[]" %79, %"variant[]"* %taddr45, align 8 + %80 = bitcast %"variant[]"* %taddr45 to { i8*, i64 }* + %81 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 0 + %lo46 = load i8*, i8** %81, align 8 + %82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 1 + %hi47 = load i64, i64* %82, align 8 + %83 = call i64 @std_io_printfln(i64* %retparam42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i32 0, i32 0), i64 9, i8* %lo46, i64 %hi47) + %not_err48 = icmp eq i64 %83, 0 + br i1 %not_err48, label %after_check49, label %voiderr50 -voiderr55: ; preds = %after_check54, %voiderr43 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i32 0, i32 0), i64 9 }, %"char[]"* %taddr57, align 8 - %88 = bitcast %"char[]"* %taddr57 to { i8*, i64 }* - %89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 0 - %lo58 = load i8*, i8** %89, align 8 - %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 1 - %hi59 = load i64, i64* %90, align 8 - %91 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 2) - store i8 %91, i8* %taddr62, align 1 - %92 = insertvalue %variant undef, i8* %taddr62, 0 - %93 = insertvalue %variant %92, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %94 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots61, i64 0, i64 0 - store %variant %93, %variant* %94, align 16 - %95 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg60, i32 0, i32 1 - store i64 1, i64* %95, align 8 - %96 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg60, i32 0, i32 0 - %97 = bitcast [1 x %variant]* %varargslots61 to %variant* - store %variant* %97, %variant** %96, align 8 - %98 = bitcast %"variant[]"* %vararg60 to { i8*, i64 }* - %99 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %98, i32 0, i32 0 - %lo63 = load i8*, i8** %99, align 8 - %100 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %98, i32 0, i32 1 - %hi64 = load i64, i64* %100, align 8 - %101 = call i64 @std_io_printfln(i64* %retparam56, i8* %lo58, i64 %hi59, i8* %lo63, i64 %hi64) - %not_err65 = icmp eq i64 %101, 0 - br i1 %not_err65, label %after_check66, label %voiderr67 +after_check49: ; preds = %voiderr41 + br label %voiderr50 -after_check66: ; preds = %voiderr55 - br label %voiderr67 +voiderr50: ; preds = %after_check49, %voiderr41 + %84 = getelementptr inbounds %Foo, %Foo* %literal51, i32 0, i32 0 + store i32 4, i32* %84, align 8 + %85 = getelementptr inbounds %Foo, %Foo* %literal51, i32 0, i32 1 + store i8* null, i8** %85, align 8 + %86 = bitcast %Foo* %literal51 to { i64, i8* }* + %87 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %86, i32 0, i32 0 + %lo52 = load i64, i64* %87, align 8 + %88 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %86, i32 0, i32 1 + %hi53 = load i8*, i8** %88, align 8 + %89 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 7, i64 %lo52, i8* %hi53) + %90 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8 + %91 = call { i8*, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(%HashMap.0* %map, %Allocator* %90) + %92 = bitcast %"Foo[]"* %result to { i8*, i64 }* + store { i8*, i64 } %91, { i8*, i64 }* %92, align 8 + %93 = bitcast %"Foo[]"* %result to i8* + %94 = insertvalue %variant undef, i8* %93, 0 + %95 = insertvalue %variant %94, i64 ptrtoint (%.introspect* @"ct$sa$test_Foo" to i64), 1 + %96 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots55, i64 0, i64 0 + store %variant %95, %variant* %96, align 16 + %97 = bitcast [1 x %variant]* %varargslots55 to %variant* + %98 = insertvalue %"variant[]" undef, %variant* %97, 0 + %99 = insertvalue %"variant[]" %98, i64 1, 1 + store %"variant[]" %99, %"variant[]"* %taddr56, align 8 + %100 = bitcast %"variant[]"* %taddr56 to { i8*, i64 }* + %101 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %100, i32 0, i32 0 + %lo57 = load i8*, i8** %101, align 8 + %102 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %100, i32 0, i32 1 + %hi58 = load i64, i64* %102, align 8 + %103 = call i64 @std_io_printfln(i64* %retparam54, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), i64 10, i8* %lo57, i64 %hi58) + %not_err59 = icmp eq i64 %103, 0 + br i1 %not_err59, label %after_check60, label %voiderr61 -voiderr67: ; preds = %after_check66, %voiderr55 - %102 = getelementptr inbounds %Foo, %Foo* %literal68, i32 0, i32 0 - store i32 4, i32* %102, align 8 - %103 = getelementptr inbounds %Foo, %Foo* %literal68, i32 0, i32 1 - store i8* null, i8** %103, align 8 - %104 = bitcast %Foo* %literal68 to { i64, i8* }* - %105 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %104, i32 0, i32 0 - %lo69 = load i64, i64* %105, align 8 - %106 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %104, i32 0, i32 1 - %hi70 = load i8*, i8** %106, align 8 - %107 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 7, i64 %lo69, i8* %hi70) - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), i64 10 }, %"char[]"* %taddr72, align 8 - %108 = bitcast %"char[]"* %taddr72 to { i8*, i64 }* - %109 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %108, i32 0, i32 0 - %lo73 = load i8*, i8** %109, align 8 - %110 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %108, i32 0, i32 1 - %hi74 = load i64, i64* %110, align 8 - %111 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8 - %112 = call { i8*, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(%HashMap.0* %map, %Allocator* %111) - %113 = bitcast %"Foo[]"* %result to { i8*, i64 }* - store { i8*, i64 } %112, { i8*, i64 }* %113, align 8 - %114 = bitcast %"Foo[]"* %result to i8* - %115 = insertvalue %variant undef, i8* %114, 0 - %116 = insertvalue %variant %115, i64 ptrtoint (%.introspect* @"ct$sa$test_Foo" to i64), 1 - %117 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots76, i64 0, i64 0 - store %variant %116, %variant* %117, align 16 - %118 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg75, i32 0, i32 1 - store i64 1, i64* %118, align 8 - %119 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg75, i32 0, i32 0 - %120 = bitcast [1 x %variant]* %varargslots76 to %variant* - store %variant* %120, %variant** %119, align 8 - %121 = bitcast %"variant[]"* %vararg75 to { i8*, i64 }* - %122 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %121, i32 0, i32 0 - %lo77 = load i8*, i8** %122, align 8 - %123 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %121, i32 0, i32 1 - %hi78 = load i64, i64* %123, align 8 - %124 = call i64 @std_io_printfln(i64* %retparam71, i8* %lo73, i64 %hi74, i8* %lo77, i64 %hi78) - %not_err79 = icmp eq i64 %124, 0 - br i1 %not_err79, label %after_check80, label %voiderr81 +after_check60: ; preds = %voiderr50 + br label %voiderr61 -after_check80: ; preds = %voiderr67 - br label %voiderr81 - -voiderr81: ; preds = %after_check80, %voiderr67 - %125 = bitcast %HashMap.3* %map2 to i8* - call void @llvm.memset.p0i8.i64(i8* align 8 %125, i8 0, i64 40, i1 false) +voiderr61: ; preds = %after_check60, %voiderr50 + %104 = bitcast %HashMap.3* %map2 to i8* + call void @llvm.memset.p0i8.i64(i8* align 8 %104, i8 0, i64 40, i1 false) call void @"std_map$$int.double_HashMap_tinit"(%HashMap.3* %map2, i32 16, float 7.500000e-01) - %126 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 4, double 1.300000e+00) - store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i32 0, i32 0), i64 12 }, %"char[]"* %taddr83, align 8 - %127 = bitcast %"char[]"* %taddr83 to { i8*, i64 }* - %128 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %127, i32 0, i32 0 - %lo84 = load i8*, i8** %128, align 8 - %129 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %127, i32 0, i32 1 - %hi85 = load i64, i64* %129, align 8 - %130 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.300000e+00) - store i8 %130, i8* %taddr88, align 1 - %131 = insertvalue %variant undef, i8* %taddr88, 0 - %132 = insertvalue %variant %131, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %133 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots87, i64 0, i64 0 - store %variant %132, %variant* %133, align 16 - %134 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 1 - store i64 1, i64* %134, align 8 - %135 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 0 - %136 = bitcast [1 x %variant]* %varargslots87 to %variant* - store %variant* %136, %variant** %135, align 8 - %137 = bitcast %"variant[]"* %vararg86 to { i8*, i64 }* - %138 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %137, i32 0, i32 0 - %lo89 = load i8*, i8** %138, align 8 - %139 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %137, i32 0, i32 1 - %hi90 = load i64, i64* %139, align 8 - %140 = call i64 @std_io_printfln(i64* %retparam82, i8* %lo84, i64 %hi85, i8* %lo89, i64 %hi90) - %not_err91 = icmp eq i64 %140, 0 - br i1 %not_err91, label %after_check92, label %voiderr93 + %105 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 4, double 1.300000e+00) + %106 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.300000e+00) + store i8 %106, i8* %taddr64, align 1 + %107 = insertvalue %variant undef, i8* %taddr64, 0 + %108 = insertvalue %variant %107, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %109 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots63, i64 0, i64 0 + store %variant %108, %variant* %109, align 16 + %110 = bitcast [1 x %variant]* %varargslots63 to %variant* + %111 = insertvalue %"variant[]" undef, %variant* %110, 0 + %112 = insertvalue %"variant[]" %111, i64 1, 1 + store %"variant[]" %112, %"variant[]"* %taddr65, align 8 + %113 = bitcast %"variant[]"* %taddr65 to { i8*, i64 }* + %114 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %113, i32 0, i32 0 + %lo66 = load i8*, i8** %114, align 8 + %115 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %113, i32 0, i32 1 + %hi67 = load i64, i64* %115, align 8 + %116 = call i64 @std_io_printfln(i64* %retparam62, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i32 0, i32 0), i64 12, i8* %lo66, i64 %hi67) + %not_err68 = icmp eq i64 %116, 0 + br i1 %not_err68, label %after_check69, label %voiderr70 -after_check92: ; preds = %voiderr81 - br label %voiderr93 +after_check69: ; preds = %voiderr61 + br label %voiderr70 -voiderr93: ; preds = %after_check92, %voiderr81 - store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i64 12 }, %"char[]"* %taddr95, align 8 - %141 = bitcast %"char[]"* %taddr95 to { i8*, i64 }* - %142 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %141, i32 0, i32 0 - %lo96 = load i8*, i8** %142, align 8 - %143 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %141, i32 0, i32 1 - %hi97 = load i64, i64* %143, align 8 - %144 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.200000e+00) - store i8 %144, i8* %taddr100, align 1 - %145 = insertvalue %variant undef, i8* %taddr100, 0 - %146 = insertvalue %variant %145, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 - %147 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots99, i64 0, i64 0 - store %variant %146, %variant* %147, align 16 - %148 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 1 - store i64 1, i64* %148, align 8 - %149 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 0 - %150 = bitcast [1 x %variant]* %varargslots99 to %variant* - store %variant* %150, %variant** %149, align 8 - %151 = bitcast %"variant[]"* %vararg98 to { i8*, i64 }* - %152 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %151, i32 0, i32 0 - %lo101 = load i8*, i8** %152, align 8 - %153 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %151, i32 0, i32 1 - %hi102 = load i64, i64* %153, align 8 - %154 = call i64 @std_io_printfln(i64* %retparam94, i8* %lo96, i64 %hi97, i8* %lo101, i64 %hi102) - %not_err103 = icmp eq i64 %154, 0 - br i1 %not_err103, label %after_check104, label %voiderr105 +voiderr70: ; preds = %after_check69, %voiderr61 + %117 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.200000e+00) + store i8 %117, i8* %taddr73, align 1 + %118 = insertvalue %variant undef, i8* %taddr73, 0 + %119 = insertvalue %variant %118, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1 + %120 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots72, i64 0, i64 0 + store %variant %119, %variant* %120, align 16 + %121 = bitcast [1 x %variant]* %varargslots72 to %variant* + %122 = insertvalue %"variant[]" undef, %variant* %121, 0 + %123 = insertvalue %"variant[]" %122, i64 1, 1 + store %"variant[]" %123, %"variant[]"* %taddr74, align 8 + %124 = bitcast %"variant[]"* %taddr74 to { i8*, i64 }* + %125 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %124, i32 0, i32 0 + %lo75 = load i8*, i8** %125, align 8 + %126 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %124, i32 0, i32 1 + %hi76 = load i64, i64* %126, align 8 + %127 = call i64 @std_io_printfln(i64* %retparam71, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i64 12, i8* %lo75, i64 %hi76) + %not_err77 = icmp eq i64 %127, 0 + br i1 %not_err77, label %after_check78, label %voiderr79 -after_check104: ; preds = %voiderr93 - br label %voiderr105 +after_check78: ; preds = %voiderr70 + br label %voiderr79 -voiderr105: ; preds = %after_check104, %voiderr93 - %155 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 100, double 3.400000e+00) - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i64 2 }, %"char[]"* %taddr107, align 8 - %156 = bitcast %"char[]"* %taddr107 to { i8*, i64 }* - %157 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %156, i32 0, i32 0 - %lo108 = load i8*, i8** %157, align 8 - %158 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %156, i32 0, i32 1 - %hi109 = load i64, i64* %158, align 8 - %159 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8 - %160 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map2, %Allocator* %159) - %161 = bitcast %"int[]"* %result112 to { i8*, i64 }* - store { i8*, i64 } %160, { i8*, i64 }* %161, align 8 - %162 = bitcast %"int[]"* %result112 to i8* - %163 = insertvalue %variant undef, i8* %162, 0 - %164 = insertvalue %variant %163, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1 - %165 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots111, i64 0, i64 0 - store %variant %164, %variant* %165, align 16 - %166 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg110, i32 0, i32 1 - store i64 1, i64* %166, align 8 - %167 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg110, i32 0, i32 0 - %168 = bitcast [1 x %variant]* %varargslots111 to %variant* - store %variant* %168, %variant** %167, align 8 - %169 = bitcast %"variant[]"* %vararg110 to { i8*, i64 }* - %170 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 0 - %lo113 = load i8*, i8** %170, align 8 - %171 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 1 - %hi114 = load i64, i64* %171, align 8 - %172 = call i64 @std_io_printfln(i64* %retparam106, i8* %lo108, i64 %hi109, i8* %lo113, i64 %hi114) - %not_err115 = icmp eq i64 %172, 0 - br i1 %not_err115, label %after_check116, label %voiderr117 +voiderr79: ; preds = %after_check78, %voiderr70 + %128 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 100, double 3.400000e+00) + %129 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8 + %130 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map2, %Allocator* %129) + %131 = bitcast %"int[]"* %result82 to { i8*, i64 }* + store { i8*, i64 } %130, { i8*, i64 }* %131, align 8 + %132 = bitcast %"int[]"* %result82 to i8* + %133 = insertvalue %variant undef, i8* %132, 0 + %134 = insertvalue %variant %133, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1 + %135 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots81, i64 0, i64 0 + store %variant %134, %variant* %135, align 16 + %136 = bitcast [1 x %variant]* %varargslots81 to %variant* + %137 = insertvalue %"variant[]" undef, %variant* %136, 0 + %138 = insertvalue %"variant[]" %137, i64 1, 1 + store %"variant[]" %138, %"variant[]"* %taddr83, align 8 + %139 = bitcast %"variant[]"* %taddr83 to { i8*, i64 }* + %140 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %139, i32 0, i32 0 + %lo84 = load i8*, i8** %140, align 8 + %141 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %139, i32 0, i32 1 + %hi85 = load i64, i64* %141, align 8 + %142 = call i64 @std_io_printfln(i64* %retparam80, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i64 2, i8* %lo84, i64 %hi85) + %not_err86 = icmp eq i64 %142, 0 + br i1 %not_err86, label %after_check87, label %voiderr88 -after_check116: ; preds = %voiderr105 - br label %voiderr117 +after_check87: ; preds = %voiderr79 + br label %voiderr88 -voiderr117: ; preds = %after_check116, %voiderr105 - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i32 0, i32 0), i64 2 }, %"char[]"* %taddr119, align 8 - %173 = bitcast %"char[]"* %taddr119 to { i8*, i64 }* - %174 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %173, i32 0, i32 0 - %lo120 = load i8*, i8** %174, align 8 - %175 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %173, i32 0, i32 1 - %hi121 = load i64, i64* %175, align 8 - %176 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8 - %177 = call { i8*, i64 } @"std_map$$int.double_HashMap_value_list"(%HashMap.3* %map2, %Allocator* %176) - %178 = bitcast %"double[]"* %result124 to { i8*, i64 }* - store { i8*, i64 } %177, { i8*, i64 }* %178, align 8 - %179 = bitcast %"double[]"* %result124 to i8* - %180 = insertvalue %variant undef, i8* %179, 0 - %181 = insertvalue %variant %180, i64 ptrtoint (%.introspect* @"ct$sa$double" to i64), 1 - %182 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots123, i64 0, i64 0 - store %variant %181, %variant* %182, align 16 - %183 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg122, i32 0, i32 1 - store i64 1, i64* %183, align 8 - %184 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg122, i32 0, i32 0 - %185 = bitcast [1 x %variant]* %varargslots123 to %variant* - store %variant* %185, %variant** %184, align 8 - %186 = bitcast %"variant[]"* %vararg122 to { i8*, i64 }* - %187 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %186, i32 0, i32 0 - %lo125 = load i8*, i8** %187, align 8 - %188 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %186, i32 0, i32 1 - %hi126 = load i64, i64* %188, align 8 - %189 = call i64 @std_io_printfln(i64* %retparam118, i8* %lo120, i64 %hi121, i8* %lo125, i64 %hi126) - %not_err127 = icmp eq i64 %189, 0 - br i1 %not_err127, label %after_check128, label %voiderr129 +voiderr88: ; preds = %after_check87, %voiderr79 + %143 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8 + %144 = call { i8*, i64 } @"std_map$$int.double_HashMap_value_list"(%HashMap.3* %map2, %Allocator* %143) + %145 = bitcast %"double[]"* %result91 to { i8*, i64 }* + store { i8*, i64 } %144, { i8*, i64 }* %145, align 8 + %146 = bitcast %"double[]"* %result91 to i8* + %147 = insertvalue %variant undef, i8* %146, 0 + %148 = insertvalue %variant %147, i64 ptrtoint (%.introspect* @"ct$sa$double" to i64), 1 + %149 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots90, i64 0, i64 0 + store %variant %148, %variant* %149, align 16 + %150 = bitcast [1 x %variant]* %varargslots90 to %variant* + %151 = insertvalue %"variant[]" undef, %variant* %150, 0 + %152 = insertvalue %"variant[]" %151, i64 1, 1 + store %"variant[]" %152, %"variant[]"* %taddr92, align 8 + %153 = bitcast %"variant[]"* %taddr92 to { i8*, i64 }* + %154 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %153, i32 0, i32 0 + %lo93 = load i8*, i8** %154, align 8 + %155 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %153, i32 0, i32 1 + %hi94 = load i64, i64* %155, align 8 + %156 = call i64 @std_io_printfln(i64* %retparam89, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i32 0, i32 0), i64 2, i8* %lo93, i64 %hi94) + %not_err95 = icmp eq i64 %156, 0 + br i1 %not_err95, label %after_check96, label %voiderr97 -after_check128: ; preds = %voiderr117 - br label %voiderr129 +after_check96: ; preds = %voiderr88 + br label %voiderr97 -voiderr129: ; preds = %after_check128, %voiderr117 - %190 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8 - %not = icmp eq %TempAllocator* %190, null +voiderr97: ; preds = %after_check96, %voiderr88 + %157 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8 + %not = icmp eq %TempAllocator* %157, null br i1 %not, label %if.then, label %if.exit -if.then: ; preds = %voiderr129 - %191 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam130, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR) - %not_err131 = icmp eq i64 %191, 0 - br i1 %not_err131, label %after_check132, label %assign_optional +if.then: ; preds = %voiderr97 + %158 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam98, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR) + %not_err99 = icmp eq i64 %158, 0 + br i1 %not_err99, label %after_check100, label %assign_optional assign_optional: ; preds = %if.then - store i64 %191, i64* %error_var, align 8 + store i64 %158, i64* %error_var, align 8 br label %panic_block -after_check132: ; preds = %if.then - %192 = load %TempAllocator*, %TempAllocator** %retparam130, align 8 +after_check100: ; preds = %if.then + %159 = load %TempAllocator*, %TempAllocator** %retparam98, align 8 br label %noerr_block panic_block: ; preds = %assign_optional - call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.11, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.12, i64 0, i64 0), i32 245) + %160 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %160(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.panic_msg, i64 0, i64 0), i64 27, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.file, i64 0, i64 0), i64 6, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.func, i64 0, i64 0), i64 4, i32 245) unreachable -noerr_block: ; preds = %after_check132 - store %TempAllocator* %192, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8 +noerr_block: ; preds = %after_check100 + store %TempAllocator* %159, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8 br label %if.exit -if.exit: ; preds = %noerr_block, %voiderr129 - %193 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8 - store %TempAllocator* %193, %TempAllocator** %temp, align 8 - %194 = load %TempAllocator*, %TempAllocator** %temp, align 8 - %195 = getelementptr inbounds %TempAllocator, %TempAllocator* %194, i32 0, i32 3 - %196 = load i64, i64* %195, align 8 - store i64 %196, i64* %mark, align 8 - %197 = bitcast %HashMap.3* %map3 to i8* - call void @llvm.memset.p0i8.i64(i8* align 8 %197, i8 0, i64 40, i1 false) +if.exit: ; preds = %noerr_block, %voiderr97 + %161 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8 + store %TempAllocator* %161, %TempAllocator** %temp, align 8 + %162 = load %TempAllocator*, %TempAllocator** %temp, align 8 + %163 = getelementptr inbounds %TempAllocator, %TempAllocator* %162, i32 0, i32 3 + %164 = load i64, i64* %163, align 8 + store i64 %164, i64* %mark, align 8 + %165 = bitcast %HashMap.3* %map3 to i8* + call void @llvm.memset.p0i8.i64(i8* align 8 %165, i8 0, i64 40, i1 false) call void @"std_map$$int.double_HashMap_tinit"(%HashMap.3* %map3, i32 16, float 7.500000e-01) - %198 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 5, double 3.200000e+00) - %199 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 7, double 5.200000e+00) - store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i32 0, i32 0), i64 2 }, %"char[]"* %taddr134, align 8 - %200 = bitcast %"char[]"* %taddr134 to { i8*, i64 }* - %201 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %200, i32 0, i32 0 - %lo135 = load i8*, i8** %201, align 8 - %202 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %200, i32 0, i32 1 - %hi136 = load i64, i64* %202, align 8 - %203 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8 - %204 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map3, %Allocator* %203) - %205 = bitcast %"int[]"* %result139 to { i8*, i64 }* - store { i8*, i64 } %204, { i8*, i64 }* %205, align 8 - %206 = bitcast %"int[]"* %result139 to i8* - %207 = insertvalue %variant undef, i8* %206, 0 - %208 = insertvalue %variant %207, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1 - %209 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots138, i64 0, i64 0 - store %variant %208, %variant* %209, align 16 - %210 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg137, i32 0, i32 1 - store i64 1, i64* %210, align 8 - %211 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg137, i32 0, i32 0 - %212 = bitcast [1 x %variant]* %varargslots138 to %variant* - store %variant* %212, %variant** %211, align 8 - %213 = bitcast %"variant[]"* %vararg137 to { i8*, i64 }* - %214 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %213, i32 0, i32 0 - %lo140 = load i8*, i8** %214, align 8 - %215 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %213, i32 0, i32 1 - %hi141 = load i64, i64* %215, align 8 - %216 = call i64 @std_io_printfln(i64* %retparam133, i8* %lo135, i64 %hi136, i8* %lo140, i64 %hi141) - %not_err142 = icmp eq i64 %216, 0 - br i1 %not_err142, label %after_check143, label %voiderr144 + %166 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 5, double 3.200000e+00) + %167 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 7, double 5.200000e+00) + %168 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8 + %169 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map3, %Allocator* %168) + %170 = bitcast %"int[]"* %result103 to { i8*, i64 }* + store { i8*, i64 } %169, { i8*, i64 }* %170, align 8 + %171 = bitcast %"int[]"* %result103 to i8* + %172 = insertvalue %variant undef, i8* %171, 0 + %173 = insertvalue %variant %172, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1 + %174 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots102, i64 0, i64 0 + store %variant %173, %variant* %174, align 16 + %175 = bitcast [1 x %variant]* %varargslots102 to %variant* + %176 = insertvalue %"variant[]" undef, %variant* %175, 0 + %177 = insertvalue %"variant[]" %176, i64 1, 1 + store %"variant[]" %177, %"variant[]"* %taddr104, align 8 + %178 = bitcast %"variant[]"* %taddr104 to { i8*, i64 }* + %179 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %178, i32 0, i32 0 + %lo105 = load i8*, i8** %179, align 8 + %180 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %178, i32 0, i32 1 + %hi106 = load i64, i64* %180, align 8 + %181 = call i64 @std_io_printfln(i64* %retparam101, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i32 0, i32 0), i64 2, i8* %lo105, i64 %hi106) + %not_err107 = icmp eq i64 %181, 0 + br i1 %not_err107, label %after_check108, label %voiderr109 -after_check143: ; preds = %if.exit - br label %voiderr144 +after_check108: ; preds = %if.exit + br label %voiderr109 -voiderr144: ; preds = %after_check143, %if.exit - %217 = load %TempAllocator*, %TempAllocator** %temp, align 8 - %218 = getelementptr inbounds %TempAllocator, %TempAllocator* %217, i32 0, i32 0 - %219 = load i64, i64* %mark, align 8 - call void @std_core_mem_allocator_Allocator_reset(%Allocator* %218, i64 %219) +voiderr109: ; preds = %after_check108, %if.exit + %182 = load %TempAllocator*, %TempAllocator** %temp, align 8 + %183 = getelementptr inbounds %TempAllocator, %TempAllocator* %182, i32 0, i32 0 + %184 = load i64, i64* %mark, align 8 + call void @std_core_mem_allocator_Allocator_reset(%Allocator* %183, i64 %184) ret void } diff --git a/test/test_suite/variant/variant_test.c3t b/test/test_suite/variant/variant_test.c3t index 574111cea..fcc4464c3 100644 --- a/test/test_suite/variant/variant_test.c3t +++ b/test/test_suite/variant/variant_test.c3t @@ -194,9 +194,9 @@ entry: %taddr19 = alloca i8, align 1 %taddr20 = alloca %variant, align 8 %df = alloca i32*, align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [5 x %variant], align 16 %taddr23 = alloca double, align 8 + %taddr24 = alloca %"variant[]", align 8 store i32 1, i32* %taddr, align 4 %0 = bitcast i32* %taddr to i8* %1 = insertvalue %variant undef, i8* %0, 0 @@ -326,16 +326,15 @@ if.exit10: ; preds = %if.then9, %if.exit7 %60 = insertvalue %variant %59, i64 ptrtoint (%.introspect* @"ct$p$int" to i64), 1 %61 = getelementptr inbounds [5 x %variant], [5 x %variant]* %varargslots, i64 0, i64 4 store %variant %60, %variant* %61, align 16 - %62 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 5, i64* %62, align 8 - %63 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %64 = bitcast [5 x %variant]* %varargslots to %variant* - store %variant* %64, %variant** %63, align 8 - %65 = bitcast %"variant[]"* %vararg to { i8*, i64 }* + %62 = bitcast [5 x %variant]* %varargslots to %variant* + %63 = insertvalue %"variant[]" undef, %variant* %62, 0 + %64 = insertvalue %"variant[]" %63, i64 5, 1 + store %"variant[]" %64, %"variant[]"* %taddr24, align 8 + %65 = bitcast %"variant[]"* %taddr24 to { i8*, i64 }* %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 0 - %lo24 = load i8*, i8** %66, align 8 + %lo25 = load i8*, i8** %66, align 8 %67 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 1 - %hi25 = load i64, i64* %67, align 8 - call void @foo_test_all(i8* %lo24, i64 %hi25) + %hi26 = load i64, i64* %67, align 8 + call void @foo_test_all(i8* %lo25, i64 %hi26) ret void } diff --git a/test/test_suite/vector/vector_ops2.c3t b/test/test_suite/vector/vector_ops2.c3t index af9f5c9fb..dc6bdf209 100644 --- a/test/test_suite/vector/vector_ops2.c3t +++ b/test/test_suite/vector/vector_ops2.c3t @@ -149,126 +149,127 @@ entry: br i1 %zero, label %panic, label %checkok panic: ; preds = %entry - call void @std_core_builtin_panic(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.2, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.3, i64 0, i64 0), i32 12) + %26 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %26(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.panic_msg, i64 0, i64 0), i64 17, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func, i64 0, i64 0), i64 5, i32 12) br label %checkok checkok: ; preds = %panic, %entry %fdiv = fdiv <4 x float> %22, %23 store <4 x float> %fdiv, <4 x float>* %w, align 16 - %26 = load <4 x float>, <4 x float>* %w, align 16 - %27 = extractelement <4 x float> %26, i64 0 - %fpfpext8 = fpext float %27 to double - %28 = load <4 x float>, <4 x float>* %w, align 16 - %29 = extractelement <4 x float> %28, i64 1 - %fpfpext9 = fpext float %29 to double - %30 = load <4 x float>, <4 x float>* %w, align 16 - %31 = extractelement <4 x float> %30, i64 2 - %fpfpext10 = fpext float %31 to double - %32 = load <4 x float>, <4 x float>* %w, align 16 - %33 = extractelement <4 x float> %32, i64 3 - %fpfpext11 = fpext float %33 to double - %34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i32 0, i32 0), double %fpfpext8, double %fpfpext9, double %fpfpext10, double %fpfpext11) - %35 = load <4 x float>, <4 x float>* %y, align 16 - %36 = load <4 x float>, <4 x float>* %z, align 16 - %fsub = fsub <4 x float> %35, %36 + %27 = load <4 x float>, <4 x float>* %w, align 16 + %28 = extractelement <4 x float> %27, i64 0 + %fpfpext8 = fpext float %28 to double + %29 = load <4 x float>, <4 x float>* %w, align 16 + %30 = extractelement <4 x float> %29, i64 1 + %fpfpext9 = fpext float %30 to double + %31 = load <4 x float>, <4 x float>* %w, align 16 + %32 = extractelement <4 x float> %31, i64 2 + %fpfpext10 = fpext float %32 to double + %33 = load <4 x float>, <4 x float>* %w, align 16 + %34 = extractelement <4 x float> %33, i64 3 + %fpfpext11 = fpext float %34 to double + %35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i32 0, i32 0), double %fpfpext8, double %fpfpext9, double %fpfpext10, double %fpfpext11) + %36 = load <4 x float>, <4 x float>* %y, align 16 + %37 = load <4 x float>, <4 x float>* %z, align 16 + %fsub = fsub <4 x float> %36, %37 store <4 x float> %fsub, <4 x float>* %w, align 16 - %37 = load <4 x float>, <4 x float>* %w, align 16 - %38 = extractelement <4 x float> %37, i64 0 - %fpfpext12 = fpext float %38 to double - %39 = load <4 x float>, <4 x float>* %w, align 16 - %40 = extractelement <4 x float> %39, i64 1 - %fpfpext13 = fpext float %40 to double - %41 = load <4 x float>, <4 x float>* %w, align 16 - %42 = extractelement <4 x float> %41, i64 2 - %fpfpext14 = fpext float %42 to double - %43 = load <4 x float>, <4 x float>* %w, align 16 - %44 = extractelement <4 x float> %43, i64 3 - %fpfpext15 = fpext float %44 to double - %45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i32 0, i32 0), double %fpfpext12, double %fpfpext13, double %fpfpext14, double %fpfpext15) - %46 = load <4 x float>, <4 x float>* %y, align 16 - %47 = load <4 x float>, <4 x float>* %z, align 16 - %lt = fcmp olt <4 x float> %46, %47 - %48 = sext <4 x i1> %lt to <4 x i32> - store <4 x i32> %48, <4 x i32>* %ww, align 16 - %49 = load <4 x i32>, <4 x i32>* %ww, align 16 - %50 = extractelement <4 x i32> %49, i64 0 - %51 = load <4 x i32>, <4 x i32>* %ww, align 16 - %52 = extractelement <4 x i32> %51, i64 1 - %53 = load <4 x i32>, <4 x i32>* %ww, align 16 - %54 = extractelement <4 x i32> %53, i64 2 - %55 = load <4 x i32>, <4 x i32>* %ww, align 16 - %56 = extractelement <4 x i32> %55, i64 3 - %57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i32 0, i32 0), i32 %50, i32 %52, i32 %54, i32 %56) - %58 = load <4 x float>, <4 x float>* %y, align 16 - %59 = load <4 x float>, <4 x float>* %z, align 16 - %le = fcmp ole <4 x float> %58, %59 - %60 = sext <4 x i1> %le to <4 x i32> - store <4 x i32> %60, <4 x i32>* %ww, align 16 - %61 = load <4 x i32>, <4 x i32>* %ww, align 16 - %62 = extractelement <4 x i32> %61, i64 0 - %63 = load <4 x i32>, <4 x i32>* %ww, align 16 - %64 = extractelement <4 x i32> %63, i64 1 - %65 = load <4 x i32>, <4 x i32>* %ww, align 16 - %66 = extractelement <4 x i32> %65, i64 2 - %67 = load <4 x i32>, <4 x i32>* %ww, align 16 - %68 = extractelement <4 x i32> %67, i64 3 - %69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i32 0, i32 0), i32 %62, i32 %64, i32 %66, i32 %68) - %70 = load <4 x float>, <4 x float>* %y, align 16 - %71 = load <4 x float>, <4 x float>* %z, align 16 - %gt = fcmp ogt <4 x float> %70, %71 - %72 = sext <4 x i1> %gt to <4 x i32> - store <4 x i32> %72, <4 x i32>* %ww, align 16 - %73 = load <4 x i32>, <4 x i32>* %ww, align 16 - %74 = extractelement <4 x i32> %73, i64 0 - %75 = load <4 x i32>, <4 x i32>* %ww, align 16 - %76 = extractelement <4 x i32> %75, i64 1 - %77 = load <4 x i32>, <4 x i32>* %ww, align 16 - %78 = extractelement <4 x i32> %77, i64 2 - %79 = load <4 x i32>, <4 x i32>* %ww, align 16 - %80 = extractelement <4 x i32> %79, i64 3 - %81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i32 %74, i32 %76, i32 %78, i32 %80) - %82 = load <4 x float>, <4 x float>* %y, align 16 - %83 = load <4 x float>, <4 x float>* %z, align 16 - %ge = fcmp oge <4 x float> %82, %83 - %84 = sext <4 x i1> %ge to <4 x i32> - store <4 x i32> %84, <4 x i32>* %ww, align 16 - %85 = load <4 x i32>, <4 x i32>* %ww, align 16 - %86 = extractelement <4 x i32> %85, i64 0 - %87 = load <4 x i32>, <4 x i32>* %ww, align 16 - %88 = extractelement <4 x i32> %87, i64 1 - %89 = load <4 x i32>, <4 x i32>* %ww, align 16 - %90 = extractelement <4 x i32> %89, i64 2 - %91 = load <4 x i32>, <4 x i32>* %ww, align 16 - %92 = extractelement <4 x i32> %91, i64 3 - %93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.9, i32 0, i32 0), i32 %86, i32 %88, i32 %90, i32 %92) - %94 = load <4 x float>, <4 x float>* %y, align 16 - %95 = load <4 x float>, <4 x float>* %z, align 16 - %eq = fcmp oeq <4 x float> %94, %95 - %96 = sext <4 x i1> %eq to <4 x i32> - store <4 x i32> %96, <4 x i32>* %ww, align 16 - %97 = load <4 x i32>, <4 x i32>* %ww, align 16 - %98 = extractelement <4 x i32> %97, i64 0 - %99 = load <4 x i32>, <4 x i32>* %ww, align 16 - %100 = extractelement <4 x i32> %99, i64 1 - %101 = load <4 x i32>, <4 x i32>* %ww, align 16 - %102 = extractelement <4 x i32> %101, i64 2 - %103 = load <4 x i32>, <4 x i32>* %ww, align 16 - %104 = extractelement <4 x i32> %103, i64 3 - %105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.10, i32 0, i32 0), i32 %98, i32 %100, i32 %102, i32 %104) - %106 = load <4 x float>, <4 x float>* %y, align 16 - %107 = load <4 x float>, <4 x float>* %z, align 16 - %neq = fcmp one <4 x float> %106, %107 - %108 = sext <4 x i1> %neq to <4 x i32> - store <4 x i32> %108, <4 x i32>* %ww, align 16 - %109 = load <4 x i32>, <4 x i32>* %ww, align 16 - %110 = extractelement <4 x i32> %109, i64 0 - %111 = load <4 x i32>, <4 x i32>* %ww, align 16 - %112 = extractelement <4 x i32> %111, i64 1 - %113 = load <4 x i32>, <4 x i32>* %ww, align 16 - %114 = extractelement <4 x i32> %113, i64 2 - %115 = load <4 x i32>, <4 x i32>* %ww, align 16 - %116 = extractelement <4 x i32> %115, i64 3 - %117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i32 0, i32 0), i32 %110, i32 %112, i32 %114, i32 %116) + %38 = load <4 x float>, <4 x float>* %w, align 16 + %39 = extractelement <4 x float> %38, i64 0 + %fpfpext12 = fpext float %39 to double + %40 = load <4 x float>, <4 x float>* %w, align 16 + %41 = extractelement <4 x float> %40, i64 1 + %fpfpext13 = fpext float %41 to double + %42 = load <4 x float>, <4 x float>* %w, align 16 + %43 = extractelement <4 x float> %42, i64 2 + %fpfpext14 = fpext float %43 to double + %44 = load <4 x float>, <4 x float>* %w, align 16 + %45 = extractelement <4 x float> %44, i64 3 + %fpfpext15 = fpext float %45 to double + %46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i32 0, i32 0), double %fpfpext12, double %fpfpext13, double %fpfpext14, double %fpfpext15) + %47 = load <4 x float>, <4 x float>* %y, align 16 + %48 = load <4 x float>, <4 x float>* %z, align 16 + %lt = fcmp olt <4 x float> %47, %48 + %49 = sext <4 x i1> %lt to <4 x i32> + store <4 x i32> %49, <4 x i32>* %ww, align 16 + %50 = load <4 x i32>, <4 x i32>* %ww, align 16 + %51 = extractelement <4 x i32> %50, i64 0 + %52 = load <4 x i32>, <4 x i32>* %ww, align 16 + %53 = extractelement <4 x i32> %52, i64 1 + %54 = load <4 x i32>, <4 x i32>* %ww, align 16 + %55 = extractelement <4 x i32> %54, i64 2 + %56 = load <4 x i32>, <4 x i32>* %ww, align 16 + %57 = extractelement <4 x i32> %56, i64 3 + %58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i32 0, i32 0), i32 %51, i32 %53, i32 %55, i32 %57) + %59 = load <4 x float>, <4 x float>* %y, align 16 + %60 = load <4 x float>, <4 x float>* %z, align 16 + %le = fcmp ole <4 x float> %59, %60 + %61 = sext <4 x i1> %le to <4 x i32> + store <4 x i32> %61, <4 x i32>* %ww, align 16 + %62 = load <4 x i32>, <4 x i32>* %ww, align 16 + %63 = extractelement <4 x i32> %62, i64 0 + %64 = load <4 x i32>, <4 x i32>* %ww, align 16 + %65 = extractelement <4 x i32> %64, i64 1 + %66 = load <4 x i32>, <4 x i32>* %ww, align 16 + %67 = extractelement <4 x i32> %66, i64 2 + %68 = load <4 x i32>, <4 x i32>* %ww, align 16 + %69 = extractelement <4 x i32> %68, i64 3 + %70 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i32 0, i32 0), i32 %63, i32 %65, i32 %67, i32 %69) + %71 = load <4 x float>, <4 x float>* %y, align 16 + %72 = load <4 x float>, <4 x float>* %z, align 16 + %gt = fcmp ogt <4 x float> %71, %72 + %73 = sext <4 x i1> %gt to <4 x i32> + store <4 x i32> %73, <4 x i32>* %ww, align 16 + %74 = load <4 x i32>, <4 x i32>* %ww, align 16 + %75 = extractelement <4 x i32> %74, i64 0 + %76 = load <4 x i32>, <4 x i32>* %ww, align 16 + %77 = extractelement <4 x i32> %76, i64 1 + %78 = load <4 x i32>, <4 x i32>* %ww, align 16 + %79 = extractelement <4 x i32> %78, i64 2 + %80 = load <4 x i32>, <4 x i32>* %ww, align 16 + %81 = extractelement <4 x i32> %80, i64 3 + %82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i32 0, i32 0), i32 %75, i32 %77, i32 %79, i32 %81) + %83 = load <4 x float>, <4 x float>* %y, align 16 + %84 = load <4 x float>, <4 x float>* %z, align 16 + %ge = fcmp oge <4 x float> %83, %84 + %85 = sext <4 x i1> %ge to <4 x i32> + store <4 x i32> %85, <4 x i32>* %ww, align 16 + %86 = load <4 x i32>, <4 x i32>* %ww, align 16 + %87 = extractelement <4 x i32> %86, i64 0 + %88 = load <4 x i32>, <4 x i32>* %ww, align 16 + %89 = extractelement <4 x i32> %88, i64 1 + %90 = load <4 x i32>, <4 x i32>* %ww, align 16 + %91 = extractelement <4 x i32> %90, i64 2 + %92 = load <4 x i32>, <4 x i32>* %ww, align 16 + %93 = extractelement <4 x i32> %92, i64 3 + %94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i32 0, i32 0), i32 %87, i32 %89, i32 %91, i32 %93) + %95 = load <4 x float>, <4 x float>* %y, align 16 + %96 = load <4 x float>, <4 x float>* %z, align 16 + %eq = fcmp oeq <4 x float> %95, %96 + %97 = sext <4 x i1> %eq to <4 x i32> + store <4 x i32> %97, <4 x i32>* %ww, align 16 + %98 = load <4 x i32>, <4 x i32>* %ww, align 16 + %99 = extractelement <4 x i32> %98, i64 0 + %100 = load <4 x i32>, <4 x i32>* %ww, align 16 + %101 = extractelement <4 x i32> %100, i64 1 + %102 = load <4 x i32>, <4 x i32>* %ww, align 16 + %103 = extractelement <4 x i32> %102, i64 2 + %104 = load <4 x i32>, <4 x i32>* %ww, align 16 + %105 = extractelement <4 x i32> %104, i64 3 + %106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i32 %99, i32 %101, i32 %103, i32 %105) + %107 = load <4 x float>, <4 x float>* %y, align 16 + %108 = load <4 x float>, <4 x float>* %z, align 16 + %neq = fcmp one <4 x float> %107, %108 + %109 = sext <4 x i1> %neq to <4 x i32> + store <4 x i32> %109, <4 x i32>* %ww, align 16 + %110 = load <4 x i32>, <4 x i32>* %ww, align 16 + %111 = extractelement <4 x i32> %110, i64 0 + %112 = load <4 x i32>, <4 x i32>* %ww, align 16 + %113 = extractelement <4 x i32> %112, i64 1 + %114 = load <4 x i32>, <4 x i32>* %ww, align 16 + %115 = extractelement <4 x i32> %114, i64 2 + %116 = load <4 x i32>, <4 x i32>* %ww, align 16 + %117 = extractelement <4 x i32> %116, i64 3 + %118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.9, i32 0, i32 0), i32 %111, i32 %113, i32 %115, i32 %117) ret void } @@ -297,7 +298,7 @@ entry: %9 = load <4 x i8>, <4 x i8>* %ww, align 4 %10 = extractelement <4 x i8> %9, i64 3 %sisiext3 = sext i8 %10 to i32 - %11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.12, i32 0, i32 0), i32 %sisiext, i32 %sisiext1, i32 %sisiext2, i32 %sisiext3) + %11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.10, i32 0, i32 0), i32 %sisiext, i32 %sisiext1, i32 %sisiext2, i32 %sisiext3) %12 = load <4 x i8>, <4 x i8>* %y, align 4 %13 = load <4 x i8>, <4 x i8>* %z, align 4 %le = icmp ule <4 x i8> %12, %13 @@ -315,7 +316,7 @@ entry: %21 = load <4 x i8>, <4 x i8>* %ww, align 4 %22 = extractelement <4 x i8> %21, i64 3 %sisiext7 = sext i8 %22 to i32 - %23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.13, i32 0, i32 0), i32 %sisiext4, i32 %sisiext5, i32 %sisiext6, i32 %sisiext7) + %23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i32 0, i32 0), i32 %sisiext4, i32 %sisiext5, i32 %sisiext6, i32 %sisiext7) %24 = load <4 x i8>, <4 x i8>* %y, align 4 %25 = load <4 x i8>, <4 x i8>* %z, align 4 %gt = icmp ugt <4 x i8> %24, %25 @@ -333,7 +334,7 @@ entry: %33 = load <4 x i8>, <4 x i8>* %ww, align 4 %34 = extractelement <4 x i8> %33, i64 3 %sisiext11 = sext i8 %34 to i32 - %35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.14, i32 0, i32 0), i32 %sisiext8, i32 %sisiext9, i32 %sisiext10, i32 %sisiext11) + %35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.12, i32 0, i32 0), i32 %sisiext8, i32 %sisiext9, i32 %sisiext10, i32 %sisiext11) %36 = load <4 x i8>, <4 x i8>* %y, align 4 %37 = load <4 x i8>, <4 x i8>* %z, align 4 %ge = icmp uge <4 x i8> %36, %37 @@ -351,7 +352,7 @@ entry: %45 = load <4 x i8>, <4 x i8>* %ww, align 4 %46 = extractelement <4 x i8> %45, i64 3 %sisiext15 = sext i8 %46 to i32 - %47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.15, i32 0, i32 0), i32 %sisiext12, i32 %sisiext13, i32 %sisiext14, i32 %sisiext15) + %47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.13, i32 0, i32 0), i32 %sisiext12, i32 %sisiext13, i32 %sisiext14, i32 %sisiext15) %48 = load <4 x i8>, <4 x i8>* %y, align 4 %49 = load <4 x i8>, <4 x i8>* %z, align 4 %eq = icmp eq <4 x i8> %48, %49 @@ -369,7 +370,7 @@ entry: %57 = load <4 x i8>, <4 x i8>* %ww, align 4 %58 = extractelement <4 x i8> %57, i64 3 %sisiext19 = sext i8 %58 to i32 - %59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.16, i32 0, i32 0), i32 %sisiext16, i32 %sisiext17, i32 %sisiext18, i32 %sisiext19) + %59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.14, i32 0, i32 0), i32 %sisiext16, i32 %sisiext17, i32 %sisiext18, i32 %sisiext19) %60 = load <4 x i8>, <4 x i8>* %y, align 4 %61 = load <4 x i8>, <4 x i8>* %z, align 4 %neq = icmp ne <4 x i8> %60, %61 @@ -387,7 +388,7 @@ entry: %69 = load <4 x i8>, <4 x i8>* %ww, align 4 %70 = extractelement <4 x i8> %69, i64 3 %sisiext23 = sext i8 %70 to i32 - %71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.17, i32 0, i32 0), i32 %sisiext20, i32 %sisiext21, i32 %sisiext22, i32 %sisiext23) + %71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.15, i32 0, i32 0), i32 %sisiext20, i32 %sisiext21, i32 %sisiext22, i32 %sisiext23) ret void } @@ -412,7 +413,7 @@ entry: %7 = extractelement <4 x i32> %6, i64 2 %8 = load <4 x i32>, <4 x i32>* %w, align 16 %9 = extractelement <4 x i32> %8, i64 3 - %10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %3, i32 %5, i32 %7, i32 %9) + %10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.16, i32 0, i32 0), i32 %3, i32 %5, i32 %7, i32 %9) %11 = load <4 x i32>, <4 x i32>* %y, align 16 %12 = load <4 x i32>, <4 x i32>* %z, align 16 %mul = mul <4 x i32> %11, %12 @@ -425,7 +426,7 @@ entry: %18 = extractelement <4 x i32> %17, i64 2 %19 = load <4 x i32>, <4 x i32>* %w, align 16 %20 = extractelement <4 x i32> %19, i64 3 - %21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %14, i32 %16, i32 %18, i32 %20) + %21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.17, i32 0, i32 0), i32 %14, i32 %16, i32 %18, i32 %20) %22 = load <4 x i32>, <4 x i32>* %y, align 16 %23 = load <4 x i32>, <4 x i32>* %z, align 16 %24 = call i32 @llvm.vector.reduce.umin.v4i32(<4 x i32> %23) @@ -433,278 +434,283 @@ entry: br i1 %zero, label %panic, label %checkok panic: ; preds = %entry - call void @std_core_builtin_panic(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.zstr.20, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.21, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.22, i64 0, i64 0), i32 56) + %25 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %25(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.panic_msg.18, i64 0, i64 0), i64 17, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.19, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.20, i64 0, i64 0), i64 5, i32 56) br label %checkok checkok: ; preds = %panic, %entry %sdiv = sdiv <4 x i32> %22, %23 store <4 x i32> %sdiv, <4 x i32>* %w, align 16 - %25 = load <4 x i32>, <4 x i32>* %w, align 16 - %26 = extractelement <4 x i32> %25, i64 0 - %27 = load <4 x i32>, <4 x i32>* %w, align 16 - %28 = extractelement <4 x i32> %27, i64 1 - %29 = load <4 x i32>, <4 x i32>* %w, align 16 - %30 = extractelement <4 x i32> %29, i64 2 - %31 = load <4 x i32>, <4 x i32>* %w, align 16 - %32 = extractelement <4 x i32> %31, i64 3 - %33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.23, i32 0, i32 0), i32 %26, i32 %28, i32 %30, i32 %32) - %34 = load <4 x i32>, <4 x i32>* %y, align 16 - %35 = load <4 x i32>, <4 x i32>* %z, align 16 - %sub = sub <4 x i32> %34, %35 + %26 = load <4 x i32>, <4 x i32>* %w, align 16 + %27 = extractelement <4 x i32> %26, i64 0 + %28 = load <4 x i32>, <4 x i32>* %w, align 16 + %29 = extractelement <4 x i32> %28, i64 1 + %30 = load <4 x i32>, <4 x i32>* %w, align 16 + %31 = extractelement <4 x i32> %30, i64 2 + %32 = load <4 x i32>, <4 x i32>* %w, align 16 + %33 = extractelement <4 x i32> %32, i64 3 + %34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.21, i32 0, i32 0), i32 %27, i32 %29, i32 %31, i32 %33) + %35 = load <4 x i32>, <4 x i32>* %y, align 16 + %36 = load <4 x i32>, <4 x i32>* %z, align 16 + %sub = sub <4 x i32> %35, %36 store <4 x i32> %sub, <4 x i32>* %w, align 16 - %36 = load <4 x i32>, <4 x i32>* %w, align 16 - %37 = extractelement <4 x i32> %36, i64 0 - %38 = load <4 x i32>, <4 x i32>* %w, align 16 - %39 = extractelement <4 x i32> %38, i64 1 - %40 = load <4 x i32>, <4 x i32>* %w, align 16 - %41 = extractelement <4 x i32> %40, i64 2 - %42 = load <4 x i32>, <4 x i32>* %w, align 16 - %43 = extractelement <4 x i32> %42, i64 3 - %44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.24, i32 0, i32 0), i32 %37, i32 %39, i32 %41, i32 %43) - %45 = load <4 x i32>, <4 x i32>* %z, align 16 - %46 = load <4 x i32>, <4 x i32>* %y, align 16 - %47 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %46) - %shift_underflow = icmp slt i32 %47, 0 + %37 = load <4 x i32>, <4 x i32>* %w, align 16 + %38 = extractelement <4 x i32> %37, i64 0 + %39 = load <4 x i32>, <4 x i32>* %w, align 16 + %40 = extractelement <4 x i32> %39, i64 1 + %41 = load <4 x i32>, <4 x i32>* %w, align 16 + %42 = extractelement <4 x i32> %41, i64 2 + %43 = load <4 x i32>, <4 x i32>* %w, align 16 + %44 = extractelement <4 x i32> %43, i64 3 + %45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.22, i32 0, i32 0), i32 %38, i32 %40, i32 %42, i32 %44) + %46 = load <4 x i32>, <4 x i32>* %z, align 16 + %47 = load <4 x i32>, <4 x i32>* %y, align 16 + %48 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %47) + %shift_underflow = icmp slt i32 %48, 0 br i1 %shift_underflow, label %panic1, label %checkok2 panic1: ; preds = %checkok - call void @std_core_builtin_panic(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.zstr.25, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.26, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.27, i64 0, i64 0), i32 60) + %49 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %49(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.panic_msg.23, i64 0, i64 0), i64 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.24, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.25, i64 0, i64 0), i64 5, i32 60) br label %checkok2 checkok2: ; preds = %panic1, %checkok - %48 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %46) - %shift_exceeds = icmp sge i32 %48, 32 + %50 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %47) + %shift_exceeds = icmp sge i32 %50, 32 br i1 %shift_exceeds, label %panic3, label %checkok4 panic3: ; preds = %checkok2 - call void @std_core_builtin_panic(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.zstr.28, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.29, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.30, i64 0, i64 0), i32 60) + %51 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %51(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.panic_msg.26, i64 0, i64 0), i64 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.27, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.28, i64 0, i64 0), i64 5, i32 60) br label %checkok4 checkok4: ; preds = %panic3, %checkok2 - %ashr = ashr <4 x i32> %45, %46 - %49 = freeze <4 x i32> %ashr - store <4 x i32> %49, <4 x i32>* %w, align 16 - %50 = load <4 x i32>, <4 x i32>* %w, align 16 - %51 = extractelement <4 x i32> %50, i64 0 - %52 = load <4 x i32>, <4 x i32>* %w, align 16 - %53 = extractelement <4 x i32> %52, i64 1 - %54 = load <4 x i32>, <4 x i32>* %w, align 16 - %55 = extractelement <4 x i32> %54, i64 2 - %56 = load <4 x i32>, <4 x i32>* %w, align 16 - %57 = extractelement <4 x i32> %56, i64 3 - %58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.31, i32 0, i32 0), i32 %51, i32 %53, i32 %55, i32 %57) - %59 = load <4 x i32>, <4 x i32>* %z, align 16 - %60 = load <4 x i32>, <4 x i32>* %y, align 16 - %61 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %60) - %shift_underflow5 = icmp slt i32 %61, 0 + %ashr = ashr <4 x i32> %46, %47 + %52 = freeze <4 x i32> %ashr + store <4 x i32> %52, <4 x i32>* %w, align 16 + %53 = load <4 x i32>, <4 x i32>* %w, align 16 + %54 = extractelement <4 x i32> %53, i64 0 + %55 = load <4 x i32>, <4 x i32>* %w, align 16 + %56 = extractelement <4 x i32> %55, i64 1 + %57 = load <4 x i32>, <4 x i32>* %w, align 16 + %58 = extractelement <4 x i32> %57, i64 2 + %59 = load <4 x i32>, <4 x i32>* %w, align 16 + %60 = extractelement <4 x i32> %59, i64 3 + %61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.29, i32 0, i32 0), i32 %54, i32 %56, i32 %58, i32 %60) + %62 = load <4 x i32>, <4 x i32>* %z, align 16 + %63 = load <4 x i32>, <4 x i32>* %y, align 16 + %64 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %63) + %shift_underflow5 = icmp slt i32 %64, 0 br i1 %shift_underflow5, label %panic6, label %checkok7 panic6: ; preds = %checkok4 - call void @std_core_builtin_panic(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.zstr.32, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.33, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.34, i64 0, i64 0), i32 62) + %65 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %65(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.panic_msg.30, i64 0, i64 0), i64 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.31, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.32, i64 0, i64 0), i64 5, i32 62) br label %checkok7 checkok7: ; preds = %panic6, %checkok4 - %62 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %60) - %shift_exceeds8 = icmp sge i32 %62, 32 + %66 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %63) + %shift_exceeds8 = icmp sge i32 %66, 32 br i1 %shift_exceeds8, label %panic9, label %checkok10 panic9: ; preds = %checkok7 - call void @std_core_builtin_panic(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.zstr.35, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.36, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.37, i64 0, i64 0), i32 62) + %67 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8 + call void %67(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.panic_msg.33, i64 0, i64 0), i64 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.34, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.35, i64 0, i64 0), i64 5, i32 62) br label %checkok10 checkok10: ; preds = %panic9, %checkok7 - %shl = shl <4 x i32> %59, %60 - %63 = freeze <4 x i32> %shl - store <4 x i32> %63, <4 x i32>* %w, align 16 - %64 = load <4 x i32>, <4 x i32>* %w, align 16 - %65 = extractelement <4 x i32> %64, i64 0 - %66 = load <4 x i32>, <4 x i32>* %w, align 16 - %67 = extractelement <4 x i32> %66, i64 1 - %68 = load <4 x i32>, <4 x i32>* %w, align 16 - %69 = extractelement <4 x i32> %68, i64 2 - %70 = load <4 x i32>, <4 x i32>* %w, align 16 - %71 = extractelement <4 x i32> %70, i64 3 - %72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.38, i32 0, i32 0), i32 %65, i32 %67, i32 %69, i32 %71) - %73 = load <4 x i32>, <4 x i32>* %z, align 16 - %74 = load <4 x i32>, <4 x i32>* %y, align 16 - %gt = icmp sgt <4 x i32> %73, %74 - %75 = sext <4 x i1> %gt to <4 x i32> - store <4 x i32> %75, <4 x i32>* %w, align 16 - %76 = load <4 x i32>, <4 x i32>* %w, align 16 - %77 = extractelement <4 x i32> %76, i64 0 - %78 = load <4 x i32>, <4 x i32>* %w, align 16 - %79 = extractelement <4 x i32> %78, i64 1 - %80 = load <4 x i32>, <4 x i32>* %w, align 16 - %81 = extractelement <4 x i32> %80, i64 2 - %82 = load <4 x i32>, <4 x i32>* %w, align 16 - %83 = extractelement <4 x i32> %82, i64 3 - %84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.39, i32 0, i32 0), i32 %77, i32 %79, i32 %81, i32 %83) - %85 = load <4 x i32>, <4 x i32>* %z, align 16 - %86 = load <4 x i32>, <4 x i32>* %y, align 16 - %ge = icmp sge <4 x i32> %85, %86 - %87 = sext <4 x i1> %ge to <4 x i32> - store <4 x i32> %87, <4 x i32>* %w, align 16 - %88 = load <4 x i32>, <4 x i32>* %w, align 16 - %89 = extractelement <4 x i32> %88, i64 0 - %90 = load <4 x i32>, <4 x i32>* %w, align 16 - %91 = extractelement <4 x i32> %90, i64 1 - %92 = load <4 x i32>, <4 x i32>* %w, align 16 - %93 = extractelement <4 x i32> %92, i64 2 - %94 = load <4 x i32>, <4 x i32>* %w, align 16 - %95 = extractelement <4 x i32> %94, i64 3 - %96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.40, i32 0, i32 0), i32 %89, i32 %91, i32 %93, i32 %95) - %97 = load <4 x i32>, <4 x i32>* %z, align 16 - %98 = load <4 x i32>, <4 x i32>* %y, align 16 - %lt = icmp slt <4 x i32> %97, %98 - %99 = sext <4 x i1> %lt to <4 x i32> - store <4 x i32> %99, <4 x i32>* %w, align 16 - %100 = load <4 x i32>, <4 x i32>* %w, align 16 - %101 = extractelement <4 x i32> %100, i64 0 - %102 = load <4 x i32>, <4 x i32>* %w, align 16 - %103 = extractelement <4 x i32> %102, i64 1 - %104 = load <4 x i32>, <4 x i32>* %w, align 16 - %105 = extractelement <4 x i32> %104, i64 2 - %106 = load <4 x i32>, <4 x i32>* %w, align 16 - %107 = extractelement <4 x i32> %106, i64 3 - %108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.41, i32 0, i32 0), i32 %101, i32 %103, i32 %105, i32 %107) - %109 = load <4 x i32>, <4 x i32>* %z, align 16 - %110 = load <4 x i32>, <4 x i32>* %y, align 16 - %le = icmp sle <4 x i32> %109, %110 - %111 = sext <4 x i1> %le to <4 x i32> - store <4 x i32> %111, <4 x i32>* %w, align 16 - %112 = load <4 x i32>, <4 x i32>* %w, align 16 - %113 = extractelement <4 x i32> %112, i64 0 - %114 = load <4 x i32>, <4 x i32>* %w, align 16 - %115 = extractelement <4 x i32> %114, i64 1 - %116 = load <4 x i32>, <4 x i32>* %w, align 16 - %117 = extractelement <4 x i32> %116, i64 2 - %118 = load <4 x i32>, <4 x i32>* %w, align 16 - %119 = extractelement <4 x i32> %118, i64 3 - %120 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.42, i32 0, i32 0), i32 %113, i32 %115, i32 %117, i32 %119) - %121 = load <4 x i32>, <4 x i32>* %z, align 16 - %122 = load <4 x i32>, <4 x i32>* %y, align 16 - %eq = icmp eq <4 x i32> %121, %122 - %123 = sext <4 x i1> %eq to <4 x i32> - store <4 x i32> %123, <4 x i32>* %w, align 16 - %124 = load <4 x i32>, <4 x i32>* %w, align 16 - %125 = extractelement <4 x i32> %124, i64 0 - %126 = load <4 x i32>, <4 x i32>* %w, align 16 - %127 = extractelement <4 x i32> %126, i64 1 - %128 = load <4 x i32>, <4 x i32>* %w, align 16 - %129 = extractelement <4 x i32> %128, i64 2 - %130 = load <4 x i32>, <4 x i32>* %w, align 16 - %131 = extractelement <4 x i32> %130, i64 3 - %132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.43, i32 0, i32 0), i32 %125, i32 %127, i32 %129, i32 %131) - %133 = load <4 x i32>, <4 x i32>* %z, align 16 - %134 = load <4 x i32>, <4 x i32>* %y, align 16 - %neq = icmp ne <4 x i32> %133, %134 - %135 = sext <4 x i1> %neq to <4 x i32> - store <4 x i32> %135, <4 x i32>* %w, align 16 - %136 = load <4 x i32>, <4 x i32>* %w, align 16 - %137 = extractelement <4 x i32> %136, i64 0 - %138 = load <4 x i32>, <4 x i32>* %w, align 16 - %139 = extractelement <4 x i32> %138, i64 1 - %140 = load <4 x i32>, <4 x i32>* %w, align 16 - %141 = extractelement <4 x i32> %140, i64 2 - %142 = load <4 x i32>, <4 x i32>* %w, align 16 - %143 = extractelement <4 x i32> %142, i64 3 - %144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.44, i32 0, i32 0), i32 %137, i32 %139, i32 %141, i32 %143) + %shl = shl <4 x i32> %62, %63 + %68 = freeze <4 x i32> %shl + store <4 x i32> %68, <4 x i32>* %w, align 16 + %69 = load <4 x i32>, <4 x i32>* %w, align 16 + %70 = extractelement <4 x i32> %69, i64 0 + %71 = load <4 x i32>, <4 x i32>* %w, align 16 + %72 = extractelement <4 x i32> %71, i64 1 + %73 = load <4 x i32>, <4 x i32>* %w, align 16 + %74 = extractelement <4 x i32> %73, i64 2 + %75 = load <4 x i32>, <4 x i32>* %w, align 16 + %76 = extractelement <4 x i32> %75, i64 3 + %77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.36, i32 0, i32 0), i32 %70, i32 %72, i32 %74, i32 %76) + %78 = load <4 x i32>, <4 x i32>* %z, align 16 + %79 = load <4 x i32>, <4 x i32>* %y, align 16 + %gt = icmp sgt <4 x i32> %78, %79 + %80 = sext <4 x i1> %gt to <4 x i32> + store <4 x i32> %80, <4 x i32>* %w, align 16 + %81 = load <4 x i32>, <4 x i32>* %w, align 16 + %82 = extractelement <4 x i32> %81, i64 0 + %83 = load <4 x i32>, <4 x i32>* %w, align 16 + %84 = extractelement <4 x i32> %83, i64 1 + %85 = load <4 x i32>, <4 x i32>* %w, align 16 + %86 = extractelement <4 x i32> %85, i64 2 + %87 = load <4 x i32>, <4 x i32>* %w, align 16 + %88 = extractelement <4 x i32> %87, i64 3 + %89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.37, i32 0, i32 0), i32 %82, i32 %84, i32 %86, i32 %88) + %90 = load <4 x i32>, <4 x i32>* %z, align 16 + %91 = load <4 x i32>, <4 x i32>* %y, align 16 + %ge = icmp sge <4 x i32> %90, %91 + %92 = sext <4 x i1> %ge to <4 x i32> + store <4 x i32> %92, <4 x i32>* %w, align 16 + %93 = load <4 x i32>, <4 x i32>* %w, align 16 + %94 = extractelement <4 x i32> %93, i64 0 + %95 = load <4 x i32>, <4 x i32>* %w, align 16 + %96 = extractelement <4 x i32> %95, i64 1 + %97 = load <4 x i32>, <4 x i32>* %w, align 16 + %98 = extractelement <4 x i32> %97, i64 2 + %99 = load <4 x i32>, <4 x i32>* %w, align 16 + %100 = extractelement <4 x i32> %99, i64 3 + %101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.38, i32 0, i32 0), i32 %94, i32 %96, i32 %98, i32 %100) + %102 = load <4 x i32>, <4 x i32>* %z, align 16 + %103 = load <4 x i32>, <4 x i32>* %y, align 16 + %lt = icmp slt <4 x i32> %102, %103 + %104 = sext <4 x i1> %lt to <4 x i32> + store <4 x i32> %104, <4 x i32>* %w, align 16 + %105 = load <4 x i32>, <4 x i32>* %w, align 16 + %106 = extractelement <4 x i32> %105, i64 0 + %107 = load <4 x i32>, <4 x i32>* %w, align 16 + %108 = extractelement <4 x i32> %107, i64 1 + %109 = load <4 x i32>, <4 x i32>* %w, align 16 + %110 = extractelement <4 x i32> %109, i64 2 + %111 = load <4 x i32>, <4 x i32>* %w, align 16 + %112 = extractelement <4 x i32> %111, i64 3 + %113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.39, i32 0, i32 0), i32 %106, i32 %108, i32 %110, i32 %112) + %114 = load <4 x i32>, <4 x i32>* %z, align 16 + %115 = load <4 x i32>, <4 x i32>* %y, align 16 + %le = icmp sle <4 x i32> %114, %115 + %116 = sext <4 x i1> %le to <4 x i32> + store <4 x i32> %116, <4 x i32>* %w, align 16 + %117 = load <4 x i32>, <4 x i32>* %w, align 16 + %118 = extractelement <4 x i32> %117, i64 0 + %119 = load <4 x i32>, <4 x i32>* %w, align 16 + %120 = extractelement <4 x i32> %119, i64 1 + %121 = load <4 x i32>, <4 x i32>* %w, align 16 + %122 = extractelement <4 x i32> %121, i64 2 + %123 = load <4 x i32>, <4 x i32>* %w, align 16 + %124 = extractelement <4 x i32> %123, i64 3 + %125 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.40, i32 0, i32 0), i32 %118, i32 %120, i32 %122, i32 %124) + %126 = load <4 x i32>, <4 x i32>* %z, align 16 + %127 = load <4 x i32>, <4 x i32>* %y, align 16 + %eq = icmp eq <4 x i32> %126, %127 + %128 = sext <4 x i1> %eq to <4 x i32> + store <4 x i32> %128, <4 x i32>* %w, align 16 + %129 = load <4 x i32>, <4 x i32>* %w, align 16 + %130 = extractelement <4 x i32> %129, i64 0 + %131 = load <4 x i32>, <4 x i32>* %w, align 16 + %132 = extractelement <4 x i32> %131, i64 1 + %133 = load <4 x i32>, <4 x i32>* %w, align 16 + %134 = extractelement <4 x i32> %133, i64 2 + %135 = load <4 x i32>, <4 x i32>* %w, align 16 + %136 = extractelement <4 x i32> %135, i64 3 + %137 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.41, i32 0, i32 0), i32 %130, i32 %132, i32 %134, i32 %136) + %138 = load <4 x i32>, <4 x i32>* %z, align 16 + %139 = load <4 x i32>, <4 x i32>* %y, align 16 + %neq = icmp ne <4 x i32> %138, %139 + %140 = sext <4 x i1> %neq to <4 x i32> + store <4 x i32> %140, <4 x i32>* %w, align 16 + %141 = load <4 x i32>, <4 x i32>* %w, align 16 + %142 = extractelement <4 x i32> %141, i64 0 + %143 = load <4 x i32>, <4 x i32>* %w, align 16 + %144 = extractelement <4 x i32> %143, i64 1 + %145 = load <4 x i32>, <4 x i32>* %w, align 16 + %146 = extractelement <4 x i32> %145, i64 2 + %147 = load <4 x i32>, <4 x i32>* %w, align 16 + %148 = extractelement <4 x i32> %147, i64 3 + %149 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.42, i32 0, i32 0), i32 %142, i32 %144, i32 %146, i32 %148) store <4 x i32> , <4 x i32>* %uz, align 16 - %145 = load <4 x i32>, <4 x i32>* %uz, align 16 - %146 = load <4 x i32>, <4 x i32>* %y, align 16 - %lt11 = icmp slt <4 x i32> %146, %145 - %check = icmp slt <4 x i32> %145, zeroinitializer + %150 = load <4 x i32>, <4 x i32>* %uz, align 16 + %151 = load <4 x i32>, <4 x i32>* %y, align 16 + %lt11 = icmp slt <4 x i32> %151, %150 + %check = icmp slt <4 x i32> %150, zeroinitializer %siui-lt = or <4 x i1> %check, %lt11 - %147 = sext <4 x i1> %siui-lt to <4 x i32> - store <4 x i32> %147, <4 x i32>* %w, align 16 - %148 = load <4 x i32>, <4 x i32>* %w, align 16 - %149 = extractelement <4 x i32> %148, i64 0 - %150 = load <4 x i32>, <4 x i32>* %w, align 16 - %151 = extractelement <4 x i32> %150, i64 1 - %152 = load <4 x i32>, <4 x i32>* %w, align 16 - %153 = extractelement <4 x i32> %152, i64 2 - %154 = load <4 x i32>, <4 x i32>* %w, align 16 - %155 = extractelement <4 x i32> %154, i64 3 - %156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.45, i32 0, i32 0), i32 %149, i32 %151, i32 %153, i32 %155) - %157 = load <4 x i32>, <4 x i32>* %uz, align 16 - %158 = load <4 x i32>, <4 x i32>* %y, align 16 - %le12 = icmp sle <4 x i32> %158, %157 - %check13 = icmp slt <4 x i32> %157, zeroinitializer + %152 = sext <4 x i1> %siui-lt to <4 x i32> + store <4 x i32> %152, <4 x i32>* %w, align 16 + %153 = load <4 x i32>, <4 x i32>* %w, align 16 + %154 = extractelement <4 x i32> %153, i64 0 + %155 = load <4 x i32>, <4 x i32>* %w, align 16 + %156 = extractelement <4 x i32> %155, i64 1 + %157 = load <4 x i32>, <4 x i32>* %w, align 16 + %158 = extractelement <4 x i32> %157, i64 2 + %159 = load <4 x i32>, <4 x i32>* %w, align 16 + %160 = extractelement <4 x i32> %159, i64 3 + %161 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.43, i32 0, i32 0), i32 %154, i32 %156, i32 %158, i32 %160) + %162 = load <4 x i32>, <4 x i32>* %uz, align 16 + %163 = load <4 x i32>, <4 x i32>* %y, align 16 + %le12 = icmp sle <4 x i32> %163, %162 + %check13 = icmp slt <4 x i32> %162, zeroinitializer %siui-le = or <4 x i1> %check13, %le12 - %159 = sext <4 x i1> %siui-le to <4 x i32> - store <4 x i32> %159, <4 x i32>* %w, align 16 - %160 = load <4 x i32>, <4 x i32>* %w, align 16 - %161 = extractelement <4 x i32> %160, i64 0 - %162 = load <4 x i32>, <4 x i32>* %w, align 16 - %163 = extractelement <4 x i32> %162, i64 1 - %164 = load <4 x i32>, <4 x i32>* %w, align 16 - %165 = extractelement <4 x i32> %164, i64 2 - %166 = load <4 x i32>, <4 x i32>* %w, align 16 - %167 = extractelement <4 x i32> %166, i64 3 - %168 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.46, i32 0, i32 0), i32 %161, i32 %163, i32 %165, i32 %167) - %169 = load <4 x i32>, <4 x i32>* %uz, align 16 - %170 = load <4 x i32>, <4 x i32>* %y, align 16 - %gt14 = icmp sgt <4 x i32> %170, %169 - %check15 = icmp sge <4 x i32> %169, zeroinitializer + %164 = sext <4 x i1> %siui-le to <4 x i32> + store <4 x i32> %164, <4 x i32>* %w, align 16 + %165 = load <4 x i32>, <4 x i32>* %w, align 16 + %166 = extractelement <4 x i32> %165, i64 0 + %167 = load <4 x i32>, <4 x i32>* %w, align 16 + %168 = extractelement <4 x i32> %167, i64 1 + %169 = load <4 x i32>, <4 x i32>* %w, align 16 + %170 = extractelement <4 x i32> %169, i64 2 + %171 = load <4 x i32>, <4 x i32>* %w, align 16 + %172 = extractelement <4 x i32> %171, i64 3 + %173 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.44, i32 0, i32 0), i32 %166, i32 %168, i32 %170, i32 %172) + %174 = load <4 x i32>, <4 x i32>* %uz, align 16 + %175 = load <4 x i32>, <4 x i32>* %y, align 16 + %gt14 = icmp sgt <4 x i32> %175, %174 + %check15 = icmp sge <4 x i32> %174, zeroinitializer %siui-gt = and <4 x i1> %check15, %gt14 - %171 = sext <4 x i1> %siui-gt to <4 x i32> - store <4 x i32> %171, <4 x i32>* %w, align 16 - %172 = load <4 x i32>, <4 x i32>* %w, align 16 - %173 = extractelement <4 x i32> %172, i64 0 - %174 = load <4 x i32>, <4 x i32>* %w, align 16 - %175 = extractelement <4 x i32> %174, i64 1 - %176 = load <4 x i32>, <4 x i32>* %w, align 16 - %177 = extractelement <4 x i32> %176, i64 2 - %178 = load <4 x i32>, <4 x i32>* %w, align 16 - %179 = extractelement <4 x i32> %178, i64 3 - %180 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.47, i32 0, i32 0), i32 %173, i32 %175, i32 %177, i32 %179) - %181 = load <4 x i32>, <4 x i32>* %uz, align 16 - %182 = load <4 x i32>, <4 x i32>* %y, align 16 - %ge16 = icmp sge <4 x i32> %182, %181 - %check17 = icmp sge <4 x i32> %181, zeroinitializer + %176 = sext <4 x i1> %siui-gt to <4 x i32> + store <4 x i32> %176, <4 x i32>* %w, align 16 + %177 = load <4 x i32>, <4 x i32>* %w, align 16 + %178 = extractelement <4 x i32> %177, i64 0 + %179 = load <4 x i32>, <4 x i32>* %w, align 16 + %180 = extractelement <4 x i32> %179, i64 1 + %181 = load <4 x i32>, <4 x i32>* %w, align 16 + %182 = extractelement <4 x i32> %181, i64 2 + %183 = load <4 x i32>, <4 x i32>* %w, align 16 + %184 = extractelement <4 x i32> %183, i64 3 + %185 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.45, i32 0, i32 0), i32 %178, i32 %180, i32 %182, i32 %184) + %186 = load <4 x i32>, <4 x i32>* %uz, align 16 + %187 = load <4 x i32>, <4 x i32>* %y, align 16 + %ge16 = icmp sge <4 x i32> %187, %186 + %check17 = icmp sge <4 x i32> %186, zeroinitializer %siui-ge = and <4 x i1> %check17, %ge16 - %183 = sext <4 x i1> %siui-ge to <4 x i32> - store <4 x i32> %183, <4 x i32>* %w, align 16 - %184 = load <4 x i32>, <4 x i32>* %w, align 16 - %185 = extractelement <4 x i32> %184, i64 0 - %186 = load <4 x i32>, <4 x i32>* %w, align 16 - %187 = extractelement <4 x i32> %186, i64 1 - %188 = load <4 x i32>, <4 x i32>* %w, align 16 - %189 = extractelement <4 x i32> %188, i64 2 - %190 = load <4 x i32>, <4 x i32>* %w, align 16 - %191 = extractelement <4 x i32> %190, i64 3 - %192 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.48, i32 0, i32 0), i32 %185, i32 %187, i32 %189, i32 %191) - %193 = load <4 x i32>, <4 x i32>* %uz, align 16 - %194 = load <4 x i32>, <4 x i32>* %y, align 16 - %eq18 = icmp eq <4 x i32> %194, %193 - %check19 = icmp sge <4 x i32> %194, zeroinitializer + %188 = sext <4 x i1> %siui-ge to <4 x i32> + store <4 x i32> %188, <4 x i32>* %w, align 16 + %189 = load <4 x i32>, <4 x i32>* %w, align 16 + %190 = extractelement <4 x i32> %189, i64 0 + %191 = load <4 x i32>, <4 x i32>* %w, align 16 + %192 = extractelement <4 x i32> %191, i64 1 + %193 = load <4 x i32>, <4 x i32>* %w, align 16 + %194 = extractelement <4 x i32> %193, i64 2 + %195 = load <4 x i32>, <4 x i32>* %w, align 16 + %196 = extractelement <4 x i32> %195, i64 3 + %197 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.46, i32 0, i32 0), i32 %190, i32 %192, i32 %194, i32 %196) + %198 = load <4 x i32>, <4 x i32>* %uz, align 16 + %199 = load <4 x i32>, <4 x i32>* %y, align 16 + %eq18 = icmp eq <4 x i32> %199, %198 + %check19 = icmp sge <4 x i32> %199, zeroinitializer %siui-eq = and <4 x i1> %check19, %eq18 - %195 = sext <4 x i1> %siui-eq to <4 x i32> - store <4 x i32> %195, <4 x i32>* %w, align 16 - %196 = load <4 x i32>, <4 x i32>* %w, align 16 - %197 = extractelement <4 x i32> %196, i64 0 - %198 = load <4 x i32>, <4 x i32>* %w, align 16 - %199 = extractelement <4 x i32> %198, i64 1 - %200 = load <4 x i32>, <4 x i32>* %w, align 16 - %201 = extractelement <4 x i32> %200, i64 2 - %202 = load <4 x i32>, <4 x i32>* %w, align 16 - %203 = extractelement <4 x i32> %202, i64 3 - %204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.49, i32 0, i32 0), i32 %197, i32 %199, i32 %201, i32 %203) - %205 = load <4 x i32>, <4 x i32>* %uz, align 16 - %206 = load <4 x i32>, <4 x i32>* %y, align 16 - %neq20 = icmp ne <4 x i32> %206, %205 - %check21 = icmp slt <4 x i32> %206, zeroinitializer + %200 = sext <4 x i1> %siui-eq to <4 x i32> + store <4 x i32> %200, <4 x i32>* %w, align 16 + %201 = load <4 x i32>, <4 x i32>* %w, align 16 + %202 = extractelement <4 x i32> %201, i64 0 + %203 = load <4 x i32>, <4 x i32>* %w, align 16 + %204 = extractelement <4 x i32> %203, i64 1 + %205 = load <4 x i32>, <4 x i32>* %w, align 16 + %206 = extractelement <4 x i32> %205, i64 2 + %207 = load <4 x i32>, <4 x i32>* %w, align 16 + %208 = extractelement <4 x i32> %207, i64 3 + %209 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.47, i32 0, i32 0), i32 %202, i32 %204, i32 %206, i32 %208) + %210 = load <4 x i32>, <4 x i32>* %uz, align 16 + %211 = load <4 x i32>, <4 x i32>* %y, align 16 + %neq20 = icmp ne <4 x i32> %211, %210 + %check21 = icmp slt <4 x i32> %211, zeroinitializer %siui-ne = or <4 x i1> %check21, %neq20 - %207 = sext <4 x i1> %siui-ne to <4 x i32> - store <4 x i32> %207, <4 x i32>* %w, align 16 - %208 = load <4 x i32>, <4 x i32>* %w, align 16 - %209 = extractelement <4 x i32> %208, i64 0 - %210 = load <4 x i32>, <4 x i32>* %w, align 16 - %211 = extractelement <4 x i32> %210, i64 1 - %212 = load <4 x i32>, <4 x i32>* %w, align 16 - %213 = extractelement <4 x i32> %212, i64 2 - %214 = load <4 x i32>, <4 x i32>* %w, align 16 - %215 = extractelement <4 x i32> %214, i64 3 - %216 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.50, i32 0, i32 0), i32 %209, i32 %211, i32 %213, i32 %215) + %212 = sext <4 x i1> %siui-ne to <4 x i32> + store <4 x i32> %212, <4 x i32>* %w, align 16 + %213 = load <4 x i32>, <4 x i32>* %w, align 16 + %214 = extractelement <4 x i32> %213, i64 0 + %215 = load <4 x i32>, <4 x i32>* %w, align 16 + %216 = extractelement <4 x i32> %215, i64 1 + %217 = load <4 x i32>, <4 x i32>* %w, align 16 + %218 = extractelement <4 x i32> %217, i64 2 + %219 = load <4 x i32>, <4 x i32>* %w, align 16 + %220 = extractelement <4 x i32> %219, i64 3 + %221 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.48, i32 0, i32 0), i32 %214, i32 %216, i32 %218, i32 %220) ret void -} +} \ No newline at end of file diff --git a/test/test_suite2/assert/unreachable.c3t b/test/test_suite2/assert/unreachable.c3t index 598c5687e..48eb633e5 100644 --- a/test/test_suite2/assert/unreachable.c3t +++ b/test/test_suite2/assert/unreachable.c3t @@ -1,3 +1,4 @@ +// #target: macos-x64 fn int foo() { return 1; @@ -27,12 +28,13 @@ if.then: ; preds = %entry ret void if.exit: ; preds = %entry - call void @std_core_builtin_panic(ptr @.str, ptr @.str.1, ptr @.str.2, i32 10) + %2 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %2(ptr @.str, i64 30, ptr @.str.1, i64 14, ptr @.str.2, i64 4, i32 10) unreachable after.unreachable: ; No predecessors! - %2 = load i32, ptr %x, align 4 - %add = add i32 %2, 1 + %3 = load i32, ptr %x, align 4 + %add = add i32 %3, 1 store i32 %add, ptr %x, align 4 ret void } diff --git a/test/test_suite2/bitstruct/bitstruct_be.c3t b/test/test_suite2/bitstruct/bitstruct_be.c3t index e35021983..0ae6725a5 100644 --- a/test/test_suite2/bitstruct/bitstruct_be.c3t +++ b/test/test_suite2/bitstruct/bitstruct_be.c3t @@ -46,32 +46,19 @@ fn void main() %0 = load i32, ptr %x, align 4 %1 = call i32 @llvm.bswap.i32(i32 %0) store i32 2063597568, ptr %x, align 4 - store %"char[]" { ptr @.str, i64 18 }, ptr %taddr, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %2, align 8 - %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %3, align 8 - %4 = insertvalue %variant undef, ptr %x, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %6 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %5, ptr %6, align 16 - %7 = load i32, ptr %x, align 4 - %8 = call i32 @llvm.bswap.i32(i32 %7) - store i32 %8, ptr %taddr1, align 4 - %9 = insertvalue %variant undef, ptr %taddr1, 0 - %10 = insertvalue %variant %9, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %11 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %10, ptr %11, align 16 - %12 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 2, ptr %12, align 8 - %13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %13, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %15, align 8 - %16 = call i64 @std_io_printf(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %16, 0 + %2 = insertvalue %variant undef, ptr %x, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %4 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %3, ptr %4, align 16 + %5 = load i32, ptr %x, align 4 + %6 = call i32 @llvm.bswap.i32(i32 %5) + store i32 %6, ptr %taddr, align 4 + %7 = insertvalue %variant undef, ptr %taddr, 0 + %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %8, ptr %9, align 16 + %10 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 2) + %not_err = icmp eq i64 %10, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -82,255 +69,177 @@ voiderr: ; preds = %after_check, %entry store [4 x i8] c"\124Vx", ptr %abc2, align 1 store ptr %abc, ptr %z, align 8 store ptr %abc2, ptr %z2, align 8 - %17 = load ptr, ptr %z2, align 8 - store ptr %17, ptr %.anon, align 8 - store i64 0, ptr %.anon4, align 8 + %11 = load ptr, ptr %z2, align 8 + store ptr %11, ptr %.anon, align 8 + store i64 0, ptr %.anon1, align 8 br label %loop.cond -loop.cond: ; preds = %voiderr15, %voiderr - %18 = load i64, ptr %.anon4, align 8 - %gt = icmp ugt i64 4, %18 +loop.cond: ; preds = %voiderr6, %voiderr + %12 = load i64, ptr %.anon1, align 8 + %gt = icmp ugt i64 4, %12 br i1 %gt, label %loop.body, label %loop.exit loop.body: ; preds = %loop.cond - %19 = load ptr, ptr %.anon, align 8 - %20 = load i64, ptr %.anon4, align 8 - %21 = getelementptr inbounds [4 x i8], ptr %19, i64 0, i64 %20 - %22 = load i8, ptr %21, align 1 - store i8 %22, ptr %d, align 1 - store %"char[]" { ptr @.str.1, i64 3 }, ptr %taddr6, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 0 - %lo7 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 1 - %hi8 = load i64, ptr %24, align 8 - %25 = insertvalue %variant undef, ptr %d, 0 - %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$char" to i64), 1 - %27 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0 - store %variant %26, ptr %27, align 16 - %28 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 1 - store i64 1, ptr %28, align 8 - %29 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 0 - store ptr %varargslots10, ptr %29, align 8 - %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 0 - %lo11 = load ptr, ptr %30, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 1 - %hi12 = load i64, ptr %31, align 8 - %32 = call i64 @std_io_printf(ptr %retparam5, ptr %lo7, i64 %hi8, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %32, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %13 = load ptr, ptr %.anon, align 8 + %14 = load i64, ptr %.anon1, align 8 + %15 = getelementptr inbounds [4 x i8], ptr %13, i64 0, i64 %14 + %16 = load i8, ptr %15, align 1 + store i8 %16, ptr %d, align 1 + %17 = insertvalue %variant undef, ptr %d, 0 + %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$char" to i64), 1 + %19 = getelementptr inbounds [1 x %variant], ptr %varargslots3, i64 0, i64 0 + store %variant %18, ptr %19, align 16 + %20 = call i64 @std_io_printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, i64 1) + %not_err4 = icmp eq i64 %20, 0 + br i1 %not_err4, label %after_check5, label %voiderr6 -after_check14: ; preds = %loop.body - br label %voiderr15 +after_check5: ; preds = %loop.body + br label %voiderr6 -voiderr15: ; preds = %after_check14, %loop.body - %33 = load i64, ptr %.anon4, align 8 - %add = add i64 %33, 1 - store i64 %add, ptr %.anon4, align 8 +voiderr6: ; preds = %after_check5, %loop.body + %21 = load i64, ptr %.anon1, align 8 + %add = add i64 %21, 1 + store i64 %add, ptr %.anon1, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - %34 = call i32 @std_io_println(ptr @.str.2) #2 - %35 = load ptr, ptr %z, align 8 - store ptr %35, ptr %.anon16, align 8 - store i64 0, ptr %.anon17, align 8 - br label %loop.cond18 + %22 = call i32 @std_io_println(ptr @.str.2) #2 + %23 = load ptr, ptr %z, align 8 + store ptr %23, ptr %.anon7, align 8 + store i64 0, ptr %.anon8, align 8 + br label %loop.cond9 -loop.cond18: ; preds = %voiderr32, %loop.exit - %36 = load i64, ptr %.anon17, align 8 - %gt19 = icmp ugt i64 4, %36 - br i1 %gt19, label %loop.body20, label %loop.exit34 +loop.cond9: ; preds = %voiderr17, %loop.exit + %24 = load i64, ptr %.anon8, align 8 + %gt10 = icmp ugt i64 4, %24 + br i1 %gt10, label %loop.body11, label %loop.exit19 -loop.body20: ; preds = %loop.cond18 - %37 = load ptr, ptr %.anon16, align 8 - %38 = load i64, ptr %.anon17, align 8 - %39 = getelementptr inbounds [4 x i8], ptr %37, i64 0, i64 %38 - %40 = load i8, ptr %39, align 1 - store i8 %40, ptr %d21, align 1 - store %"char[]" { ptr @.str.3, i64 3 }, ptr %taddr23, align 8 - %41 = getelementptr inbounds { ptr, i64 }, ptr %taddr23, i32 0, i32 0 - %lo24 = load ptr, ptr %41, align 8 - %42 = getelementptr inbounds { ptr, i64 }, ptr %taddr23, i32 0, i32 1 - %hi25 = load i64, ptr %42, align 8 - %43 = insertvalue %variant undef, ptr %d21, 0 - %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$char" to i64), 1 - %45 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0 - store %variant %44, ptr %45, align 16 - %46 = getelementptr inbounds %"variant[]", ptr %vararg26, i32 0, i32 1 - store i64 1, ptr %46, align 8 - %47 = getelementptr inbounds %"variant[]", ptr %vararg26, i32 0, i32 0 - store ptr %varargslots27, ptr %47, align 8 - %48 = getelementptr inbounds { ptr, i64 }, ptr %vararg26, i32 0, i32 0 - %lo28 = load ptr, ptr %48, align 8 - %49 = getelementptr inbounds { ptr, i64 }, ptr %vararg26, i32 0, i32 1 - %hi29 = load i64, ptr %49, align 8 - %50 = call i64 @std_io_printf(ptr %retparam22, ptr %lo24, i64 %hi25, ptr %lo28, i64 %hi29) - %not_err30 = icmp eq i64 %50, 0 +loop.body11: ; preds = %loop.cond9 + %25 = load ptr, ptr %.anon7, align 8 + %26 = load i64, ptr %.anon8, align 8 + %27 = getelementptr inbounds [4 x i8], ptr %25, i64 0, i64 %26 + %28 = load i8, ptr %27, align 1 + store i8 %28, ptr %d12, align 1 + %29 = insertvalue %variant undef, ptr %d12, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$char" to i64), 1 + %31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0 + store %variant %30, ptr %31, align 16 + %32 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.3, i64 3, ptr %varargslots14, i64 1) + %not_err15 = icmp eq i64 %32, 0 + br i1 %not_err15, label %after_check16, label %voiderr17 + +after_check16: ; preds = %loop.body11 + br label %voiderr17 + +voiderr17: ; preds = %after_check16, %loop.body11 + %33 = load i64, ptr %.anon8, align 8 + %add18 = add i64 %33, 1 + store i64 %add18, ptr %.anon8, align 8 + br label %loop.cond9 + +loop.exit19: ; preds = %loop.cond9 + %34 = call i32 @std_io_println(ptr @.str.4) #2 + %35 = load i32, ptr %abc, align 4 + %36 = call i32 @llvm.bswap.i32(i32 %35) + %37 = and i32 65535, %36 + %ztrunc = trunc i32 %37 to i16 + store i16 %ztrunc, ptr %taddr22, align 2 + %38 = insertvalue %variant undef, ptr %taddr22, 0 + %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$ushort" to i64), 1 + %40 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0 + store %variant %39, ptr %40, align 16 + %41 = call i64 @std_io_printfln(ptr %retparam20, ptr @.str.5, i64 10, ptr %varargslots21, i64 1) + %not_err23 = icmp eq i64 %41, 0 + br i1 %not_err23, label %after_check24, label %voiderr25 + +after_check24: ; preds = %loop.exit19 + br label %voiderr25 + +voiderr25: ; preds = %after_check24, %loop.exit19 + %42 = load i32, ptr %abc, align 4 + %43 = call i32 @llvm.bswap.i32(i32 %42) + %44 = and i32 %43, -65536 + %45 = or i32 %44, 4660 + %46 = call i32 @llvm.bswap.i32(i32 %45) + store i32 %46, ptr %abc, align 4 + %47 = load i32, ptr %abc, align 4 + %48 = call i32 @llvm.bswap.i32(i32 %47) + %49 = and i32 %48, 65535 + %50 = or i32 %49, 1450704896 + %51 = call i32 @llvm.bswap.i32(i32 %50) + store i32 %51, ptr %abc, align 4 + %52 = load i32, ptr %abc, align 4 + %53 = call i32 @llvm.bswap.i32(i32 %52) + %54 = and i32 65535, %53 + %ztrunc28 = trunc i32 %54 to i16 + store i16 %ztrunc28, ptr %taddr29, align 2 + %55 = insertvalue %variant undef, ptr %taddr29, 0 + %56 = insertvalue %variant %55, i64 ptrtoint (ptr @"ct$ushort" to i64), 1 + %57 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0 + store %variant %56, ptr %57, align 16 + %58 = call i64 @std_io_printfln(ptr %retparam26, ptr @.str.6, i64 12, ptr %varargslots27, i64 1) + %not_err30 = icmp eq i64 %58, 0 br i1 %not_err30, label %after_check31, label %voiderr32 -after_check31: ; preds = %loop.body20 +after_check31: ; preds = %voiderr25 br label %voiderr32 -voiderr32: ; preds = %after_check31, %loop.body20 - %51 = load i64, ptr %.anon17, align 8 - %add33 = add i64 %51, 1 - store i64 %add33, ptr %.anon17, align 8 - br label %loop.cond18 +voiderr32: ; preds = %after_check31, %voiderr25 + %59 = load ptr, ptr %z, align 8 + store ptr %59, ptr %.anon33, align 8 + store i64 0, ptr %.anon34, align 8 + br label %loop.cond35 -loop.exit34: ; preds = %loop.cond18 - %52 = call i32 @std_io_println(ptr @.str.4) #2 - store %"char[]" { ptr @.str.5, i64 10 }, ptr %taddr36, align 8 - %53 = getelementptr inbounds { ptr, i64 }, ptr %taddr36, i32 0, i32 0 - %lo37 = load ptr, ptr %53, align 8 - %54 = getelementptr inbounds { ptr, i64 }, ptr %taddr36, i32 0, i32 1 - %hi38 = load i64, ptr %54, align 8 - %55 = load i32, ptr %abc, align 4 - %56 = call i32 @llvm.bswap.i32(i32 %55) - %57 = and i32 65535, %56 - %ztrunc = trunc i32 %57 to i16 - store i16 %ztrunc, ptr %taddr41, align 2 - %58 = insertvalue %variant undef, ptr %taddr41, 0 - %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$ushort" to i64), 1 - %60 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0 - store %variant %59, ptr %60, align 16 - %61 = getelementptr inbounds %"variant[]", ptr %vararg39, i32 0, i32 1 - store i64 1, ptr %61, align 8 - %62 = getelementptr inbounds %"variant[]", ptr %vararg39, i32 0, i32 0 - store ptr %varargslots40, ptr %62, align 8 - %63 = getelementptr inbounds { ptr, i64 }, ptr %vararg39, i32 0, i32 0 - %lo42 = load ptr, ptr %63, align 8 - %64 = getelementptr inbounds { ptr, i64 }, ptr %vararg39, i32 0, i32 1 - %hi43 = load i64, ptr %64, align 8 - %65 = call i64 @std_io_printfln(ptr %retparam35, ptr %lo37, i64 %hi38, ptr %lo42, i64 %hi43) - %not_err44 = icmp eq i64 %65, 0 - br i1 %not_err44, label %after_check45, label %voiderr46 +loop.cond35: ; preds = %voiderr43, %voiderr32 + %60 = load i64, ptr %.anon34, align 8 + %gt36 = icmp ugt i64 4, %60 + br i1 %gt36, label %loop.body37, label %loop.exit45 -after_check45: ; preds = %loop.exit34 - br label %voiderr46 +loop.body37: ; preds = %loop.cond35 + %61 = load ptr, ptr %.anon33, align 8 + %62 = load i64, ptr %.anon34, align 8 + %63 = getelementptr inbounds [4 x i8], ptr %61, i64 0, i64 %62 + %64 = load i8, ptr %63, align 1 + store i8 %64, ptr %d38, align 1 + %65 = insertvalue %variant undef, ptr %d38, 0 + %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$char" to i64), 1 + %67 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0 + store %variant %66, ptr %67, align 16 + %68 = call i64 @std_io_printf(ptr %retparam39, ptr @.str.7, i64 3, ptr %varargslots40, i64 1) + %not_err41 = icmp eq i64 %68, 0 + br i1 %not_err41, label %after_check42, label %voiderr43 -voiderr46: ; preds = %after_check45, %loop.exit34 - %66 = load i32, ptr %abc, align 4 - %67 = call i32 @llvm.bswap.i32(i32 %66) - %68 = and i32 %67, -65536 - %69 = or i32 %68, 4660 - %70 = call i32 @llvm.bswap.i32(i32 %69) - store i32 %70, ptr %abc, align 4 - %71 = load i32, ptr %abc, align 4 - %72 = call i32 @llvm.bswap.i32(i32 %71) - %73 = and i32 %72, 65535 - %74 = or i32 %73, 1450704896 - %75 = call i32 @llvm.bswap.i32(i32 %74) - store i32 %75, ptr %abc, align 4 - store %"char[]" { ptr @.str.6, i64 12 }, ptr %taddr48, align 8 - %76 = getelementptr inbounds { ptr, i64 }, ptr %taddr48, i32 0, i32 0 - %lo49 = load ptr, ptr %76, align 8 - %77 = getelementptr inbounds { ptr, i64 }, ptr %taddr48, i32 0, i32 1 - %hi50 = load i64, ptr %77, align 8 - %78 = load i32, ptr %abc, align 4 - %79 = call i32 @llvm.bswap.i32(i32 %78) - %80 = and i32 65535, %79 - %ztrunc53 = trunc i32 %80 to i16 - store i16 %ztrunc53, ptr %taddr54, align 2 - %81 = insertvalue %variant undef, ptr %taddr54, 0 - %82 = insertvalue %variant %81, i64 ptrtoint (ptr @"ct$ushort" to i64), 1 - %83 = getelementptr inbounds [1 x %variant], ptr %varargslots52, i64 0, i64 0 - store %variant %82, ptr %83, align 16 - %84 = getelementptr inbounds %"variant[]", ptr %vararg51, i32 0, i32 1 - store i64 1, ptr %84, align 8 - %85 = getelementptr inbounds %"variant[]", ptr %vararg51, i32 0, i32 0 - store ptr %varargslots52, ptr %85, align 8 - %86 = getelementptr inbounds { ptr, i64 }, ptr %vararg51, i32 0, i32 0 - %lo55 = load ptr, ptr %86, align 8 - %87 = getelementptr inbounds { ptr, i64 }, ptr %vararg51, i32 0, i32 1 - %hi56 = load i64, ptr %87, align 8 - %88 = call i64 @std_io_printfln(ptr %retparam47, ptr %lo49, i64 %hi50, ptr %lo55, i64 %hi56) - %not_err57 = icmp eq i64 %88, 0 - br i1 %not_err57, label %after_check58, label %voiderr59 +after_check42: ; preds = %loop.body37 + br label %voiderr43 -after_check58: ; preds = %voiderr46 - br label %voiderr59 +voiderr43: ; preds = %after_check42, %loop.body37 + %69 = load i64, ptr %.anon34, align 8 + %add44 = add i64 %69, 1 + store i64 %add44, ptr %.anon34, align 8 + br label %loop.cond35 -voiderr59: ; preds = %after_check58, %voiderr46 - %89 = load ptr, ptr %z, align 8 - store ptr %89, ptr %.anon60, align 8 - store i64 0, ptr %.anon61, align 8 - br label %loop.cond62 - -loop.cond62: ; preds = %voiderr76, %voiderr59 - %90 = load i64, ptr %.anon61, align 8 - %gt63 = icmp ugt i64 4, %90 - br i1 %gt63, label %loop.body64, label %loop.exit78 - -loop.body64: ; preds = %loop.cond62 - %91 = load ptr, ptr %.anon60, align 8 - %92 = load i64, ptr %.anon61, align 8 - %93 = getelementptr inbounds [4 x i8], ptr %91, i64 0, i64 %92 - %94 = load i8, ptr %93, align 1 - store i8 %94, ptr %d65, align 1 - store %"char[]" { ptr @.str.7, i64 3 }, ptr %taddr67, align 8 - %95 = getelementptr inbounds { ptr, i64 }, ptr %taddr67, i32 0, i32 0 - %lo68 = load ptr, ptr %95, align 8 - %96 = getelementptr inbounds { ptr, i64 }, ptr %taddr67, i32 0, i32 1 - %hi69 = load i64, ptr %96, align 8 - %97 = insertvalue %variant undef, ptr %d65, 0 - %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"ct$char" to i64), 1 - %99 = getelementptr inbounds [1 x %variant], ptr %varargslots71, i64 0, i64 0 - store %variant %98, ptr %99, align 16 - %100 = getelementptr inbounds %"variant[]", ptr %vararg70, i32 0, i32 1 - store i64 1, ptr %100, align 8 - %101 = getelementptr inbounds %"variant[]", ptr %vararg70, i32 0, i32 0 - store ptr %varargslots71, ptr %101, align 8 - %102 = getelementptr inbounds { ptr, i64 }, ptr %vararg70, i32 0, i32 0 - %lo72 = load ptr, ptr %102, align 8 - %103 = getelementptr inbounds { ptr, i64 }, ptr %vararg70, i32 0, i32 1 - %hi73 = load i64, ptr %103, align 8 - %104 = call i64 @std_io_printf(ptr %retparam66, ptr %lo68, i64 %hi69, ptr %lo72, i64 %hi73) - %not_err74 = icmp eq i64 %104, 0 - br i1 %not_err74, label %after_check75, label %voiderr76 - -after_check75: ; preds = %loop.body64 - br label %voiderr76 - -voiderr76: ; preds = %after_check75, %loop.body64 - %105 = load i64, ptr %.anon61, align 8 - %add77 = add i64 %105, 1 - store i64 %add77, ptr %.anon61, align 8 - br label %loop.cond62 - -loop.exit78: ; preds = %loop.cond62 - %106 = call i32 @std_io_println(ptr @.str.8) #2 +loop.exit45: ; preds = %loop.cond35 + %70 = call i32 @std_io_println(ptr @.str.8) #2 store i32 0, ptr %y, align 4 - %107 = load i32, ptr %y, align 4 + %71 = load i32, ptr %y, align 4 store i32 123, ptr %y, align 4 - store %"char[]" { ptr @.str.9, i64 18 }, ptr %taddr80, align 8 - %108 = getelementptr inbounds { ptr, i64 }, ptr %taddr80, i32 0, i32 0 - %lo81 = load ptr, ptr %108, align 8 - %109 = getelementptr inbounds { ptr, i64 }, ptr %taddr80, i32 0, i32 1 - %hi82 = load i64, ptr %109, align 8 - %110 = insertvalue %variant undef, ptr %y, 0 - %111 = insertvalue %variant %110, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %112 = getelementptr inbounds [2 x %variant], ptr %varargslots84, i64 0, i64 0 - store %variant %111, ptr %112, align 16 - %113 = load i32, ptr %y, align 4 - store i32 %113, ptr %taddr85, align 4 - %114 = insertvalue %variant undef, ptr %taddr85, 0 - %115 = insertvalue %variant %114, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %116 = getelementptr inbounds [2 x %variant], ptr %varargslots84, i64 0, i64 1 - store %variant %115, ptr %116, align 16 - %117 = getelementptr inbounds %"variant[]", ptr %vararg83, i32 0, i32 1 - store i64 2, ptr %117, align 8 - %118 = getelementptr inbounds %"variant[]", ptr %vararg83, i32 0, i32 0 - store ptr %varargslots84, ptr %118, align 8 - %119 = getelementptr inbounds { ptr, i64 }, ptr %vararg83, i32 0, i32 0 - %lo86 = load ptr, ptr %119, align 8 - %120 = getelementptr inbounds { ptr, i64 }, ptr %vararg83, i32 0, i32 1 - %hi87 = load i64, ptr %120, align 8 - %121 = call i64 @std_io_printf(ptr %retparam79, ptr %lo81, i64 %hi82, ptr %lo86, i64 %hi87) - %not_err88 = icmp eq i64 %121, 0 - br i1 %not_err88, label %after_check89, label %voiderr90 + %72 = insertvalue %variant undef, ptr %y, 0 + %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %74 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 0 + store %variant %73, ptr %74, align 16 + %75 = load i32, ptr %y, align 4 + store i32 %75, ptr %taddr48, align 4 + %76 = insertvalue %variant undef, ptr %taddr48, 0 + %77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %78 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 1 + store %variant %77, ptr %78, align 16 + %79 = call i64 @std_io_printf(ptr %retparam46, ptr @.str.9, i64 18, ptr %varargslots47, i64 2) + %not_err49 = icmp eq i64 %79, 0 + br i1 %not_err49, label %after_check50, label %voiderr51 -after_check89: ; preds = %loop.exit78 - br label %voiderr90 +after_check50: ; preds = %loop.exit45 + br label %voiderr51 -voiderr90: ; preds = %after_check89, %loop.exit78 +voiderr51: ; preds = %after_check50, %loop.exit45 ret void } \ No newline at end of file diff --git a/test/test_suite2/bitstruct/bitstruct_initializer.c3t b/test/test_suite2/bitstruct/bitstruct_initializer.c3t index d837a6c4b..a031d5c98 100644 --- a/test/test_suite2/bitstruct/bitstruct_initializer.c3t +++ b/test/test_suite2/bitstruct/bitstruct_initializer.c3t @@ -55,47 +55,35 @@ entry: %d = alloca %Abc, align 8 %b = alloca [8 x i8], align 1 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [3 x %variant], align 16 - %taddr11 = alloca i32, align 4 - %taddr14 = alloca i32, align 4 - %taddr17 = alloca i8, align 1 - %retparam20 = alloca i64, align 8 - %taddr21 = alloca %"char[]", align 8 - %vararg24 = alloca %"variant[]", align 8 - %varargslots25 = alloca [3 x %variant], align 16 - %taddr27 = alloca i32, align 4 - %taddr30 = alloca i32, align 4 - %taddr33 = alloca i8, align 1 - %retparam39 = alloca i64, align 8 - %taddr40 = alloca %"char[]", align 8 - %vararg43 = alloca %"variant[]", align 8 - %varargslots44 = alloca [3 x %variant], align 16 - %taddr52 = alloca i32, align 4 - %taddr60 = alloca i32, align 4 - %taddr62 = alloca i8, align 1 - %retparam82 = alloca i64, align 8 - %taddr83 = alloca %"char[]", align 8 - %vararg86 = alloca %"variant[]", align 8 - %varargslots87 = alloca [3 x %variant], align 16 - %taddr89 = alloca i32, align 4 - %taddr92 = alloca i32, align 4 - %taddr95 = alloca i8, align 1 - %retparam101 = alloca i64, align 8 - %taddr102 = alloca %"char[]", align 8 - %vararg105 = alloca %"variant[]", align 8 - %varargslots106 = alloca [3 x %variant], align 16 - %taddr108 = alloca i32, align 4 - %taddr111 = alloca i32, align 4 - %taddr114 = alloca i8, align 1 - %retparam120 = alloca i64, align 8 - %taddr121 = alloca %"char[]", align 8 - %vararg124 = alloca %"variant[]", align 8 - %varargslots125 = alloca [3 x %variant], align 16 - %taddr133 = alloca i32, align 4 - %taddr141 = alloca i32, align 4 - %taddr143 = alloca i8, align 1 + %taddr = alloca i32, align 4 + %taddr13 = alloca i32, align 4 + %taddr16 = alloca i8, align 1 + %retparam17 = alloca i64, align 8 + %varargslots18 = alloca [3 x %variant], align 16 + %taddr20 = alloca i32, align 4 + %taddr23 = alloca i32, align 4 + %taddr26 = alloca i8, align 1 + %retparam30 = alloca i64, align 8 + %varargslots31 = alloca [3 x %variant], align 16 + %taddr39 = alloca i32, align 4 + %taddr47 = alloca i32, align 4 + %taddr49 = alloca i8, align 1 + %retparam67 = alloca i64, align 8 + %varargslots68 = alloca [3 x %variant], align 16 + %taddr70 = alloca i32, align 4 + %taddr73 = alloca i32, align 4 + %taddr76 = alloca i8, align 1 + %retparam80 = alloca i64, align 8 + %varargslots81 = alloca [3 x %variant], align 16 + %taddr83 = alloca i32, align 4 + %taddr86 = alloca i32, align 4 + %taddr89 = alloca i8, align 1 + %retparam93 = alloca i64, align 8 + %varargslots94 = alloca [3 x %variant], align 16 + %taddr102 = alloca i32, align 4 + %taddr110 = alloca i32, align 4 + %taddr112 = alloca i8, align 1 store i64 0, ptr %x, align 8 %zext = zext i32 %0 to i64 %1 = and i64 %zext, 4294967295 @@ -165,421 +153,350 @@ entry: %29 = and i8 %28, 127 %30 = or i8 %29, %shl9 store i8 %30, ptr %27, align 1 - store %"char[]" { ptr @.str, i64 8 }, ptr %taddr, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %31, align 8 - %32 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %32, align 8 - %33 = load i64, ptr %x, align 8 - %34 = and i64 4294967295, %33 - %ztrunc10 = trunc i64 %34 to i32 - store i32 %ztrunc10, ptr %taddr11, align 4 - %35 = insertvalue %variant undef, ptr %taddr11, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %37 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %36, ptr %37, align 16 - %38 = load i64, ptr %x, align 8 - %lshrl12 = lshr i64 %38, 32 - %39 = and i64 2147483647, %lshrl12 - %ztrunc13 = trunc i64 %39 to i32 - store i32 %ztrunc13, ptr %taddr14, align 4 - %40 = insertvalue %variant undef, ptr %taddr14, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %42 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %41, ptr %42, align 16 - %43 = load i64, ptr %x, align 8 - %lshrl15 = lshr i64 %43, 63 - %44 = and i64 1, %lshrl15 - %ztrunc16 = trunc i64 %44 to i8 - store i8 %ztrunc16, ptr %taddr17, align 1 - %45 = insertvalue %variant undef, ptr %taddr17, 0 - %46 = insertvalue %variant %45, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %47 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2 - store %variant %46, ptr %47, align 16 - %48 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 3, ptr %48, align 8 - %49 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %49, align 8 - %50 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo18 = load ptr, ptr %50, align 8 - %51 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi19 = load i64, ptr %51, align 8 - %52 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo18, i64 %hi19) - %not_err = icmp eq i64 %52, 0 + %31 = load i64, ptr %x, align 8 + %32 = and i64 4294967295, %31 + %ztrunc10 = trunc i64 %32 to i32 + store i32 %ztrunc10, ptr %taddr, align 4 + %33 = insertvalue %variant undef, ptr %taddr, 0 + %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %35 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %34, ptr %35, align 16 + %36 = load i64, ptr %x, align 8 + %lshrl11 = lshr i64 %36, 32 + %37 = and i64 2147483647, %lshrl11 + %ztrunc12 = trunc i64 %37 to i32 + store i32 %ztrunc12, ptr %taddr13, align 4 + %38 = insertvalue %variant undef, ptr %taddr13, 0 + %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %40 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %39, ptr %40, align 16 + %41 = load i64, ptr %x, align 8 + %lshrl14 = lshr i64 %41, 63 + %42 = and i64 1, %lshrl14 + %ztrunc15 = trunc i64 %42 to i8 + store i8 %ztrunc15, ptr %taddr16, align 1 + %43 = insertvalue %variant undef, ptr %taddr16, 0 + %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %45 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2 + store %variant %44, ptr %45, align 16 + %46 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3) + %not_err = icmp eq i64 %46, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { ptr @.str.2, i64 8 }, ptr %taddr21, align 8 - %53 = getelementptr inbounds { ptr, i64 }, ptr %taddr21, i32 0, i32 0 - %lo22 = load ptr, ptr %53, align 8 - %54 = getelementptr inbounds { ptr, i64 }, ptr %taddr21, i32 0, i32 1 - %hi23 = load i64, ptr %54, align 8 - %55 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 - %56 = load i64, ptr %55, align 8 - %57 = and i64 4294967295, %56 - %ztrunc26 = trunc i64 %57 to i32 - store i32 %ztrunc26, ptr %taddr27, align 4 - %58 = insertvalue %variant undef, ptr %taddr27, 0 - %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %60 = getelementptr inbounds [3 x %variant], ptr %varargslots25, i64 0, i64 0 - store %variant %59, ptr %60, align 16 - %61 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 - %62 = load i64, ptr %61, align 8 - %lshrl28 = lshr i64 %62, 32 - %63 = and i64 2147483647, %lshrl28 - %ztrunc29 = trunc i64 %63 to i32 - store i32 %ztrunc29, ptr %taddr30, align 4 - %64 = insertvalue %variant undef, ptr %taddr30, 0 - %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %66 = getelementptr inbounds [3 x %variant], ptr %varargslots25, i64 0, i64 1 - store %variant %65, ptr %66, align 16 - %67 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 - %68 = load i64, ptr %67, align 8 - %lshrl31 = lshr i64 %68, 63 - %69 = and i64 1, %lshrl31 - %ztrunc32 = trunc i64 %69 to i8 - store i8 %ztrunc32, ptr %taddr33, align 1 - %70 = insertvalue %variant undef, ptr %taddr33, 0 - %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %72 = getelementptr inbounds [3 x %variant], ptr %varargslots25, i64 0, i64 2 - store %variant %71, ptr %72, align 16 - %73 = getelementptr inbounds %"variant[]", ptr %vararg24, i32 0, i32 1 - store i64 3, ptr %73, align 8 - %74 = getelementptr inbounds %"variant[]", ptr %vararg24, i32 0, i32 0 - store ptr %varargslots25, ptr %74, align 8 - %75 = getelementptr inbounds { ptr, i64 }, ptr %vararg24, i32 0, i32 0 - %lo34 = load ptr, ptr %75, align 8 - %76 = getelementptr inbounds { ptr, i64 }, ptr %vararg24, i32 0, i32 1 - %hi35 = load i64, ptr %76, align 8 - %77 = call i64 @std_io_printfln(ptr %retparam20, ptr %lo22, i64 %hi23, ptr %lo34, i64 %hi35) - %not_err36 = icmp eq i64 %77, 0 - br i1 %not_err36, label %after_check37, label %voiderr38 + %47 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 + %48 = load i64, ptr %47, align 8 + %49 = and i64 4294967295, %48 + %ztrunc19 = trunc i64 %49 to i32 + store i32 %ztrunc19, ptr %taddr20, align 4 + %50 = insertvalue %variant undef, ptr %taddr20, 0 + %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %52 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 0 + store %variant %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 + %ztrunc22 = trunc i64 %55 to i32 + store i32 %ztrunc22, ptr %taddr23, align 4 + %56 = insertvalue %variant undef, ptr %taddr23, 0 + %57 = insertvalue %variant %56, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %58 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 1 + store %variant %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 + %ztrunc25 = trunc i64 %61 to i8 + store i8 %ztrunc25, ptr %taddr26, align 1 + %62 = insertvalue %variant undef, ptr %taddr26, 0 + %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %64 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 2 + store %variant %63, ptr %64, align 16 + %65 = call i64 @std_io_printfln(ptr %retparam17, ptr @.str.2, i64 8, ptr %varargslots18, i64 3) + %not_err27 = icmp eq i64 %65, 0 + br i1 %not_err27, label %after_check28, label %voiderr29 -after_check37: ; preds = %voiderr - br label %voiderr38 +after_check28: ; preds = %voiderr + br label %voiderr29 -voiderr38: ; preds = %after_check37, %voiderr - store %"char[]" { ptr @.str.3, i64 8 }, ptr %taddr40, align 8 - %78 = getelementptr inbounds { ptr, i64 }, ptr %taddr40, i32 0, i32 0 - %lo41 = load ptr, ptr %78, align 8 - %79 = getelementptr inbounds { ptr, i64 }, ptr %taddr40, i32 0, i32 1 - %hi42 = load i64, ptr %79, align 8 - %80 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 +voiderr29: ; preds = %after_check28, %voiderr + %66 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 + %67 = load i8, ptr %66, align 1 + %zext32 = zext i8 %67 to i32 + %68 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 + %69 = load i8, ptr %68, align 1 + %zext33 = zext i8 %69 to i32 + %shl34 = shl i32 %zext33, 8 + %70 = or i32 %shl34, %zext32 + %71 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 + %72 = load i8, ptr %71, align 1 + %zext35 = zext i8 %72 to i32 + %shl36 = shl i32 %zext35, 16 + %73 = or i32 %shl36, %70 + %74 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 + %75 = load i8, ptr %74, align 1 + %zext37 = zext i8 %75 to i32 + %shl38 = shl i32 %zext37, 24 + %76 = or i32 %shl38, %73 + store i32 %76, ptr %taddr39, align 4 + %77 = insertvalue %variant undef, ptr %taddr39, 0 + %78 = insertvalue %variant %77, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %79 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 0 + store %variant %78, ptr %79, align 16 + %80 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 %81 = load i8, ptr %80, align 1 - %zext45 = zext i8 %81 to i32 - %82 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 + %zext40 = zext i8 %81 to i32 + %82 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 %83 = load i8, ptr %82, align 1 - %zext46 = zext i8 %83 to i32 - %shl47 = shl i32 %zext46, 8 - %84 = or i32 %shl47, %zext45 - %85 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 + %zext41 = zext i8 %83 to i32 + %shl42 = shl i32 %zext41, 8 + %84 = or i32 %shl42, %zext40 + %85 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 %86 = load i8, ptr %85, align 1 - %zext48 = zext i8 %86 to i32 - %shl49 = shl i32 %zext48, 16 - %87 = or i32 %shl49, %84 - %88 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 + %zext43 = zext i8 %86 to i32 + %shl44 = shl i32 %zext43, 16 + %87 = or i32 %shl44, %84 + %88 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 %89 = load i8, ptr %88, align 1 - %zext50 = zext i8 %89 to i32 - %shl51 = shl i32 %zext50, 24 - %90 = or i32 %shl51, %87 - store i32 %90, ptr %taddr52, align 4 - %91 = insertvalue %variant undef, ptr %taddr52, 0 - %92 = insertvalue %variant %91, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %93 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 0 - store %variant %92, ptr %93, align 16 - %94 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 - %95 = load i8, ptr %94, align 1 - %zext53 = zext i8 %95 to i32 - %96 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 - %97 = load i8, ptr %96, align 1 - %zext54 = zext i8 %97 to i32 - %shl55 = shl i32 %zext54, 8 - %98 = or i32 %shl55, %zext53 - %99 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 - %100 = load i8, ptr %99, align 1 - %zext56 = zext i8 %100 to i32 - %shl57 = shl i32 %zext56, 16 - %101 = or i32 %shl57, %98 - %102 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 - %103 = load i8, ptr %102, align 1 - %zext58 = zext i8 %103 to i32 - %shl59 = shl i32 %zext58, 24 - %104 = or i32 %shl59, %101 - %105 = and i32 2147483647, %104 - store i32 %105, ptr %taddr60, align 4 - %106 = insertvalue %variant undef, ptr %taddr60, 0 - %107 = insertvalue %variant %106, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %108 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 1 - store %variant %107, ptr %108, align 16 - %109 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 - %110 = load i8, ptr %109, align 1 - %lshrl61 = lshr i8 %110, 7 - %111 = trunc i8 %lshrl61 to i1 - %112 = zext i1 %111 to i8 - store i8 %112, ptr %taddr62, align 1 - %113 = insertvalue %variant undef, ptr %taddr62, 0 - %114 = insertvalue %variant %113, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %115 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 2 - store %variant %114, ptr %115, align 16 - %116 = getelementptr inbounds %"variant[]", ptr %vararg43, i32 0, i32 1 - store i64 3, ptr %116, align 8 - %117 = getelementptr inbounds %"variant[]", ptr %vararg43, i32 0, i32 0 - store ptr %varargslots44, ptr %117, align 8 - %118 = getelementptr inbounds { ptr, i64 }, ptr %vararg43, i32 0, i32 0 - %lo63 = load ptr, ptr %118, align 8 - %119 = getelementptr inbounds { ptr, i64 }, ptr %vararg43, i32 0, i32 1 - %hi64 = load i64, ptr %119, align 8 - %120 = call i64 @std_io_printfln(ptr %retparam39, ptr %lo41, i64 %hi42, ptr %lo63, i64 %hi64) - %not_err65 = icmp eq i64 %120, 0 - br i1 %not_err65, label %after_check66, label %voiderr67 + %zext45 = zext i8 %89 to i32 + %shl46 = shl i32 %zext45, 24 + %90 = or i32 %shl46, %87 + %91 = and i32 2147483647, %90 + store i32 %91, ptr %taddr47, align 4 + %92 = insertvalue %variant undef, ptr %taddr47, 0 + %93 = insertvalue %variant %92, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %94 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 1 + store %variant %93, ptr %94, align 16 + %95 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 + %96 = load i8, ptr %95, align 1 + %lshrl48 = lshr i8 %96, 7 + %97 = trunc i8 %lshrl48 to i1 + %98 = zext i1 %97 to i8 + store i8 %98, ptr %taddr49, align 1 + %99 = insertvalue %variant undef, ptr %taddr49, 0 + %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %101 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 2 + store %variant %100, ptr %101, align 16 + %102 = call i64 @std_io_printfln(ptr %retparam30, ptr @.str.3, i64 8, ptr %varargslots31, i64 3) + %not_err50 = icmp eq i64 %102, 0 + br i1 %not_err50, label %after_check51, label %voiderr52 -after_check66: ; preds = %voiderr38 - br label %voiderr67 +after_check51: ; preds = %voiderr29 + br label %voiderr52 -voiderr67: ; preds = %after_check66, %voiderr38 +voiderr52: ; preds = %after_check51, %voiderr29 %add = add i32 %0, 1 - %zext68 = zext i32 %add to i64 - %121 = and i64 %zext68, 4294967295 - %122 = and i64 %121, -9223372032559808513 - %123 = or i64 %122, 4294967296 + %zext53 = zext i32 %add to i64 + %103 = and i64 %zext53, 4294967295 + %104 = and i64 %103, -9223372032559808513 + %105 = or i64 %104, 4294967296 %gt = icmp sgt i32 %0, 100 - %124 = zext i1 %gt to i8 - %zext69 = zext i8 %124 to i64 - %shl70 = shl i64 %zext69, 63 - %125 = and i64 %shl70, -9223372036854775808 - %126 = and i64 %123, 9223372036854775807 - %127 = or i64 %126, %125 - store i64 %127, ptr %x, align 8 - %128 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 - store i64 -9223371989610135519, ptr %128, align 8 - %129 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 - store i8 0, ptr %129, align 1 - %130 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 - store i8 0, ptr %130, align 1 - %131 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 - store i8 0, ptr %131, align 1 - %132 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 - store i8 0, ptr %132, align 1 - %133 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 - store i8 0, ptr %133, align 1 - %134 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 - store i8 0, ptr %134, align 1 - %135 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 - store i8 0, ptr %135, align 1 - %136 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 - store i8 0, ptr %136, align 1 - %add71 = add i32 %0, 1 - %137 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 - %ztrunc72 = trunc i32 %add71 to i8 - store i8 %ztrunc72, ptr %137, align 1 - %lshrl73 = lshr i32 %add71, 8 - %138 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 - %ztrunc74 = trunc i32 %lshrl73 to i8 - store i8 %ztrunc74, ptr %138, align 1 - %lshrl75 = lshr i32 %lshrl73, 8 - %139 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 - %ztrunc76 = trunc i32 %lshrl75 to i8 - store i8 %ztrunc76, ptr %139, align 1 - %lshrl77 = lshr i32 %lshrl75, 8 - %140 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 - %ztrunc78 = trunc i32 %lshrl77 to i8 - store i8 %ztrunc78, ptr %140, align 1 - %lshrl79 = lshr i32 %lshrl77, 8 - %141 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 - store i8 1, ptr %141, align 1 - %142 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 - store i8 0, ptr %142, align 1 - %143 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 - store i8 0, ptr %143, align 1 - %144 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 - %145 = load i8, ptr %144, align 1 - %146 = and i8 %145, -128 - store i8 %146, ptr %144, align 1 - %gt80 = icmp sgt i32 %0, 100 - %147 = zext i1 %gt80 to i8 - %shl81 = shl i8 %147, 7 - %148 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 - %149 = load i8, ptr %148, align 1 - %150 = and i8 %149, 127 - %151 = or i8 %150, %shl81 - store i8 %151, ptr %148, align 1 - store %"char[]" { ptr @.str.4, i64 8 }, ptr %taddr83, align 8 - %152 = getelementptr inbounds { ptr, i64 }, ptr %taddr83, i32 0, i32 0 - %lo84 = load ptr, ptr %152, align 8 - %153 = getelementptr inbounds { ptr, i64 }, ptr %taddr83, i32 0, i32 1 - %hi85 = load i64, ptr %153, align 8 - %154 = load i64, ptr %x, align 8 - %155 = and i64 4294967295, %154 - %ztrunc88 = trunc i64 %155 to i32 - store i32 %ztrunc88, ptr %taddr89, align 4 - %156 = insertvalue %variant undef, ptr %taddr89, 0 - %157 = insertvalue %variant %156, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %158 = getelementptr inbounds [3 x %variant], ptr %varargslots87, i64 0, i64 0 - store %variant %157, ptr %158, align 16 - %159 = load i64, ptr %x, align 8 - %lshrl90 = lshr i64 %159, 32 - %160 = and i64 2147483647, %lshrl90 - %ztrunc91 = trunc i64 %160 to i32 - store i32 %ztrunc91, ptr %taddr92, align 4 - %161 = insertvalue %variant undef, ptr %taddr92, 0 - %162 = insertvalue %variant %161, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %163 = getelementptr inbounds [3 x %variant], ptr %varargslots87, i64 0, i64 1 - store %variant %162, ptr %163, align 16 - %164 = load i64, ptr %x, align 8 - %lshrl93 = lshr i64 %164, 63 - %165 = and i64 1, %lshrl93 - %ztrunc94 = trunc i64 %165 to i8 - store i8 %ztrunc94, ptr %taddr95, align 1 - %166 = insertvalue %variant undef, ptr %taddr95, 0 - %167 = insertvalue %variant %166, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %168 = getelementptr inbounds [3 x %variant], ptr %varargslots87, i64 0, i64 2 - store %variant %167, ptr %168, align 16 - %169 = getelementptr inbounds %"variant[]", ptr %vararg86, i32 0, i32 1 - store i64 3, ptr %169, align 8 - %170 = getelementptr inbounds %"variant[]", ptr %vararg86, i32 0, i32 0 - store ptr %varargslots87, ptr %170, align 8 - %171 = getelementptr inbounds { ptr, i64 }, ptr %vararg86, i32 0, i32 0 - %lo96 = load ptr, ptr %171, align 8 - %172 = getelementptr inbounds { ptr, i64 }, ptr %vararg86, i32 0, i32 1 - %hi97 = load i64, ptr %172, align 8 - %173 = call i64 @std_io_printfln(ptr %retparam82, ptr %lo84, i64 %hi85, ptr %lo96, i64 %hi97) - %not_err98 = icmp eq i64 %173, 0 - br i1 %not_err98, label %after_check99, label %voiderr100 + %106 = zext i1 %gt to i8 + %zext54 = zext i8 %106 to i64 + %shl55 = shl i64 %zext54, 63 + %107 = and i64 %shl55, -9223372036854775808 + %108 = and i64 %105, 9223372036854775807 + %109 = or i64 %108, %107 + store i64 %109, ptr %x, align 8 + %110 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 + store i64 -9223371989610135519, ptr %110, align 8 + %111 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 + store i8 0, ptr %111, align 1 + %112 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 + store i8 0, ptr %112, align 1 + %113 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 + store i8 0, ptr %113, align 1 + %114 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 + store i8 0, ptr %114, align 1 + %115 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 + store i8 0, ptr %115, align 1 + %116 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 + store i8 0, ptr %116, align 1 + %117 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 + store i8 0, ptr %117, align 1 + %118 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 + store i8 0, ptr %118, align 1 + %add56 = add i32 %0, 1 + %119 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 + %ztrunc57 = trunc i32 %add56 to i8 + store i8 %ztrunc57, ptr %119, align 1 + %lshrl58 = lshr i32 %add56, 8 + %120 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 + %ztrunc59 = trunc i32 %lshrl58 to i8 + store i8 %ztrunc59, ptr %120, align 1 + %lshrl60 = lshr i32 %lshrl58, 8 + %121 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 + %ztrunc61 = trunc i32 %lshrl60 to i8 + store i8 %ztrunc61, ptr %121, align 1 + %lshrl62 = lshr i32 %lshrl60, 8 + %122 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 + %ztrunc63 = trunc i32 %lshrl62 to i8 + store i8 %ztrunc63, ptr %122, align 1 + %lshrl64 = lshr i32 %lshrl62, 8 + %123 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 + store i8 1, ptr %123, align 1 + %124 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 + store i8 0, ptr %124, align 1 + %125 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 + store i8 0, ptr %125, align 1 + %126 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 + %127 = load i8, ptr %126, align 1 + %128 = and i8 %127, -128 + store i8 %128, ptr %126, align 1 + %gt65 = icmp sgt i32 %0, 100 + %129 = zext i1 %gt65 to i8 + %shl66 = shl i8 %129, 7 + %130 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 + %131 = load i8, ptr %130, align 1 + %132 = and i8 %131, 127 + %133 = or i8 %132, %shl66 + store i8 %133, ptr %130, align 1 + %134 = load i64, ptr %x, align 8 + %135 = and i64 4294967295, %134 + %ztrunc69 = trunc i64 %135 to i32 + store i32 %ztrunc69, ptr %taddr70, align 4 + %136 = insertvalue %variant undef, ptr %taddr70, 0 + %137 = insertvalue %variant %136, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %138 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 0 + store %variant %137, ptr %138, align 16 + %139 = load i64, ptr %x, align 8 + %lshrl71 = lshr i64 %139, 32 + %140 = and i64 2147483647, %lshrl71 + %ztrunc72 = trunc i64 %140 to i32 + store i32 %ztrunc72, ptr %taddr73, align 4 + %141 = insertvalue %variant undef, ptr %taddr73, 0 + %142 = insertvalue %variant %141, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %143 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 1 + store %variant %142, ptr %143, align 16 + %144 = load i64, ptr %x, align 8 + %lshrl74 = lshr i64 %144, 63 + %145 = and i64 1, %lshrl74 + %ztrunc75 = trunc i64 %145 to i8 + store i8 %ztrunc75, ptr %taddr76, align 1 + %146 = insertvalue %variant undef, ptr %taddr76, 0 + %147 = insertvalue %variant %146, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %148 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 2 + store %variant %147, ptr %148, align 16 + %149 = call i64 @std_io_printfln(ptr %retparam67, ptr @.str.4, i64 8, ptr %varargslots68, i64 3) + %not_err77 = icmp eq i64 %149, 0 + br i1 %not_err77, label %after_check78, label %voiderr79 -after_check99: ; preds = %voiderr67 - br label %voiderr100 +after_check78: ; preds = %voiderr52 + br label %voiderr79 -voiderr100: ; preds = %after_check99, %voiderr67 - store %"char[]" { ptr @.str.5, i64 8 }, ptr %taddr102, align 8 - %174 = getelementptr inbounds { ptr, i64 }, ptr %taddr102, i32 0, i32 0 - %lo103 = load ptr, ptr %174, align 8 - %175 = getelementptr inbounds { ptr, i64 }, ptr %taddr102, i32 0, i32 1 - %hi104 = load i64, ptr %175, align 8 - %176 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 - %177 = load i64, ptr %176, align 8 - %178 = and i64 4294967295, %177 - %ztrunc107 = trunc i64 %178 to i32 - store i32 %ztrunc107, ptr %taddr108, align 4 - %179 = insertvalue %variant undef, ptr %taddr108, 0 - %180 = insertvalue %variant %179, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %181 = getelementptr inbounds [3 x %variant], ptr %varargslots106, i64 0, i64 0 - store %variant %180, ptr %181, align 16 - %182 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 - %183 = load i64, ptr %182, align 8 - %lshrl109 = lshr i64 %183, 32 - %184 = and i64 2147483647, %lshrl109 - %ztrunc110 = trunc i64 %184 to i32 - store i32 %ztrunc110, ptr %taddr111, align 4 - %185 = insertvalue %variant undef, ptr %taddr111, 0 - %186 = insertvalue %variant %185, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %187 = getelementptr inbounds [3 x %variant], ptr %varargslots106, i64 0, i64 1 - store %variant %186, ptr %187, align 16 - %188 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 - %189 = load i64, ptr %188, align 8 - %lshrl112 = lshr i64 %189, 63 - %190 = and i64 1, %lshrl112 - %ztrunc113 = trunc i64 %190 to i8 - store i8 %ztrunc113, ptr %taddr114, align 1 - %191 = insertvalue %variant undef, ptr %taddr114, 0 - %192 = insertvalue %variant %191, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %193 = getelementptr inbounds [3 x %variant], ptr %varargslots106, i64 0, i64 2 - store %variant %192, ptr %193, align 16 - %194 = getelementptr inbounds %"variant[]", ptr %vararg105, i32 0, i32 1 - store i64 3, ptr %194, align 8 - %195 = getelementptr inbounds %"variant[]", ptr %vararg105, i32 0, i32 0 - store ptr %varargslots106, ptr %195, align 8 - %196 = getelementptr inbounds { ptr, i64 }, ptr %vararg105, i32 0, i32 0 - %lo115 = load ptr, ptr %196, align 8 - %197 = getelementptr inbounds { ptr, i64 }, ptr %vararg105, i32 0, i32 1 - %hi116 = load i64, ptr %197, align 8 - %198 = call i64 @std_io_printfln(ptr %retparam101, ptr %lo103, i64 %hi104, ptr %lo115, i64 %hi116) - %not_err117 = icmp eq i64 %198, 0 - br i1 %not_err117, label %after_check118, label %voiderr119 +voiderr79: ; preds = %after_check78, %voiderr52 + %150 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 + %151 = load i64, ptr %150, align 8 + %152 = and i64 4294967295, %151 + %ztrunc82 = trunc i64 %152 to i32 + store i32 %ztrunc82, ptr %taddr83, align 4 + %153 = insertvalue %variant undef, ptr %taddr83, 0 + %154 = insertvalue %variant %153, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %155 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 0 + store %variant %154, ptr %155, align 16 + %156 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 + %157 = load i64, ptr %156, align 8 + %lshrl84 = lshr i64 %157, 32 + %158 = and i64 2147483647, %lshrl84 + %ztrunc85 = trunc i64 %158 to i32 + store i32 %ztrunc85, ptr %taddr86, align 4 + %159 = insertvalue %variant undef, ptr %taddr86, 0 + %160 = insertvalue %variant %159, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %161 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 1 + store %variant %160, ptr %161, align 16 + %162 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1 + %163 = load i64, ptr %162, align 8 + %lshrl87 = lshr i64 %163, 63 + %164 = and i64 1, %lshrl87 + %ztrunc88 = trunc i64 %164 to i8 + store i8 %ztrunc88, ptr %taddr89, align 1 + %165 = insertvalue %variant undef, ptr %taddr89, 0 + %166 = insertvalue %variant %165, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %167 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 2 + store %variant %166, ptr %167, align 16 + %168 = call i64 @std_io_printfln(ptr %retparam80, ptr @.str.5, i64 8, ptr %varargslots81, i64 3) + %not_err90 = icmp eq i64 %168, 0 + br i1 %not_err90, label %after_check91, label %voiderr92 -after_check118: ; preds = %voiderr100 - br label %voiderr119 +after_check91: ; preds = %voiderr79 + br label %voiderr92 -voiderr119: ; preds = %after_check118, %voiderr100 - store %"char[]" { ptr @.str.6, i64 8 }, ptr %taddr121, align 8 - %199 = getelementptr inbounds { ptr, i64 }, ptr %taddr121, i32 0, i32 0 - %lo122 = load ptr, ptr %199, align 8 - %200 = getelementptr inbounds { ptr, i64 }, ptr %taddr121, i32 0, i32 1 - %hi123 = load i64, ptr %200, align 8 - %201 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 - %202 = load i8, ptr %201, align 1 - %zext126 = zext i8 %202 to i32 - %203 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 - %204 = load i8, ptr %203, align 1 - %zext127 = zext i8 %204 to i32 - %shl128 = shl i32 %zext127, 8 - %205 = or i32 %shl128, %zext126 - %206 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 - %207 = load i8, ptr %206, align 1 - %zext129 = zext i8 %207 to i32 - %shl130 = shl i32 %zext129, 16 - %208 = or i32 %shl130, %205 - %209 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 - %210 = load i8, ptr %209, align 1 - %zext131 = zext i8 %210 to i32 - %shl132 = shl i32 %zext131, 24 - %211 = or i32 %shl132, %208 - store i32 %211, ptr %taddr133, align 4 - %212 = insertvalue %variant undef, ptr %taddr133, 0 - %213 = insertvalue %variant %212, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %214 = getelementptr inbounds [3 x %variant], ptr %varargslots125, i64 0, i64 0 - store %variant %213, ptr %214, align 16 - %215 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 - %216 = load i8, ptr %215, align 1 - %zext134 = zext i8 %216 to i32 - %217 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 - %218 = load i8, ptr %217, align 1 - %zext135 = zext i8 %218 to i32 - %shl136 = shl i32 %zext135, 8 - %219 = or i32 %shl136, %zext134 - %220 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 - %221 = load i8, ptr %220, align 1 - %zext137 = zext i8 %221 to i32 - %shl138 = shl i32 %zext137, 16 - %222 = or i32 %shl138, %219 - %223 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 - %224 = load i8, ptr %223, align 1 - %zext139 = zext i8 %224 to i32 - %shl140 = shl i32 %zext139, 24 - %225 = or i32 %shl140, %222 - %226 = and i32 2147483647, %225 - store i32 %226, ptr %taddr141, align 4 - %227 = insertvalue %variant undef, ptr %taddr141, 0 - %228 = insertvalue %variant %227, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %229 = getelementptr inbounds [3 x %variant], ptr %varargslots125, i64 0, i64 1 - store %variant %228, ptr %229, align 16 - %230 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 - %231 = load i8, ptr %230, align 1 - %lshrl142 = lshr i8 %231, 7 - %232 = trunc i8 %lshrl142 to i1 - %233 = zext i1 %232 to i8 - store i8 %233, ptr %taddr143, align 1 - %234 = insertvalue %variant undef, ptr %taddr143, 0 - %235 = insertvalue %variant %234, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %236 = getelementptr inbounds [3 x %variant], ptr %varargslots125, i64 0, i64 2 - store %variant %235, ptr %236, align 16 - %237 = getelementptr inbounds %"variant[]", ptr %vararg124, i32 0, i32 1 - store i64 3, ptr %237, align 8 - %238 = getelementptr inbounds %"variant[]", ptr %vararg124, i32 0, i32 0 - store ptr %varargslots125, ptr %238, align 8 - %239 = getelementptr inbounds { ptr, i64 }, ptr %vararg124, i32 0, i32 0 - %lo144 = load ptr, ptr %239, align 8 - %240 = getelementptr inbounds { ptr, i64 }, ptr %vararg124, i32 0, i32 1 - %hi145 = load i64, ptr %240, align 8 - %241 = call i64 @std_io_printfln(ptr %retparam120, ptr %lo122, i64 %hi123, ptr %lo144, i64 %hi145) - %not_err146 = icmp eq i64 %241, 0 - br i1 %not_err146, label %after_check147, label %voiderr148 +voiderr92: ; preds = %after_check91, %voiderr79 + %169 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0 + %170 = load i8, ptr %169, align 1 + %zext95 = zext i8 %170 to i32 + %171 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1 + %172 = load i8, ptr %171, align 1 + %zext96 = zext i8 %172 to i32 + %shl97 = shl i32 %zext96, 8 + %173 = or i32 %shl97, %zext95 + %174 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2 + %175 = load i8, ptr %174, align 1 + %zext98 = zext i8 %175 to i32 + %shl99 = shl i32 %zext98, 16 + %176 = or i32 %shl99, %173 + %177 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3 + %178 = load i8, ptr %177, align 1 + %zext100 = zext i8 %178 to i32 + %shl101 = shl i32 %zext100, 24 + %179 = or i32 %shl101, %176 + store i32 %179, ptr %taddr102, align 4 + %180 = insertvalue %variant undef, ptr %taddr102, 0 + %181 = insertvalue %variant %180, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %182 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 0 + store %variant %181, ptr %182, align 16 + %183 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4 + %184 = load i8, ptr %183, align 1 + %zext103 = zext i8 %184 to i32 + %185 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5 + %186 = load i8, ptr %185, align 1 + %zext104 = zext i8 %186 to i32 + %shl105 = shl i32 %zext104, 8 + %187 = or i32 %shl105, %zext103 + %188 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6 + %189 = load i8, ptr %188, align 1 + %zext106 = zext i8 %189 to i32 + %shl107 = shl i32 %zext106, 16 + %190 = or i32 %shl107, %187 + %191 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 + %192 = load i8, ptr %191, align 1 + %zext108 = zext i8 %192 to i32 + %shl109 = shl i32 %zext108, 24 + %193 = or i32 %shl109, %190 + %194 = and i32 2147483647, %193 + store i32 %194, ptr %taddr110, align 4 + %195 = insertvalue %variant undef, ptr %taddr110, 0 + %196 = insertvalue %variant %195, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %197 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 1 + store %variant %196, ptr %197, align 16 + %198 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7 + %199 = load i8, ptr %198, align 1 + %lshrl111 = lshr i8 %199, 7 + %200 = trunc i8 %lshrl111 to i1 + %201 = zext i1 %200 to i8 + store i8 %201, ptr %taddr112, align 1 + %202 = insertvalue %variant undef, ptr %taddr112, 0 + %203 = insertvalue %variant %202, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %204 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 2 + store %variant %203, ptr %204, align 16 + %205 = call i64 @std_io_printfln(ptr %retparam93, ptr @.str.6, i64 8, ptr %varargslots94, i64 3) + %not_err113 = icmp eq i64 %205, 0 + br i1 %not_err113, label %after_check114, label %voiderr115 -after_check147: ; preds = %voiderr119 - br label %voiderr148 +after_check114: ; preds = %voiderr92 + br label %voiderr115 -voiderr148: ; preds = %after_check147, %voiderr119 +voiderr115: ; preds = %after_check114, %voiderr92 + ret void +} + +; Function Attrs: nounwind +define void @test_main() #0 { +entry: + call void @test_hello(i32 12) ret void } diff --git a/test/test_suite2/builtins/reverse_builtin.c3t b/test/test_suite2/builtins/reverse_builtin.c3t index a63183303..a3b556f78 100644 --- a/test/test_suite2/builtins/reverse_builtin.c3t +++ b/test/test_suite2/builtins/reverse_builtin.c3t @@ -11,4 +11,4 @@ fn void main() /* #expect: test.ll -%reverse = shufflevector <4 x i32> %2, <4 x i32> poison, <4 x i32> \ No newline at end of file + %reverse = shufflevector <4 x i32> %0, <4 x i32> poison, <4 x i32> \ No newline at end of file diff --git a/test/test_suite2/compile_time/compile_time_access_subscript.c3t b/test/test_suite2/compile_time/compile_time_access_subscript.c3t index c13a4995c..5e6eaef55 100644 --- a/test/test_suite2/compile_time/compile_time_access_subscript.c3t +++ b/test/test_suite2/compile_time/compile_time_access_subscript.c3t @@ -44,82 +44,67 @@ fn void main() /* #expect: test.ll - %z = alloca i32, align 4 - %z1 = alloca %Abc, align 4 - %z2 = alloca i64, align 8 - %z3 = alloca i32, align 4 - %z4 = alloca ptr, align 8 - %z5 = alloca i8, align 1 - %z6 = alloca i64, align 8 - %z7 = alloca <3 x i32>, align 16 - %z8 = alloca %Abc, align 4 - %z9 = alloca [2 x i32], align 4 - %z10 = alloca %"int[]", align 8 - %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 - %varargslots = alloca [1 x %variant], align 16 - %literal = alloca %Abc, align 4 - 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 - %1 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 1 - store float 0.000000e+00, ptr %1, align 4 - %2 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 2 - store float 0.000000e+00, ptr %2, align 4 - %3 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 3 - store float 0.000000e+00, ptr %3, align 4 - store i64 0, ptr %z2, align 8 - store i32 0, ptr %z3, align 4 - store ptr null, ptr %z4, align 8 - store i8 0, ptr %z5, align 1 - store i64 0, ptr %z6, align 8 - store <3 x i32> zeroinitializer, ptr %z7, align 16 - %4 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 0 - store float 0.000000e+00, ptr %4, align 4 - %5 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 1 - store float 0.000000e+00, ptr %5, align 4 - %6 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 2 - store float 0.000000e+00, ptr %6, align 4 - %7 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 3 - store float 0.000000e+00, ptr %7, align 4 - %8 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 0 - store i32 0, ptr %8, align 4 - %9 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 1 - store i32 0, ptr %9, align 4 - call void @llvm.memset.p0.i64(ptr align 8 %z10, i8 0, i64 16, i1 false) - store %"char[]" { ptr @.str, i64 2 }, ptr %taddr, align 8 - %10 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %10, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %11, align 8 - %12 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 0 - store float 0.000000e+00, ptr %12, align 4 - %13 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 1 - store float 0.000000e+00, ptr %13, align 4 - %14 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 2 - store float 0.000000e+00, ptr %14, align 4 - %15 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 3 - store float 0.000000e+00, ptr %15, align 4 - %16 = insertvalue %variant undef, ptr %literal, 0 - %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$test_Abc" to i64), 1 - %18 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %17, ptr %18, align 16 - %19 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %19, align 8 - %20 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo11 = load ptr, ptr %21, align 8 - %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi12 = load i64, ptr %22, align 8 - %23 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo11, i64 %hi12) - %not_err = icmp eq i64 %23, 0 - br i1 %not_err, label %after_check, label %voiderr + %z = alloca i32, align 4 + %z1 = alloca %Abc, align 4 + %z2 = alloca i64, align 8 + %z3 = alloca i32, align 4 + %z4 = alloca ptr, align 8 + %z5 = alloca i8, align 1 + %z6 = alloca i64, align 8 + %z7 = alloca <3 x i32>, align 16 + %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 %variant], align 16 + %literal = alloca %Abc, align 4 + 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 + %1 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 1 + store float 0.000000e+00, ptr %1, align 4 + %2 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 2 + store float 0.000000e+00, ptr %2, align 4 + %3 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 3 + store float 0.000000e+00, ptr %3, align 4 + store i64 0, ptr %z2, align 8 + store i32 0, ptr %z3, align 4 + store ptr null, ptr %z4, align 8 + store i8 0, ptr %z5, align 1 + store i64 0, ptr %z6, align 8 + store <3 x i32> zeroinitializer, ptr %z7, align 16 + %4 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 0 + store float 0.000000e+00, ptr %4, align 4 + %5 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 1 + store float 0.000000e+00, ptr %5, align 4 + %6 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 2 + store float 0.000000e+00, ptr %6, align 4 + %7 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 3 + store float 0.000000e+00, ptr %7, align 4 + %8 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 0 + store i32 0, ptr %8, align 4 + %9 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 1 + store i32 0, ptr %9, align 4 + call void @llvm.memset.p0.i64(ptr align 8 %z10, i8 0, i64 16, i1 false) + %10 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 0 + store float 0.000000e+00, ptr %10, align 4 + %11 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 1 + store float 0.000000e+00, ptr %11, align 4 + %12 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 2 + store float 0.000000e+00, ptr %12, align 4 + %13 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 3 + store float 0.000000e+00, ptr %13, align 4 + %14 = insertvalue %variant undef, ptr %literal, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$test_Abc" to i64), 1 + %16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %15, ptr %16, align 16 + %17 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %17, 0 + br i1 %not_err, label %after_check, label %voiderr -after_check: ; preds = %entry - br label %voiderr + after_check: ; preds = %entry + br label %voiderr -voiderr: ; preds = %after_check, %entry - ret void -} + voiderr: ; preds = %after_check, %entry + ret void + } diff --git a/test/test_suite2/compile_time/ct_builtin_time_date.c3t b/test/test_suite2/compile_time/ct_builtin_time_date.c3t index c0e59a2a5..c7d179d7d 100644 --- a/test/test_suite2/compile_time/ct_builtin_time_date.c3t +++ b/test/test_suite2/compile_time/ct_builtin_time_date.c3t @@ -25,45 +25,26 @@ fn void main() } /* #expect: test.ll -target triple = "x86_64-apple-darwin" + define void @test_test(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 - %taddr10 = alloca i64, align 8 - %retparam16 = alloca i64, align 8 - %taddr17 = alloca %"char[]", align 8 - %vararg20 = alloca %"variant[]", align 8 - %varargslots21 = alloca [1 x %variant], align 16 - %taddr22 = alloca i64, align 8 - store %"char[]" { ptr @.str, i64 2 }, ptr %taddr, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %1, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %2, align 8 - store i32 %0, ptr %taddr1, align 4 - %3 = insertvalue %variant undef, ptr %taddr1, 0 - %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %4, ptr %5, align 16 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %6, align 8 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %9, align 8 - %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %10, 0 + %taddr = alloca i32, align 4 + %retparam1 = alloca i64, align 8 + %varargslots2 = alloca [1 x %variant], align 16 + %taddr3 = alloca i64, align 8 + %retparam7 = alloca i64, align 8 + %varargslots8 = alloca [1 x %variant], align 16 + %taddr9 = alloca i64, align 8 + store i32 %0, ptr %taddr, align 4 + %1 = insertvalue %variant undef, ptr %taddr, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %2, ptr %3, align 16 + %4 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %4, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -79,61 +60,35 @@ if.then: ; preds = %voiderr br label %if.exit if.exit: ; preds = %if.then, %voiderr - %11 = call i32 @std_io_println(ptr @.str.1) #1 - %12 = call i32 @std_io_println(ptr @.str.2) #1 - store %"char[]" { ptr @.str.3, i64 2 }, ptr %taddr5, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 0 - %lo6 = load ptr, ptr %13, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 1 - %hi7 = load i64, ptr %14, align 8 - store i64 14, ptr %taddr10, align 8 - %15 = insertvalue %variant undef, ptr %taddr10, 0 - %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$long" to i64), 1 - %17 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0 - store %variant %16, ptr %17, align 16 - %18 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 1 - store i64 1, ptr %18, align 8 - %19 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 0 - store ptr %varargslots9, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 0 - %lo11 = load ptr, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 1 - %hi12 = load i64, ptr %21, align 8 - %22 = call i64 @std_io_printfln(ptr %retparam4, ptr %lo6, i64 %hi7, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %22, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %5 = call i32 @std_io_println(ptr @.str.1) #1 + %6 = call i32 @std_io_println(ptr @.str.2) #1 + store i64 14, ptr %taddr3, align 8 + %7 = insertvalue %variant undef, ptr %taddr3, 0 + %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$long" to i64), 1 + %9 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0 + store %variant %8, ptr %9, align 16 + %10 = call i64 @std_io_printfln(ptr %retparam1, ptr @.str.3, i64 2, ptr %varargslots2, i64 1) + %not_err4 = icmp eq i64 %10, 0 + br i1 %not_err4, label %after_check5, label %voiderr6 -after_check14: ; preds = %if.exit - br label %voiderr15 +after_check5: ; preds = %if.exit + br label %voiderr6 -voiderr15: ; preds = %after_check14, %if.exit - store %"char[]" { ptr @.str.4, i64 2 }, ptr %taddr17, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 0 - %lo18 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 1 - %hi19 = load i64, ptr %24, align 8 - store i64 6, ptr %taddr22, align 8 - %25 = insertvalue %variant undef, ptr %taddr22, 0 - %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$long" to i64), 1 - %27 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0 - store %variant %26, ptr %27, align 16 - %28 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 1 - store i64 1, ptr %28, align 8 - %29 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 0 - store ptr %varargslots21, ptr %29, align 8 - %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 0 - %lo23 = load ptr, ptr %30, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 1 - %hi24 = load i64, ptr %31, align 8 - %32 = call i64 @std_io_printfln(ptr %retparam16, ptr %lo18, i64 %hi19, ptr %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %32, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 +voiderr6: ; preds = %after_check5, %if.exit + store i64 6, ptr %taddr9, align 8 + %11 = insertvalue %variant undef, ptr %taddr9, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$long" to i64), 1 + %13 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0 + store %variant %12, ptr %13, align 16 + %14 = call i64 @std_io_printfln(ptr %retparam7, ptr @.str.4, i64 2, ptr %varargslots8, i64 1) + %not_err10 = icmp eq i64 %14, 0 + br i1 %not_err10, label %after_check11, label %voiderr12 -after_check26: ; preds = %voiderr15 - br label %voiderr27 +after_check11: ; preds = %voiderr6 + br label %voiderr12 -voiderr27: ; preds = %after_check26, %voiderr15 - %33 = call i32 @std_io_println(ptr @.str.5) #1 - %34 = call i32 @std_io_println(ptr @.str.6) #1 +voiderr12: ; preds = %after_check11, %voiderr6 + %15 = call i32 @std_io_println(ptr @.str.5) #1 + %16 = call i32 @std_io_println(ptr @.str.6) #1 ret void } diff --git a/test/test_suite2/compile_time/ct_funcptr.c3t b/test/test_suite2/compile_time/ct_funcptr.c3t index 4a2467bc3..13036980e 100644 --- a/test/test_suite2/compile_time/ct_funcptr.c3t +++ b/test/test_suite2/compile_time/ct_funcptr.c3t @@ -20,31 +20,16 @@ define void @test_test(i32 %0) #0 { entry: %ptr = alloca ptr, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 + %taddr = alloca i32, align 4 store ptr @test_test, ptr %ptr, align 8 - store %"char[]" { ptr @.str, i64 2 }, ptr %taddr, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %1, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %2, align 8 - store i32 %0, ptr %taddr1, align 4 - %3 = insertvalue %variant undef, ptr %taddr1, 0 - %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %4, ptr %5, align 16 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %6, align 8 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %9, align 8 - %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %10, 0 + store i32 %0, ptr %taddr, align 4 + %1 = insertvalue %variant undef, ptr %taddr, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %2, ptr %3, align 16 + %4 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %4, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -55,9 +40,9 @@ voiderr: ; preds = %after_check, %entry br i1 %gt, label %if.then, label %if.exit if.then: ; preds = %voiderr - %11 = load ptr, ptr %ptr, align 8 + %5 = load ptr, ptr %ptr, align 8 %sub = sub i32 %0, 1 - call void %11(i32 %sub) + call void %5(i32 %sub) br label %if.exit if.exit: ; preds = %if.then, %voiderr diff --git a/test/test_suite2/compile_time/ct_memberof.c3t b/test/test_suite2/compile_time/ct_memberof.c3t index 5a5d51798..71de872f2 100644 --- a/test/test_suite2/compile_time/ct_memberof.c3t +++ b/test/test_suite2/compile_time/ct_memberof.c3t @@ -120,80 +120,54 @@ entry: define void @test_test(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca ptr, align 8 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 + %taddr = alloca ptr, align 8 + %retparam1 = alloca i64, align 8 + %varargslots2 = alloca [2 x %variant], align 16 + %taddr3 = alloca ptr, align 8 + %taddr4 = alloca ptr, align 8 + %retparam8 = alloca i64, align 8 %varargslots9 = alloca [2 x %variant], align 16 %taddr10 = alloca ptr, align 8 %taddr11 = alloca ptr, align 8 - %retparam17 = alloca i64, align 8 - %taddr18 = alloca %"char[]", align 8 - %vararg21 = alloca %"variant[]", align 8 - %varargslots22 = alloca [2 x %variant], align 16 - %taddr23 = alloca ptr, align 8 + %retparam15 = alloca i64, align 8 + %varargslots16 = alloca [2 x %variant], align 16 + %taddr17 = alloca ptr, align 8 + %taddr18 = alloca ptr, align 8 + %retparam22 = alloca i64, align 8 + %varargslots23 = alloca [2 x %variant], align 16 %taddr24 = alloca ptr, align 8 - %retparam30 = alloca i64, align 8 - %taddr31 = alloca %"char[]", align 8 - %vararg34 = alloca %"variant[]", align 8 - %varargslots35 = alloca [2 x %variant], align 16 - %taddr36 = alloca ptr, align 8 + %taddr25 = alloca ptr, align 8 + %retparam29 = alloca i64, align 8 + %varargslots30 = alloca [1 x %variant], align 16 + %taddr31 = alloca ptr, align 8 + %retparam35 = alloca i64, align 8 + %varargslots36 = alloca [2 x %variant], align 16 %taddr37 = alloca ptr, align 8 - %retparam43 = alloca i64, align 8 - %taddr44 = alloca %"char[]", align 8 - %vararg47 = alloca %"variant[]", align 8 - %varargslots48 = alloca [2 x %variant], align 16 - %taddr49 = alloca ptr, align 8 - %taddr50 = alloca ptr, align 8 + %taddr38 = alloca ptr, align 8 + %retparam42 = alloca i64, align 8 + %varargslots43 = alloca [2 x %variant], align 16 + %taddr44 = alloca ptr, align 8 + %taddr45 = alloca ptr, align 8 + %retparam49 = alloca i64, align 8 + %varargslots50 = alloca [2 x %variant], align 16 + %taddr51 = alloca ptr, align 8 + %taddr52 = alloca ptr, align 8 %retparam56 = alloca i64, align 8 - %taddr57 = alloca %"char[]", align 8 - %vararg60 = alloca %"variant[]", align 8 - %varargslots61 = alloca [1 x %variant], align 16 - %taddr62 = alloca ptr, align 8 - %retparam68 = alloca i64, align 8 - %taddr69 = alloca %"char[]", align 8 - %vararg72 = alloca %"variant[]", align 8 - %varargslots73 = alloca [2 x %variant], align 16 - %taddr74 = alloca ptr, align 8 - %taddr75 = alloca ptr, align 8 - %retparam81 = alloca i64, align 8 - %taddr82 = alloca %"char[]", align 8 - %vararg85 = alloca %"variant[]", align 8 - %varargslots86 = alloca [2 x %variant], align 16 - %taddr87 = alloca ptr, align 8 - %taddr88 = alloca ptr, align 8 - %retparam94 = alloca i64, align 8 - %taddr95 = alloca %"char[]", align 8 - %vararg98 = alloca %"variant[]", align 8 - %varargslots99 = alloca [2 x %variant], align 16 - %taddr100 = alloca ptr, align 8 - %taddr101 = alloca ptr, align 8 - %retparam107 = alloca i64, align 8 - %taddr108 = alloca %"char[]", align 8 - %vararg111 = alloca %"variant[]", align 8 - %varargslots112 = alloca [2 x %variant], align 16 - %taddr113 = alloca ptr, align 8 - %taddr114 = alloca ptr, align 8 - %retparam120 = alloca i64, align 8 - %taddr121 = alloca %"char[]", align 8 - %vararg124 = alloca %"variant[]", align 8 - %varargslots125 = alloca [1 x %variant], align 16 - %taddr126 = alloca ptr, align 8 - %retparam132 = alloca i64, align 8 - %taddr133 = alloca %"char[]", align 8 - %vararg136 = alloca %"variant[]", align 8 - %varargslots137 = alloca [2 x %variant], align 16 - %taddr138 = alloca ptr, align 8 - %taddr139 = alloca ptr, align 8 - %retparam145 = alloca i64, align 8 - %taddr146 = alloca %"char[]", align 8 - %vararg149 = alloca %"variant[]", align 8 - %varargslots150 = alloca [2 x %variant], align 16 - %taddr151 = alloca ptr, align 8 - %taddr152 = alloca ptr, align 8 + %varargslots57 = alloca [2 x %variant], align 16 + %taddr58 = alloca ptr, align 8 + %taddr59 = alloca ptr, align 8 + %retparam63 = alloca i64, align 8 + %varargslots64 = alloca [1 x %variant], align 16 + %taddr65 = alloca ptr, align 8 + %retparam69 = alloca i64, align 8 + %varargslots70 = alloca [2 x %variant], align 16 + %taddr71 = alloca ptr, align 8 + %taddr72 = alloca ptr, align 8 + %retparam76 = alloca i64, align 8 + %varargslots77 = alloca [2 x %variant], align 16 + %taddr78 = alloca ptr, align 8 + %taddr79 = alloca ptr, align 8 %1 = call i32 @std_io_println(ptr @.str) #1 %2 = call i32 @std_io_println(ptr @.str.10) #1 %3 = call i32 @std_io_println(ptr @.str.11) #1 @@ -201,394 +175,225 @@ entry: %5 = call i32 @std_io_println(ptr @.str.13) #1 %6 = call i32 @std_io_println(ptr @.str.14) #1 %7 = call i32 @std_io_println(ptr @.str.15) #1 - store %"char[]" { ptr @.str.16, i64 8 }, ptr %taddr, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %9, align 8 - store ptr @.str.17, ptr %taddr1, align 8 - %10 = insertvalue %variant undef, ptr %taddr1, 0 - %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %12 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %11, ptr %12, align 16 - %13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %13, align 8 - %14 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %15, align 8 - %16 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %16, align 8 - %17 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %17, 0 + store ptr @.str.17, ptr %taddr, align 8 + %8 = insertvalue %variant undef, ptr %taddr, 0 + %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 + %10 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %9, ptr %10, align 16 + %11 = call i64 @std_io_printfln(ptr %retparam, ptr @.str.16, i64 8, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { ptr @.str.18, i64 6 }, ptr %taddr5, align 8 - %18 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 0 - %lo6 = load ptr, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 1 - %hi7 = load i64, ptr %19, align 8 - store ptr @.str.19, ptr %taddr10, align 8 - %20 = insertvalue %variant undef, ptr %taddr10, 0 - %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 - %22 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0 - store %variant %21, ptr %22, align 16 - store ptr @.str.20, ptr %taddr11, align 8 - %23 = insertvalue %variant undef, ptr %taddr11, 0 - %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %25 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1 - store %variant %24, ptr %25, align 16 - %26 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 1 - store i64 2, ptr %26, align 8 - %27 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 0 - store ptr %varargslots9, ptr %27, align 8 - %28 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 0 - %lo12 = load ptr, ptr %28, align 8 - %29 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 1 - %hi13 = load i64, ptr %29, align 8 - %30 = call i64 @std_io_printfln(ptr %retparam4, ptr %lo6, i64 %hi7, ptr %lo12, i64 %hi13) - %not_err14 = icmp eq i64 %30, 0 - br i1 %not_err14, label %after_check15, label %voiderr16 + store ptr @.str.19, ptr %taddr3, align 8 + %12 = insertvalue %variant undef, ptr %taddr3, 0 + %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 + %14 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 0 + store %variant %13, ptr %14, align 16 + store ptr @.str.20, ptr %taddr4, align 8 + %15 = insertvalue %variant undef, ptr %taddr4, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 + %17 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 1 + store %variant %16, ptr %17, align 16 + %18 = call i64 @std_io_printfln(ptr %retparam1, ptr @.str.18, i64 6, ptr %varargslots2, i64 2) + %not_err5 = icmp eq i64 %18, 0 + br i1 %not_err5, label %after_check6, label %voiderr7 -after_check15: ; preds = %voiderr - br label %voiderr16 +after_check6: ; preds = %voiderr + br label %voiderr7 -voiderr16: ; preds = %after_check15, %voiderr - store %"char[]" { ptr @.str.21, i64 6 }, ptr %taddr18, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 0 - %lo19 = load ptr, ptr %31, align 8 - %32 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 1 - %hi20 = load i64, ptr %32, align 8 - store ptr @.str.22, ptr %taddr23, align 8 - %33 = insertvalue %variant undef, ptr %taddr23, 0 - %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 - %35 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 0 +voiderr7: ; preds = %after_check6, %voiderr + store ptr @.str.22, ptr %taddr10, align 8 + %19 = insertvalue %variant undef, ptr %taddr10, 0 + %20 = insertvalue %variant %19, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 + %21 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0 + store %variant %20, ptr %21, align 16 + store ptr @.str.23, ptr %taddr11, align 8 + %22 = insertvalue %variant undef, ptr %taddr11, 0 + %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 + %24 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1 + store %variant %23, ptr %24, align 16 + %25 = call i64 @std_io_printfln(ptr %retparam8, ptr @.str.21, i64 6, ptr %varargslots9, i64 2) + %not_err12 = icmp eq i64 %25, 0 + br i1 %not_err12, label %after_check13, label %voiderr14 + +after_check13: ; preds = %voiderr7 + br label %voiderr14 + +voiderr14: ; preds = %after_check13, %voiderr7 + store ptr @.str.25, ptr %taddr17, align 8 + %26 = insertvalue %variant undef, ptr %taddr17, 0 + %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1 + %28 = getelementptr inbounds [2 x %variant], ptr %varargslots16, i64 0, i64 0 + store %variant %27, ptr %28, align 16 + store ptr @.str.26, ptr %taddr18, align 8 + %29 = insertvalue %variant undef, ptr %taddr18, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 + %31 = getelementptr inbounds [2 x %variant], ptr %varargslots16, i64 0, i64 1 + store %variant %30, ptr %31, align 16 + %32 = call i64 @std_io_printfln(ptr %retparam15, ptr @.str.24, i64 6, ptr %varargslots16, i64 2) + %not_err19 = icmp eq i64 %32, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 + +after_check20: ; preds = %voiderr14 + br label %voiderr21 + +voiderr21: ; preds = %after_check20, %voiderr14 + store ptr @.str.28, ptr %taddr24, align 8 + %33 = insertvalue %variant undef, ptr %taddr24, 0 + %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 + %35 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 0 store %variant %34, ptr %35, align 16 - store ptr @.str.23, ptr %taddr24, align 8 - %36 = insertvalue %variant undef, ptr %taddr24, 0 - %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 - %38 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 1 + store ptr @.str.29, ptr %taddr25, align 8 + %36 = insertvalue %variant undef, ptr %taddr25, 0 + %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1 + %38 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 1 store %variant %37, ptr %38, align 16 - %39 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 1 - store i64 2, ptr %39, align 8 - %40 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 0 - store ptr %varargslots22, ptr %40, align 8 - %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 0 - %lo25 = load ptr, ptr %41, align 8 - %42 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 1 - %hi26 = load i64, ptr %42, align 8 - %43 = call i64 @std_io_printfln(ptr %retparam17, ptr %lo19, i64 %hi20, ptr %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %43, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 + %39 = call i64 @std_io_printfln(ptr %retparam22, ptr @.str.27, i64 6, ptr %varargslots23, i64 2) + %not_err26 = icmp eq i64 %39, 0 + br i1 %not_err26, label %after_check27, label %voiderr28 -after_check28: ; preds = %voiderr16 - br label %voiderr29 +after_check27: ; preds = %voiderr21 + br label %voiderr28 -voiderr29: ; preds = %after_check28, %voiderr16 - store %"char[]" { ptr @.str.24, i64 6 }, ptr %taddr31, align 8 - %44 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 0 - %lo32 = load ptr, ptr %44, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 1 - %hi33 = load i64, ptr %45, align 8 - store ptr @.str.25, ptr %taddr36, align 8 - %46 = insertvalue %variant undef, ptr %taddr36, 0 - %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1 - %48 = getelementptr inbounds [2 x %variant], ptr %varargslots35, i64 0, i64 0 - store %variant %47, ptr %48, align 16 - store ptr @.str.26, ptr %taddr37, align 8 - %49 = insertvalue %variant undef, ptr %taddr37, 0 - %50 = insertvalue %variant %49, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 - %51 = getelementptr inbounds [2 x %variant], ptr %varargslots35, i64 0, i64 1 - store %variant %50, ptr %51, align 16 - %52 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 1 - store i64 2, ptr %52, align 8 - %53 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 0 - store ptr %varargslots35, ptr %53, align 8 - %54 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 0 - %lo38 = load ptr, ptr %54, align 8 - %55 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 1 - %hi39 = load i64, ptr %55, align 8 - %56 = call i64 @std_io_printfln(ptr %retparam30, ptr %lo32, i64 %hi33, ptr %lo38, i64 %hi39) - %not_err40 = icmp eq i64 %56, 0 - br i1 %not_err40, label %after_check41, label %voiderr42 +voiderr28: ; preds = %after_check27, %voiderr21 + store ptr @.str.31, ptr %taddr31, align 8 + %40 = insertvalue %variant undef, ptr %taddr31, 0 + %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 + %42 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0 + store %variant %41, ptr %42, align 16 + %43 = call i64 @std_io_printfln(ptr %retparam29, ptr @.str.30, i64 8, ptr %varargslots30, i64 1) + %not_err32 = icmp eq i64 %43, 0 + br i1 %not_err32, label %after_check33, label %voiderr34 -after_check41: ; preds = %voiderr29 - br label %voiderr42 +after_check33: ; preds = %voiderr28 + br label %voiderr34 -voiderr42: ; preds = %after_check41, %voiderr29 - store %"char[]" { ptr @.str.27, i64 6 }, ptr %taddr44, align 8 - %57 = getelementptr inbounds { ptr, i64 }, ptr %taddr44, i32 0, i32 0 - %lo45 = load ptr, ptr %57, align 8 - %58 = getelementptr inbounds { ptr, i64 }, ptr %taddr44, i32 0, i32 1 - %hi46 = load i64, ptr %58, align 8 - store ptr @.str.28, ptr %taddr49, align 8 - %59 = insertvalue %variant undef, ptr %taddr49, 0 - %60 = insertvalue %variant %59, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 - %61 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0 - store %variant %60, ptr %61, align 16 - store ptr @.str.29, ptr %taddr50, align 8 - %62 = insertvalue %variant undef, ptr %taddr50, 0 - %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1 - %64 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1 - store %variant %63, ptr %64, align 16 - %65 = getelementptr inbounds %"variant[]", ptr %vararg47, i32 0, i32 1 - store i64 2, ptr %65, align 8 - %66 = getelementptr inbounds %"variant[]", ptr %vararg47, i32 0, i32 0 - store ptr %varargslots48, ptr %66, align 8 - %67 = getelementptr inbounds { ptr, i64 }, ptr %vararg47, i32 0, i32 0 - %lo51 = load ptr, ptr %67, align 8 - %68 = getelementptr inbounds { ptr, i64 }, ptr %vararg47, i32 0, i32 1 - %hi52 = load i64, ptr %68, align 8 - %69 = call i64 @std_io_printfln(ptr %retparam43, ptr %lo45, i64 %hi46, ptr %lo51, i64 %hi52) - %not_err53 = icmp eq i64 %69, 0 +voiderr34: ; preds = %after_check33, %voiderr28 + store ptr @.str.33, ptr %taddr37, align 8 + %44 = insertvalue %variant undef, ptr %taddr37, 0 + %45 = insertvalue %variant %44, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 + %46 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0 + store %variant %45, ptr %46, align 16 + store ptr @.str.34, ptr %taddr38, align 8 + %47 = insertvalue %variant undef, ptr %taddr38, 0 + %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 + %49 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1 + store %variant %48, ptr %49, align 16 + %50 = call i64 @std_io_printfln(ptr %retparam35, ptr @.str.32, i64 6, ptr %varargslots36, i64 2) + %not_err39 = icmp eq i64 %50, 0 + br i1 %not_err39, label %after_check40, label %voiderr41 + +after_check40: ; preds = %voiderr34 + br label %voiderr41 + +voiderr41: ; preds = %after_check40, %voiderr34 + store ptr @.str.36, ptr %taddr44, align 8 + %51 = insertvalue %variant undef, ptr %taddr44, 0 + %52 = insertvalue %variant %51, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 + %53 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 0 + store %variant %52, ptr %53, align 16 + store ptr @.str.37, ptr %taddr45, align 8 + %54 = insertvalue %variant undef, ptr %taddr45, 0 + %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 + %56 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 1 + store %variant %55, ptr %56, align 16 + %57 = call i64 @std_io_printfln(ptr %retparam42, ptr @.str.35, i64 6, ptr %varargslots43, i64 2) + %not_err46 = icmp eq i64 %57, 0 + br i1 %not_err46, label %after_check47, label %voiderr48 + +after_check47: ; preds = %voiderr41 + br label %voiderr48 + +voiderr48: ; preds = %after_check47, %voiderr41 + store ptr @.str.39, ptr %taddr51, align 8 + %58 = insertvalue %variant undef, ptr %taddr51, 0 + %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1 + %60 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 0 + store %variant %59, ptr %60, align 16 + store ptr @.str.40, ptr %taddr52, align 8 + %61 = insertvalue %variant undef, ptr %taddr52, 0 + %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 + %63 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 1 + store %variant %62, ptr %63, align 16 + %64 = call i64 @std_io_printfln(ptr %retparam49, ptr @.str.38, i64 6, ptr %varargslots50, i64 2) + %not_err53 = icmp eq i64 %64, 0 br i1 %not_err53, label %after_check54, label %voiderr55 -after_check54: ; preds = %voiderr42 +after_check54: ; preds = %voiderr48 br label %voiderr55 -voiderr55: ; preds = %after_check54, %voiderr42 - store %"char[]" { ptr @.str.30, i64 8 }, ptr %taddr57, align 8 - %70 = getelementptr inbounds { ptr, i64 }, ptr %taddr57, i32 0, i32 0 - %lo58 = load ptr, ptr %70, align 8 - %71 = getelementptr inbounds { ptr, i64 }, ptr %taddr57, i32 0, i32 1 - %hi59 = load i64, ptr %71, align 8 - store ptr @.str.31, ptr %taddr62, align 8 - %72 = insertvalue %variant undef, ptr %taddr62, 0 - %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %74 = getelementptr inbounds [1 x %variant], ptr %varargslots61, i64 0, i64 0 +voiderr55: ; preds = %after_check54, %voiderr48 + store ptr @.str.42, ptr %taddr58, align 8 + %65 = insertvalue %variant undef, ptr %taddr58, 0 + %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 + %67 = getelementptr inbounds [2 x %variant], ptr %varargslots57, i64 0, i64 0 + store %variant %66, ptr %67, align 16 + store ptr @.str.43, ptr %taddr59, align 8 + %68 = insertvalue %variant undef, ptr %taddr59, 0 + %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 + %70 = getelementptr inbounds [2 x %variant], ptr %varargslots57, i64 0, i64 1 + store %variant %69, ptr %70, align 16 + %71 = call i64 @std_io_printfln(ptr %retparam56, ptr @.str.41, i64 6, ptr %varargslots57, i64 2) + %not_err60 = icmp eq i64 %71, 0 + br i1 %not_err60, label %after_check61, label %voiderr62 + +after_check61: ; preds = %voiderr55 + br label %voiderr62 + +voiderr62: ; preds = %after_check61, %voiderr55 + store ptr @.str.45, ptr %taddr65, align 8 + %72 = insertvalue %variant undef, ptr %taddr65, 0 + %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 + %74 = getelementptr inbounds [1 x %variant], ptr %varargslots64, i64 0, i64 0 store %variant %73, ptr %74, align 16 - %75 = getelementptr inbounds %"variant[]", ptr %vararg60, i32 0, i32 1 - store i64 1, ptr %75, align 8 - %76 = getelementptr inbounds %"variant[]", ptr %vararg60, i32 0, i32 0 - store ptr %varargslots61, ptr %76, align 8 - %77 = getelementptr inbounds { ptr, i64 }, ptr %vararg60, i32 0, i32 0 - %lo63 = load ptr, ptr %77, align 8 - %78 = getelementptr inbounds { ptr, i64 }, ptr %vararg60, i32 0, i32 1 - %hi64 = load i64, ptr %78, align 8 - %79 = call i64 @std_io_printfln(ptr %retparam56, ptr %lo58, i64 %hi59, ptr %lo63, i64 %hi64) - %not_err65 = icmp eq i64 %79, 0 - br i1 %not_err65, label %after_check66, label %voiderr67 + %75 = call i64 @std_io_printfln(ptr %retparam63, ptr @.str.44, i64 8, ptr %varargslots64, i64 1) + %not_err66 = icmp eq i64 %75, 0 + br i1 %not_err66, label %after_check67, label %voiderr68 -after_check66: ; preds = %voiderr55 - br label %voiderr67 +after_check67: ; preds = %voiderr62 + br label %voiderr68 -voiderr67: ; preds = %after_check66, %voiderr55 - store %"char[]" { ptr @.str.32, i64 6 }, ptr %taddr69, align 8 - %80 = getelementptr inbounds { ptr, i64 }, ptr %taddr69, i32 0, i32 0 - %lo70 = load ptr, ptr %80, align 8 - %81 = getelementptr inbounds { ptr, i64 }, ptr %taddr69, i32 0, i32 1 - %hi71 = load i64, ptr %81, align 8 - store ptr @.str.33, ptr %taddr74, align 8 - %82 = insertvalue %variant undef, ptr %taddr74, 0 - %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 - %84 = getelementptr inbounds [2 x %variant], ptr %varargslots73, i64 0, i64 0 - store %variant %83, ptr %84, align 16 - store ptr @.str.34, ptr %taddr75, align 8 - %85 = insertvalue %variant undef, ptr %taddr75, 0 - %86 = insertvalue %variant %85, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 - %87 = getelementptr inbounds [2 x %variant], ptr %varargslots73, i64 0, i64 1 - store %variant %86, ptr %87, align 16 - %88 = getelementptr inbounds %"variant[]", ptr %vararg72, i32 0, i32 1 - store i64 2, ptr %88, align 8 - %89 = getelementptr inbounds %"variant[]", ptr %vararg72, i32 0, i32 0 - store ptr %varargslots73, ptr %89, align 8 - %90 = getelementptr inbounds { ptr, i64 }, ptr %vararg72, i32 0, i32 0 - %lo76 = load ptr, ptr %90, align 8 - %91 = getelementptr inbounds { ptr, i64 }, ptr %vararg72, i32 0, i32 1 - %hi77 = load i64, ptr %91, align 8 - %92 = call i64 @std_io_printfln(ptr %retparam68, ptr %lo70, i64 %hi71, ptr %lo76, i64 %hi77) - %not_err78 = icmp eq i64 %92, 0 - br i1 %not_err78, label %after_check79, label %voiderr80 +voiderr68: ; preds = %after_check67, %voiderr62 + store ptr @.str.47, ptr %taddr71, align 8 + %76 = insertvalue %variant undef, ptr %taddr71, 0 + %77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 + %78 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 0 + store %variant %77, ptr %78, align 16 + store ptr @.str.48, ptr %taddr72, align 8 + %79 = insertvalue %variant undef, ptr %taddr72, 0 + %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 + %81 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 1 + store %variant %80, ptr %81, align 16 + %82 = call i64 @std_io_printfln(ptr %retparam69, ptr @.str.46, i64 6, ptr %varargslots70, i64 2) + %not_err73 = icmp eq i64 %82, 0 + br i1 %not_err73, label %after_check74, label %voiderr75 -after_check79: ; preds = %voiderr67 - br label %voiderr80 +after_check74: ; preds = %voiderr68 + br label %voiderr75 -voiderr80: ; preds = %after_check79, %voiderr67 - store %"char[]" { ptr @.str.35, i64 6 }, ptr %taddr82, align 8 - %93 = getelementptr inbounds { ptr, i64 }, ptr %taddr82, i32 0, i32 0 - %lo83 = load ptr, ptr %93, align 8 - %94 = getelementptr inbounds { ptr, i64 }, ptr %taddr82, i32 0, i32 1 - %hi84 = load i64, ptr %94, align 8 - store ptr @.str.36, ptr %taddr87, align 8 - %95 = insertvalue %variant undef, ptr %taddr87, 0 - %96 = insertvalue %variant %95, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 - %97 = getelementptr inbounds [2 x %variant], ptr %varargslots86, i64 0, i64 0 - store %variant %96, ptr %97, align 16 - store ptr @.str.37, ptr %taddr88, align 8 - %98 = insertvalue %variant undef, ptr %taddr88, 0 - %99 = insertvalue %variant %98, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 - %100 = getelementptr inbounds [2 x %variant], ptr %varargslots86, i64 0, i64 1 - store %variant %99, ptr %100, align 16 - %101 = getelementptr inbounds %"variant[]", ptr %vararg85, i32 0, i32 1 - store i64 2, ptr %101, align 8 - %102 = getelementptr inbounds %"variant[]", ptr %vararg85, i32 0, i32 0 - store ptr %varargslots86, ptr %102, align 8 - %103 = getelementptr inbounds { ptr, i64 }, ptr %vararg85, i32 0, i32 0 - %lo89 = load ptr, ptr %103, align 8 - %104 = getelementptr inbounds { ptr, i64 }, ptr %vararg85, i32 0, i32 1 - %hi90 = load i64, ptr %104, align 8 - %105 = call i64 @std_io_printfln(ptr %retparam81, ptr %lo83, i64 %hi84, ptr %lo89, i64 %hi90) - %not_err91 = icmp eq i64 %105, 0 - br i1 %not_err91, label %after_check92, label %voiderr93 +voiderr75: ; preds = %after_check74, %voiderr68 + store ptr @.str.50, ptr %taddr78, align 8 + %83 = insertvalue %variant undef, ptr %taddr78, 0 + %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 + %85 = getelementptr inbounds [2 x %variant], ptr %varargslots77, i64 0, i64 0 + store %variant %84, ptr %85, align 16 + store ptr @.str.51, ptr %taddr79, align 8 + %86 = insertvalue %variant undef, ptr %taddr79, 0 + %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 + %88 = getelementptr inbounds [2 x %variant], ptr %varargslots77, i64 0, i64 1 + store %variant %87, ptr %88, align 16 + %89 = call i64 @std_io_printfln(ptr %retparam76, ptr @.str.49, i64 6, ptr %varargslots77, i64 2) + %not_err80 = icmp eq i64 %89, 0 + br i1 %not_err80, label %after_check81, label %voiderr82 -after_check92: ; preds = %voiderr80 - br label %voiderr93 +after_check81: ; preds = %voiderr75 + br label %voiderr82 -voiderr93: ; preds = %after_check92, %voiderr80 - store %"char[]" { ptr @.str.38, i64 6 }, ptr %taddr95, align 8 - %106 = getelementptr inbounds { ptr, i64 }, ptr %taddr95, i32 0, i32 0 - %lo96 = load ptr, ptr %106, align 8 - %107 = getelementptr inbounds { ptr, i64 }, ptr %taddr95, i32 0, i32 1 - %hi97 = load i64, ptr %107, align 8 - store ptr @.str.39, ptr %taddr100, align 8 - %108 = insertvalue %variant undef, ptr %taddr100, 0 - %109 = insertvalue %variant %108, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1 - %110 = getelementptr inbounds [2 x %variant], ptr %varargslots99, i64 0, i64 0 - store %variant %109, ptr %110, align 16 - store ptr @.str.40, ptr %taddr101, align 8 - %111 = insertvalue %variant undef, ptr %taddr101, 0 - %112 = insertvalue %variant %111, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 - %113 = getelementptr inbounds [2 x %variant], ptr %varargslots99, i64 0, i64 1 - store %variant %112, ptr %113, align 16 - %114 = getelementptr inbounds %"variant[]", ptr %vararg98, i32 0, i32 1 - store i64 2, ptr %114, align 8 - %115 = getelementptr inbounds %"variant[]", ptr %vararg98, i32 0, i32 0 - store ptr %varargslots99, ptr %115, align 8 - %116 = getelementptr inbounds { ptr, i64 }, ptr %vararg98, i32 0, i32 0 - %lo102 = load ptr, ptr %116, align 8 - %117 = getelementptr inbounds { ptr, i64 }, ptr %vararg98, i32 0, i32 1 - %hi103 = load i64, ptr %117, align 8 - %118 = call i64 @std_io_printfln(ptr %retparam94, ptr %lo96, i64 %hi97, ptr %lo102, i64 %hi103) - %not_err104 = icmp eq i64 %118, 0 - br i1 %not_err104, label %after_check105, label %voiderr106 - -after_check105: ; preds = %voiderr93 - br label %voiderr106 - -voiderr106: ; preds = %after_check105, %voiderr93 - store %"char[]" { ptr @.str.41, i64 6 }, ptr %taddr108, align 8 - %119 = getelementptr inbounds { ptr, i64 }, ptr %taddr108, i32 0, i32 0 - %lo109 = load ptr, ptr %119, align 8 - %120 = getelementptr inbounds { ptr, i64 }, ptr %taddr108, i32 0, i32 1 - %hi110 = load i64, ptr %120, align 8 - store ptr @.str.42, ptr %taddr113, align 8 - %121 = insertvalue %variant undef, ptr %taddr113, 0 - %122 = insertvalue %variant %121, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %123 = getelementptr inbounds [2 x %variant], ptr %varargslots112, i64 0, i64 0 - store %variant %122, ptr %123, align 16 - store ptr @.str.43, ptr %taddr114, align 8 - %124 = insertvalue %variant undef, ptr %taddr114, 0 - %125 = insertvalue %variant %124, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %126 = getelementptr inbounds [2 x %variant], ptr %varargslots112, i64 0, i64 1 - store %variant %125, ptr %126, align 16 - %127 = getelementptr inbounds %"variant[]", ptr %vararg111, i32 0, i32 1 - store i64 2, ptr %127, align 8 - %128 = getelementptr inbounds %"variant[]", ptr %vararg111, i32 0, i32 0 - store ptr %varargslots112, ptr %128, align 8 - %129 = getelementptr inbounds { ptr, i64 }, ptr %vararg111, i32 0, i32 0 - %lo115 = load ptr, ptr %129, align 8 - %130 = getelementptr inbounds { ptr, i64 }, ptr %vararg111, i32 0, i32 1 - %hi116 = load i64, ptr %130, align 8 - %131 = call i64 @std_io_printfln(ptr %retparam107, ptr %lo109, i64 %hi110, ptr %lo115, i64 %hi116) - %not_err117 = icmp eq i64 %131, 0 - br i1 %not_err117, label %after_check118, label %voiderr119 - -after_check118: ; preds = %voiderr106 - br label %voiderr119 - -voiderr119: ; preds = %after_check118, %voiderr106 - store %"char[]" { ptr @.str.44, i64 8 }, ptr %taddr121, align 8 - %132 = getelementptr inbounds { ptr, i64 }, ptr %taddr121, i32 0, i32 0 - %lo122 = load ptr, ptr %132, align 8 - %133 = getelementptr inbounds { ptr, i64 }, ptr %taddr121, i32 0, i32 1 - %hi123 = load i64, ptr %133, align 8 - store ptr @.str.45, ptr %taddr126, align 8 - %134 = insertvalue %variant undef, ptr %taddr126, 0 - %135 = insertvalue %variant %134, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 - %136 = getelementptr inbounds [1 x %variant], ptr %varargslots125, i64 0, i64 0 - store %variant %135, ptr %136, align 16 - %137 = getelementptr inbounds %"variant[]", ptr %vararg124, i32 0, i32 1 - store i64 1, ptr %137, align 8 - %138 = getelementptr inbounds %"variant[]", ptr %vararg124, i32 0, i32 0 - store ptr %varargslots125, ptr %138, align 8 - %139 = getelementptr inbounds { ptr, i64 }, ptr %vararg124, i32 0, i32 0 - %lo127 = load ptr, ptr %139, align 8 - %140 = getelementptr inbounds { ptr, i64 }, ptr %vararg124, i32 0, i32 1 - %hi128 = load i64, ptr %140, align 8 - %141 = call i64 @std_io_printfln(ptr %retparam120, ptr %lo122, i64 %hi123, ptr %lo127, i64 %hi128) - %not_err129 = icmp eq i64 %141, 0 - br i1 %not_err129, label %after_check130, label %voiderr131 - -after_check130: ; preds = %voiderr119 - br label %voiderr131 - -voiderr131: ; preds = %after_check130, %voiderr119 - store %"char[]" { ptr @.str.46, i64 6 }, ptr %taddr133, align 8 - %142 = getelementptr inbounds { ptr, i64 }, ptr %taddr133, i32 0, i32 0 - %lo134 = load ptr, ptr %142, align 8 - %143 = getelementptr inbounds { ptr, i64 }, ptr %taddr133, i32 0, i32 1 - %hi135 = load i64, ptr %143, align 8 - store ptr @.str.47, ptr %taddr138, align 8 - %144 = insertvalue %variant undef, ptr %taddr138, 0 - %145 = insertvalue %variant %144, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 - %146 = getelementptr inbounds [2 x %variant], ptr %varargslots137, i64 0, i64 0 - store %variant %145, ptr %146, align 16 - store ptr @.str.48, ptr %taddr139, align 8 - %147 = insertvalue %variant undef, ptr %taddr139, 0 - %148 = insertvalue %variant %147, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %149 = getelementptr inbounds [2 x %variant], ptr %varargslots137, i64 0, i64 1 - store %variant %148, ptr %149, align 16 - %150 = getelementptr inbounds %"variant[]", ptr %vararg136, i32 0, i32 1 - store i64 2, ptr %150, align 8 - %151 = getelementptr inbounds %"variant[]", ptr %vararg136, i32 0, i32 0 - store ptr %varargslots137, ptr %151, align 8 - %152 = getelementptr inbounds { ptr, i64 }, ptr %vararg136, i32 0, i32 0 - %lo140 = load ptr, ptr %152, align 8 - %153 = getelementptr inbounds { ptr, i64 }, ptr %vararg136, i32 0, i32 1 - %hi141 = load i64, ptr %153, align 8 - %154 = call i64 @std_io_printfln(ptr %retparam132, ptr %lo134, i64 %hi135, ptr %lo140, i64 %hi141) - %not_err142 = icmp eq i64 %154, 0 - br i1 %not_err142, label %after_check143, label %voiderr144 - -after_check143: ; preds = %voiderr131 - br label %voiderr144 - -voiderr144: ; preds = %after_check143, %voiderr131 - store %"char[]" { ptr @.str.49, i64 6 }, ptr %taddr146, align 8 - %155 = getelementptr inbounds { ptr, i64 }, ptr %taddr146, i32 0, i32 0 - %lo147 = load ptr, ptr %155, align 8 - %156 = getelementptr inbounds { ptr, i64 }, ptr %taddr146, i32 0, i32 1 - %hi148 = load i64, ptr %156, align 8 - store ptr @.str.50, ptr %taddr151, align 8 - %157 = insertvalue %variant undef, ptr %taddr151, 0 - %158 = insertvalue %variant %157, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1 - %159 = getelementptr inbounds [2 x %variant], ptr %varargslots150, i64 0, i64 0 - store %variant %158, ptr %159, align 16 - store ptr @.str.51, ptr %taddr152, align 8 - %160 = insertvalue %variant undef, ptr %taddr152, 0 - %161 = insertvalue %variant %160, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 - %162 = getelementptr inbounds [2 x %variant], ptr %varargslots150, i64 0, i64 1 - store %variant %161, ptr %162, align 16 - %163 = getelementptr inbounds %"variant[]", ptr %vararg149, i32 0, i32 1 - store i64 2, ptr %163, align 8 - %164 = getelementptr inbounds %"variant[]", ptr %vararg149, i32 0, i32 0 - store ptr %varargslots150, ptr %164, align 8 - %165 = getelementptr inbounds { ptr, i64 }, ptr %vararg149, i32 0, i32 0 - %lo153 = load ptr, ptr %165, align 8 - %166 = getelementptr inbounds { ptr, i64 }, ptr %vararg149, i32 0, i32 1 - %hi154 = load i64, ptr %166, align 8 - %167 = call i64 @std_io_printfln(ptr %retparam145, ptr %lo147, i64 %hi148, ptr %lo153, i64 %hi154) - %not_err155 = icmp eq i64 %167, 0 - br i1 %not_err155, label %after_check156, label %voiderr157 - -after_check156: ; preds = %voiderr144 - br label %voiderr157 - -voiderr157: ; preds = %after_check156, %voiderr144 +voiderr82: ; preds = %after_check81, %voiderr75 ret void } @@ -596,394 +401,229 @@ voiderr157: ; preds = %after_check156, %vo define void @test_main() #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i64, align 8 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 + %taddr = alloca i64, align 8 + %retparam1 = alloca i64, align 8 + %varargslots2 = alloca [1 x %variant], align 16 + %taddr3 = alloca i64, align 8 + %retparam7 = alloca i64, align 8 + %varargslots8 = alloca [2 x %variant], align 16 + %taddr9 = alloca i64, align 8 %taddr10 = alloca i64, align 8 - %retparam16 = alloca i64, align 8 - %taddr17 = alloca %"char[]", align 8 - %vararg20 = alloca %"variant[]", align 8 - %varargslots21 = alloca [2 x %variant], align 16 - %taddr22 = alloca i64, align 8 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [2 x %variant], align 16 + %taddr16 = alloca i64, align 8 + %taddr17 = alloca i64, align 8 + %retparam21 = alloca i64, align 8 + %varargslots22 = alloca [2 x %variant], align 16 %taddr23 = alloca i64, align 8 - %retparam29 = alloca i64, align 8 - %taddr30 = alloca %"char[]", align 8 - %vararg33 = alloca %"variant[]", align 8 - %varargslots34 = alloca [2 x %variant], align 16 - %taddr35 = alloca i64, align 8 - %taddr36 = alloca i64, align 8 + %taddr24 = alloca i64, align 8 + %retparam28 = alloca i64, align 8 + %varargslots29 = alloca [2 x %variant], align 16 + %taddr30 = alloca i64, align 8 + %taddr31 = alloca i64, align 8 + %retparam35 = alloca i64, align 8 + %varargslots36 = alloca [2 x %variant], align 16 + %taddr37 = alloca i64, align 8 + %taddr38 = alloca i64, align 8 %retparam42 = alloca i64, align 8 - %taddr43 = alloca %"char[]", align 8 - %vararg46 = alloca %"variant[]", align 8 - %varargslots47 = alloca [2 x %variant], align 16 - %taddr48 = alloca i64, align 8 - %taddr49 = alloca i64, align 8 - %retparam55 = alloca i64, align 8 - %taddr56 = alloca %"char[]", align 8 - %vararg59 = alloca %"variant[]", align 8 - %varargslots60 = alloca [2 x %variant], align 16 - %taddr61 = alloca i64, align 8 - %taddr62 = alloca i64, align 8 - %retparam68 = alloca i64, align 8 - %taddr69 = alloca %"char[]", align 8 - %vararg72 = alloca %"variant[]", align 8 - %varargslots73 = alloca [2 x %variant], align 16 - %taddr74 = alloca i64, align 8 - %taddr75 = alloca i64, align 8 - %retparam81 = alloca i64, align 8 - %taddr82 = alloca %"char[]", align 8 - %vararg85 = alloca %"variant[]", align 8 - %varargslots86 = alloca [2 x %variant], align 16 - %taddr87 = alloca i64, align 8 - %taddr88 = alloca i64, align 8 - %retparam94 = alloca i64, align 8 - %taddr95 = alloca %"char[]", align 8 - %vararg98 = alloca %"variant[]", align 8 - %varargslots99 = alloca [2 x %variant], align 16 - %taddr100 = alloca i64, align 8 - %taddr101 = alloca i64, align 8 - %retparam107 = alloca i64, align 8 - %taddr108 = alloca %"char[]", align 8 - %vararg111 = alloca %"variant[]", align 8 - %varargslots112 = alloca [1 x %variant], align 16 - %taddr113 = alloca i64, align 8 - %retparam119 = alloca i64, align 8 - %taddr120 = alloca %"char[]", align 8 - %vararg123 = alloca %"variant[]", align 8 - %varargslots124 = alloca [2 x %variant], align 16 - %taddr125 = alloca i64, align 8 - %taddr126 = alloca i64, align 8 - store %"char[]" { ptr @.str.52, i64 7 }, ptr %taddr, align 8 - %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - store i64 4, ptr %taddr1, align 8 - %2 = insertvalue %variant undef, ptr %taddr1, 0 - %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$long" to i64), 1 - %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %3, ptr %4, align 16 - %5 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %5, align 8 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %6, align 8 - %7 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %8, align 8 - %9 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %9, 0 + %varargslots43 = alloca [2 x %variant], align 16 + %taddr44 = alloca i64, align 8 + %taddr45 = alloca i64, align 8 + %retparam49 = alloca i64, align 8 + %varargslots50 = alloca [2 x %variant], align 16 + %taddr51 = alloca i64, align 8 + %taddr52 = alloca i64, align 8 + %retparam56 = alloca i64, align 8 + %varargslots57 = alloca [1 x %variant], align 16 + %taddr58 = alloca i64, align 8 + %retparam62 = alloca i64, align 8 + %varargslots63 = alloca [2 x %variant], align 16 + %taddr64 = alloca i64, align 8 + %taddr65 = alloca i64, align 8 + store i64 4, ptr %taddr, align 8 + %0 = insertvalue %variant undef, ptr %taddr, 0 + %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$long" to i64), 1 + %2 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %1, ptr %2, align 16 + %3 = call i64 @std_io_printfln(ptr %retparam, ptr @.str.52, i64 7, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %3, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { ptr @.str.53, i64 7 }, ptr %taddr5, align 8 - %10 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 0 - %lo6 = load ptr, ptr %10, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 1 - %hi7 = load i64, ptr %11, align 8 - store i64 1, ptr %taddr10, align 8 - %12 = insertvalue %variant undef, ptr %taddr10, 0 - %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$long" to i64), 1 - %14 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0 - store %variant %13, ptr %14, align 16 - %15 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 1 - store i64 1, ptr %15, align 8 - %16 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 0 - store ptr %varargslots9, ptr %16, align 8 - %17 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 0 - %lo11 = load ptr, ptr %17, align 8 - %18 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 1 - %hi12 = load i64, ptr %18, align 8 - %19 = call i64 @std_io_printfln(ptr %retparam4, ptr %lo6, i64 %hi7, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %19, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + store i64 1, ptr %taddr3, align 8 + %4 = insertvalue %variant undef, ptr %taddr3, 0 + %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$long" to i64), 1 + %6 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0 + store %variant %5, ptr %6, align 16 + %7 = call i64 @std_io_printfln(ptr %retparam1, ptr @.str.53, i64 7, ptr %varargslots2, i64 1) + %not_err4 = icmp eq i64 %7, 0 + br i1 %not_err4, label %after_check5, label %voiderr6 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check5: ; preds = %voiderr + br label %voiderr6 -voiderr15: ; preds = %after_check14, %voiderr - store %"char[]" { ptr @.str.54, i64 8 }, ptr %taddr17, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 0 - %lo18 = load ptr, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 1 - %hi19 = load i64, ptr %21, align 8 - store i64 0, ptr %taddr22, align 8 - %22 = insertvalue %variant undef, ptr %taddr22, 0 - %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %24 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0 - store %variant %23, ptr %24, align 16 +voiderr6: ; preds = %after_check5, %voiderr + store i64 0, ptr %taddr9, align 8 + %8 = insertvalue %variant undef, ptr %taddr9, 0 + %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %10 = getelementptr inbounds [2 x %variant], ptr %varargslots8, i64 0, i64 0 + store %variant %9, ptr %10, align 16 + store i64 4, ptr %taddr10, align 8 + %11 = insertvalue %variant undef, ptr %taddr10, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %13 = getelementptr inbounds [2 x %variant], ptr %varargslots8, i64 0, i64 1 + store %variant %12, ptr %13, align 16 + %14 = call i64 @std_io_printfln(ptr %retparam7, ptr @.str.54, i64 8, ptr %varargslots8, i64 2) + %not_err11 = icmp eq i64 %14, 0 + br i1 %not_err11, label %after_check12, label %voiderr13 + +after_check12: ; preds = %voiderr6 + br label %voiderr13 + +voiderr13: ; preds = %after_check12, %voiderr6 + store i64 2, ptr %taddr16, align 8 + %15 = insertvalue %variant undef, ptr %taddr16, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %17 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 0 + store %variant %16, ptr %17, align 16 + store i64 2, ptr %taddr17, align 8 + %18 = insertvalue %variant undef, ptr %taddr17, 0 + %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %20 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 1 + store %variant %19, ptr %20, align 16 + %21 = call i64 @std_io_printfln(ptr %retparam14, ptr @.str.55, i64 8, ptr %varargslots15, i64 2) + %not_err18 = icmp eq i64 %21, 0 + br i1 %not_err18, label %after_check19, label %voiderr20 + +after_check19: ; preds = %voiderr13 + br label %voiderr20 + +voiderr20: ; preds = %after_check19, %voiderr13 store i64 4, ptr %taddr23, align 8 - %25 = insertvalue %variant undef, ptr %taddr23, 0 + %22 = insertvalue %variant undef, ptr %taddr23, 0 + %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %24 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 0 + store %variant %23, ptr %24, align 16 + store i64 4, ptr %taddr24, align 8 + %25 = insertvalue %variant undef, ptr %taddr24, 0 %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %27 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1 + %27 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 1 store %variant %26, ptr %27, align 16 - %28 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 1 - store i64 2, ptr %28, align 8 - %29 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 0 - store ptr %varargslots21, ptr %29, align 8 - %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 0 - %lo24 = load ptr, ptr %30, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 1 - %hi25 = load i64, ptr %31, align 8 - %32 = call i64 @std_io_printfln(ptr %retparam16, ptr %lo18, i64 %hi19, ptr %lo24, i64 %hi25) - %not_err26 = icmp eq i64 %32, 0 - br i1 %not_err26, label %after_check27, label %voiderr28 + %28 = call i64 @std_io_printfln(ptr %retparam21, ptr @.str.56, i64 8, ptr %varargslots22, i64 2) + %not_err25 = icmp eq i64 %28, 0 + br i1 %not_err25, label %after_check26, label %voiderr27 -after_check27: ; preds = %voiderr15 - br label %voiderr28 +after_check26: ; preds = %voiderr20 + br label %voiderr27 -voiderr28: ; preds = %after_check27, %voiderr15 - store %"char[]" { ptr @.str.55, i64 8 }, ptr %taddr30, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 0 - %lo31 = load ptr, ptr %33, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 1 - %hi32 = load i64, ptr %34, align 8 - store i64 2, ptr %taddr35, align 8 - %35 = insertvalue %variant undef, ptr %taddr35, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %37 = getelementptr inbounds [2 x %variant], ptr %varargslots34, i64 0, i64 0 - store %variant %36, ptr %37, align 16 - store i64 2, ptr %taddr36, align 8 - %38 = insertvalue %variant undef, ptr %taddr36, 0 - %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %40 = getelementptr inbounds [2 x %variant], ptr %varargslots34, i64 0, i64 1 - store %variant %39, ptr %40, align 16 - %41 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 1 - store i64 2, ptr %41, align 8 - %42 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 0 - store ptr %varargslots34, ptr %42, align 8 - %43 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 0 - %lo37 = load ptr, ptr %43, align 8 - %44 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 1 - %hi38 = load i64, ptr %44, align 8 - %45 = call i64 @std_io_printfln(ptr %retparam29, ptr %lo31, i64 %hi32, ptr %lo37, i64 %hi38) - %not_err39 = icmp eq i64 %45, 0 +voiderr27: ; preds = %after_check26, %voiderr20 + store i64 4, ptr %taddr30, align 8 + %29 = insertvalue %variant undef, ptr %taddr30, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %31 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0 + store %variant %30, ptr %31, align 16 + store i64 4, ptr %taddr31, align 8 + %32 = insertvalue %variant undef, ptr %taddr31, 0 + %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %34 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1 + store %variant %33, ptr %34, align 16 + %35 = call i64 @std_io_printfln(ptr %retparam28, ptr @.str.57, i64 8, ptr %varargslots29, i64 2) + %not_err32 = icmp eq i64 %35, 0 + br i1 %not_err32, label %after_check33, label %voiderr34 + +after_check33: ; preds = %voiderr27 + br label %voiderr34 + +voiderr34: ; preds = %after_check33, %voiderr27 + store i64 4, ptr %taddr37, align 8 + %36 = insertvalue %variant undef, ptr %taddr37, 0 + %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %38 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0 + store %variant %37, ptr %38, align 16 + store i64 4, ptr %taddr38, align 8 + %39 = insertvalue %variant undef, ptr %taddr38, 0 + %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %41 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1 + store %variant %40, ptr %41, align 16 + %42 = call i64 @std_io_printfln(ptr %retparam35, ptr @.str.58, i64 9, ptr %varargslots36, i64 2) + %not_err39 = icmp eq i64 %42, 0 br i1 %not_err39, label %after_check40, label %voiderr41 -after_check40: ; preds = %voiderr28 +after_check40: ; preds = %voiderr34 br label %voiderr41 -voiderr41: ; preds = %after_check40, %voiderr28 - store %"char[]" { ptr @.str.56, i64 8 }, ptr %taddr43, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 0 - %lo44 = load ptr, ptr %46, align 8 - %47 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 1 - %hi45 = load i64, ptr %47, align 8 - store i64 4, ptr %taddr48, align 8 - %48 = insertvalue %variant undef, ptr %taddr48, 0 - %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %50 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 0 - store %variant %49, ptr %50, align 16 - store i64 4, ptr %taddr49, align 8 - %51 = insertvalue %variant undef, ptr %taddr49, 0 - %52 = insertvalue %variant %51, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %53 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 1 - store %variant %52, ptr %53, align 16 - %54 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 1 - store i64 2, ptr %54, align 8 - %55 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 0 - store ptr %varargslots47, ptr %55, align 8 - %56 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 0 - %lo50 = load ptr, ptr %56, align 8 - %57 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 1 - %hi51 = load i64, ptr %57, align 8 - %58 = call i64 @std_io_printfln(ptr %retparam42, ptr %lo44, i64 %hi45, ptr %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %58, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 +voiderr41: ; preds = %after_check40, %voiderr34 + store i64 5, ptr %taddr44, align 8 + %43 = insertvalue %variant undef, ptr %taddr44, 0 + %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %45 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 0 + store %variant %44, ptr %45, align 16 + store i64 1, ptr %taddr45, align 8 + %46 = insertvalue %variant undef, ptr %taddr45, 0 + %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %48 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 1 + store %variant %47, ptr %48, align 16 + %49 = call i64 @std_io_printfln(ptr %retparam42, ptr @.str.59, i64 9, ptr %varargslots43, i64 2) + %not_err46 = icmp eq i64 %49, 0 + br i1 %not_err46, label %after_check47, label %voiderr48 -after_check53: ; preds = %voiderr41 - br label %voiderr54 +after_check47: ; preds = %voiderr41 + br label %voiderr48 -voiderr54: ; preds = %after_check53, %voiderr41 - store %"char[]" { ptr @.str.57, i64 8 }, ptr %taddr56, align 8 - %59 = getelementptr inbounds { ptr, i64 }, ptr %taddr56, i32 0, i32 0 - %lo57 = load ptr, ptr %59, align 8 - %60 = getelementptr inbounds { ptr, i64 }, ptr %taddr56, i32 0, i32 1 - %hi58 = load i64, ptr %60, align 8 - store i64 4, ptr %taddr61, align 8 - %61 = insertvalue %variant undef, ptr %taddr61, 0 +voiderr48: ; preds = %after_check47, %voiderr41 + store i64 8, ptr %taddr51, align 8 + %50 = insertvalue %variant undef, ptr %taddr51, 0 + %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %52 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 0 + store %variant %51, ptr %52, align 16 + store i64 4, ptr %taddr52, align 8 + %53 = insertvalue %variant undef, ptr %taddr52, 0 + %54 = insertvalue %variant %53, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %55 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 1 + store %variant %54, ptr %55, align 16 + %56 = call i64 @std_io_printfln(ptr %retparam49, ptr @.str.60, i64 10, ptr %varargslots50, i64 2) + %not_err53 = icmp eq i64 %56, 0 + br i1 %not_err53, label %after_check54, label %voiderr55 + +after_check54: ; preds = %voiderr48 + br label %voiderr55 + +voiderr55: ; preds = %after_check54, %voiderr48 + store i64 4, ptr %taddr58, align 8 + %57 = insertvalue %variant undef, ptr %taddr58, 0 + %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %59 = getelementptr inbounds [1 x %variant], ptr %varargslots57, i64 0, i64 0 + store %variant %58, ptr %59, align 16 + %60 = call i64 @std_io_printfln(ptr %retparam56, ptr @.str.61, i64 7, ptr %varargslots57, i64 1) + %not_err59 = icmp eq i64 %60, 0 + br i1 %not_err59, label %after_check60, label %voiderr61 + +after_check60: ; preds = %voiderr55 + br label %voiderr61 + +voiderr61: ; preds = %after_check60, %voiderr55 + store i64 8, ptr %taddr64, align 8 + %61 = insertvalue %variant undef, ptr %taddr64, 0 %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %63 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 0 + %63 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0 store %variant %62, ptr %63, align 16 - store i64 4, ptr %taddr62, align 8 - %64 = insertvalue %variant undef, ptr %taddr62, 0 + store i64 4, ptr %taddr65, align 8 + %64 = insertvalue %variant undef, ptr %taddr65, 0 %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %66 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 1 + %66 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1 store %variant %65, ptr %66, align 16 - %67 = getelementptr inbounds %"variant[]", ptr %vararg59, i32 0, i32 1 - store i64 2, ptr %67, align 8 - %68 = getelementptr inbounds %"variant[]", ptr %vararg59, i32 0, i32 0 - store ptr %varargslots60, ptr %68, align 8 - %69 = getelementptr inbounds { ptr, i64 }, ptr %vararg59, i32 0, i32 0 - %lo63 = load ptr, ptr %69, align 8 - %70 = getelementptr inbounds { ptr, i64 }, ptr %vararg59, i32 0, i32 1 - %hi64 = load i64, ptr %70, align 8 - %71 = call i64 @std_io_printfln(ptr %retparam55, ptr %lo57, i64 %hi58, ptr %lo63, i64 %hi64) - %not_err65 = icmp eq i64 %71, 0 - br i1 %not_err65, label %after_check66, label %voiderr67 + %67 = call i64 @std_io_printfln(ptr %retparam62, ptr @.str.62, i64 10, ptr %varargslots63, i64 2) + %not_err66 = icmp eq i64 %67, 0 + br i1 %not_err66, label %after_check67, label %voiderr68 -after_check66: ; preds = %voiderr54 - br label %voiderr67 +after_check67: ; preds = %voiderr61 + br label %voiderr68 -voiderr67: ; preds = %after_check66, %voiderr54 - store %"char[]" { ptr @.str.58, i64 9 }, ptr %taddr69, align 8 - %72 = getelementptr inbounds { ptr, i64 }, ptr %taddr69, i32 0, i32 0 - %lo70 = load ptr, ptr %72, align 8 - %73 = getelementptr inbounds { ptr, i64 }, ptr %taddr69, i32 0, i32 1 - %hi71 = load i64, ptr %73, align 8 - store i64 4, ptr %taddr74, align 8 - %74 = insertvalue %variant undef, ptr %taddr74, 0 - %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %76 = getelementptr inbounds [2 x %variant], ptr %varargslots73, i64 0, i64 0 - store %variant %75, ptr %76, align 16 - store i64 4, ptr %taddr75, align 8 - %77 = insertvalue %variant undef, ptr %taddr75, 0 - %78 = insertvalue %variant %77, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %79 = getelementptr inbounds [2 x %variant], ptr %varargslots73, i64 0, i64 1 - store %variant %78, ptr %79, align 16 - %80 = getelementptr inbounds %"variant[]", ptr %vararg72, i32 0, i32 1 - store i64 2, ptr %80, align 8 - %81 = getelementptr inbounds %"variant[]", ptr %vararg72, i32 0, i32 0 - store ptr %varargslots73, ptr %81, align 8 - %82 = getelementptr inbounds { ptr, i64 }, ptr %vararg72, i32 0, i32 0 - %lo76 = load ptr, ptr %82, align 8 - %83 = getelementptr inbounds { ptr, i64 }, ptr %vararg72, i32 0, i32 1 - %hi77 = load i64, ptr %83, align 8 - %84 = call i64 @std_io_printfln(ptr %retparam68, ptr %lo70, i64 %hi71, ptr %lo76, i64 %hi77) - %not_err78 = icmp eq i64 %84, 0 - br i1 %not_err78, label %after_check79, label %voiderr80 - -after_check79: ; preds = %voiderr67 - br label %voiderr80 - -voiderr80: ; preds = %after_check79, %voiderr67 - store %"char[]" { ptr @.str.59, i64 9 }, ptr %taddr82, align 8 - %85 = getelementptr inbounds { ptr, i64 }, ptr %taddr82, i32 0, i32 0 - %lo83 = load ptr, ptr %85, align 8 - %86 = getelementptr inbounds { ptr, i64 }, ptr %taddr82, i32 0, i32 1 - %hi84 = load i64, ptr %86, align 8 - store i64 5, ptr %taddr87, align 8 - %87 = insertvalue %variant undef, ptr %taddr87, 0 - %88 = insertvalue %variant %87, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %89 = getelementptr inbounds [2 x %variant], ptr %varargslots86, i64 0, i64 0 - store %variant %88, ptr %89, align 16 - store i64 1, ptr %taddr88, align 8 - %90 = insertvalue %variant undef, ptr %taddr88, 0 - %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %92 = getelementptr inbounds [2 x %variant], ptr %varargslots86, i64 0, i64 1 - store %variant %91, ptr %92, align 16 - %93 = getelementptr inbounds %"variant[]", ptr %vararg85, i32 0, i32 1 - store i64 2, ptr %93, align 8 - %94 = getelementptr inbounds %"variant[]", ptr %vararg85, i32 0, i32 0 - store ptr %varargslots86, ptr %94, align 8 - %95 = getelementptr inbounds { ptr, i64 }, ptr %vararg85, i32 0, i32 0 - %lo89 = load ptr, ptr %95, align 8 - %96 = getelementptr inbounds { ptr, i64 }, ptr %vararg85, i32 0, i32 1 - %hi90 = load i64, ptr %96, align 8 - %97 = call i64 @std_io_printfln(ptr %retparam81, ptr %lo83, i64 %hi84, ptr %lo89, i64 %hi90) - %not_err91 = icmp eq i64 %97, 0 - br i1 %not_err91, label %after_check92, label %voiderr93 - -after_check92: ; preds = %voiderr80 - br label %voiderr93 - -voiderr93: ; preds = %after_check92, %voiderr80 - store %"char[]" { ptr @.str.60, i64 10 }, ptr %taddr95, align 8 - %98 = getelementptr inbounds { ptr, i64 }, ptr %taddr95, i32 0, i32 0 - %lo96 = load ptr, ptr %98, align 8 - %99 = getelementptr inbounds { ptr, i64 }, ptr %taddr95, i32 0, i32 1 - %hi97 = load i64, ptr %99, align 8 - store i64 8, ptr %taddr100, align 8 - %100 = insertvalue %variant undef, ptr %taddr100, 0 - %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %102 = getelementptr inbounds [2 x %variant], ptr %varargslots99, i64 0, i64 0 - store %variant %101, ptr %102, align 16 - store i64 4, ptr %taddr101, align 8 - %103 = insertvalue %variant undef, ptr %taddr101, 0 - %104 = insertvalue %variant %103, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %105 = getelementptr inbounds [2 x %variant], ptr %varargslots99, i64 0, i64 1 - store %variant %104, ptr %105, align 16 - %106 = getelementptr inbounds %"variant[]", ptr %vararg98, i32 0, i32 1 - store i64 2, ptr %106, align 8 - %107 = getelementptr inbounds %"variant[]", ptr %vararg98, i32 0, i32 0 - store ptr %varargslots99, ptr %107, align 8 - %108 = getelementptr inbounds { ptr, i64 }, ptr %vararg98, i32 0, i32 0 - %lo102 = load ptr, ptr %108, align 8 - %109 = getelementptr inbounds { ptr, i64 }, ptr %vararg98, i32 0, i32 1 - %hi103 = load i64, ptr %109, align 8 - %110 = call i64 @std_io_printfln(ptr %retparam94, ptr %lo96, i64 %hi97, ptr %lo102, i64 %hi103) - %not_err104 = icmp eq i64 %110, 0 - br i1 %not_err104, label %after_check105, label %voiderr106 - -after_check105: ; preds = %voiderr93 - br label %voiderr106 - -voiderr106: ; preds = %after_check105, %voiderr93 - store %"char[]" { ptr @.str.61, i64 7 }, ptr %taddr108, align 8 - %111 = getelementptr inbounds { ptr, i64 }, ptr %taddr108, i32 0, i32 0 - %lo109 = load ptr, ptr %111, align 8 - %112 = getelementptr inbounds { ptr, i64 }, ptr %taddr108, i32 0, i32 1 - %hi110 = load i64, ptr %112, align 8 - store i64 4, ptr %taddr113, align 8 - %113 = insertvalue %variant undef, ptr %taddr113, 0 - %114 = insertvalue %variant %113, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %115 = getelementptr inbounds [1 x %variant], ptr %varargslots112, i64 0, i64 0 - store %variant %114, ptr %115, align 16 - %116 = getelementptr inbounds %"variant[]", ptr %vararg111, i32 0, i32 1 - store i64 1, ptr %116, align 8 - %117 = getelementptr inbounds %"variant[]", ptr %vararg111, i32 0, i32 0 - store ptr %varargslots112, ptr %117, align 8 - %118 = getelementptr inbounds { ptr, i64 }, ptr %vararg111, i32 0, i32 0 - %lo114 = load ptr, ptr %118, align 8 - %119 = getelementptr inbounds { ptr, i64 }, ptr %vararg111, i32 0, i32 1 - %hi115 = load i64, ptr %119, align 8 - %120 = call i64 @std_io_printfln(ptr %retparam107, ptr %lo109, i64 %hi110, ptr %lo114, i64 %hi115) - %not_err116 = icmp eq i64 %120, 0 - br i1 %not_err116, label %after_check117, label %voiderr118 - -after_check117: ; preds = %voiderr106 - br label %voiderr118 - -voiderr118: ; preds = %after_check117, %voiderr106 - store %"char[]" { ptr @.str.62, i64 10 }, ptr %taddr120, align 8 - %121 = getelementptr inbounds { ptr, i64 }, ptr %taddr120, i32 0, i32 0 - %lo121 = load ptr, ptr %121, align 8 - %122 = getelementptr inbounds { ptr, i64 }, ptr %taddr120, i32 0, i32 1 - %hi122 = load i64, ptr %122, align 8 - store i64 8, ptr %taddr125, align 8 - %123 = insertvalue %variant undef, ptr %taddr125, 0 - %124 = insertvalue %variant %123, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %125 = getelementptr inbounds [2 x %variant], ptr %varargslots124, i64 0, i64 0 - store %variant %124, ptr %125, align 16 - store i64 4, ptr %taddr126, align 8 - %126 = insertvalue %variant undef, ptr %taddr126, 0 - %127 = insertvalue %variant %126, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %128 = getelementptr inbounds [2 x %variant], ptr %varargslots124, i64 0, i64 1 - store %variant %127, ptr %128, align 16 - %129 = getelementptr inbounds %"variant[]", ptr %vararg123, i32 0, i32 1 - store i64 2, ptr %129, align 8 - %130 = getelementptr inbounds %"variant[]", ptr %vararg123, i32 0, i32 0 - store ptr %varargslots124, ptr %130, align 8 - %131 = getelementptr inbounds { ptr, i64 }, ptr %vararg123, i32 0, i32 0 - %lo127 = load ptr, ptr %131, align 8 - %132 = getelementptr inbounds { ptr, i64 }, ptr %vararg123, i32 0, i32 1 - %hi128 = load i64, ptr %132, align 8 - %133 = call i64 @std_io_printfln(ptr %retparam119, ptr %lo121, i64 %hi122, ptr %lo127, i64 %hi128) - %not_err129 = icmp eq i64 %133, 0 - br i1 %not_err129, label %after_check130, label %voiderr131 - -after_check130: ; preds = %voiderr118 - br label %voiderr131 - -voiderr131: ; preds = %after_check130, %voiderr118 +voiderr68: ; preds = %after_check67, %voiderr61 call void @test_test(i32 10) ret void } \ No newline at end of file diff --git a/test/test_suite2/compile_time/untyped_conversions.c3t b/test/test_suite2/compile_time/untyped_conversions.c3t index 7dba485b9..447f66f62 100644 --- a/test/test_suite2/compile_time/untyped_conversions.c3t +++ b/test/test_suite2/compile_time/untyped_conversions.c3t @@ -24,15 +24,9 @@ fn void main() /* #expect: test.ll -source_filename = "test" -target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" -target triple = "x86_64-apple-darwin" - %.introspect = type { i8, i64, i64, i64, [0 x i64] } %Foo = type { i32, i32 } %"int[]" = type { ptr, i64 } -%"char[]" = type { ptr, i64 } -%"variant[]" = type { ptr, i64 } %variant = type { ptr, i64 } @"ct$test_Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 @@ -58,8 +52,6 @@ entry: %b = alloca %"int[]", align 8 %c = alloca <2 x i32>, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [3 x %variant], align 16 store i64 %0, ptr %a, align 4 %4 = getelementptr inbounds { ptr, i64 }, ptr %b, i32 0, i32 0 @@ -67,33 +59,20 @@ entry: %5 = getelementptr inbounds { ptr, i64 }, ptr %b, i32 0, i32 1 store i64 %2, ptr %5, align 8 store double %3, ptr %c, align 8 - store %"char[]" { ptr @.str, i64 8 }, ptr %taddr, align 8 - %6 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %6, align 8 - %7 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %7, align 8 - %8 = insertvalue %variant undef, ptr %a, 0 - %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$a2$int" to i64), 1 - %10 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %9, ptr %10, align 16 - %11 = insertvalue %variant undef, ptr %b, 0 - %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1 - %13 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %12, ptr %13, align 16 - %14 = insertvalue %variant undef, ptr %c, 0 - %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$v2$int" to i64), 1 - %16 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2 - store %variant %15, ptr %16, align 16 - %17 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 3, ptr %17, align 8 - %18 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo1 = load ptr, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi2 = load i64, ptr %20, align 8 - %21 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) - %not_err = icmp eq i64 %21, 0 + %6 = insertvalue %variant undef, ptr %a, 0 + %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$a2$int" to i64), 1 + %8 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %7, ptr %8, align 16 + %9 = insertvalue %variant undef, ptr %b, 0 + %10 = insertvalue %variant %9, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1 + %11 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %10, ptr %11, align 16 + %12 = insertvalue %variant undef, ptr %c, 0 + %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$v2$int" to i64), 1 + %14 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2 + store %variant %13, ptr %14, align 16 + %15 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3) + %not_err = icmp eq i64 %15, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -111,109 +90,66 @@ entry: %y = alloca [1 x [2 x i32]], align 4 %y2 = alloca [1 x [2 x double]], align 16 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [4 x %variant], align 16 %literal = alloca [2 x i32], align 4 + %literal1 = alloca [2 x i32], align 4 + %taddr = alloca <2 x i32>, align 8 + %literal2 = alloca [2 x i32], align 4 %literal3 = alloca [2 x i32], align 4 - %taddr4 = alloca %"int[]", align 8 - %taddr7 = alloca <2 x i32>, align 8 - %literal8 = alloca [2 x i32], align 4 - %literal9 = alloca [2 x i32], align 4 - %taddr10 = alloca %"int[]", align 8 - %taddr13 = alloca <2 x i32>, align 8 + %taddr4 = alloca <2 x i32>, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %abc, ptr align 4 @.__const, i32 8, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %def, ptr align 4 @.__const.1, i32 8, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y, ptr align 4 @.__const.2, i32 8, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 16 %y2, ptr align 16 @.__const.3, i32 16, i1 false) - store %"char[]" { ptr @.str.4, i64 14 }, ptr %taddr, align 8 - %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - %2 = insertvalue %variant undef, ptr %y, 0 - %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$a1$a2$int" to i64), 1 - %4 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %3, ptr %4, align 16 - %5 = insertvalue %variant undef, ptr %y2, 0 - %6 = insertvalue %variant %5, i64 ptrtoint (ptr @"ct$a1$a2$double" to i64), 1 - %7 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %6, ptr %7, align 16 - %8 = getelementptr inbounds %Foo, ptr %def, i32 0, i32 0 - %9 = insertvalue %variant undef, ptr %8, 0 - %10 = insertvalue %variant %9, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %11 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 2 - store %variant %10, ptr %11, align 16 - %12 = getelementptr inbounds %Foo, ptr %def, i32 0, i32 1 - %13 = insertvalue %variant undef, ptr %12, 0 - %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %15 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 3 - store %variant %14, ptr %15, align 16 - %16 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 4, ptr %16, align 8 - %17 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %17, align 8 - %18 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo1 = load ptr, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi2 = load i64, ptr %19, align 8 - %20 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) - %not_err = icmp eq i64 %20, 0 + %0 = insertvalue %variant undef, ptr %y, 0 + %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$a1$a2$int" to i64), 1 + %2 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %1, ptr %2, align 16 + %3 = insertvalue %variant undef, ptr %y2, 0 + %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$a1$a2$double" to i64), 1 + %5 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %4, ptr %5, align 16 + %6 = getelementptr inbounds %Foo, ptr %def, i32 0, i32 0 + %7 = insertvalue %variant undef, ptr %6, 0 + %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %9 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 2 + store %variant %8, ptr %9, align 16 + %10 = getelementptr inbounds %Foo, ptr %def, i32 0, i32 1 + %11 = insertvalue %variant undef, ptr %10, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %13 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 3 + store %variant %12, ptr %13, align 16 + %14 = call i64 @std_io_printfln(ptr %retparam, ptr @.str.4, i64 14, ptr %varargslots, i64 4) + %not_err = icmp eq i64 %14, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %21 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 0 - store i32 1, ptr %21, align 4 - %22 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 1 - store i32 2, ptr %22, align 4 - %23 = load i64, ptr %literal, align 4 + %15 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 0 + store i32 1, ptr %15, align 4 + %16 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 1 + store i32 2, ptr %16, align 4 + %17 = load i64, ptr %literal, align 4 + %18 = getelementptr inbounds [2 x i32], ptr %literal1, i64 0, i64 0 + store i32 3, ptr %18, align 4 + %19 = getelementptr inbounds [2 x i32], ptr %literal1, i64 0, i64 1 + store i32 4, ptr %19, align 4 + store <2 x i32> , ptr %taddr, align 8 + %20 = load double, ptr %taddr, align 8 + call void @test_test(i64 %17, ptr %literal1, i64 2, double %20) + %21 = getelementptr inbounds [2 x i32], ptr %literal2, i64 0, i64 0 + store i32 2, ptr %21, align 4 + %22 = getelementptr inbounds [2 x i32], ptr %literal2, i64 0, i64 1 + store i32 7, ptr %22, align 4 + %23 = load i64, ptr %literal2, align 4 %24 = getelementptr inbounds [2 x i32], ptr %literal3, i64 0, i64 0 - store i32 3, ptr %24, align 4 + store i32 2, ptr %24, align 4 %25 = getelementptr inbounds [2 x i32], ptr %literal3, i64 0, i64 1 - store i32 4, ptr %25, align 4 - %26 = insertvalue %"int[]" undef, ptr %literal3, 0 - %27 = insertvalue %"int[]" %26, i64 2, 1 - store %"int[]" %27, ptr %taddr4, align 8 - %28 = getelementptr inbounds { ptr, i64 }, ptr %taddr4, i32 0, i32 0 - %lo5 = load ptr, ptr %28, align 8 - %29 = getelementptr inbounds { ptr, i64 }, ptr %taddr4, i32 0, i32 1 - %hi6 = load i64, ptr %29, align 8 - store <2 x i32> , ptr %taddr7, align 8 - %30 = load double, ptr %taddr7, align 8 - call void @test_test(i64 %23, ptr %lo5, i64 %hi6, double %30) - %31 = getelementptr inbounds [2 x i32], ptr %literal8, i64 0, i64 0 - store i32 2, ptr %31, align 4 - %32 = getelementptr inbounds [2 x i32], ptr %literal8, i64 0, i64 1 - store i32 7, ptr %32, align 4 - %33 = load i64, ptr %literal8, align 4 - %34 = getelementptr inbounds [2 x i32], ptr %literal9, i64 0, i64 0 - store i32 2, ptr %34, align 4 - %35 = getelementptr inbounds [2 x i32], ptr %literal9, i64 0, i64 1 - store i32 7, ptr %35, align 4 - %36 = insertvalue %"int[]" undef, ptr %literal9, 0 - %37 = insertvalue %"int[]" %36, i64 2, 1 - store %"int[]" %37, ptr %taddr10, align 8 - %38 = getelementptr inbounds { ptr, i64 }, ptr %taddr10, i32 0, i32 0 - %lo11 = load ptr, ptr %38, align 8 - %39 = getelementptr inbounds { ptr, i64 }, ptr %taddr10, i32 0, i32 1 - %hi12 = load i64, ptr %39, align 8 - store <2 x i32> , ptr %taddr13, align 8 - %40 = load double, ptr %taddr13, align 8 - call void @test_test(i64 %33, ptr %lo11, i64 %hi12, double %40) + store i32 7, ptr %25, align 4 + store <2 x i32> , ptr %taddr4, align 8 + %26 = load double, ptr %taddr4, align 8 + call void @test_test(i64 %23, ptr %literal3, i64 2, double %26) ret void } - -; Function Attrs: nounwind -define i32 @main(i32 %0, ptr %1) #0 { -entry: - call void @test_main() - ret i32 0 -} - -declare i64 @std_io_printfln(ptr, ptr, i64, ptr, i64) - -; Function Attrs: argmemonly nocallback nofree nounwind willreturn -declare void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i32, i1 immarg) #1 diff --git a/test/test_suite2/errors/error_regression_2.c3t b/test/test_suite2/errors/error_regression_2.c3t index e52114144..a429d8e30 100644 --- a/test/test_suite2/errors/error_regression_2.c3t +++ b/test/test_suite2/errors/error_regression_2.c3t @@ -265,279 +265,255 @@ loop.exit: ; preds = %loop.cond define i64 @test_readDoc(ptr %0, ptr %1, i64 %2) #0 { entry: %url = alloca %"char[]", align 8 - %taddr = alloca %"char[]", align 8 - %taddr5 = alloca %"char[]", align 8 %reterr = alloca i64, align 8 %literal = alloca %Doc, align 8 - %taddr12 = alloca %"char[]", align 8 - %reterr16 = alloca i64, align 8 - %literal17 = alloca %Doc, align 8 + %reterr8 = alloca i64, align 8 + %literal9 = alloca %Doc, align 8 %error_var = alloca i64, align 8 %value = alloca %Head, align 8 - %literal18 = alloca %Head, align 8 + %literal10 = alloca %Head, align 8 %temp = alloca ptr, align 8 - %taddr24 = alloca %"char[]", align 8 - %reterr28 = alloca i64, align 8 - %literal29 = alloca %Doc, align 8 - %error_var30 = alloca i64, align 8 - %value31 = alloca %Head, align 8 - %literal32 = alloca %Head, align 8 - %error_var33 = alloca i64, align 8 - %value34 = alloca %"char[]", align 8 - %temp35 = alloca ptr, align 8 - %temp41 = alloca ptr, align 8 + %reterr17 = alloca i64, align 8 + %literal18 = alloca %Doc, align 8 + %error_var19 = alloca i64, align 8 + %value20 = alloca %Head, align 8 + %literal21 = alloca %Head, align 8 + %error_var22 = alloca i64, align 8 + %value23 = alloca %"char[]", align 8 + %temp24 = alloca ptr, align 8 + %temp30 = alloca ptr, align 8 %len = alloca i32, align 4 %str = alloca ptr, align 8 - %reterr54 = alloca i64, align 8 - %literal55 = alloca %Doc, align 8 - %error_var56 = alloca i64, align 8 - %value57 = alloca %Head, align 8 - %literal58 = alloca %Head, align 8 - %error_var59 = alloca i64, align 8 - %value60 = alloca %"char[]", align 8 - %temp61 = alloca ptr, align 8 - %temp67 = alloca ptr, align 8 + %reterr43 = alloca i64, align 8 + %literal44 = alloca %Doc, align 8 + %error_var45 = alloca i64, align 8 + %value46 = alloca %Head, align 8 + %literal47 = alloca %Head, align 8 + %error_var48 = alloca i64, align 8 + %value49 = alloca %"char[]", align 8 + %temp50 = alloca ptr, align 8 + %temp56 = alloca ptr, align 8 %3 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 store ptr %1, ptr %3, align 8 %4 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 store i64 %2, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 + %5 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 %lo = load ptr, ptr %5, align 8 - %6 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 + %6 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 %hi = load i64, ptr %6, align 8 - store %"char[]" { ptr @.str, i64 4 }, ptr %taddr, align 8 - %7 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo1 = load ptr, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi2 = load i64, ptr %8, align 8 - %9 = call i8 @test_contains(ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) - %10 = trunc i8 %9 to i1 - br i1 %10, label %if.then, label %if.exit + %7 = call i8 @test_contains(ptr %lo, i64 %hi, ptr @.str, i64 4) + %8 = trunc i8 %7 to i1 + br i1 %8, label %if.then, label %if.exit if.then: ; preds = %entry ret i64 ptrtoint (ptr @"test_ReadError$BAD_READ" to i64) if.exit: ; preds = %entry - %11 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 - %lo3 = load ptr, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 - %hi4 = load i64, ptr %12, align 8 - store %"char[]" { ptr @.str.3, i64 12 }, ptr %taddr5, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 0 - %lo6 = load ptr, ptr %13, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 1 - %hi7 = load i64, ptr %14, align 8 - %15 = call i8 @test_contains(ptr %lo3, i64 %hi4, ptr %lo6, i64 %hi7) - %16 = trunc i8 %15 to i1 - br i1 %16, label %if.then8, label %if.exit9 + %9 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %lo1 = load ptr, ptr %9, align 8 + %10 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %hi2 = load i64, ptr %10, align 8 + %11 = call i8 @test_contains(ptr %lo1, i64 %hi2, ptr @.str.3, i64 12) + %12 = trunc i8 %11 to i1 + br i1 %12, label %if.then3, label %if.exit4 -if.then8: ; preds = %if.exit - %17 = getelementptr inbounds %Doc, ptr %literal, i32 0, i32 0 - store ptr null, ptr %17, align 8 +if.then3: ; preds = %if.exit + %13 = getelementptr inbounds %Doc, ptr %literal, i32 0, i32 0 + store ptr null, ptr %13, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal, i32 8, i1 false) ret i64 0 -if.exit9: ; preds = %if.exit - %18 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 - %lo10 = load ptr, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 - %hi11 = load i64, ptr %19, align 8 - store %"char[]" { ptr @.str.4, i64 13 }, ptr %taddr12, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %taddr12, i32 0, i32 0 - %lo13 = load ptr, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %taddr12, i32 0, i32 1 - %hi14 = load i64, ptr %21, align 8 - %22 = call i8 @test_contains(ptr %lo10, i64 %hi11, ptr %lo13, i64 %hi14) - %23 = trunc i8 %22 to i1 - br i1 %23, label %if.then15, label %if.exit21 +if.exit4: ; preds = %if.exit + %14 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %lo5 = load ptr, ptr %14, align 8 + %15 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %hi6 = load i64, ptr %15, align 8 + %16 = call i8 @test_contains(ptr %lo5, i64 %hi6, ptr @.str.4, i64 13) + %17 = trunc i8 %16 to i1 + br i1 %17, label %if.then7, label %if.exit13 -if.then15: ; preds = %if.exit9 - %24 = getelementptr inbounds %Doc, ptr %literal17, i32 0, i32 0 - %25 = getelementptr inbounds %Head, ptr %literal18, i32 0, i32 0 - store ptr null, ptr %25, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value, ptr align 8 %literal18, i32 8, i1 false) - %26 = call ptr @std_core_mem_malloc(i64 8) #2 - store ptr %26, ptr %temp, align 8 - %27 = load ptr, ptr %temp, align 8 - %not = icmp eq ptr %27, null - br i1 %not, label %if.then19, label %if.exit20 +if.then7: ; preds = %if.exit4 + %18 = getelementptr inbounds %Doc, ptr %literal9, i32 0, i32 0 + %19 = getelementptr inbounds %Head, ptr %literal10, i32 0, i32 0 + store ptr null, ptr %19, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value, ptr align 8 %literal10, i32 8, i1 false) + %20 = call ptr @std_core_mem_malloc(i64 8) #2 + store ptr %20, ptr %temp, align 8 + %21 = load ptr, ptr %temp, align 8 + %not = icmp eq ptr %21, null + br i1 %not, label %if.then11, label %if.exit12 -if.then19: ; preds = %if.then15 +if.then11: ; preds = %if.then7 store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var, align 8 br label %guard_block -if.exit20: ; preds = %if.then15 - %28 = load ptr, ptr %temp, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %28, ptr align 8 %value, i32 8, i1 false) +if.exit12: ; preds = %if.then7 + %22 = load ptr, ptr %temp, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %22, ptr align 8 %value, i32 8, i1 false) br label %noerr_block -guard_block: ; preds = %if.then19 - %29 = load i64, ptr %error_var, align 8 - ret i64 %29 +guard_block: ; preds = %if.then11 + %23 = load i64, ptr %error_var, align 8 + ret i64 %23 -noerr_block: ; preds = %if.exit20 - %30 = load ptr, ptr %temp, align 8 - store ptr %30, ptr %24, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal17, i32 8, i1 false) +noerr_block: ; preds = %if.exit12 + %24 = load ptr, ptr %temp, align 8 + store ptr %24, ptr %18, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal9, i32 8, i1 false) ret i64 0 -if.exit21: ; preds = %if.exit9 - %31 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 - %lo22 = load ptr, ptr %31, align 8 - %32 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 - %hi23 = load i64, ptr %32, align 8 - store %"char[]" { ptr @.str.5, i64 11 }, ptr %taddr24, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 0 - %lo25 = load ptr, ptr %33, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 1 - %hi26 = load i64, ptr %34, align 8 - %35 = call i8 @test_contains(ptr %lo22, i64 %hi23, ptr %lo25, i64 %hi26) - %36 = trunc i8 %35 to i1 - br i1 %36, label %if.then27, label %if.exit47 +if.exit13: ; preds = %if.exit4 + %25 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %lo14 = load ptr, ptr %25, align 8 + %26 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %hi15 = load i64, ptr %26, align 8 + %27 = call i8 @test_contains(ptr %lo14, i64 %hi15, ptr @.str.5, i64 11) + %28 = trunc i8 %27 to i1 + br i1 %28, label %if.then16, label %if.exit36 -if.then27: ; preds = %if.exit21 - %37 = getelementptr inbounds %Doc, ptr %literal29, i32 0, i32 0 - store ptr null, ptr %literal32, align 8 - %38 = getelementptr inbounds %Head, ptr %literal32, i32 0, i32 0 - store %"char[]" zeroinitializer, ptr %value34, align 8 - %39 = call ptr @std_core_mem_malloc(i64 16) #2 - store ptr %39, ptr %temp35, align 8 - %40 = load ptr, ptr %temp35, align 8 - %not36 = icmp eq ptr %40, null - br i1 %not36, label %if.then37, label %if.exit38 +if.then16: ; preds = %if.exit13 + %29 = getelementptr inbounds %Doc, ptr %literal18, i32 0, i32 0 + store ptr null, ptr %literal21, align 8 + %30 = getelementptr inbounds %Head, ptr %literal21, i32 0, i32 0 + store %"char[]" zeroinitializer, ptr %value23, align 8 + %31 = call ptr @std_core_mem_malloc(i64 16) #2 + store ptr %31, ptr %temp24, align 8 + %32 = load ptr, ptr %temp24, align 8 + %not25 = icmp eq ptr %32, null + br i1 %not25, label %if.then26, label %if.exit27 -if.then37: ; preds = %if.then27 - store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var33, align 8 - br label %guard_block39 +if.then26: ; preds = %if.then16 + store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var22, align 8 + br label %guard_block28 -if.exit38: ; preds = %if.then27 - %41 = load ptr, ptr %temp35, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %41, ptr align 8 %value34, i32 16, i1 false) - br label %noerr_block40 +if.exit27: ; preds = %if.then16 + %33 = load ptr, ptr %temp24, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %33, ptr align 8 %value23, i32 16, i1 false) + br label %noerr_block29 -guard_block39: ; preds = %if.then37 - %42 = load i64, ptr %error_var33, align 8 - ret i64 %42 +guard_block28: ; preds = %if.then26 + %34 = load i64, ptr %error_var22, align 8 + ret i64 %34 -noerr_block40: ; preds = %if.exit38 - %43 = load ptr, ptr %temp35, align 8 - store ptr %43, ptr %38, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value31, ptr align 8 %literal32, i32 8, i1 false) - %44 = call ptr @std_core_mem_malloc(i64 8) #2 - store ptr %44, ptr %temp41, align 8 - %45 = load ptr, ptr %temp41, align 8 - %not42 = icmp eq ptr %45, null - br i1 %not42, label %if.then43, label %if.exit44 +noerr_block29: ; preds = %if.exit27 + %35 = load ptr, ptr %temp24, align 8 + store ptr %35, ptr %30, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value20, ptr align 8 %literal21, i32 8, i1 false) + %36 = call ptr @std_core_mem_malloc(i64 8) #2 + store ptr %36, ptr %temp30, align 8 + %37 = load ptr, ptr %temp30, align 8 + %not31 = icmp eq ptr %37, null + br i1 %not31, label %if.then32, label %if.exit33 -if.then43: ; preds = %noerr_block40 - store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var30, align 8 - br label %guard_block45 +if.then32: ; preds = %noerr_block29 + store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var19, align 8 + br label %guard_block34 -if.exit44: ; preds = %noerr_block40 - %46 = load ptr, ptr %temp41, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %46, ptr align 8 %value31, i32 8, i1 false) - br label %noerr_block46 +if.exit33: ; preds = %noerr_block29 + %38 = load ptr, ptr %temp30, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %38, ptr align 8 %value20, i32 8, i1 false) + br label %noerr_block35 -guard_block45: ; preds = %if.then43 - %47 = load i64, ptr %error_var30, align 8 - ret i64 %47 +guard_block34: ; preds = %if.then32 + %39 = load i64, ptr %error_var19, align 8 + ret i64 %39 -noerr_block46: ; preds = %if.exit44 - %48 = load ptr, ptr %temp41, align 8 - store ptr %48, ptr %37, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal29, i32 8, i1 false) +noerr_block35: ; preds = %if.exit33 + %40 = load ptr, ptr %temp30, align 8 + store ptr %40, ptr %29, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal18, i32 8, i1 false) ret i64 0 -if.exit47: ; preds = %if.exit21 - %49 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 - %50 = load i64, ptr %49, align 8 - %uisitrunc = trunc i64 %50 to i32 - %51 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 - %52 = load ptr, ptr %51, align 8 - %53 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.7, i32 %uisitrunc, ptr %52) - store i32 %53, ptr %len, align 4 - %54 = load i32, ptr %len, align 4 - %siuiext = sext i32 %54 to i64 +if.exit36: ; preds = %if.exit13 + %41 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %42 = load i64, ptr %41, align 8 + %uisitrunc = trunc i64 %42 to i32 + %43 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %44 = load ptr, ptr %43, align 8 + %45 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.7, i32 %uisitrunc, ptr %44) + store i32 %45, ptr %len, align 4 + %46 = load i32, ptr %len, align 4 + %siuiext = sext i32 %46 to i64 %add = add i64 %siuiext, 1 - %55 = call ptr @std_core_mem_malloc(i64 %add) #2 - store ptr %55, ptr %str, align 8 - %56 = load ptr, ptr %str, align 8 - %not48 = icmp eq ptr %56, null - br i1 %not48, label %if.then49, label %if.exit50 + %47 = call ptr @std_core_mem_malloc(i64 %add) #2 + store ptr %47, ptr %str, align 8 + %48 = load ptr, ptr %str, align 8 + %not37 = icmp eq ptr %48, null + br i1 %not37, label %if.then38, label %if.exit39 -if.then49: ; preds = %if.exit47 +if.then38: ; preds = %if.exit36 ret i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64) -if.exit50: ; preds = %if.exit47 - %57 = load ptr, ptr %str, align 8 - %58 = load i32, ptr %len, align 4 - %siuiext51 = sext i32 %58 to i64 - %add52 = add i64 %siuiext51, 1 - %59 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 - %60 = load i64, ptr %59, align 8 - %uisitrunc53 = trunc i64 %60 to i32 - %61 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 - %62 = load ptr, ptr %61, align 8 - %63 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %57, i64 %add52, ptr @.str.8, i32 %uisitrunc53, ptr %62) - %64 = getelementptr inbounds %Doc, ptr %literal55, i32 0, i32 0 - store ptr null, ptr %literal58, align 8 - %65 = getelementptr inbounds %Head, ptr %literal58, i32 0, i32 0 - %66 = load ptr, ptr %str, align 8 - %67 = load i32, ptr %len, align 4 - %sub = sub i32 %67, 1 +if.exit39: ; preds = %if.exit36 + %49 = load ptr, ptr %str, align 8 + %50 = load i32, ptr %len, align 4 + %siuiext40 = sext i32 %50 to i64 + %add41 = add i64 %siuiext40, 1 + %51 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %52 = load i64, ptr %51, align 8 + %uisitrunc42 = trunc i64 %52 to i32 + %53 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %54 = load ptr, ptr %53, align 8 + %55 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %49, i64 %add41, ptr @.str.8, i32 %uisitrunc42, ptr %54) + %56 = getelementptr inbounds %Doc, ptr %literal44, i32 0, i32 0 + store ptr null, ptr %literal47, align 8 + %57 = getelementptr inbounds %Head, ptr %literal47, i32 0, i32 0 + %58 = load ptr, ptr %str, align 8 + %59 = load i32, ptr %len, align 4 + %sub = sub i32 %59, 1 %sisiext = sext i32 %sub to i64 - %68 = add i64 %sisiext, 1 - %size = sub i64 %68, 0 - %ptroffset = getelementptr inbounds i8, ptr %66, i64 0 - %69 = insertvalue %"char[]" undef, ptr %ptroffset, 0 - %70 = insertvalue %"char[]" %69, i64 %size, 1 - store %"char[]" %70, ptr %value60, align 8 - %71 = call ptr @std_core_mem_malloc(i64 16) #2 - store ptr %71, ptr %temp61, align 8 - %72 = load ptr, ptr %temp61, align 8 - %not62 = icmp eq ptr %72, null - br i1 %not62, label %if.then63, label %if.exit64 + %60 = add i64 %sisiext, 1 + %size = sub i64 %60, 0 + %ptroffset = getelementptr inbounds i8, ptr %58, i64 0 + %61 = insertvalue %"char[]" undef, ptr %ptroffset, 0 + %62 = insertvalue %"char[]" %61, i64 %size, 1 + store %"char[]" %62, ptr %value49, align 8 + %63 = call ptr @std_core_mem_malloc(i64 16) #2 + store ptr %63, ptr %temp50, align 8 + %64 = load ptr, ptr %temp50, align 8 + %not51 = icmp eq ptr %64, null + br i1 %not51, label %if.then52, label %if.exit53 -if.then63: ; preds = %if.exit50 - store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var59, align 8 - br label %guard_block65 +if.then52: ; preds = %if.exit39 + store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var48, align 8 + br label %guard_block54 -if.exit64: ; preds = %if.exit50 - %73 = load ptr, ptr %temp61, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %73, ptr align 8 %value60, i32 16, i1 false) - br label %noerr_block66 +if.exit53: ; preds = %if.exit39 + %65 = load ptr, ptr %temp50, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %65, ptr align 8 %value49, i32 16, i1 false) + br label %noerr_block55 -guard_block65: ; preds = %if.then63 - %74 = load i64, ptr %error_var59, align 8 - ret i64 %74 +guard_block54: ; preds = %if.then52 + %66 = load i64, ptr %error_var48, align 8 + ret i64 %66 -noerr_block66: ; preds = %if.exit64 - %75 = load ptr, ptr %temp61, align 8 - store ptr %75, ptr %65, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value57, ptr align 8 %literal58, i32 8, i1 false) - %76 = call ptr @std_core_mem_malloc(i64 8) #2 - store ptr %76, ptr %temp67, align 8 - %77 = load ptr, ptr %temp67, align 8 - %not68 = icmp eq ptr %77, null - br i1 %not68, label %if.then69, label %if.exit70 +noerr_block55: ; preds = %if.exit53 + %67 = load ptr, ptr %temp50, align 8 + store ptr %67, ptr %57, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value46, ptr align 8 %literal47, i32 8, i1 false) + %68 = call ptr @std_core_mem_malloc(i64 8) #2 + store ptr %68, ptr %temp56, align 8 + %69 = load ptr, ptr %temp56, align 8 + %not57 = icmp eq ptr %69, null + br i1 %not57, label %if.then58, label %if.exit59 -if.then69: ; preds = %noerr_block66 - store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var56, align 8 - br label %guard_block71 +if.then58: ; preds = %noerr_block55 + store i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64), ptr %error_var45, align 8 + br label %guard_block60 -if.exit70: ; preds = %noerr_block66 - %78 = load ptr, ptr %temp67, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %78, ptr align 8 %value57, i32 8, i1 false) - br label %noerr_block72 +if.exit59: ; preds = %noerr_block55 + %70 = load ptr, ptr %temp56, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %70, ptr align 8 %value46, i32 8, i1 false) + br label %noerr_block61 -guard_block71: ; preds = %if.then69 - %79 = load i64, ptr %error_var56, align 8 - ret i64 %79 +guard_block60: ; preds = %if.then58 + %71 = load i64, ptr %error_var45, align 8 + ret i64 %71 -noerr_block72: ; preds = %if.exit70 - %80 = load ptr, ptr %temp67, align 8 - store ptr %80, ptr %64, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal55, i32 8, i1 false) +noerr_block61: ; preds = %if.exit59 + %72 = load ptr, ptr %temp56, align 8 + store ptr %72, ptr %56, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal44, i32 8, i1 false) ret i64 0 } @@ -589,9 +565,9 @@ entry: store ptr %0, ptr %2, align 8 %3 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 store i64 %1, ptr %3, align 8 - %4 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 + %4 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 %lo = load ptr, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 + %5 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 %hi = load i64, ptr %5, align 8 %6 = call i64 @test_readDoc(ptr %retparam, ptr %lo, i64 %hi) %not_err = icmp eq i64 %6, 0 @@ -670,9 +646,9 @@ entry: store ptr %1, ptr %3, align 8 %4 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 store i64 %2, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 + %5 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 %lo = load ptr, ptr %5, align 8 - %6 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 + %6 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 %hi = load i64, ptr %6, align 8 %7 = call i64 @test_readDoc(ptr %retparam1, ptr %lo, i64 %hi) %not_err = icmp eq i64 %7, 0 @@ -799,9 +775,9 @@ loop.body: ; preds = %loop.cond %16 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 %17 = load ptr, ptr %16, align 8 %18 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %uisitrunc, ptr %17) - %19 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 + %19 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 %lo = load ptr, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 + %20 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 %hi = load i64, ptr %20, align 8 %21 = call { ptr, i8 } @test_readAndBuildSummary(ptr %lo, i64 %hi) store { ptr, i8 } %21, ptr %result, align 8 @@ -833,9 +809,9 @@ cond.phi: ; preds = %cond.rhs, %cond.lhs %32 = getelementptr inbounds %"char[]", ptr %title_sure, i32 0, i32 0 %33 = load ptr, ptr %32, align 8 %34 = call i32 (ptr, ...) @printf(ptr @.str.24, i32 %uisitrunc2, ptr %33) - %35 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 + %35 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 %lo3 = load ptr, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 + %36 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 %hi4 = load i64, ptr %36, align 8 %37 = call i64 @test_readWhetherTitleNonEmpty(ptr %retparam, ptr %lo3, i64 %hi4) %not_err = icmp eq i64 %37, 0 diff --git a/test/test_suite2/errors/optional_chained_init.c3t b/test/test_suite2/errors/optional_chained_init.c3t index b45123f51..05c1e308d 100644 --- a/test/test_suite2/errors/optional_chained_init.c3t +++ b/test/test_suite2/errors/optional_chained_init.c3t @@ -54,22 +54,14 @@ entry: %b.f = alloca i64, align 8 %err = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %err5 = alloca i64, align 8 - %retparam14 = alloca i64, align 8 - %taddr15 = alloca %"char[]", align 8 - %vararg18 = alloca %"variant[]", align 8 + %err3 = alloca i64, align 8 + %retparam12 = alloca i64, align 8 + %varargslots13 = alloca [1 x %variant], align 16 + %retparam18 = alloca i64, align 8 %varargslots19 = alloca [1 x %variant], align 16 %retparam26 = alloca i64, align 8 - %taddr27 = alloca %"char[]", align 8 - %vararg30 = alloca %"variant[]", align 8 - %varargslots31 = alloca [1 x %variant], align 16 - %retparam40 = alloca i64, align 8 - %taddr41 = alloca %"char[]", align 8 - %vararg44 = alloca %"variant[]", align 8 - %varargslots45 = alloca [1 x %variant], align 16 + %varargslots27 = alloca [1 x %variant], align 16 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 @@ -98,143 +90,91 @@ end_block: ; preds = %after_check, %assig br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block - store %"char[]" { ptr @.str, i64 13 }, ptr %taddr, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %1, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %2, align 8 - %3 = insertvalue %variant undef, ptr %err, 0 - %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %4, ptr %5, align 16 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %6, align 8 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo1 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi2 = load i64, ptr %9, align 8 - %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) - %not_err3 = icmp eq i64 %10, 0 - br i1 %not_err3, label %after_check4, label %voiderr + %1 = insertvalue %variant undef, ptr %err, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %2, ptr %3, align 16 + %4 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 13, ptr %varargslots, i64 1) + %not_err1 = icmp eq i64 %4, 0 + br i1 %not_err1, label %after_check2, label %voiderr -after_check4: ; preds = %if.then +after_check2: ; preds = %if.then br label %voiderr -voiderr: ; preds = %after_check4, %if.then +voiderr: ; preds = %after_check2, %if.then br label %if.exit if.exit: ; preds = %voiderr, %end_block - br label %testblock6 + br label %testblock4 -testblock6: ; preds = %if.exit - %optval7 = load i64, ptr %b.f, align 8 - %not_err8 = icmp eq i64 %optval7, 0 - br i1 %not_err8, label %after_check10, label %assign_optional9 +testblock4: ; preds = %if.exit + %optval5 = load i64, ptr %b.f, align 8 + %not_err6 = icmp eq i64 %optval5, 0 + br i1 %not_err6, label %after_check8, label %assign_optional7 -assign_optional9: ; preds = %testblock6 - store i64 %optval7, ptr %err5, align 8 - br label %end_block11 +assign_optional7: ; preds = %testblock4 + store i64 %optval5, ptr %err3, align 8 + br label %end_block9 -after_check10: ; preds = %testblock6 - store i64 0, ptr %err5, align 8 - br label %end_block11 +after_check8: ; preds = %testblock4 + store i64 0, ptr %err3, align 8 + br label %end_block9 -end_block11: ; preds = %after_check10, %assign_optional9 - %11 = load i64, ptr %err5, align 8 - %neq12 = icmp ne i64 %11, 0 - br i1 %neq12, label %if.then13, label %if.exit25 +end_block9: ; preds = %after_check8, %assign_optional7 + %5 = load i64, ptr %err3, align 8 + %neq10 = icmp ne i64 %5, 0 + br i1 %neq10, label %if.then11, label %if.exit17 -if.then13: ; preds = %end_block11 - store %"char[]" { ptr @.str.1, i64 13 }, ptr %taddr15, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr15, i32 0, i32 0 - %lo16 = load ptr, ptr %12, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr15, i32 0, i32 1 - %hi17 = load i64, ptr %13, align 8 - %14 = insertvalue %variant undef, ptr %err5, 0 - %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %16 = getelementptr inbounds [1 x %variant], ptr %varargslots19, i64 0, i64 0 +if.then11: ; preds = %end_block9 + %6 = insertvalue %variant undef, ptr %err3, 0 + %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %8 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0 + store %variant %7, ptr %8, align 16 + %9 = call i64 @std_io_printfln(ptr %retparam12, ptr @.str.1, i64 13, ptr %varargslots13, i64 1) + %not_err14 = icmp eq i64 %9, 0 + br i1 %not_err14, label %after_check15, label %voiderr16 + +after_check15: ; preds = %if.then11 + br label %voiderr16 + +voiderr16: ; preds = %after_check15, %if.then11 + br label %if.exit17 + +if.exit17: ; preds = %voiderr16, %end_block9 + %optval20 = load i64, ptr %a.f, align 8 + %not_err21 = icmp eq i64 %optval20, 0 + br i1 %not_err21, label %after_check22, label %voiderr25 + +after_check22: ; preds = %if.exit17 + %10 = insertvalue %variant undef, ptr %a, 0 + %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %12 = getelementptr inbounds [1 x %variant], ptr %varargslots19, i64 0, i64 0 + store %variant %11, ptr %12, align 16 + %13 = call i64 @std_io_printfln(ptr %retparam18, ptr @.str.2, i64 9, ptr %varargslots19, i64 1) + %not_err23 = icmp eq i64 %13, 0 + br i1 %not_err23, label %after_check24, label %voiderr25 + +after_check24: ; preds = %after_check22 + br label %voiderr25 + +voiderr25: ; preds = %after_check24, %after_check22, %if.exit17 + %optval28 = load i64, ptr %b.f, align 8 + %not_err29 = icmp eq i64 %optval28, 0 + br i1 %not_err29, label %after_check30, label %voiderr33 + +after_check30: ; preds = %voiderr25 + %14 = insertvalue %variant undef, ptr %b, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %16 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0 store %variant %15, ptr %16, align 16 - %17 = getelementptr inbounds %"variant[]", ptr %vararg18, i32 0, i32 1 - store i64 1, ptr %17, align 8 - %18 = getelementptr inbounds %"variant[]", ptr %vararg18, i32 0, i32 0 - store ptr %varargslots19, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %vararg18, i32 0, i32 0 - %lo20 = load ptr, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg18, i32 0, i32 1 - %hi21 = load i64, ptr %20, align 8 - %21 = call i64 @std_io_printfln(ptr %retparam14, ptr %lo16, i64 %hi17, ptr %lo20, i64 %hi21) - %not_err22 = icmp eq i64 %21, 0 - br i1 %not_err22, label %after_check23, label %voiderr24 + %17 = call i64 @std_io_printfln(ptr %retparam26, ptr @.str.3, i64 9, ptr %varargslots27, i64 1) + %not_err31 = icmp eq i64 %17, 0 + br i1 %not_err31, label %after_check32, label %voiderr33 -after_check23: ; preds = %if.then13 - br label %voiderr24 +after_check32: ; preds = %after_check30 + br label %voiderr33 -voiderr24: ; preds = %after_check23, %if.then13 - br label %if.exit25 - -if.exit25: ; preds = %voiderr24, %end_block11 - store %"char[]" { ptr @.str.2, i64 9 }, ptr %taddr27, align 8 - %22 = getelementptr inbounds { ptr, i64 }, ptr %taddr27, i32 0, i32 0 - %lo28 = load ptr, ptr %22, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr27, i32 0, i32 1 - %hi29 = load i64, ptr %23, align 8 - %optval32 = load i64, ptr %a.f, align 8 - %not_err33 = icmp eq i64 %optval32, 0 - br i1 %not_err33, label %after_check34, label %voiderr39 - -after_check34: ; preds = %if.exit25 - %24 = insertvalue %variant undef, ptr %a, 0 - %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %26 = getelementptr inbounds [1 x %variant], ptr %varargslots31, i64 0, i64 0 - store %variant %25, ptr %26, align 16 - %27 = getelementptr inbounds %"variant[]", ptr %vararg30, i32 0, i32 1 - store i64 1, ptr %27, align 8 - %28 = getelementptr inbounds %"variant[]", ptr %vararg30, i32 0, i32 0 - store ptr %varargslots31, ptr %28, align 8 - %29 = getelementptr inbounds { ptr, i64 }, ptr %vararg30, i32 0, i32 0 - %lo35 = load ptr, ptr %29, align 8 - %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg30, i32 0, i32 1 - %hi36 = load i64, ptr %30, align 8 - %31 = call i64 @std_io_printfln(ptr %retparam26, ptr %lo28, i64 %hi29, ptr %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %31, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 - -after_check38: ; preds = %after_check34 - br label %voiderr39 - -voiderr39: ; preds = %after_check38, %after_check34, %if.exit25 - store %"char[]" { ptr @.str.3, i64 9 }, ptr %taddr41, align 8 - %32 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 0 - %lo42 = load ptr, ptr %32, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 1 - %hi43 = load i64, ptr %33, align 8 - %optval46 = load i64, ptr %b.f, align 8 - %not_err47 = icmp eq i64 %optval46, 0 - br i1 %not_err47, label %after_check48, label %voiderr53 - -after_check48: ; preds = %voiderr39 - %34 = insertvalue %variant undef, ptr %b, 0 - %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %36 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0 - store %variant %35, ptr %36, align 16 - %37 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 1 - store i64 1, ptr %37, align 8 - %38 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 0 - store ptr %varargslots45, ptr %38, align 8 - %39 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 0 - %lo49 = load ptr, ptr %39, align 8 - %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 1 - %hi50 = load i64, ptr %40, align 8 - %41 = call i64 @std_io_printfln(ptr %retparam40, ptr %lo42, i64 %hi43, ptr %lo49, i64 %hi50) - %not_err51 = icmp eq i64 %41, 0 - br i1 %not_err51, label %after_check52, label %voiderr53 - -after_check52: ; preds = %after_check48 - br label %voiderr53 - -voiderr53: ; preds = %after_check52, %after_check48, %voiderr39 +voiderr33: ; preds = %after_check32, %after_check30, %voiderr25 ret void } @@ -249,22 +189,14 @@ entry: %b.f = alloca i64, align 8 %err = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %err10 = alloca i64, align 8 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 + %err8 = alloca i64, align 8 + %retparam17 = alloca i64, align 8 + %varargslots18 = alloca [1 x %variant], align 16 + %retparam23 = alloca i64, align 8 %varargslots24 = alloca [1 x %variant], align 16 %retparam31 = alloca i64, align 8 - %taddr32 = alloca %"char[]", align 8 - %vararg35 = alloca %"variant[]", align 8 - %varargslots36 = alloca [1 x %variant], align 16 - %retparam45 = alloca i64, align 8 - %taddr46 = alloca %"char[]", align 8 - %vararg49 = alloca %"variant[]", align 8 - %varargslots50 = alloca [1 x %variant], align 16 + %varargslots32 = alloca [1 x %variant], align 16 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 @@ -314,143 +246,91 @@ end_block: ; preds = %after_check5, %assi br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block - store %"char[]" { ptr @.str.4, i64 13 }, ptr %taddr, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %2, align 8 - %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %3, align 8 - %4 = insertvalue %variant undef, ptr %err, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %5, ptr %6, align 16 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %7, align 8 - %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo6 = load ptr, ptr %9, align 8 - %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi7 = load i64, ptr %10, align 8 - %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo6, i64 %hi7) - %not_err8 = icmp eq i64 %11, 0 - br i1 %not_err8, label %after_check9, label %voiderr + %2 = insertvalue %variant undef, ptr %err, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %3, ptr %4, align 16 + %5 = call i64 @std_io_printfln(ptr %retparam, ptr @.str.4, i64 13, ptr %varargslots, i64 1) + %not_err6 = icmp eq i64 %5, 0 + br i1 %not_err6, label %after_check7, label %voiderr -after_check9: ; preds = %if.then +after_check7: ; preds = %if.then br label %voiderr -voiderr: ; preds = %after_check9, %if.then +voiderr: ; preds = %after_check7, %if.then br label %if.exit if.exit: ; preds = %voiderr, %end_block - br label %testblock11 + br label %testblock9 -testblock11: ; preds = %if.exit - %optval12 = load i64, ptr %b.f, align 8 - %not_err13 = icmp eq i64 %optval12, 0 - br i1 %not_err13, label %after_check15, label %assign_optional14 +testblock9: ; preds = %if.exit + %optval10 = load i64, ptr %b.f, align 8 + %not_err11 = icmp eq i64 %optval10, 0 + br i1 %not_err11, label %after_check13, label %assign_optional12 -assign_optional14: ; preds = %testblock11 - store i64 %optval12, ptr %err10, align 8 - br label %end_block16 +assign_optional12: ; preds = %testblock9 + store i64 %optval10, ptr %err8, align 8 + br label %end_block14 -after_check15: ; preds = %testblock11 - store i64 0, ptr %err10, align 8 - br label %end_block16 +after_check13: ; preds = %testblock9 + store i64 0, ptr %err8, align 8 + br label %end_block14 -end_block16: ; preds = %after_check15, %assign_optional14 - %12 = load i64, ptr %err10, align 8 - %neq17 = icmp ne i64 %12, 0 - br i1 %neq17, label %if.then18, label %if.exit30 +end_block14: ; preds = %after_check13, %assign_optional12 + %6 = load i64, ptr %err8, align 8 + %neq15 = icmp ne i64 %6, 0 + br i1 %neq15, label %if.then16, label %if.exit22 -if.then18: ; preds = %end_block16 - store %"char[]" { ptr @.str.5, i64 13 }, ptr %taddr20, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0 - %lo21 = load ptr, ptr %13, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1 - %hi22 = load i64, ptr %14, align 8 - %15 = insertvalue %variant undef, ptr %err10, 0 - %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %17 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 +if.then16: ; preds = %end_block14 + %7 = insertvalue %variant undef, ptr %err8, 0 + %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %9 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0 + store %variant %8, ptr %9, align 16 + %10 = call i64 @std_io_printfln(ptr %retparam17, ptr @.str.5, i64 13, ptr %varargslots18, i64 1) + %not_err19 = icmp eq i64 %10, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 + +after_check20: ; preds = %if.then16 + br label %voiderr21 + +voiderr21: ; preds = %after_check20, %if.then16 + br label %if.exit22 + +if.exit22: ; preds = %voiderr21, %end_block14 + %optval25 = load i64, ptr %a.f, align 8 + %not_err26 = icmp eq i64 %optval25, 0 + br i1 %not_err26, label %after_check27, label %voiderr30 + +after_check27: ; preds = %if.exit22 + %11 = insertvalue %variant undef, ptr %a, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %13 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 + store %variant %12, ptr %13, align 16 + %14 = call i64 @std_io_printfln(ptr %retparam23, ptr @.str.6, i64 9, ptr %varargslots24, i64 1) + %not_err28 = icmp eq i64 %14, 0 + br i1 %not_err28, label %after_check29, label %voiderr30 + +after_check29: ; preds = %after_check27 + br label %voiderr30 + +voiderr30: ; preds = %after_check29, %after_check27, %if.exit22 + %optval33 = load i64, ptr %b.f, align 8 + %not_err34 = icmp eq i64 %optval33, 0 + br i1 %not_err34, label %after_check35, label %voiderr38 + +after_check35: ; preds = %voiderr30 + %15 = insertvalue %variant undef, ptr %b, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %17 = getelementptr inbounds [1 x %variant], ptr %varargslots32, i64 0, i64 0 store %variant %16, ptr %17, align 16 - %18 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1 - store i64 1, ptr %18, align 8 - %19 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0 - store ptr %varargslots24, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0 - %lo25 = load ptr, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1 - %hi26 = load i64, ptr %21, align 8 - %22 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %22, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 + %18 = call i64 @std_io_printfln(ptr %retparam31, ptr @.str.7, i64 9, ptr %varargslots32, i64 1) + %not_err36 = icmp eq i64 %18, 0 + br i1 %not_err36, label %after_check37, label %voiderr38 -after_check28: ; preds = %if.then18 - br label %voiderr29 +after_check37: ; preds = %after_check35 + br label %voiderr38 -voiderr29: ; preds = %after_check28, %if.then18 - br label %if.exit30 - -if.exit30: ; preds = %voiderr29, %end_block16 - store %"char[]" { ptr @.str.6, i64 9 }, ptr %taddr32, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 0 - %lo33 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 1 - %hi34 = load i64, ptr %24, align 8 - %optval37 = load i64, ptr %a.f, align 8 - %not_err38 = icmp eq i64 %optval37, 0 - br i1 %not_err38, label %after_check39, label %voiderr44 - -after_check39: ; preds = %if.exit30 - %25 = insertvalue %variant undef, ptr %a, 0 - %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %27 = getelementptr inbounds [1 x %variant], ptr %varargslots36, i64 0, i64 0 - store %variant %26, ptr %27, align 16 - %28 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 1 - store i64 1, ptr %28, align 8 - %29 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 0 - store ptr %varargslots36, ptr %29, align 8 - %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 0 - %lo40 = load ptr, ptr %30, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 1 - %hi41 = load i64, ptr %31, align 8 - %32 = call i64 @std_io_printfln(ptr %retparam31, ptr %lo33, i64 %hi34, ptr %lo40, i64 %hi41) - %not_err42 = icmp eq i64 %32, 0 - br i1 %not_err42, label %after_check43, label %voiderr44 - -after_check43: ; preds = %after_check39 - br label %voiderr44 - -voiderr44: ; preds = %after_check43, %after_check39, %if.exit30 - store %"char[]" { ptr @.str.7, i64 9 }, ptr %taddr46, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 0 - %lo47 = load ptr, ptr %33, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 1 - %hi48 = load i64, ptr %34, align 8 - %optval51 = load i64, ptr %b.f, align 8 - %not_err52 = icmp eq i64 %optval51, 0 - br i1 %not_err52, label %after_check53, label %voiderr58 - -after_check53: ; preds = %voiderr44 - %35 = insertvalue %variant undef, ptr %b, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %37 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0 - store %variant %36, ptr %37, align 16 - %38 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 1 - store i64 1, ptr %38, align 8 - %39 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 0 - store ptr %varargslots50, ptr %39, align 8 - %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 0 - %lo54 = load ptr, ptr %40, align 8 - %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 1 - %hi55 = load i64, ptr %41, align 8 - %42 = call i64 @std_io_printfln(ptr %retparam45, ptr %lo47, i64 %hi48, ptr %lo54, i64 %hi55) - %not_err56 = icmp eq i64 %42, 0 - br i1 %not_err56, label %after_check57, label %voiderr58 - -after_check57: ; preds = %after_check53 - br label %voiderr58 - -voiderr58: ; preds = %after_check57, %after_check53, %voiderr44 +voiderr38: ; preds = %after_check37, %after_check35, %voiderr30 ret void } @@ -465,22 +345,14 @@ entry: %b.f = alloca i64, align 8 %err = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %err10 = alloca i64, align 8 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 + %err8 = alloca i64, align 8 + %retparam17 = alloca i64, align 8 + %varargslots18 = alloca [1 x %variant], align 16 + %retparam23 = alloca i64, align 8 %varargslots24 = alloca [1 x %variant], align 16 %retparam31 = alloca i64, align 8 - %taddr32 = alloca %"char[]", align 8 - %vararg35 = alloca %"variant[]", align 8 - %varargslots36 = alloca [1 x %variant], align 16 - %retparam45 = alloca i64, align 8 - %taddr46 = alloca %"char[]", align 8 - %vararg49 = alloca %"variant[]", align 8 - %varargslots50 = alloca [1 x %variant], align 16 + %varargslots32 = alloca [1 x %variant], align 16 store i32 23, ptr %x, align 4 store i64 0, ptr %x.f, align 8 store i32 1, ptr %a, align 4 @@ -531,142 +403,90 @@ end_block: ; preds = %after_check5, %assi br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block - store %"char[]" { ptr @.str.8, i64 13 }, ptr %taddr, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %2, align 8 - %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %3, align 8 - %4 = insertvalue %variant undef, ptr %err, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %5, ptr %6, align 16 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %7, align 8 - %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo6 = load ptr, ptr %9, align 8 - %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi7 = load i64, ptr %10, align 8 - %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo6, i64 %hi7) - %not_err8 = icmp eq i64 %11, 0 - br i1 %not_err8, label %after_check9, label %voiderr + %2 = insertvalue %variant undef, ptr %err, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %3, ptr %4, align 16 + %5 = call i64 @std_io_printfln(ptr %retparam, ptr @.str.8, i64 13, ptr %varargslots, i64 1) + %not_err6 = icmp eq i64 %5, 0 + br i1 %not_err6, label %after_check7, label %voiderr -after_check9: ; preds = %if.then +after_check7: ; preds = %if.then br label %voiderr -voiderr: ; preds = %after_check9, %if.then +voiderr: ; preds = %after_check7, %if.then br label %if.exit if.exit: ; preds = %voiderr, %end_block - br label %testblock11 + br label %testblock9 -testblock11: ; preds = %if.exit - %optval12 = load i64, ptr %b.f, align 8 - %not_err13 = icmp eq i64 %optval12, 0 - br i1 %not_err13, label %after_check15, label %assign_optional14 +testblock9: ; preds = %if.exit + %optval10 = load i64, ptr %b.f, align 8 + %not_err11 = icmp eq i64 %optval10, 0 + br i1 %not_err11, label %after_check13, label %assign_optional12 -assign_optional14: ; preds = %testblock11 - store i64 %optval12, ptr %err10, align 8 - br label %end_block16 +assign_optional12: ; preds = %testblock9 + store i64 %optval10, ptr %err8, align 8 + br label %end_block14 -after_check15: ; preds = %testblock11 - store i64 0, ptr %err10, align 8 - br label %end_block16 +after_check13: ; preds = %testblock9 + store i64 0, ptr %err8, align 8 + br label %end_block14 -end_block16: ; preds = %after_check15, %assign_optional14 - %12 = load i64, ptr %err10, align 8 - %neq17 = icmp ne i64 %12, 0 - br i1 %neq17, label %if.then18, label %if.exit30 +end_block14: ; preds = %after_check13, %assign_optional12 + %6 = load i64, ptr %err8, align 8 + %neq15 = icmp ne i64 %6, 0 + br i1 %neq15, label %if.then16, label %if.exit22 -if.then18: ; preds = %end_block16 - store %"char[]" { ptr @.str.9, i64 13 }, ptr %taddr20, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0 - %lo21 = load ptr, ptr %13, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1 - %hi22 = load i64, ptr %14, align 8 - %15 = insertvalue %variant undef, ptr %err10, 0 - %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %17 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 +if.then16: ; preds = %end_block14 + %7 = insertvalue %variant undef, ptr %err8, 0 + %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %9 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0 + store %variant %8, ptr %9, align 16 + %10 = call i64 @std_io_printfln(ptr %retparam17, ptr @.str.9, i64 13, ptr %varargslots18, i64 1) + %not_err19 = icmp eq i64 %10, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 + +after_check20: ; preds = %if.then16 + br label %voiderr21 + +voiderr21: ; preds = %after_check20, %if.then16 + br label %if.exit22 + +if.exit22: ; preds = %voiderr21, %end_block14 + %optval25 = load i64, ptr %a.f, align 8 + %not_err26 = icmp eq i64 %optval25, 0 + br i1 %not_err26, label %after_check27, label %voiderr30 + +after_check27: ; preds = %if.exit22 + %11 = insertvalue %variant undef, ptr %a, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %13 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 + store %variant %12, ptr %13, align 16 + %14 = call i64 @std_io_printfln(ptr %retparam23, ptr @.str.10, i64 9, ptr %varargslots24, i64 1) + %not_err28 = icmp eq i64 %14, 0 + br i1 %not_err28, label %after_check29, label %voiderr30 + +after_check29: ; preds = %after_check27 + br label %voiderr30 + +voiderr30: ; preds = %after_check29, %after_check27, %if.exit22 + %optval33 = load i64, ptr %b.f, align 8 + %not_err34 = icmp eq i64 %optval33, 0 + br i1 %not_err34, label %after_check35, label %voiderr38 + +after_check35: ; preds = %voiderr30 + %15 = insertvalue %variant undef, ptr %b, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %17 = getelementptr inbounds [1 x %variant], ptr %varargslots32, i64 0, i64 0 store %variant %16, ptr %17, align 16 - %18 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1 - store i64 1, ptr %18, align 8 - %19 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0 - store ptr %varargslots24, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0 - %lo25 = load ptr, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1 - %hi26 = load i64, ptr %21, align 8 - %22 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %22, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 + %18 = call i64 @std_io_printfln(ptr %retparam31, ptr @.str.11, i64 9, ptr %varargslots32, i64 1) + %not_err36 = icmp eq i64 %18, 0 + br i1 %not_err36, label %after_check37, label %voiderr38 -after_check28: ; preds = %if.then18 - br label %voiderr29 +after_check37: ; preds = %after_check35 + br label %voiderr38 -voiderr29: ; preds = %after_check28, %if.then18 - br label %if.exit30 - -if.exit30: ; preds = %voiderr29, %end_block16 - store %"char[]" { ptr @.str.10, i64 9 }, ptr %taddr32, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 0 - %lo33 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 1 - %hi34 = load i64, ptr %24, align 8 - %optval37 = load i64, ptr %a.f, align 8 - %not_err38 = icmp eq i64 %optval37, 0 - br i1 %not_err38, label %after_check39, label %voiderr44 - -after_check39: ; preds = %if.exit30 - %25 = insertvalue %variant undef, ptr %a, 0 - %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %27 = getelementptr inbounds [1 x %variant], ptr %varargslots36, i64 0, i64 0 - store %variant %26, ptr %27, align 16 - %28 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 1 - store i64 1, ptr %28, align 8 - %29 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 0 - store ptr %varargslots36, ptr %29, align 8 - %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 0 - %lo40 = load ptr, ptr %30, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 1 - %hi41 = load i64, ptr %31, align 8 - %32 = call i64 @std_io_printfln(ptr %retparam31, ptr %lo33, i64 %hi34, ptr %lo40, i64 %hi41) - %not_err42 = icmp eq i64 %32, 0 - br i1 %not_err42, label %after_check43, label %voiderr44 - -after_check43: ; preds = %after_check39 - br label %voiderr44 - -voiderr44: ; preds = %after_check43, %after_check39, %if.exit30 - store %"char[]" { ptr @.str.11, i64 9 }, ptr %taddr46, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 0 - %lo47 = load ptr, ptr %33, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 1 - %hi48 = load i64, ptr %34, align 8 - %optval51 = load i64, ptr %b.f, align 8 - %not_err52 = icmp eq i64 %optval51, 0 - br i1 %not_err52, label %after_check53, label %voiderr58 - -after_check53: ; preds = %voiderr44 - %35 = insertvalue %variant undef, ptr %b, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %37 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0 - store %variant %36, ptr %37, align 16 - %38 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 1 - store i64 1, ptr %38, align 8 - %39 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 0 - store ptr %varargslots50, ptr %39, align 8 - %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 0 - %lo54 = load ptr, ptr %40, align 8 - %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 1 - %hi55 = load i64, ptr %41, align 8 - %42 = call i64 @std_io_printfln(ptr %retparam45, ptr %lo47, i64 %hi48, ptr %lo54, i64 %hi55) - %not_err56 = icmp eq i64 %42, 0 - br i1 %not_err56, label %after_check57, label %voiderr58 - -after_check57: ; preds = %after_check53 - br label %voiderr58 - -voiderr58: ; preds = %after_check57, %after_check53, %voiderr44 +voiderr38: ; preds = %after_check37, %after_check35, %voiderr30 ret void } diff --git a/test/test_suite2/errors/optional_with_optional.c3t b/test/test_suite2/errors/optional_with_optional.c3t index af36bf6e3..3074c174d 100644 --- a/test/test_suite2/errors/optional_with_optional.c3t +++ b/test/test_suite2/errors/optional_with_optional.c3t @@ -35,77 +35,56 @@ fn int! get_b(int x) define void @test_main() #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 %retparam1 = alloca i32, align 4 %retparam2 = alloca i32, align 4 - %taddr8 = alloca i32, align 4 - %retparam13 = alloca i64, align 8 - %taddr14 = alloca %"char[]", align 8 - %vararg17 = alloca %"variant[]", align 8 - %varargslots18 = alloca [1 x %variant], align 16 - %retparam19 = alloca i32, align 4 - %retparam23 = alloca i32, align 4 - %taddr31 = alloca i32, align 4 - %retparam37 = alloca i64, align 8 - %taddr38 = alloca %"char[]", align 8 - %vararg41 = alloca %"variant[]", align 8 - %varargslots42 = alloca [1 x %variant], align 16 - %retparam43 = alloca i32, align 4 - %retparam47 = alloca i32, align 4 - %taddr55 = alloca i32, align 4 - %retparam61 = alloca i64, align 8 - %taddr62 = alloca %"char[]", align 8 - %vararg65 = alloca %"variant[]", align 8 - %varargslots66 = alloca [1 x %variant], align 16 - %taddr67 = alloca i64, align 8 - %retparam73 = alloca i64, align 8 - %taddr74 = alloca %"char[]", align 8 - %vararg77 = alloca %"variant[]", align 8 - %varargslots78 = alloca [1 x %variant], align 16 - %taddr79 = alloca i32, align 4 - %retparam85 = alloca i64, align 8 - %taddr86 = alloca %"char[]", align 8 - %vararg89 = alloca %"variant[]", align 8 - %varargslots90 = alloca [1 x %variant], align 16 - %taddr91 = alloca i64, align 8 - %retparam97 = alloca i64, align 8 - %taddr98 = alloca %"char[]", align 8 - %vararg101 = alloca %"variant[]", align 8 - %varargslots102 = alloca [1 x %variant], align 16 + %taddr = alloca i32, align 4 + %retparam10 = alloca i64, align 8 + %varargslots11 = alloca [1 x %variant], align 16 + %retparam12 = alloca i32, align 4 + %retparam16 = alloca i32, align 4 + %taddr24 = alloca i32, align 4 + %retparam28 = alloca i64, align 8 + %varargslots29 = alloca [1 x %variant], align 16 + %retparam30 = alloca i32, align 4 + %retparam34 = alloca i32, align 4 + %taddr42 = alloca i32, align 4 + %retparam46 = alloca i64, align 8 + %varargslots47 = alloca [1 x %variant], align 16 + %taddr48 = alloca i64, align 8 + %retparam52 = alloca i64, align 8 + %varargslots53 = alloca [1 x %variant], align 16 + %taddr54 = alloca i32, align 4 + %retparam58 = alloca i64, align 8 + %varargslots59 = alloca [1 x %variant], align 16 + %taddr60 = alloca i64, align 8 + %retparam64 = alloca i64, align 8 + %varargslots65 = alloca [1 x %variant], align 16 %error_var = alloca i64, align 8 %x = alloca i64, align 8 - %retparam110 = alloca i64, align 8 - %taddr111 = alloca %"char[]", align 8 - %vararg114 = alloca %"variant[]", align 8 - %varargslots115 = alloca [1 x %variant], align 16 + %retparam71 = alloca i64, align 8 + %varargslots72 = alloca [1 x %variant], align 16 %xy = alloca i32, align 4 %xy.f = alloca i64, align 8 - store %"char[]" { ptr @.str, i64 4 }, ptr %taddr, align 8 - %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - %2 = call i64 @test_get_a(ptr %retparam1, i32 1) - %not_err = icmp eq i64 %2, 0 + %0 = call i64 @test_get_a(ptr %retparam1, i32 1) + %not_err = icmp eq i64 %0, 0 br i1 %not_err, label %after_check, label %else_block after_check: ; preds = %entry - %3 = load i32, ptr %retparam1, align 4 + %1 = load i32, ptr %retparam1, align 4 br label %phi_block else_block: ; preds = %entry - %4 = call i64 @test_get_b(ptr %retparam2, i32 4) - %not_err3 = icmp eq i64 %4, 0 + %2 = call i64 @test_get_b(ptr %retparam2, i32 4) + %not_err3 = icmp eq i64 %2, 0 br i1 %not_err3, label %after_check4, label %else_block5 after_check4: ; preds = %else_block - %5 = load i32, ptr %retparam2, align 4 + %3 = load i32, ptr %retparam2, align 4 br label %phi_block phi_block: ; preds = %after_check4, %after_check - %val = phi i32 [ %3, %after_check ], [ %5, %after_check4 ] + %val = phi i32 [ %1, %after_check ], [ %3, %after_check4 ] br label %phi_block6 else_block5: ; preds = %else_block @@ -113,267 +92,168 @@ else_block5: ; preds = %else_block phi_block6: ; preds = %else_block5, %phi_block %val7 = phi i32 [ %val, %phi_block ], [ -1, %else_block5 ] - store i32 %val7, ptr %taddr8, align 4 - %6 = insertvalue %variant undef, ptr %taddr8, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %8 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %7, ptr %8, align 16 - %9 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %9, align 8 - %10 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %10, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo9 = load ptr, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi10 = load i64, ptr %12, align 8 - %13 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo9, i64 %hi10) - %not_err11 = icmp eq i64 %13, 0 - br i1 %not_err11, label %after_check12, label %voiderr + store i32 %val7, ptr %taddr, align 4 + %4 = insertvalue %variant undef, ptr %taddr, 0 + %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %5, ptr %6, align 16 + %7 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 4, ptr %varargslots, i64 1) + %not_err8 = icmp eq i64 %7, 0 + br i1 %not_err8, label %after_check9, label %voiderr -after_check12: ; preds = %phi_block6 +after_check9: ; preds = %phi_block6 br label %voiderr -voiderr: ; preds = %after_check12, %phi_block6 - store %"char[]" { ptr @.str.2, i64 4 }, ptr %taddr14, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr14, i32 0, i32 0 - %lo15 = load ptr, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %taddr14, i32 0, i32 1 - %hi16 = load i64, ptr %15, align 8 - %16 = call i64 @test_get_a(ptr %retparam19, i32 2) - %not_err20 = icmp eq i64 %16, 0 - br i1 %not_err20, label %after_check21, label %else_block22 +voiderr: ; preds = %after_check9, %phi_block6 + %8 = call i64 @test_get_a(ptr %retparam12, i32 2) + %not_err13 = icmp eq i64 %8, 0 + br i1 %not_err13, label %after_check14, label %else_block15 -after_check21: ; preds = %voiderr - %17 = load i32, ptr %retparam19, align 4 - br label %phi_block26 +after_check14: ; preds = %voiderr + %9 = load i32, ptr %retparam12, align 4 + br label %phi_block19 -else_block22: ; preds = %voiderr - %18 = call i64 @test_get_b(ptr %retparam23, i32 4) - %not_err24 = icmp eq i64 %18, 0 - br i1 %not_err24, label %after_check25, label %else_block28 +else_block15: ; preds = %voiderr + %10 = call i64 @test_get_b(ptr %retparam16, i32 4) + %not_err17 = icmp eq i64 %10, 0 + br i1 %not_err17, label %after_check18, label %else_block21 -after_check25: ; preds = %else_block22 - %19 = load i32, ptr %retparam23, align 4 - br label %phi_block26 +after_check18: ; preds = %else_block15 + %11 = load i32, ptr %retparam16, align 4 + br label %phi_block19 -phi_block26: ; preds = %after_check25, %after_check21 - %val27 = phi i32 [ %17, %after_check21 ], [ %19, %after_check25 ] - br label %phi_block29 +phi_block19: ; preds = %after_check18, %after_check14 + %val20 = phi i32 [ %9, %after_check14 ], [ %11, %after_check18 ] + br label %phi_block22 -else_block28: ; preds = %else_block22 - br label %phi_block29 +else_block21: ; preds = %else_block15 + br label %phi_block22 -phi_block29: ; preds = %else_block28, %phi_block26 - %val30 = phi i32 [ %val27, %phi_block26 ], [ -1, %else_block28 ] - store i32 %val30, ptr %taddr31, align 4 - %20 = insertvalue %variant undef, ptr %taddr31, 0 +phi_block22: ; preds = %else_block21, %phi_block19 + %val23 = phi i32 [ %val20, %phi_block19 ], [ -1, %else_block21 ] + store i32 %val23, ptr %taddr24, align 4 + %12 = insertvalue %variant undef, ptr %taddr24, 0 + %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %14 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0 + store %variant %13, ptr %14, align 16 + %15 = call i64 @std_io_printfln(ptr %retparam10, ptr @.str.2, i64 4, ptr %varargslots11, i64 1) + %not_err25 = icmp eq i64 %15, 0 + br i1 %not_err25, label %after_check26, label %voiderr27 + +after_check26: ; preds = %phi_block22 + br label %voiderr27 + +voiderr27: ; preds = %after_check26, %phi_block22 + %16 = call i64 @test_get_a(ptr %retparam30, i32 1) + %not_err31 = icmp eq i64 %16, 0 + br i1 %not_err31, label %after_check32, label %else_block33 + +after_check32: ; preds = %voiderr27 + %17 = load i32, ptr %retparam30, align 4 + br label %phi_block37 + +else_block33: ; preds = %voiderr27 + %18 = call i64 @test_get_b(ptr %retparam34, i32 5) + %not_err35 = icmp eq i64 %18, 0 + br i1 %not_err35, label %after_check36, label %else_block39 + +after_check36: ; preds = %else_block33 + %19 = load i32, ptr %retparam34, align 4 + br label %phi_block37 + +phi_block37: ; preds = %after_check36, %after_check32 + %val38 = phi i32 [ %17, %after_check32 ], [ %19, %after_check36 ] + br label %phi_block40 + +else_block39: ; preds = %else_block33 + br label %phi_block40 + +phi_block40: ; preds = %else_block39, %phi_block37 + %val41 = phi i32 [ %val38, %phi_block37 ], [ -1, %else_block39 ] + store i32 %val41, ptr %taddr42, align 4 + %20 = insertvalue %variant undef, ptr %taddr42, 0 %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %22 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0 + %22 = getelementptr inbounds [1 x %variant], ptr %varargslots29, i64 0, i64 0 store %variant %21, ptr %22, align 16 - %23 = getelementptr inbounds %"variant[]", ptr %vararg17, i32 0, i32 1 - store i64 1, ptr %23, align 8 - %24 = getelementptr inbounds %"variant[]", ptr %vararg17, i32 0, i32 0 - store ptr %varargslots18, ptr %24, align 8 - %25 = getelementptr inbounds { ptr, i64 }, ptr %vararg17, i32 0, i32 0 - %lo32 = load ptr, ptr %25, align 8 - %26 = getelementptr inbounds { ptr, i64 }, ptr %vararg17, i32 0, i32 1 - %hi33 = load i64, ptr %26, align 8 - %27 = call i64 @std_io_printfln(ptr %retparam13, ptr %lo15, i64 %hi16, ptr %lo32, i64 %hi33) - %not_err34 = icmp eq i64 %27, 0 - br i1 %not_err34, label %after_check35, label %voiderr36 + %23 = call i64 @std_io_printfln(ptr %retparam28, ptr @.str.3, i64 4, ptr %varargslots29, i64 1) + %not_err43 = icmp eq i64 %23, 0 + br i1 %not_err43, label %after_check44, label %voiderr45 -after_check35: ; preds = %phi_block29 - br label %voiderr36 +after_check44: ; preds = %phi_block40 + br label %voiderr45 -voiderr36: ; preds = %after_check35, %phi_block29 - store %"char[]" { ptr @.str.3, i64 4 }, ptr %taddr38, align 8 - %28 = getelementptr inbounds { ptr, i64 }, ptr %taddr38, i32 0, i32 0 - %lo39 = load ptr, ptr %28, align 8 - %29 = getelementptr inbounds { ptr, i64 }, ptr %taddr38, i32 0, i32 1 - %hi40 = load i64, ptr %29, align 8 - %30 = call i64 @test_get_a(ptr %retparam43, i32 1) - %not_err44 = icmp eq i64 %30, 0 - br i1 %not_err44, label %after_check45, label %else_block46 +voiderr45: ; preds = %after_check44, %phi_block40 + store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr48, align 8 + %24 = insertvalue %variant undef, ptr %taddr48, 0 + %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %26 = getelementptr inbounds [1 x %variant], ptr %varargslots47, i64 0, i64 0 + store %variant %25, ptr %26, align 16 + %27 = call i64 @std_io_printfln(ptr %retparam46, ptr @.str.4, i64 4, ptr %varargslots47, i64 1) + %not_err49 = icmp eq i64 %27, 0 + br i1 %not_err49, label %after_check50, label %voiderr51 -after_check45: ; preds = %voiderr36 - %31 = load i32, ptr %retparam43, align 4 - br label %phi_block50 +after_check50: ; preds = %voiderr45 + br label %voiderr51 -else_block46: ; preds = %voiderr36 - %32 = call i64 @test_get_b(ptr %retparam47, i32 5) - %not_err48 = icmp eq i64 %32, 0 - br i1 %not_err48, label %after_check49, label %else_block52 +voiderr51: ; preds = %after_check50, %voiderr45 + store i32 3, ptr %taddr54, align 4 + %28 = insertvalue %variant undef, ptr %taddr54, 0 + %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %30 = getelementptr inbounds [1 x %variant], ptr %varargslots53, i64 0, i64 0 + store %variant %29, ptr %30, align 16 + %31 = call i64 @std_io_printfln(ptr %retparam52, ptr @.str.5, i64 4, ptr %varargslots53, i64 1) + %not_err55 = icmp eq i64 %31, 0 + br i1 %not_err55, label %after_check56, label %voiderr57 -after_check49: ; preds = %else_block46 - %33 = load i32, ptr %retparam47, align 4 - br label %phi_block50 +after_check56: ; preds = %voiderr51 + br label %voiderr57 -phi_block50: ; preds = %after_check49, %after_check45 - %val51 = phi i32 [ %31, %after_check45 ], [ %33, %after_check49 ] - br label %phi_block53 +voiderr57: ; preds = %after_check56, %voiderr51 + store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr60, align 8 + %32 = insertvalue %variant undef, ptr %taddr60, 0 + %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %34 = getelementptr inbounds [1 x %variant], ptr %varargslots59, i64 0, i64 0 + store %variant %33, ptr %34, align 16 + %35 = call i64 @std_io_printfln(ptr %retparam58, ptr @.str.6, i64 4, ptr %varargslots59, i64 1) + %not_err61 = icmp eq i64 %35, 0 + br i1 %not_err61, label %after_check62, label %voiderr63 -else_block52: ; preds = %else_block46 - br label %phi_block53 +after_check62: ; preds = %voiderr57 + br label %voiderr63 -phi_block53: ; preds = %else_block52, %phi_block50 - %val54 = phi i32 [ %val51, %phi_block50 ], [ -1, %else_block52 ] - store i32 %val54, ptr %taddr55, align 4 - %34 = insertvalue %variant undef, ptr %taddr55, 0 - %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %36 = getelementptr inbounds [1 x %variant], ptr %varargslots42, i64 0, i64 0 - store %variant %35, ptr %36, align 16 - %37 = getelementptr inbounds %"variant[]", ptr %vararg41, i32 0, i32 1 - store i64 1, ptr %37, align 8 - %38 = getelementptr inbounds %"variant[]", ptr %vararg41, i32 0, i32 0 - store ptr %varargslots42, ptr %38, align 8 - %39 = getelementptr inbounds { ptr, i64 }, ptr %vararg41, i32 0, i32 0 - %lo56 = load ptr, ptr %39, align 8 - %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg41, i32 0, i32 1 - %hi57 = load i64, ptr %40, align 8 - %41 = call i64 @std_io_printfln(ptr %retparam37, ptr %lo39, i64 %hi40, ptr %lo56, i64 %hi57) - %not_err58 = icmp eq i64 %41, 0 - br i1 %not_err58, label %after_check59, label %voiderr60 - -after_check59: ; preds = %phi_block53 - br label %voiderr60 - -voiderr60: ; preds = %after_check59, %phi_block53 - store %"char[]" { ptr @.str.4, i64 4 }, ptr %taddr62, align 8 - %42 = getelementptr inbounds { ptr, i64 }, ptr %taddr62, i32 0, i32 0 - %lo63 = load ptr, ptr %42, align 8 - %43 = getelementptr inbounds { ptr, i64 }, ptr %taddr62, i32 0, i32 1 - %hi64 = load i64, ptr %43, align 8 - store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr67, align 8 - %44 = insertvalue %variant undef, ptr %taddr67, 0 - %45 = insertvalue %variant %44, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %46 = getelementptr inbounds [1 x %variant], ptr %varargslots66, i64 0, i64 0 - store %variant %45, ptr %46, align 16 - %47 = getelementptr inbounds %"variant[]", ptr %vararg65, i32 0, i32 1 - store i64 1, ptr %47, align 8 - %48 = getelementptr inbounds %"variant[]", ptr %vararg65, i32 0, i32 0 - store ptr %varargslots66, ptr %48, align 8 - %49 = getelementptr inbounds { ptr, i64 }, ptr %vararg65, i32 0, i32 0 - %lo68 = load ptr, ptr %49, align 8 - %50 = getelementptr inbounds { ptr, i64 }, ptr %vararg65, i32 0, i32 1 - %hi69 = load i64, ptr %50, align 8 - %51 = call i64 @std_io_printfln(ptr %retparam61, ptr %lo63, i64 %hi64, ptr %lo68, i64 %hi69) - %not_err70 = icmp eq i64 %51, 0 - br i1 %not_err70, label %after_check71, label %voiderr72 - -after_check71: ; preds = %voiderr60 - br label %voiderr72 - -voiderr72: ; preds = %after_check71, %voiderr60 - store %"char[]" { ptr @.str.5, i64 4 }, ptr %taddr74, align 8 - %52 = getelementptr inbounds { ptr, i64 }, ptr %taddr74, i32 0, i32 0 - %lo75 = load ptr, ptr %52, align 8 - %53 = getelementptr inbounds { ptr, i64 }, ptr %taddr74, i32 0, i32 1 - %hi76 = load i64, ptr %53, align 8 - store i32 3, ptr %taddr79, align 4 - %54 = insertvalue %variant undef, ptr %taddr79, 0 - %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %56 = getelementptr inbounds [1 x %variant], ptr %varargslots78, i64 0, i64 0 - store %variant %55, ptr %56, align 16 - %57 = getelementptr inbounds %"variant[]", ptr %vararg77, i32 0, i32 1 - store i64 1, ptr %57, align 8 - %58 = getelementptr inbounds %"variant[]", ptr %vararg77, i32 0, i32 0 - store ptr %varargslots78, ptr %58, align 8 - %59 = getelementptr inbounds { ptr, i64 }, ptr %vararg77, i32 0, i32 0 - %lo80 = load ptr, ptr %59, align 8 - %60 = getelementptr inbounds { ptr, i64 }, ptr %vararg77, i32 0, i32 1 - %hi81 = load i64, ptr %60, align 8 - %61 = call i64 @std_io_printfln(ptr %retparam73, ptr %lo75, i64 %hi76, ptr %lo80, i64 %hi81) - %not_err82 = icmp eq i64 %61, 0 - br i1 %not_err82, label %after_check83, label %voiderr84 - -after_check83: ; preds = %voiderr72 - br label %voiderr84 - -voiderr84: ; preds = %after_check83, %voiderr72 - store %"char[]" { ptr @.str.6, i64 4 }, ptr %taddr86, align 8 - %62 = getelementptr inbounds { ptr, i64 }, ptr %taddr86, i32 0, i32 0 - %lo87 = load ptr, ptr %62, align 8 - %63 = getelementptr inbounds { ptr, i64 }, ptr %taddr86, i32 0, i32 1 - %hi88 = load i64, ptr %63, align 8 - store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr91, align 8 - %64 = insertvalue %variant undef, ptr %taddr91, 0 - %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %66 = getelementptr inbounds [1 x %variant], ptr %varargslots90, i64 0, i64 0 - store %variant %65, ptr %66, align 16 - %67 = getelementptr inbounds %"variant[]", ptr %vararg89, i32 0, i32 1 - store i64 1, ptr %67, align 8 - %68 = getelementptr inbounds %"variant[]", ptr %vararg89, i32 0, i32 0 - store ptr %varargslots90, ptr %68, align 8 - %69 = getelementptr inbounds { ptr, i64 }, ptr %vararg89, i32 0, i32 0 - %lo92 = load ptr, ptr %69, align 8 - %70 = getelementptr inbounds { ptr, i64 }, ptr %vararg89, i32 0, i32 1 - %hi93 = load i64, ptr %70, align 8 - %71 = call i64 @std_io_printfln(ptr %retparam85, ptr %lo87, i64 %hi88, ptr %lo92, i64 %hi93) - %not_err94 = icmp eq i64 %71, 0 - br i1 %not_err94, label %after_check95, label %voiderr96 - -after_check95: ; preds = %voiderr84 - br label %voiderr96 - -voiderr96: ; preds = %after_check95, %voiderr84 - store %"char[]" { ptr @.str.7, i64 4 }, ptr %taddr98, align 8 - %72 = getelementptr inbounds { ptr, i64 }, ptr %taddr98, i32 0, i32 0 - %lo99 = load ptr, ptr %72, align 8 - %73 = getelementptr inbounds { ptr, i64 }, ptr %taddr98, i32 0, i32 1 - %hi100 = load i64, ptr %73, align 8 +voiderr63: ; preds = %after_check62, %voiderr57 store i64 0, ptr %error_var, align 8 - br label %phi_block104 + br label %phi_block67 -phi_block104: ; preds = %voiderr96 +phi_block67: ; preds = %voiderr63 br label %noerr_block -noerr_block: ; preds = %phi_block104 - %74 = insertvalue %variant undef, ptr %error_var, 0 - %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %76 = getelementptr inbounds [1 x %variant], ptr %varargslots102, i64 0, i64 0 - store %variant %75, ptr %76, align 16 - %77 = getelementptr inbounds %"variant[]", ptr %vararg101, i32 0, i32 1 - store i64 1, ptr %77, align 8 - %78 = getelementptr inbounds %"variant[]", ptr %vararg101, i32 0, i32 0 - store ptr %varargslots102, ptr %78, align 8 - %79 = getelementptr inbounds { ptr, i64 }, ptr %vararg101, i32 0, i32 0 - %lo105 = load ptr, ptr %79, align 8 - %80 = getelementptr inbounds { ptr, i64 }, ptr %vararg101, i32 0, i32 1 - %hi106 = load i64, ptr %80, align 8 - %81 = call i64 @std_io_printfln(ptr %retparam97, ptr %lo99, i64 %hi100, ptr %lo105, i64 %hi106) - %not_err107 = icmp eq i64 %81, 0 - br i1 %not_err107, label %after_check108, label %voiderr109 +noerr_block: ; preds = %phi_block67 + %36 = insertvalue %variant undef, ptr %error_var, 0 + %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %38 = getelementptr inbounds [1 x %variant], ptr %varargslots65, i64 0, i64 0 + store %variant %37, ptr %38, align 16 + %39 = call i64 @std_io_printfln(ptr %retparam64, ptr @.str.7, i64 4, ptr %varargslots65, i64 1) + %not_err68 = icmp eq i64 %39, 0 + br i1 %not_err68, label %after_check69, label %voiderr70 -after_check108: ; preds = %noerr_block - br label %voiderr109 +after_check69: ; preds = %noerr_block + br label %voiderr70 -voiderr109: ; preds = %after_check108, %noerr_block +voiderr70: ; preds = %after_check69, %noerr_block store i64 3, ptr %x, align 8 - store %"char[]" { ptr @.str.8, i64 4 }, ptr %taddr111, align 8 - %82 = getelementptr inbounds { ptr, i64 }, ptr %taddr111, i32 0, i32 0 - %lo112 = load ptr, ptr %82, align 8 - %83 = getelementptr inbounds { ptr, i64 }, ptr %taddr111, i32 0, i32 1 - %hi113 = load i64, ptr %83, align 8 - %84 = insertvalue %variant undef, ptr %x, 0 - %85 = insertvalue %variant %84, i64 ptrtoint (ptr @"ct$long" to i64), 1 - %86 = getelementptr inbounds [1 x %variant], ptr %varargslots115, i64 0, i64 0 - store %variant %85, ptr %86, align 16 - %87 = getelementptr inbounds %"variant[]", ptr %vararg114, i32 0, i32 1 - store i64 1, ptr %87, align 8 - %88 = getelementptr inbounds %"variant[]", ptr %vararg114, i32 0, i32 0 - store ptr %varargslots115, ptr %88, align 8 - %89 = getelementptr inbounds { ptr, i64 }, ptr %vararg114, i32 0, i32 0 - %lo116 = load ptr, ptr %89, align 8 - %90 = getelementptr inbounds { ptr, i64 }, ptr %vararg114, i32 0, i32 1 - %hi117 = load i64, ptr %90, align 8 - %91 = call i64 @std_io_printfln(ptr %retparam110, ptr %lo112, i64 %hi113, ptr %lo116, i64 %hi117) - %not_err118 = icmp eq i64 %91, 0 - br i1 %not_err118, label %after_check119, label %voiderr120 + %40 = insertvalue %variant undef, ptr %x, 0 + %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$long" to i64), 1 + %42 = getelementptr inbounds [1 x %variant], ptr %varargslots72, i64 0, i64 0 + store %variant %41, ptr %42, align 16 + %43 = call i64 @std_io_printfln(ptr %retparam71, ptr @.str.8, i64 4, ptr %varargslots72, i64 1) + %not_err73 = icmp eq i64 %43, 0 + br i1 %not_err73, label %after_check74, label %voiderr75 -after_check119: ; preds = %voiderr109 - br label %voiderr120 +after_check74: ; preds = %voiderr70 + br label %voiderr75 -voiderr120: ; preds = %after_check119, %voiderr109 +voiderr75: ; preds = %after_check74, %voiderr70 store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %xy.f, align 8 ret void } diff --git a/test/test_suite2/errors/or_and_rethrow.c3t b/test/test_suite2/errors/or_and_rethrow.c3t index 4c63392da..1b58a141c 100644 --- a/test/test_suite2/errors/or_and_rethrow.c3t +++ b/test/test_suite2/errors/or_and_rethrow.c3t @@ -42,35 +42,20 @@ fn void main() define i64 @foo_test(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 + %taddr = alloca i32, align 4 %error_var = alloca i64, align 8 %blockret = alloca i32, align 4 - %error_var4 = alloca i64, align 8 - %blockret5 = alloca i32, align 4 + %error_var1 = alloca i64, align 8 + %blockret2 = alloca i32, align 4 %reterr = alloca i64, align 8 - store %"char[]" { ptr @.str.1, i64 8 }, ptr %taddr, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %1, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %2, align 8 - store i32 %0, ptr %taddr1, align 4 - %3 = insertvalue %variant undef, ptr %taddr1, 0 - %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %4, ptr %5, align 16 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %6, align 8 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %9, align 8 - %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %10, 0 + store i32 %0, ptr %taddr, align 4 + %1 = insertvalue %variant undef, ptr %taddr, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %2, ptr %3, align 16 + %4 = call i64 @std_io_printfln(ptr %retparam, ptr @.str.1, i64 8, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %4, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -89,66 +74,52 @@ opt_block_cleanup: ; preds = %or.rhs br label %guard_block guard_block: ; preds = %opt_block_cleanup - %11 = load i64, ptr %error_var, align 8 - ret i64 %11 + %5 = load i64, ptr %error_var, align 8 + ret i64 %5 or.phi: ; preds = %voiderr br label %if.then if.then: ; preds = %or.phi - %12 = call i32 @std_io_println(ptr @.str.2) #1 + %6 = call i32 @std_io_println(ptr @.str.2) #1 br label %if.exit if.exit: ; preds = %if.then - %13 = call i32 @std_io_println(ptr @.str.3) #1 - store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var4, align 8 - br label %opt_block_cleanup6 + %7 = call i32 @std_io_println(ptr @.str.3) #1 + store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var1, align 8 + br label %opt_block_cleanup3 -opt_block_cleanup6: ; preds = %if.exit +opt_block_cleanup3: ; preds = %if.exit call void @foo_blurb() - br label %guard_block7 + br label %guard_block4 -guard_block7: ; preds = %opt_block_cleanup6 - %14 = load i64, ptr %error_var4, align 8 - ret i64 %14 +guard_block4: ; preds = %opt_block_cleanup3 + %8 = load i64, ptr %error_var1, align 8 + ret i64 %8 -if.exit9: ; No predecessors! - %15 = call i32 @std_io_println(ptr @.str.5) #1 +if.exit6: ; No predecessors! + %9 = call i32 @std_io_println(ptr @.str.5) #1 ret i64 0 } +; Function Attrs: nounwind define i64 @foo_test2(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 + %taddr = alloca i32, align 4 %error_var = alloca i64, align 8 %blockret = alloca i32, align 4 - %error_var4 = alloca i64, align 8 - %blockret5 = alloca i32, align 4 + %error_var1 = alloca i64, align 8 + %blockret2 = alloca i32, align 4 %reterr = alloca i64, align 8 - store %"char[]" { ptr @.str.6, i64 9 }, ptr %taddr, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %1, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %2, align 8 - store i32 %0, ptr %taddr1, align 4 - %3 = insertvalue %variant undef, ptr %taddr1, 0 - %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %4, ptr %5, align 16 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %6, align 8 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %9, align 8 - %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %10, 0 + store i32 %0, ptr %taddr, align 4 + %1 = insertvalue %variant undef, ptr %taddr, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %2, ptr %3, align 16 + %4 = call i64 @std_io_printfln(ptr %retparam, ptr @.str.6, i64 9, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %4, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -167,26 +138,26 @@ opt_block_cleanup: ; preds = %and.rhs br label %guard_block guard_block: ; preds = %opt_block_cleanup - %11 = load i64, ptr %error_var, align 8 - ret i64 %11 + %5 = load i64, ptr %error_var, align 8 + ret i64 %5 and.phi: ; preds = %voiderr br label %if.exit if.exit: ; preds = %and.phi - %12 = call i32 @std_io_println(ptr @.str.7) #1 - store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var4, align 8 - br label %opt_block_cleanup6 + %6 = call i32 @std_io_println(ptr @.str.7) #1 + store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var1, align 8 + br label %opt_block_cleanup3 -opt_block_cleanup6: ; preds = %if.exit +opt_block_cleanup3: ; preds = %if.exit call void @foo_blurb() - br label %guard_block7 + br label %guard_block4 -guard_block7: ; preds = %opt_block_cleanup6 - %13 = load i64, ptr %error_var4, align 8 - ret i64 %13 +guard_block4: ; preds = %opt_block_cleanup3 + %7 = load i64, ptr %error_var1, align 8 + ret i64 %7 -if.exit8: ; No predecessors! - %14 = call i32 @std_io_println(ptr @.str.8) #1 +if.exit5: ; No predecessors! + %8 = call i32 @std_io_println(ptr @.str.8) #1 ret i64 0 } diff --git a/test/test_suite2/errors/printing_errors.c3t b/test/test_suite2/errors/printing_errors.c3t index da6f92d77..35623daea 100644 --- a/test/test_suite2/errors/printing_errors.c3t +++ b/test/test_suite2/errors/printing_errors.c3t @@ -19,24 +19,17 @@ define void @test_main() #0 { entry: %x = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 - %taddr1 = alloca ptr, align 8 + %taddr = alloca ptr, 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, i64 6 }, ptr %taddr, align 8 - %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - store ptr @.str.2, ptr %taddr1, align 8 - %2 = insertvalue %variant undef, ptr %taddr1, 0 - %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 - %4 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %3, ptr %4, align 16 - %5 = load i64, ptr %x, align 8 - %eq = icmp eq i64 %5, 0 + store ptr @.str.2, ptr %taddr, align 8 + %0 = insertvalue %variant undef, ptr %taddr, 0 + %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 + %2 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %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 @@ -44,26 +37,18 @@ faultname_no: ; preds = %entry br label %faultname_exit faultname_ok: ; preds = %entry - %6 = inttoptr i64 %5 to ptr - %7 = getelementptr inbounds %.fault, ptr %6, i32 0, i32 1 + %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 ], [ %7, %faultname_ok ] - %8 = insertvalue %variant undef, ptr %faultname, 0 - %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$sa$char" to i64), 1 - %10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %9, ptr %10, align 16 - %11 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 2, ptr %11, align 8 - %12 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %12, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %13, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %14, align 8 - %15 = call i64 @std_io_printf(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %15, 0 + %faultname = phi ptr [ %faultname_zero, %faultname_no ], [ %5, %faultname_ok ] + %6 = insertvalue %variant undef, ptr %faultname, 0 + %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$sa$char" to i64), 1 + %8 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %7, ptr %8, align 16 + %9 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 6, ptr %varargslots, i64 2) + %not_err = icmp eq i64 %9, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %faultname_exit diff --git a/test/test_suite2/expressions/type_support.c3t b/test/test_suite2/expressions/type_support.c3t index 29ae694f5..a5ec1158b 100644 --- a/test/test_suite2/expressions/type_support.c3t +++ b/test/test_suite2/expressions/type_support.c3t @@ -25,52 +25,52 @@ fn void main() /* #expect: test.ll - store i64 0 - store i64 1 - store i8 0 - store i8 -1 - store i16 0 - store i16 -1 - store i64 4 - store i64 2 - store i32 0 - store i32 -1 - store i64 8 - store i64 0 - store i64 -1 - store i64 8 - store i64 0 - store i64 -1 - store i64 8 - store i64 0 - store i64 -1 - store i64 8 - store i64 0 - store i64 -1 - store i64 1 - store i8 -128 - store i8 127 - store i64 2 - store i16 -32768 - store i16 32767 - store i64 4 - store i32 -2147483648 - store i32 2147483647 - store i64 8 - store i64 -9223372036854775808 - store i64 9223372036854775807 - store i64 8 - store i64 -9223372036854775808 - store i64 9223372036854775807 - store i64 8 - store i64 -9223372036854775808 - store i64 9223372036854775807 - store i64 8 - store i64 -9223372036854775808 - store i64 9223372036854775807 - store i64 4 - store float 0xC7EFFFFFE0000000 - store float 0x47EFFFFFE0000000 - store i64 8 - store double 0xFFEFFFFFFFFFFFFF - store double 0x7FEFFFFFFFFFFFFF \ No newline at end of file + i64 0 + i64 1 + i8 0 + i8 -1 + i16 0 + i16 -1 + i64 4 + i64 2 + i32 0 + i32 -1 + i64 8 + i64 0 + i64 -1 + i64 8 + i64 0 + i64 -1 + i64 8 + i64 0 + i64 -1 + i64 8 + i64 0 + i64 -1 + i64 1 + i8 -128 + i8 127 + i64 2 + i16 -32768 + i16 32767 + i64 4 + i32 -2147483648 + i32 2147483647 + i64 8 + i64 -9223372036854775808 + i64 9223372036854775807 + i64 8 + i64 -9223372036854775808 + i64 9223372036854775807 + i64 8 + i64 -9223372036854775808 + i64 9223372036854775807 + i64 8 + i64 -9223372036854775808 + i64 9223372036854775807 + i64 4 + float 0xC7EFFFFFE0000000 + float 0x47EFFFFFE0000000 + i64 8 + double 0xFFEFFFFFFFFFFFFF + double 0x7FEFFFFFFFFFFFFF \ No newline at end of file diff --git a/test/test_suite2/from_docs/examples_forswitch.c3t b/test/test_suite2/from_docs/examples_forswitch.c3t index b9feafa0c..437e4c4a5 100644 --- a/test/test_suite2/from_docs/examples_forswitch.c3t +++ b/test/test_suite2/from_docs/examples_forswitch.c3t @@ -109,7 +109,8 @@ loop.body: ; preds = %loop.cond br label %loop.cond loop.exit: ; preds = %loop.cond - call void @std_core_builtin_panic(ptr @.zstr, ptr @.zstr.1, ptr @.zstr.2, i32 14) + %4 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %4(ptr @.panic_msg, i64 19, ptr @.file, i64 21, ptr @.func, i64 11, i32 14) unreachable unreachable_block: ; No predecessors! @@ -138,11 +139,11 @@ switch.entry: ; preds = %entry ] switch.case: ; preds = %switch.entry, %switch.entry - %2 = call i32 @std_io_println(ptr @.str.3) #1 + %2 = call i32 @std_io_println(ptr @.str.1) #1 br label %switch.exit switch.case1: ; preds = %switch.entry - %3 = call i32 @std_io_println(ptr @.str.4) #1 + %3 = call i32 @std_io_println(ptr @.str.2) #1 br label %switch.exit switch.exit: ; preds = %switch.case1, %switch.case, %switch.entry @@ -158,11 +159,11 @@ switch.entry3: ; preds = %switch.exit ] switch.case4: ; preds = %switch.entry3, %switch.entry3 - %5 = call i32 @std_io_println(ptr @.str.5) #1 + %5 = call i32 @std_io_println(ptr @.str.3) #1 br label %switch.exit6 switch.case5: ; preds = %switch.entry3 - %6 = call i32 @std_io_println(ptr @.str.6) #1 + %6 = call i32 @std_io_println(ptr @.str.4) #1 br label %switch.exit6 switch.exit6: ; preds = %switch.case5, %switch.case4, %switch.entry3 @@ -181,7 +182,7 @@ switch.case9: ; preds = %switch.entry8 br label %switch.exit12 switch.case10: ; preds = %switch.entry8 - %8 = call i32 @std_io_println(ptr @.str.7) #1 + %8 = call i32 @std_io_println(ptr @.str.5) #1 br label %switch.exit12 switch.case11: ; preds = %switch.entry8 @@ -219,16 +220,16 @@ switch.entry18: ; preds = %switch.exit16 switch.case19: ; preds = %switch.entry18 store i32 1, ptr %a, align 4 - %11 = call i32 @std_io_println(ptr @.str.8) #1 + %11 = call i32 @std_io_println(ptr @.str.6) #1 br label %switch.case20 switch.case20: ; preds = %switch.entry18, %switch.case19 store i32 2, ptr %a21, align 4 - %12 = call i32 @std_io_println(ptr @.str.9) #1 + %12 = call i32 @std_io_println(ptr @.str.7) #1 br label %switch.case22 switch.case22: ; preds = %switch.entry18, %switch.case20 - %13 = call i32 @std_io_println(ptr @.str.10) #1 + %13 = call i32 @std_io_println(ptr @.str.8) #1 br label %switch.exit23 switch.exit23: ; preds = %switch.case22, %switch.entry18 diff --git a/test/test_suite2/functions/func_ptr_conversions_and_names.c3t b/test/test_suite2/functions/func_ptr_conversions_and_names.c3t index 28fd2ce77..6d459694a 100644 --- a/test/test_suite2/functions/func_ptr_conversions_and_names.c3t +++ b/test/test_suite2/functions/func_ptr_conversions_and_names.c3t @@ -60,264 +60,144 @@ entry: %a = alloca ptr, align 8 %b = alloca ptr, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 - %taddr10 = alloca i32, align 4 + %taddr = alloca i32, align 4 + %retparam1 = alloca i64, align 8 + %varargslots2 = alloca [1 x %variant], align 16 + %taddr3 = alloca i32, align 4 %z = alloca ptr, align 8 - %retparam16 = alloca i64, align 8 - %taddr17 = alloca %"char[]", align 8 - %vararg20 = alloca %"variant[]", align 8 - %varargslots21 = alloca [1 x %variant], align 16 - %taddr22 = alloca i32, align 4 - %retparam28 = alloca i64, align 8 - %taddr29 = alloca %"char[]", align 8 - %vararg32 = alloca %"variant[]", align 8 - %varargslots33 = alloca [1 x %variant], align 16 - %taddr34 = alloca ptr, align 8 - %retparam40 = alloca i64, align 8 - %taddr41 = alloca %"char[]", align 8 - %vararg44 = alloca %"variant[]", align 8 - %varargslots45 = alloca [1 x %variant], align 16 - %taddr46 = alloca ptr, align 8 - %retparam52 = alloca i64, align 8 - %taddr53 = alloca %"char[]", align 8 - %vararg56 = alloca %"variant[]", align 8 - %varargslots57 = alloca [1 x %variant], align 16 - %taddr58 = alloca ptr, align 8 - %retparam64 = alloca i64, align 8 - %taddr65 = alloca %"char[]", align 8 - %vararg68 = alloca %"variant[]", align 8 - %varargslots69 = alloca [1 x %variant], align 16 - %taddr70 = alloca ptr, align 8 - %retparam76 = alloca i64, align 8 - %taddr77 = alloca %"char[]", align 8 - %vararg80 = alloca %"variant[]", align 8 - %varargslots81 = alloca [1 x %variant], align 16 - %taddr82 = alloca ptr, align 8 + %retparam7 = alloca i64, align 8 + %varargslots8 = alloca [1 x %variant], align 16 + %taddr9 = alloca i32, align 4 + %retparam13 = alloca i64, align 8 + %varargslots14 = alloca [1 x %variant], align 16 + %taddr15 = alloca ptr, align 8 + %retparam19 = alloca i64, align 8 + %varargslots20 = alloca [1 x %variant], align 16 + %taddr21 = alloca ptr, align 8 + %retparam25 = alloca i64, align 8 + %varargslots26 = alloca [1 x %variant], align 16 + %taddr27 = alloca ptr, align 8 + %retparam31 = alloca i64, align 8 + %varargslots32 = alloca [1 x %variant], align 16 + %taddr33 = alloca ptr, align 8 + %retparam37 = alloca i64, align 8 + %varargslots38 = alloca [1 x %variant], align 16 + %taddr39 = alloca ptr, align 8 %y = alloca ptr, align 8 %zfoke = alloca i64, align 8 store ptr @test_test, ptr %a, align 8 store ptr @test_test2, ptr %b, align 8 - store %"char[]" { ptr @.str, i64 2 }, ptr %taddr, align 8 - %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - %2 = load ptr, ptr %a, align 8 - %3 = call i32 %2(i32 123) - store i32 %3, ptr %taddr1, align 4 - %4 = insertvalue %variant undef, ptr %taddr1, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %5, ptr %6, align 16 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %7, align 8 - %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %9, align 8 - %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %10, align 8 - %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %11, 0 + %0 = load ptr, ptr %a, align 8 + %1 = call i32 %0(i32 123) + store i32 %1, ptr %taddr, align 4 + %2 = insertvalue %variant undef, ptr %taddr, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %3, ptr %4, align 16 + %5 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %5, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { ptr @.str.1, i64 2 }, ptr %taddr5, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 0 - %lo6 = load ptr, ptr %12, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 1 - %hi7 = load i64, ptr %13, align 8 - %14 = call i32 @test_test2(i32 3) - store i32 %14, ptr %taddr10, align 4 - %15 = insertvalue %variant undef, ptr %taddr10, 0 - %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %17 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0 - store %variant %16, ptr %17, align 16 - %18 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 1 - store i64 1, ptr %18, align 8 - %19 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 0 - store ptr %varargslots9, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 0 - %lo11 = load ptr, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 1 - %hi12 = load i64, ptr %21, align 8 - %22 = call i64 @std_io_printfln(ptr %retparam4, ptr %lo6, i64 %hi7, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %22, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %6 = call i32 @test_test2(i32 3) + store i32 %6, ptr %taddr3, align 4 + %7 = insertvalue %variant undef, ptr %taddr3, 0 + %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %9 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0 + store %variant %8, ptr %9, align 16 + %10 = call i64 @std_io_printfln(ptr %retparam1, ptr @.str.1, i64 2, ptr %varargslots2, i64 1) + %not_err4 = icmp eq i64 %10, 0 + br i1 %not_err4, label %after_check5, label %voiderr6 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check5: ; preds = %voiderr + br label %voiderr6 -voiderr15: ; preds = %after_check14, %voiderr +voiderr6: ; preds = %after_check5, %voiderr store ptr @test_test2, ptr %z, align 8 - store %"char[]" { ptr @.str.2, i64 2 }, ptr %taddr17, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 0 - %lo18 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 1 - %hi19 = load i64, ptr %24, align 8 - %25 = load ptr, ptr %z, align 8 - %26 = call i32 %25(i32 444) - store i32 %26, ptr %taddr22, align 4 - %27 = insertvalue %variant undef, ptr %taddr22, 0 - %28 = insertvalue %variant %27, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %29 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0 - store %variant %28, ptr %29, align 16 - %30 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 1 - store i64 1, ptr %30, align 8 - %31 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 0 - store ptr %varargslots21, ptr %31, align 8 - %32 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 0 - %lo23 = load ptr, ptr %32, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 1 - %hi24 = load i64, ptr %33, align 8 - %34 = call i64 @std_io_printfln(ptr %retparam16, ptr %lo18, i64 %hi19, ptr %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %34, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 + %11 = load ptr, ptr %z, align 8 + %12 = call i32 %11(i32 444) + store i32 %12, ptr %taddr9, align 4 + %13 = insertvalue %variant undef, ptr %taddr9, 0 + %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %15 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0 + store %variant %14, ptr %15, align 16 + %16 = call i64 @std_io_printfln(ptr %retparam7, ptr @.str.2, i64 2, ptr %varargslots8, i64 1) + %not_err10 = icmp eq i64 %16, 0 + br i1 %not_err10, label %after_check11, label %voiderr12 -after_check26: ; preds = %voiderr15 - br label %voiderr27 +after_check11: ; preds = %voiderr6 + br label %voiderr12 -voiderr27: ; preds = %after_check26, %voiderr15 - store %"char[]" { ptr @.str.3, i64 2 }, ptr %taddr29, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr29, i32 0, i32 0 - %lo30 = load ptr, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %taddr29, i32 0, i32 1 - %hi31 = load i64, ptr %36, align 8 - store ptr @.str.4, ptr %taddr34, align 8 - %37 = insertvalue %variant undef, ptr %taddr34, 0 - %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1 - %39 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0 - store %variant %38, ptr %39, align 16 - %40 = getelementptr inbounds %"variant[]", ptr %vararg32, i32 0, i32 1 - store i64 1, ptr %40, align 8 - %41 = getelementptr inbounds %"variant[]", ptr %vararg32, i32 0, i32 0 - store ptr %varargslots33, ptr %41, align 8 - %42 = getelementptr inbounds { ptr, i64 }, ptr %vararg32, i32 0, i32 0 - %lo35 = load ptr, ptr %42, align 8 - %43 = getelementptr inbounds { ptr, i64 }, ptr %vararg32, i32 0, i32 1 - %hi36 = load i64, ptr %43, align 8 - %44 = call i64 @std_io_printfln(ptr %retparam28, ptr %lo30, i64 %hi31, ptr %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %44, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 +voiderr12: ; preds = %after_check11, %voiderr6 + store ptr @.str.4, ptr %taddr15, align 8 + %17 = insertvalue %variant undef, ptr %taddr15, 0 + %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1 + %19 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0 + store %variant %18, ptr %19, align 16 + %20 = call i64 @std_io_printfln(ptr %retparam13, ptr @.str.3, i64 2, ptr %varargslots14, i64 1) + %not_err16 = icmp eq i64 %20, 0 + br i1 %not_err16, label %after_check17, label %voiderr18 -after_check38: ; preds = %voiderr27 - br label %voiderr39 +after_check17: ; preds = %voiderr12 + br label %voiderr18 -voiderr39: ; preds = %after_check38, %voiderr27 - store %"char[]" { ptr @.str.5, i64 2 }, ptr %taddr41, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 0 - %lo42 = load ptr, ptr %45, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 1 - %hi43 = load i64, ptr %46, align 8 - store ptr @.str.6, ptr %taddr46, align 8 - %47 = insertvalue %variant undef, ptr %taddr46, 0 - %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1 - %49 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0 - store %variant %48, ptr %49, align 16 - %50 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 1 - store i64 1, ptr %50, align 8 - %51 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 0 - store ptr %varargslots45, ptr %51, align 8 - %52 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 0 - %lo47 = load ptr, ptr %52, align 8 - %53 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 1 - %hi48 = load i64, ptr %53, align 8 - %54 = call i64 @std_io_printfln(ptr %retparam40, ptr %lo42, i64 %hi43, ptr %lo47, i64 %hi48) - %not_err49 = icmp eq i64 %54, 0 - br i1 %not_err49, label %after_check50, label %voiderr51 +voiderr18: ; preds = %after_check17, %voiderr12 + store ptr @.str.6, ptr %taddr21, align 8 + %21 = insertvalue %variant undef, ptr %taddr21, 0 + %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1 + %23 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0 + store %variant %22, ptr %23, align 16 + %24 = call i64 @std_io_printfln(ptr %retparam19, ptr @.str.5, i64 2, ptr %varargslots20, i64 1) + %not_err22 = icmp eq i64 %24, 0 + br i1 %not_err22, label %after_check23, label %voiderr24 -after_check50: ; preds = %voiderr39 - br label %voiderr51 +after_check23: ; preds = %voiderr18 + br label %voiderr24 -voiderr51: ; preds = %after_check50, %voiderr39 - store %"char[]" { ptr @.str.7, i64 2 }, ptr %taddr53, align 8 - %55 = getelementptr inbounds { ptr, i64 }, ptr %taddr53, i32 0, i32 0 - %lo54 = load ptr, ptr %55, align 8 - %56 = getelementptr inbounds { ptr, i64 }, ptr %taddr53, i32 0, i32 1 - %hi55 = load i64, ptr %56, align 8 - store ptr @.str.8, ptr %taddr58, align 8 - %57 = insertvalue %variant undef, ptr %taddr58, 0 - %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1 - %59 = getelementptr inbounds [1 x %variant], ptr %varargslots57, i64 0, i64 0 - store %variant %58, ptr %59, align 16 - %60 = getelementptr inbounds %"variant[]", ptr %vararg56, i32 0, i32 1 - store i64 1, ptr %60, align 8 - %61 = getelementptr inbounds %"variant[]", ptr %vararg56, i32 0, i32 0 - store ptr %varargslots57, ptr %61, align 8 - %62 = getelementptr inbounds { ptr, i64 }, ptr %vararg56, i32 0, i32 0 - %lo59 = load ptr, ptr %62, align 8 - %63 = getelementptr inbounds { ptr, i64 }, ptr %vararg56, i32 0, i32 1 - %hi60 = load i64, ptr %63, align 8 - %64 = call i64 @std_io_printfln(ptr %retparam52, ptr %lo54, i64 %hi55, ptr %lo59, i64 %hi60) - %not_err61 = icmp eq i64 %64, 0 - br i1 %not_err61, label %after_check62, label %voiderr63 +voiderr24: ; preds = %after_check23, %voiderr18 + store ptr @.str.8, ptr %taddr27, align 8 + %25 = insertvalue %variant undef, ptr %taddr27, 0 + %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1 + %27 = getelementptr inbounds [1 x %variant], ptr %varargslots26, i64 0, i64 0 + store %variant %26, ptr %27, align 16 + %28 = call i64 @std_io_printfln(ptr %retparam25, ptr @.str.7, i64 2, ptr %varargslots26, i64 1) + %not_err28 = icmp eq i64 %28, 0 + br i1 %not_err28, label %after_check29, label %voiderr30 -after_check62: ; preds = %voiderr51 - br label %voiderr63 +after_check29: ; preds = %voiderr24 + br label %voiderr30 -voiderr63: ; preds = %after_check62, %voiderr51 - store %"char[]" { ptr @.str.9, i64 2 }, ptr %taddr65, align 8 - %65 = getelementptr inbounds { ptr, i64 }, ptr %taddr65, i32 0, i32 0 - %lo66 = load ptr, ptr %65, align 8 - %66 = getelementptr inbounds { ptr, i64 }, ptr %taddr65, i32 0, i32 1 - %hi67 = load i64, ptr %66, align 8 - store ptr @.str.10, ptr %taddr70, align 8 - %67 = insertvalue %variant undef, ptr %taddr70, 0 - %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1 - %69 = getelementptr inbounds [1 x %variant], ptr %varargslots69, i64 0, i64 0 - store %variant %68, ptr %69, align 16 - %70 = getelementptr inbounds %"variant[]", ptr %vararg68, i32 0, i32 1 - store i64 1, ptr %70, align 8 - %71 = getelementptr inbounds %"variant[]", ptr %vararg68, i32 0, i32 0 - store ptr %varargslots69, ptr %71, align 8 - %72 = getelementptr inbounds { ptr, i64 }, ptr %vararg68, i32 0, i32 0 - %lo71 = load ptr, ptr %72, align 8 - %73 = getelementptr inbounds { ptr, i64 }, ptr %vararg68, i32 0, i32 1 - %hi72 = load i64, ptr %73, align 8 - %74 = call i64 @std_io_printfln(ptr %retparam64, ptr %lo66, i64 %hi67, ptr %lo71, i64 %hi72) - %not_err73 = icmp eq i64 %74, 0 - br i1 %not_err73, label %after_check74, label %voiderr75 +voiderr30: ; preds = %after_check29, %voiderr24 + store ptr @.str.10, ptr %taddr33, align 8 + %29 = insertvalue %variant undef, ptr %taddr33, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1 + %31 = getelementptr inbounds [1 x %variant], ptr %varargslots32, i64 0, i64 0 + store %variant %30, ptr %31, align 16 + %32 = call i64 @std_io_printfln(ptr %retparam31, ptr @.str.9, i64 2, ptr %varargslots32, i64 1) + %not_err34 = icmp eq i64 %32, 0 + br i1 %not_err34, label %after_check35, label %voiderr36 -after_check74: ; preds = %voiderr63 - br label %voiderr75 +after_check35: ; preds = %voiderr30 + br label %voiderr36 -voiderr75: ; preds = %after_check74, %voiderr63 - store %"char[]" { ptr @.str.11, i64 2 }, ptr %taddr77, align 8 - %75 = getelementptr inbounds { ptr, i64 }, ptr %taddr77, i32 0, i32 0 - %lo78 = load ptr, ptr %75, align 8 - %76 = getelementptr inbounds { ptr, i64 }, ptr %taddr77, i32 0, i32 1 - %hi79 = load i64, ptr %76, align 8 - store ptr @.str.12, ptr %taddr82, align 8 - %77 = insertvalue %variant undef, ptr %taddr82, 0 - %78 = insertvalue %variant %77, i64 ptrtoint (ptr @"ct$p$a13$char" to i64), 1 - %79 = getelementptr inbounds [1 x %variant], ptr %varargslots81, i64 0, i64 0 - store %variant %78, ptr %79, align 16 - %80 = getelementptr inbounds %"variant[]", ptr %vararg80, i32 0, i32 1 - store i64 1, ptr %80, align 8 - %81 = getelementptr inbounds %"variant[]", ptr %vararg80, i32 0, i32 0 - store ptr %varargslots81, ptr %81, align 8 - %82 = getelementptr inbounds { ptr, i64 }, ptr %vararg80, i32 0, i32 0 - %lo83 = load ptr, ptr %82, align 8 - %83 = getelementptr inbounds { ptr, i64 }, ptr %vararg80, i32 0, i32 1 - %hi84 = load i64, ptr %83, align 8 - %84 = call i64 @std_io_printfln(ptr %retparam76, ptr %lo78, i64 %hi79, ptr %lo83, i64 %hi84) - %not_err85 = icmp eq i64 %84, 0 - br i1 %not_err85, label %after_check86, label %voiderr87 +voiderr36: ; preds = %after_check35, %voiderr30 + store ptr @.str.12, ptr %taddr39, align 8 + %33 = insertvalue %variant undef, ptr %taddr39, 0 + %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a13$char" to i64), 1 + %35 = getelementptr inbounds [1 x %variant], ptr %varargslots38, i64 0, i64 0 + store %variant %34, ptr %35, align 16 + %36 = call i64 @std_io_printfln(ptr %retparam37, ptr @.str.11, i64 2, ptr %varargslots38, i64 1) + %not_err40 = icmp eq i64 %36, 0 + br i1 %not_err40, label %after_check41, label %voiderr42 -after_check86: ; preds = %voiderr75 - br label %voiderr87 +after_check41: ; preds = %voiderr36 + br label %voiderr42 -voiderr87: ; preds = %after_check86, %voiderr75 +voiderr42: ; preds = %after_check41, %voiderr36 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_suite2/functions/splat.c3t b/test/test_suite2/functions/splat.c3t index 875f1e99b..de3dae794 100644 --- a/test/test_suite2/functions/splat.c3t +++ b/test/test_suite2/functions/splat.c3t @@ -16,53 +16,28 @@ fn void test() /* #expect: splat.ll - %vararg = alloca %"int[]", align 8 +declare i32 @sum_us(ptr, i64) #0 + %varargslots = alloca [3 x i32], align 4 %x = alloca [3 x i32], align 4 %z = alloca %"int[]", align 8 - %vararg1 = alloca %"int[]", align 8 - %vararg4 = alloca %"int[]", align 8 - %vararg7 = alloca %"int[]", align 8 %0 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 0 store i32 1, ptr %0, align 4 %1 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 1 store i32 2, ptr %1, align 4 %2 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 2 store i32 3, ptr %2, align 4 - %3 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 1 - store i64 3, ptr %3, align 8 - %4 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo = load ptr, ptr %5, align 8 - %6 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi = load i64, ptr %6, align 8 - %7 = call i32 @sum_us(ptr %lo, i64 %hi) + %3 = call i32 @sum_us(ptr %varargslots, i64 3) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 12, i1 false) - %8 = insertvalue %"int[]" undef, ptr %x, 0 - %9 = insertvalue %"int[]" %8, i64 3, 1 - store %"int[]" %9, ptr %z, align 8 - %10 = getelementptr inbounds %"int[]", ptr %vararg1, i32 0, i32 1 - %11 = getelementptr inbounds %"int[]", ptr %vararg1, i32 0, i32 0 - store i64 3, ptr %10, align 8 - store ptr %x, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %vararg1, i32 0, i32 0 - %lo2 = load ptr, ptr %12, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %vararg1, i32 0, i32 1 - %hi3 = load i64, ptr %13, align 8 - %14 = call i32 @sum_us(ptr %lo2, i64 %hi3) - %15 = getelementptr inbounds %"int[]", ptr %vararg4, i32 0, i32 1 - %16 = getelementptr inbounds %"int[]", ptr %vararg4, i32 0, i32 0 - %17 = getelementptr inbounds { ptr, i64 }, ptr %z, i32 0, i32 0 - %lo5 = load ptr, ptr %17, align 8 - %18 = getelementptr inbounds { ptr, i64 }, ptr %z, i32 0, i32 1 - %hi6 = load i64, ptr %18, align 8 - %19 = call i32 @sum_us(ptr %lo5, i64 %hi6) - %20 = getelementptr inbounds %"int[]", ptr %vararg7, i32 0, i32 1 - store i64 0, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg7, i32 0, i32 0 - %lo8 = load ptr, ptr %21, align 8 - %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg7, i32 0, i32 1 - %hi9 = load i64, ptr %22, align 8 - %23 = call i32 @sum_us(ptr %lo8, i64 %hi9) + %4 = insertvalue %"int[]" undef, ptr %x, 0 + %5 = insertvalue %"int[]" %4, i64 3, 1 + store %"int[]" %5, ptr %z, align 8 + %6 = call i32 @sum_us(ptr %x, i64 3) + %7 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 0 + %lo = load ptr, ptr %7, align 8 + %8 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 1 + %hi = load i64, ptr %8, align 8 + %9 = call i32 @sum_us(ptr %lo, i64 %hi) + %10 = call i32 @sum_us(ptr null, i64 0) ret void +} \ No newline at end of file diff --git a/test/test_suite2/functions/splat_aarch64.c3t b/test/test_suite2/functions/splat_aarch64.c3t index 7ea7e934b..902213b4b 100644 --- a/test/test_suite2/functions/splat_aarch64.c3t +++ b/test/test_suite2/functions/splat_aarch64.c3t @@ -22,42 +22,36 @@ declare i32 @sum_us([2 x i64]) #0 define void @splat_test() #0 { entry: - %vararg = alloca %"int[]", align 8 %varargslots = alloca [3 x i32], align 4 + %taddr = alloca %"int[]", align 8 %x = alloca [3 x i32], align 4 %z = alloca %"int[]", align 8 - %vararg1 = alloca %"int[]", align 8 - %vararg2 = alloca %"int[]", align 8 - %vararg3 = alloca %"int[]", align 8 + %taddr1 = alloca %"int[]", align 8 + %taddr2 = alloca %"int[]", align 8 %0 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 0 store i32 1, ptr %0, align 4 %1 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 1 store i32 2, ptr %1, align 4 %2 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 2 store i32 3, ptr %2, align 4 - %3 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 1 - store i64 3, ptr %3, align 8 - %4 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %4, align 8 - %5 = load [2 x i64], ptr %vararg, align 8 + %3 = insertvalue %"int[]" undef, ptr %varargslots, 0 + %4 = insertvalue %"int[]" %3, i64 3, 1 + store %"int[]" %4, ptr %taddr, align 8 + %5 = load [2 x i64], ptr %taddr, align 8 %6 = call i32 @sum_us([2 x i64] %5) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 12, i1 false) %7 = insertvalue %"int[]" undef, ptr %x, 0 %8 = insertvalue %"int[]" %7, i64 3, 1 store %"int[]" %8, ptr %z, align 8 - %9 = getelementptr inbounds %"int[]", ptr %vararg1, i32 0, i32 1 - %10 = getelementptr inbounds %"int[]", ptr %vararg1, i32 0, i32 0 - store i64 3, ptr %9, align 8 - store ptr %x, ptr %10, align 8 - %11 = load [2 x i64], ptr %vararg1, align 8 + %9 = insertvalue %"int[]" undef, ptr %x, 0 + %10 = insertvalue %"int[]" %9, i64 3, 1 + store %"int[]" %10, ptr %taddr1, align 8 + %11 = load [2 x i64], ptr %taddr1, align 8 %12 = call i32 @sum_us([2 x i64] %11) - %13 = getelementptr inbounds %"int[]", ptr %vararg2, i32 0, i32 1 - %14 = getelementptr inbounds %"int[]", ptr %vararg2, i32 0, i32 0 - %15 = load [2 x i64], ptr %z, align 8 + %13 = load [2 x i64], ptr %z, align 8 + %14 = call i32 @sum_us([2 x i64] %13) + store %"int[]" zeroinitializer, ptr %taddr2, align 8 + %15 = load [2 x i64], ptr %taddr2, align 8 %16 = call i32 @sum_us([2 x i64] %15) - %17 = getelementptr inbounds %"int[]", ptr %vararg3, i32 0, i32 1 - store i64 0, ptr %17, align 8 - %18 = load [2 x i64], ptr %vararg3, align 8 - %19 = call i32 @sum_us([2 x i64] %18) ret void } diff --git a/test/test_suite2/functions/splat_mingw.c3t b/test/test_suite2/functions/splat_mingw.c3t index dccf70884..bcedcd954 100644 --- a/test/test_suite2/functions/splat_mingw.c3t +++ b/test/test_suite2/functions/splat_mingw.c3t @@ -15,47 +15,37 @@ fn void test() /* #expect: splat.ll +declare i32 @sum_us(ptr align 8) #0 + define void @splat_test() #0 { entry: - %vararg = alloca %"int[]", align 8 %varargslots = alloca [3 x i32], align 4 %indirectarg = alloca %"int[]", align 8 %x = alloca [3 x i32], align 4 %z = alloca %"int[]", align 8 - %vararg1 = alloca %"int[]", align 8 + %indirectarg1 = alloca %"int[]", align 8 %indirectarg2 = alloca %"int[]", align 8 - %vararg3 = alloca %"int[]", align 8 - %indirectarg4 = alloca %"int[]", align 8 - %vararg5 = alloca %"int[]", align 8 - %indirectarg6 = alloca %"int[]", align 8 + %indirectarg3 = alloca %"int[]", align 8 %0 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 0 store i32 1, ptr %0, align 4 %1 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 1 store i32 2, ptr %1, align 4 %2 = getelementptr inbounds [3 x i32], ptr %varargslots, i64 0, i64 2 store i32 3, ptr %2, align 4 - %3 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 1 - store i64 3, ptr %3, align 8 - %4 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %4, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 8 %vararg, i32 16, i1 false) + %3 = insertvalue %"int[]" undef, ptr %varargslots, 0 + %4 = insertvalue %"int[]" %3, i64 3, 1 + store %"int[]" %4, ptr %indirectarg, align 8 %5 = call i32 @sum_us(ptr align 8 %indirectarg) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 12, i1 false) %6 = insertvalue %"int[]" undef, ptr %x, 0 %7 = insertvalue %"int[]" %6, i64 3, 1 store %"int[]" %7, ptr %z, align 8 - %8 = getelementptr inbounds %"int[]", ptr %vararg1, i32 0, i32 1 - %9 = getelementptr inbounds %"int[]", ptr %vararg1, i32 0, i32 0 - store i64 3, ptr %8, align 8 - store ptr %x, ptr %9, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg2, ptr align 8 %vararg1, i32 16, i1 false) - %10 = call i32 @sum_us(ptr align 8 %indirectarg2) - %11 = getelementptr inbounds %"int[]", ptr %vararg3, i32 0, i32 1 - %12 = getelementptr inbounds %"int[]", ptr %vararg3, i32 0, i32 0 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg4, ptr align 8 %z, i32 16, i1 false) - %13 = call i32 @sum_us(ptr align 8 %indirectarg4) - %14 = getelementptr inbounds %"int[]", ptr %vararg5, i32 0, i32 1 - store i64 0, ptr %14, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg6, ptr align 8 %vararg5, i32 16, i1 false) - %15 = call i32 @sum_us(ptr align 8 %indirectarg6) + %8 = insertvalue %"int[]" undef, ptr %x, 0 + %9 = insertvalue %"int[]" %8, i64 3, 1 + store %"int[]" %9, ptr %indirectarg1, align 8 + %10 = call i32 @sum_us(ptr align 8 %indirectarg1) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg2, ptr align 8 %z, i32 16, i1 false) + %11 = call i32 @sum_us(ptr align 8 %indirectarg2) + store %"int[]" zeroinitializer, ptr %indirectarg3, align 8 + %12 = call i32 @sum_us(ptr align 8 %indirectarg3) ret void diff --git a/test/test_suite2/functions/test_regression.c3t b/test/test_suite2/functions/test_regression.c3t index 0e6254b62..0092950a4 100644 --- a/test/test_suite2/functions/test_regression.c3t +++ b/test/test_suite2/functions/test_regression.c3t @@ -234,380 +234,323 @@ fn Type getValue(Blob blob) /* #expect: test.ll -%Blob = type { i32 } -%Blob.0 = type { double } -%Foo2 = type { i32 } -%Bobo = type { i16, float, i16, i16, float, i16 } -%"int[]" = type { ptr, i64 } -%LinkedList = type { i64, ptr, ptr } -%List = type { i64, i64, ptr, ptr } -%Foo = type { i32, i32 } + %Blob = type { i32 } + %Blob.0 = type { double } + %Foo2 = type { i32 } + %Bobo = type { i16, float, i16, i16, float, i16 } + %"int[]" = type { ptr, i64 } + %LinkedList = type { i64, ptr, ptr } + %List = type { i64, i64, ptr, ptr } + %Foo = type { i32, i32 } -@"ct$test_Bobo" = linkonce constant %.introspect { i8 10, i64 20, i64 0, i64 6, [0 x i64] zeroinitializer }, align 8 -@"ct$test_Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 -@"ct$test_Foor" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 -@"ct$test_Foo2" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8 -@"ct$test_Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 -@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8 -@"ct$test_MyEnum" = linkonce constant { i8, i64, i64, i64, [3 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"ct$int" to i64), i64 3, [3 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 4 }, %"char[]" { ptr @.enum.1, i64 5 }, %"char[]" { ptr @.enum.2, i64 3 }] }, align 8 -@"test_static$x" = internal unnamed_addr global i32 1, align 4 + @"ct$test_Bobo" = linkonce constant %.introspect { i8 10, i64 20, i64 0, i64 6, [0 x i64] zeroinitializer }, align 8 + @"ct$test_Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 + @"ct$test_Foor" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 + @"ct$test_Foo2" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8 + @"ct$test_Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 + @"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8 + @"ct$test_MyEnum" = linkonce constant { i8, i64, i64, i64, [3 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"ct$int" to i64), i64 3, [3 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 4 }, %"char[]" { ptr @.enum.1, i64 5 }, %"char[]" { ptr @.enum.2, i64 3 }] }, align 8 + @"test_static$x" = internal unnamed_addr global i32 1, align 4 -define void @test_Foo2_printme(ptr %0) #0 { -entry: - %1 = getelementptr inbounds %Foo2, ptr %0, i32 0, i32 0 - %2 = load i32, ptr %1, align 8 - %3 = call i32 (ptr, ...) @printf(ptr @.str.21, i32 %2) - ret void -} + define void @test_Foo2_printme(ptr %0) #0 { + entry: + %1 = getelementptr inbounds %Foo2, ptr %0, i32 0, i32 0 + %2 = load i32, ptr %1, align 8 + %3 = call i32 (ptr, ...) @printf(ptr @.str.21, i32 %2) + ret void + } -; Function Attrs: nounwind -define i32 @test_Foo2_mutate(ptr %0) #0 { -entry: - %1 = call i32 (ptr, ...) @printf(ptr @.str.22) - %2 = getelementptr inbounds %Foo2, ptr %0, i32 0, i32 0 - %3 = load i32, ptr %2, align 8 - %add = add i32 %3, 1 - store i32 %add, ptr %2, align 8 - ret i32 %add -} + ; Function Attrs: nounwind + define i32 @test_Foo2_mutate(ptr %0) #0 { + entry: + %1 = call i32 (ptr, ...) @printf(ptr @.str.22) + %2 = getelementptr inbounds %Foo2, ptr %0, i32 0, i32 0 + %3 = load i32, ptr %2, align 8 + %add = add i32 %3, 1 + store i32 %add, ptr %2, align 8 + ret i32 %add + } -; Function Attrs: nounwind -declare i32 @printf(ptr, ...) #0 + ; Function Attrs: nounwind + declare i32 @printf(ptr, ...) #0 -; Function Attrs: nounwind -define void @test_helloWorld() #0 { -entry: - %0 = call i32 (ptr, ...) @printf(ptr @.str) - ret void -} + ; Function Attrs: nounwind + define void @test_helloWorld() #0 { + entry: + %0 = call i32 (ptr, ...) @printf(ptr @.str) + ret void + } -; Function Attrs: nounwind -define i32 @test_test_static() #0 { -entry: - %0 = load i32, ptr @"test_static$x", align 4 - %add = add i32 %0, 1 - store i32 %add, ptr @"test_static$x", align 4 - %1 = load i32, ptr @"test_static$x", align 4 - %2 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %1) - %3 = load i32, ptr @"test_static$x", align 4 - ret i32 %3 -} + ; Function Attrs: nounwind + define i32 @test_test_static() #0 { + entry: + %0 = load i32, ptr @"test_static$x", align 4 + %add = add i32 %0, 1 + store i32 %add, ptr @"test_static$x", align 4 + %1 = load i32, ptr @"test_static$x", align 4 + %2 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %1) + %3 = load i32, ptr @"test_static$x", align 4 + ret i32 %3 + } -; Function Attrs: nounwind -define i32 @test_helo(double %0, ptr byval(%Bobo) align 8 %1) #0 { -entry: - %de = alloca [3 x i32], align 4 - %c = alloca %Bobo, align 4 - %indirectarg = alloca %Bobo, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %de, ptr align 4 @.__const, i32 12, i1 false) - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %c, ptr align 4 %1, i32 20, i1 false) - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 4 %c, i32 20, i1 false) - %2 = call i32 @test_helo(double 1.000000e+00, ptr byval(%Bobo) align 8 %indirectarg) - ret i32 1 -} + ; Function Attrs: nounwind + define i32 @test_helo(double %0, ptr byval(%Bobo) align 8 %1) #0 { + entry: + %de = alloca [3 x i32], align 4 + %c = alloca %Bobo, align 4 + %indirectarg = alloca %Bobo, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %de, ptr align 4 @.__const, i32 12, i1 false) + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %c, ptr align 4 %1, i32 20, i1 false) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 4 %c, i32 20, i1 false) + %2 = call i32 @test_helo(double 1.000000e+00, ptr byval(%Bobo) align 8 %indirectarg) + ret i32 1 + } -; Function Attrs: nounwind -define i32 @test_test1(i32 %0, i32 %1) #0 { -entry: - %a = alloca i32, align 4 - store i32 %0, ptr %a, align 4 - %2 = load i32, ptr %a, align 4 - %ashr = ashr i32 %2, %1 - %3 = freeze i32 %ashr - store i32 %3, ptr %a, align 4 - %gt = icmp sgt i32 %1, 128 - br i1 %gt, label %if.then, label %if.exit + ; Function Attrs: nounwind + define i32 @test_test1(i32 %0, i32 %1) #0 { + entry: + %a = alloca i32, align 4 + store i32 %0, ptr %a, align 4 + %2 = load i32, ptr %a, align 4 + %ashr = ashr i32 %2, %1 + %3 = freeze i32 %ashr + store i32 %3, ptr %a, align 4 + %gt = icmp sgt i32 %1, 128 + br i1 %gt, label %if.then, label %if.exit -if.then: ; preds = %entry - ret i32 -1 + if.then: ; preds = %entry + ret i32 -1 -if.exit: ; preds = %entry - %4 = load i32, ptr %a, align 4 - ret i32 %4 -} + if.exit: ; preds = %entry + %4 = load i32, ptr %a, align 4 + ret i32 %4 + } -; Function Attrs: nounwind -define i32 @test_sum_us(ptr %0, i64 %1) #0 { -entry: - %x = alloca %"int[]", align 8 - %sum = alloca i32, align 4 - %vararg = alloca %"int[]", align 8 - %taddr = alloca %"int[]", align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %x, i32 0, i32 0 - store ptr %0, ptr %2, align 8 - %3 = getelementptr inbounds { ptr, i64 }, ptr %x, i32 0, i32 1 - store i64 %1, ptr %3, align 8 - store i32 0, ptr %sum, align 4 - %4 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1 - %5 = load i64, ptr %4, align 8 - %eq = icmp eq i64 0, %5 - br i1 %eq, label %if.then, label %if.exit + ; Function Attrs: nounwind + define i32 @test_sum_us(ptr %0, i64 %1) #0 { + entry: + %x = alloca %"int[]", align 8 + %sum = alloca i32, align 4 + %2 = getelementptr inbounds { ptr, i64 }, ptr %x, i32 0, i32 0 + store ptr %0, ptr %2, align 8 + %3 = getelementptr inbounds { ptr, i64 }, ptr %x, i32 0, i32 1 + store i64 %1, ptr %3, align 8 + store i32 0, ptr %sum, align 4 + %4 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1 + %5 = load i64, ptr %4, align 8 + %eq = icmp eq i64 0, %5 + br i1 %eq, label %if.then, label %if.exit -if.then: ; preds = %entry - ret i32 0 + if.then: ; preds = %entry + ret i32 0 -if.exit: ; preds = %entry - %6 = load i32, ptr %sum, align 4 - %7 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0 - %8 = load ptr, ptr %7, align 8 - %ptroffset = getelementptr inbounds i32, ptr %8, i64 0 - %9 = load i32, ptr %ptroffset, align 4 - %10 = load %"int[]", ptr %x, align 8 - %11 = extractvalue %"int[]" %10, 0 - %12 = extractvalue %"int[]" %10, 1 - %sub = sub i64 %12, 1 - %13 = add i64 %sub, 1 - %size = sub i64 %13, 1 - %ptroffset1 = getelementptr inbounds i32, ptr %11, i64 1 - %14 = insertvalue %"int[]" undef, ptr %ptroffset1, 0 - %15 = insertvalue %"int[]" %14, i64 %size, 1 - %16 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 1 - %17 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 0 - store %"int[]" %15, ptr %taddr, align 8 - %18 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %19, align 8 - %20 = call i32 @test_sum_us(ptr %lo, i64 %hi) - %add = add i32 %9, %20 - %add2 = add i32 %6, %add - store i32 %add2, ptr %sum, align 4 - %21 = load i32, ptr %sum, align 4 - ret i32 %21 -} + if.exit: ; preds = %entry + %6 = load i32, ptr %sum, align 4 + %7 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0 + %8 = load ptr, ptr %7, align 8 + %ptroffset = getelementptr inbounds i32, ptr %8, i64 0 + %9 = load i32, ptr %ptroffset, align 4 + %10 = load %"int[]", ptr %x, align 8 + %11 = extractvalue %"int[]" %10, 0 + %12 = extractvalue %"int[]" %10, 1 + %sub = sub i64 %12, 1 + %13 = add i64 %sub, 1 + %size = sub i64 %13, 1 + %ptroffset1 = getelementptr inbounds i32, ptr %11, i64 1 + %14 = call i32 @test_sum_us(ptr %ptroffset1, i64 %size) + %add = add i32 %9, %14 + %add2 = add i32 %6, %add + store i32 %add2, ptr %sum, align 4 + %15 = load i32, ptr %sum, align 4 + ret i32 %15 + } -; Function Attrs: nounwind -define i32 @test_sumd(ptr %0, i64 %1) #0 { -entry: - %x = alloca %"int[]", align 8 - %sum = alloca i32, align 4 - %i = alloca i32, align 4 - %2 = getelementptr inbounds { ptr, i64 }, ptr %x, i32 0, i32 0 - store ptr %0, ptr %2, align 8 - %3 = getelementptr inbounds { ptr, i64 }, ptr %x, i32 0, i32 1 - store i64 %1, ptr %3, align 8 - store i32 0, ptr %sum, align 4 - store i32 0, ptr %i, align 4 - br label %loop.cond + ; Function Attrs: nounwind + define i32 @test_sumd(ptr %0, i64 %1) #0 { + entry: + %x = alloca %"int[]", align 8 + %sum = alloca i32, align 4 + %i = alloca i32, align 4 + %2 = getelementptr inbounds { ptr, i64 }, ptr %x, i32 0, i32 0 + store ptr %0, ptr %2, align 8 + %3 = getelementptr inbounds { ptr, i64 }, ptr %x, i32 0, i32 1 + store i64 %1, ptr %3, align 8 + store i32 0, ptr %sum, align 4 + store i32 0, ptr %i, align 4 + br label %loop.cond -loop.cond: ; preds = %loop.body, %entry - %4 = load i32, ptr %i, align 4 - %sisiext = sext i32 %4 to i64 - %5 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1 - %6 = load i64, ptr %5, align 8 - %lt = icmp slt i64 %sisiext, %6 - %check = icmp slt i64 %6, 0 - %siui-lt = or i1 %check, %lt - br i1 %siui-lt, label %loop.body, label %loop.exit + loop.cond: ; preds = %loop.body, %entry + %4 = load i32, ptr %i, align 4 + %sisiext = sext i32 %4 to i64 + %5 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1 + %6 = load i64, ptr %5, align 8 + %lt = icmp slt i64 %sisiext, %6 + %check = icmp slt i64 %6, 0 + %siui-lt = or i1 %check, %lt + br i1 %siui-lt, label %loop.body, label %loop.exit -loop.body: ; preds = %loop.cond - %7 = load i32, ptr %sum, align 4 - %8 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0 - %9 = load ptr, ptr %8, align 8 - %10 = load i32, ptr %i, align 4 - %sisiext1 = sext i32 %10 to i64 - %ptroffset = getelementptr inbounds i32, ptr %9, i64 %sisiext1 - %11 = load i32, ptr %ptroffset, align 4 - %add = add i32 %7, %11 - store i32 %add, ptr %sum, align 4 - %12 = load i32, ptr %i, align 4 - %add2 = add i32 %12, 1 - store i32 %add2, ptr %i, align 4 - br label %loop.cond + loop.body: ; preds = %loop.cond + %7 = load i32, ptr %sum, align 4 + %8 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0 + %9 = load ptr, ptr %8, align 8 + %10 = load i32, ptr %i, align 4 + %sisiext1 = sext i32 %10 to i64 + %ptroffset = getelementptr inbounds i32, ptr %9, i64 %sisiext1 + %11 = load i32, ptr %ptroffset, align 4 + %add = add i32 %7, %11 + store i32 %add, ptr %sum, align 4 + %12 = load i32, ptr %i, align 4 + %add2 = add i32 %12, 1 + store i32 %add2, ptr %i, align 4 + br label %loop.cond -loop.exit: ; preds = %loop.cond - %13 = load i32, ptr %sum, align 4 - ret i32 %13 -} + loop.exit: ; preds = %loop.cond + %13 = load i32, ptr %sum, align 4 + ret i32 %13 + } -; Function Attrs: nounwind -define void @test_main() #0 { -entry: - %list = alloca %LinkedList, align 8 - %i = alloca i32, align 4 - %elements = alloca i32, align 4 - %array = alloca %List, align 8 - %i1 = alloca i32, align 4 - %a = alloca %Blob, align 4 - %b = alloca %Blob.0, align 8 - %ddx = alloca %Foo, align 4 - %fro = alloca i32, align 4 - %x = alloca [4 x i32], align 16 - %vararg = alloca %"int[]", align 8 - %z = alloca %"int[]", align 8 - %de = alloca [3 x i32], align 4 - %vararg10 = alloca %"int[]", align 8 - %vararg13 = alloca %"int[]", align 8 - %vararg16 = alloca %"int[]", align 8 - %varargslots = alloca [4 x i32], align 16 - %vararg19 = alloca %"int[]", align 8 - %varargslots20 = alloca [1 x i32], align 4 - %vararg23 = alloca %"int[]", align 8 - %a1 = alloca ptr, align 8 - %b2 = alloca ptr, align 8 - %0 = call i32 @test_test_static() - %1 = call i32 @test_test_static() - %2 = call i32 @test_test_static() - call void @hello_world_hello() - call void @llvm.memset.p0.i64(ptr align 8 %list, i8 0, i64 24, i1 false) - call void @"std_array_linkedlist$$int_LinkedList_push"(ptr %list, i32 10) - call void @"std_array_linkedlist$$int_LinkedList_push"(ptr %list, i32 15) - call void @"std_array_linkedlist$$int_LinkedList_push"(ptr %list, i32 30) - store i32 0, ptr %i, align 4 - br label %loop.cond + ; Function Attrs: nounwind + define void @test_main() #0 { + entry: + %list = alloca %LinkedList, align 8 + %i = alloca i32, align 4 + %elements = alloca i32, align 4 + %array = alloca %List, align 8 + %i1 = alloca i32, align 4 + %a = alloca %Blob, align 4 + %b = alloca %Blob.0, align 8 + %ddx = alloca %Foo, align 4 + %fro = alloca i32, align 4 + %x = alloca [4 x i32], align 16 + %z = alloca %"int[]", align 8 + %de = alloca [3 x i32], align 4 + %varargslots = alloca [4 x i32], align 16 + %varargslots10 = alloca [1 x i32], align 4 + %a1 = alloca ptr, align 8 + %b2 = alloca ptr, align 8 + %0 = call i32 @test_test_static() + %1 = call i32 @test_test_static() + %2 = call i32 @test_test_static() + call void @hello_world_hello() + call void @llvm.memset.p0.i64(ptr align 8 %list, i8 0, i64 24, i1 false) + call void @"std_array_linkedlist$$int_LinkedList_push"(ptr %list, i32 10) + call void @"std_array_linkedlist$$int_LinkedList_push"(ptr %list, i32 15) + call void @"std_array_linkedlist$$int_LinkedList_push"(ptr %list, i32 30) + store i32 0, ptr %i, align 4 + br label %loop.cond -loop.cond: ; preds = %loop.body, %entry - %3 = load i32, ptr %i, align 4 - %4 = call i64 @"std_array_linkedlist$$int_LinkedList_len"(ptr %list) #3 - %uisitrunc = trunc i64 %4 to i32 - %lt = icmp slt i32 %3, %uisitrunc - br i1 %lt, label %loop.body, label %loop.exit + loop.cond: ; preds = %loop.body, %entry + %3 = load i32, ptr %i, align 4 + %4 = call i64 @"std_array_linkedlist$$int_LinkedList_len"(ptr %list) #3 + %uisitrunc = trunc i64 %4 to i32 + %lt = icmp slt i32 %3, %uisitrunc + br i1 %lt, label %loop.body, label %loop.exit -loop.body: ; preds = %loop.cond - %5 = load i32, ptr %i, align 4 - %6 = load i32, ptr %i, align 4 - %siuiext = sext i32 %6 to i64 - %7 = call i32 @"std_array_linkedlist$$int_LinkedList_get"(ptr %list, i64 %siuiext) - %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %5, i32 %7) - %9 = load i32, ptr %i, align 4 - %add = add i32 %9, 1 - store i32 %add, ptr %i, align 4 - br label %loop.cond + loop.body: ; preds = %loop.cond + %5 = load i32, ptr %i, align 4 + %6 = load i32, ptr %i, align 4 + %siuiext = sext i32 %6 to i64 + %7 = call i32 @"std_array_linkedlist$$int_LinkedList_get"(ptr %list, i64 %siuiext) + %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %5, i32 %7) + %9 = load i32, ptr %i, align 4 + %add = add i32 %9, 1 + store i32 %add, ptr %i, align 4 + br label %loop.cond -loop.exit: ; preds = %loop.cond - call void @"std_array_linkedlist$$int_LinkedList_free"(ptr %list) - %10 = call i32 (ptr, ...) @printf(ptr @.str.3, i32 3) - store i32 3, ptr %elements, align 4 - %11 = call i32 (ptr, ...) @printf(ptr @.str.4) - call void @llvm.memset.p0.i64(ptr align 8 %array, i8 0, i64 32, i1 false) - call void @"std_array_list$$int_List_append"(ptr %array, i32 100) - call void @"std_array_list$$int_List_append"(ptr %array, i32 200) - call void @"std_array_list$$int_List_append"(ptr %array, i32 400) - call void @"std_array_list$$int_List_push"(ptr %array, i32 600) #3 - call void @"std_array_list$$int_List_insert_at"(ptr %array, i64 2, i32 300) - store i32 0, ptr %i1, align 4 - br label %loop.cond2 + loop.exit: ; preds = %loop.cond + call void @"std_array_linkedlist$$int_LinkedList_free"(ptr %list) + %10 = call i32 (ptr, ...) @printf(ptr @.str.3, i32 3) + store i32 3, ptr %elements, align 4 + %11 = call i32 (ptr, ...) @printf(ptr @.str.4) + call void @llvm.memset.p0.i64(ptr align 8 %array, i8 0, i64 32, i1 false) + call void @"std_array_list$$int_List_append"(ptr %array, i32 100) + call void @"std_array_list$$int_List_append"(ptr %array, i32 200) + call void @"std_array_list$$int_List_append"(ptr %array, i32 400) + call void @"std_array_list$$int_List_push"(ptr %array, i32 600) #3 + call void @"std_array_list$$int_List_insert_at"(ptr %array, i64 2, i32 300) + store i32 0, ptr %i1, align 4 + br label %loop.cond2 -loop.cond2: ; preds = %loop.body5, %loop.exit - %12 = load i32, ptr %i1, align 4 - %13 = call i64 @"std_array_list$$int_List_len"(ptr %array) - %uisitrunc3 = trunc i64 %13 to i32 - %lt4 = icmp slt i32 %12, %uisitrunc3 - br i1 %lt4, label %loop.body5, label %loop.exit8 + loop.cond2: ; preds = %loop.body5, %loop.exit + %12 = load i32, ptr %i1, align 4 + %13 = call i64 @"std_array_list$$int_List_len"(ptr %array) + %uisitrunc3 = trunc i64 %13 to i32 + %lt4 = icmp slt i32 %12, %uisitrunc3 + br i1 %lt4, label %loop.body5, label %loop.exit8 -loop.body5: ; preds = %loop.cond2 - %14 = load i32, ptr %i1, align 4 - %15 = load i32, ptr %i1, align 4 - %siuiext6 = sext i32 %15 to i64 - %16 = call i32 @"std_array_list$$int_List_get"(ptr %array, i64 %siuiext6) - %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %14, i32 %16) - %18 = load i32, ptr %i1, align 4 - %add7 = add i32 %18, 1 - store i32 %add7, ptr %i1, align 4 - br label %loop.cond2 + loop.body5: ; preds = %loop.cond2 + %14 = load i32, ptr %i1, align 4 + %15 = load i32, ptr %i1, align 4 + %siuiext6 = sext i32 %15 to i64 + %16 = call i32 @"std_array_list$$int_List_get"(ptr %array, i64 %siuiext6) + %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %14, i32 %16) + %18 = load i32, ptr %i1, align 4 + %add7 = add i32 %18, 1 + store i32 %add7, ptr %i1, align 4 + br label %loop.cond2 -loop.exit8: ; preds = %loop.cond2 - call void @"std_array_list$$int_List_free"(ptr %array) - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const.6, i32 4, i1 false) - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %b, ptr align 8 @.__const.7, i32 8, i1 false) - %19 = getelementptr inbounds %Blob, ptr %a, i32 0, i32 0 - %20 = load i32, ptr %19, align 4 - %21 = call i32 @"test2$$int_getValue"(i32 %20) - %22 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %21) - %23 = getelementptr inbounds %Blob.0, ptr %b, i32 0, i32 0 - %24 = load double, ptr %23, align 8 - %25 = call double @"test2$$double_getValue"(double %24) - %26 = call i32 (ptr, ...) @printf(ptr @.str.9, double %25) - %27 = call i32 @"test2$$int_getMult"(i32 25) - %28 = call i32 (ptr, ...) @printf(ptr @.str.10, i32 %27) - %29 = call double @"test2$$double_getMult"(double 3.300000e+00) - %30 = call i32 (ptr, ...) @printf(ptr @.str.11, double %29) - call void @test_helloWorld() - %31 = getelementptr inbounds %Foo, ptr %ddx, i32 0, i32 0 - store i32 0, ptr %31, align 4 - %32 = getelementptr inbounds %Foo, ptr %ddx, i32 0, i32 1 - store i32 0, ptr %32, align 4 - store i32 3, ptr %fro, align 4 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %x, ptr align 16 @.__const.12, i32 16, i1 false) - %33 = load i32, ptr %fro, align 4 - %34 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 1 - %35 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 0 - store i64 4, ptr %34, align 8 - store ptr %x, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo = load ptr, ptr %36, align 8 - %37 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi = load i64, ptr %37, align 8 - %38 = call i32 @test_sum_us(ptr %lo, i64 %hi) - %39 = call i32 (ptr, ...) @printf(ptr @.str.13, i32 %38) - %add9 = add i32 %33, %39 - store i32 %add9, ptr %fro, align 4 - %40 = load i32, ptr %fro, align 4 - %41 = call i32 (ptr, ...) @printf(ptr @.str.14, i32 %40) - %42 = insertvalue %"int[]" undef, ptr %x, 0 - %43 = insertvalue %"int[]" %42, i64 4, 1 - store %"int[]" %43, ptr %z, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %de, ptr align 4 @.__const.15, i32 12, i1 false) - %44 = getelementptr inbounds %"int[]", ptr %vararg10, i32 0, i32 1 - %45 = getelementptr inbounds %"int[]", ptr %vararg10, i32 0, i32 0 - store i64 4, ptr %44, align 8 - store ptr %x, ptr %45, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg10, i32 0, i32 0 - %lo11 = load ptr, ptr %46, align 8 - %47 = getelementptr inbounds { ptr, i64 }, ptr %vararg10, i32 0, i32 1 - %hi12 = load i64, ptr %47, align 8 - %48 = call i32 @test_sum_us(ptr %lo11, i64 %hi12) - %49 = call i32 (ptr, ...) @printf(ptr @.str.16, i32 %48) - %50 = getelementptr inbounds %"int[]", ptr %vararg13, i32 0, i32 1 - %51 = getelementptr inbounds %"int[]", ptr %vararg13, i32 0, i32 0 - %52 = getelementptr inbounds { ptr, i64 }, ptr %z, i32 0, i32 0 - %lo14 = load ptr, ptr %52, align 8 - %53 = getelementptr inbounds { ptr, i64 }, ptr %z, i32 0, i32 1 - %hi15 = load i64, ptr %53, align 8 - %54 = call i32 @test_sum_us(ptr %lo14, i64 %hi15) - %55 = call i32 (ptr, ...) @printf(ptr @.str.17, i32 %54) - %56 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 0 - store i32 1, ptr %56, align 4 - %57 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 1 - store i32 2, ptr %57, align 4 - %58 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 2 - store i32 4, ptr %58, align 4 - %59 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 3 - store i32 5, ptr %59, align 4 - %60 = getelementptr inbounds %"int[]", ptr %vararg16, i32 0, i32 1 - store i64 4, ptr %60, align 8 - %61 = getelementptr inbounds %"int[]", ptr %vararg16, i32 0, i32 0 - store ptr %varargslots, ptr %61, align 8 - %62 = getelementptr inbounds { ptr, i64 }, ptr %vararg16, i32 0, i32 0 - %lo17 = load ptr, ptr %62, align 8 - %63 = getelementptr inbounds { ptr, i64 }, ptr %vararg16, i32 0, i32 1 - %hi18 = load i64, ptr %63, align 8 - %64 = call i32 @test_sum_us(ptr %lo17, i64 %hi18) - %65 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %64) - %66 = getelementptr inbounds [1 x i32], ptr %varargslots20, i64 0, i64 0 - store i32 1, ptr %66, align 4 - %67 = getelementptr inbounds %"int[]", ptr %vararg19, i32 0, i32 1 - store i64 1, ptr %67, align 8 - %68 = getelementptr inbounds %"int[]", ptr %vararg19, i32 0, i32 0 - store ptr %varargslots20, ptr %68, align 8 - %69 = getelementptr inbounds { ptr, i64 }, ptr %vararg19, i32 0, i32 0 - %lo21 = load ptr, ptr %69, align 8 - %70 = getelementptr inbounds { ptr, i64 }, ptr %vararg19, i32 0, i32 1 - %hi22 = load i64, ptr %70, align 8 - %71 = call i32 @test_sum_us(ptr %lo21, i64 %hi22) - %72 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %71) - %73 = getelementptr inbounds %"int[]", ptr %vararg23, i32 0, i32 1 - store i64 0, ptr %73, align 8 - %74 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0 - %lo24 = load ptr, ptr %74, align 8 - %75 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1 - %hi25 = load i64, ptr %75, align 8 - %76 = call i32 @test_sum_us(ptr %lo24, i64 %hi25) - %77 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %76) - store ptr null, ptr %a1, align 8 - store ptr null, ptr %b2, align 8 - ret void -} + loop.exit8: ; preds = %loop.cond2 + call void @"std_array_list$$int_List_free"(ptr %array) + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const.6, i32 4, i1 false) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %b, ptr align 8 @.__const.7, i32 8, i1 false) + %19 = getelementptr inbounds %Blob, ptr %a, i32 0, i32 0 + %20 = load i32, ptr %19, align 4 + %21 = call i32 @"test2$$int_getValue"(i32 %20) + %22 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %21) + %23 = getelementptr inbounds %Blob.0, ptr %b, i32 0, i32 0 + %24 = load double, ptr %23, align 8 + %25 = call double @"test2$$double_getValue"(double %24) + %26 = call i32 (ptr, ...) @printf(ptr @.str.9, double %25) + %27 = call i32 @"test2$$int_getMult"(i32 25) + %28 = call i32 (ptr, ...) @printf(ptr @.str.10, i32 %27) + %29 = call double @"test2$$double_getMult"(double 3.300000e+00) + %30 = call i32 (ptr, ...) @printf(ptr @.str.11, double %29) + call void @test_helloWorld() + %31 = getelementptr inbounds %Foo, ptr %ddx, i32 0, i32 0 + store i32 0, ptr %31, align 4 + %32 = getelementptr inbounds %Foo, ptr %ddx, i32 0, i32 1 + store i32 0, ptr %32, align 4 + store i32 3, ptr %fro, align 4 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %x, ptr align 16 @.__const.12, i32 16, i1 false) + %33 = load i32, ptr %fro, align 4 + %34 = call i32 @test_sum_us(ptr %x, i64 4) + %35 = call i32 (ptr, ...) @printf(ptr @.str.13, i32 %34) + %add9 = add i32 %33, %35 + store i32 %add9, ptr %fro, align 4 + %36 = load i32, ptr %fro, align 4 + %37 = call i32 (ptr, ...) @printf(ptr @.str.14, i32 %36) + %38 = insertvalue %"int[]" undef, ptr %x, 0 + %39 = insertvalue %"int[]" %38, i64 4, 1 + store %"int[]" %39, ptr %z, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %de, ptr align 4 @.__const.15, i32 12, i1 false) + %40 = call i32 @test_sum_us(ptr %x, i64 4) + %41 = call i32 (ptr, ...) @printf(ptr @.str.16, i32 %40) + %42 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 0 + %lo = load ptr, ptr %42, align 8 + %43 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 1 + %hi = load i64, ptr %43, align 8 + %44 = call i32 @test_sum_us(ptr %lo, i64 %hi) + %45 = call i32 (ptr, ...) @printf(ptr @.str.17, i32 %44) + %46 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 0 + store i32 1, ptr %46, align 4 + %47 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 1 + store i32 2, ptr %47, align 4 + %48 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 2 + store i32 4, ptr %48, align 4 + %49 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 3 + store i32 5, ptr %49, align 4 + %50 = call i32 @test_sum_us(ptr %varargslots, i64 4) + %51 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %50) + %52 = getelementptr inbounds [1 x i32], ptr %varargslots10, i64 0, i64 0 + store i32 1, ptr %52, align 4 + %53 = call i32 @test_sum_us(ptr %varargslots10, i64 1) + %54 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %53) + %55 = call i32 @test_sum_us(ptr null, i64 0) + %56 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %55) + store ptr null, ptr %a1, align 8 + store ptr null, ptr %b2, align 8 + ret void + } // #expect: hello_world.ll define void @hello_world_hello() @@ -666,7 +609,7 @@ entry: ret i32 1 define double @"test2$$double_getValue"(double %0) -entry: + entry: %blob = alloca %Blob, align 8 %1 = getelementptr inbounds %Blob, ptr %blob, i32 0, i32 0 store double %0, ptr %1, align 8 diff --git a/test/test_suite2/functions/test_regression_mingw.c3t b/test/test_suite2/functions/test_regression_mingw.c3t index 0f4d90edb..feb7dd13e 100644 --- a/test/test_suite2/functions/test_regression_mingw.c3t +++ b/test/test_suite2/functions/test_regression_mingw.c3t @@ -371,7 +371,6 @@ if.exit: ; preds = %entry define i32 @test_sum_us(ptr align 8 %0) #0 { entry: %sum = alloca i32, align 4 - %vararg = alloca %"int[]", align 8 %indirectarg = alloca %"int[]", align 8 store i32 0, ptr %sum, align 4 %1 = getelementptr inbounds %"int[]", ptr %0, i32 0, i32 1 @@ -397,15 +396,13 @@ if.exit: ; preds = %entry %ptroffset1 = getelementptr inbounds i32, ptr %8, i64 1 %11 = insertvalue %"int[]" undef, ptr %ptroffset1, 0 %12 = insertvalue %"int[]" %11, i64 %size, 1 - %13 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 1 - %14 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 0 store %"int[]" %12, ptr %indirectarg, align 8 - %15 = call i32 @test_sum_us(ptr align 8 %indirectarg) - %add = add i32 %6, %15 + %13 = call i32 @test_sum_us(ptr align 8 %indirectarg) + %add = add i32 %6, %13 %add2 = add i32 %3, %add store i32 %add2, ptr %sum, align 4 - %16 = load i32, ptr %sum, align 4 - ret i32 %16 + %14 = load i32, ptr %sum, align 4 + ret i32 %14 } ; Function Attrs: nounwind @@ -460,22 +457,16 @@ entry: %ddx = alloca %Foo, align 4 %fro = alloca i32, align 4 %x = alloca [4 x i32], align 16 - %vararg = alloca %"int[]", align 8 %indirectarg = alloca %"int[]", align 8 %z = alloca %"int[]", align 8 %de = alloca [3 x i32], align 4 - %vararg10 = alloca %"int[]", align 8 + %indirectarg10 = alloca %"int[]", align 8 %indirectarg11 = alloca %"int[]", align 8 - %vararg12 = alloca %"int[]", align 8 - %indirectarg13 = alloca %"int[]", align 8 - %vararg14 = alloca %"int[]", align 8 %varargslots = alloca [4 x i32], align 16 + %indirectarg12 = alloca %"int[]", align 8 + %varargslots13 = alloca [1 x i32], align 4 + %indirectarg14 = alloca %"int[]", align 8 %indirectarg15 = alloca %"int[]", align 8 - %vararg16 = alloca %"int[]", align 8 - %varargslots17 = alloca [1 x i32], align 4 - %indirectarg18 = alloca %"int[]", align 8 - %vararg19 = alloca %"int[]", align 8 - %indirectarg20 = alloca %"int[]", align 8 %a1 = alloca ptr, align 8 %b2 = alloca ptr, align 8 %0 = call i32 @test_test_static() @@ -563,11 +554,9 @@ loop.exit8: ; preds = %loop.cond2 store i32 3, ptr %fro, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 16 %x, ptr align 16 @.__const.12, i32 16, i1 false) %33 = load i32, ptr %fro, align 4 - %34 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 1 - %35 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 0 - store i64 4, ptr %34, align 8 - store ptr %x, ptr %35, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 8 %vararg, i32 16, i1 false) + %34 = insertvalue %"int[]" undef, ptr %x, 0 + %35 = insertvalue %"int[]" %34, i64 4, 1 + store %"int[]" %35, ptr %indirectarg, align 8 %36 = call i32 @test_sum_us(ptr align 8 %indirectarg) %37 = call i32 (ptr, ...) @printf(ptr @.str.13, i32 %36) %add9 = add i32 %33, %37 @@ -578,47 +567,37 @@ loop.exit8: ; preds = %loop.cond2 %41 = insertvalue %"int[]" %40, i64 4, 1 store %"int[]" %41, ptr %z, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %de, ptr align 4 @.__const.15, i32 12, i1 false) - %42 = getelementptr inbounds %"int[]", ptr %vararg10, i32 0, i32 1 - %43 = getelementptr inbounds %"int[]", ptr %vararg10, i32 0, i32 0 - store i64 4, ptr %42, align 8 - store ptr %x, ptr %43, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg11, ptr align 8 %vararg10, i32 16, i1 false) - %44 = call i32 @test_sum_us(ptr align 8 %indirectarg11) + %42 = insertvalue %"int[]" undef, ptr %x, 0 + %43 = insertvalue %"int[]" %42, i64 4, 1 + store %"int[]" %43, ptr %indirectarg10, align 8 + %44 = call i32 @test_sum_us(ptr align 8 %indirectarg10) %45 = call i32 (ptr, ...) @printf(ptr @.str.16, i32 %44) - %46 = getelementptr inbounds %"int[]", ptr %vararg12, i32 0, i32 1 - %47 = getelementptr inbounds %"int[]", ptr %vararg12, i32 0, i32 0 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg13, ptr align 8 %z, i32 16, i1 false) - %48 = call i32 @test_sum_us(ptr align 8 %indirectarg13) - %49 = call i32 (ptr, ...) @printf(ptr @.str.17, i32 %48) - %50 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 0 - store i32 1, ptr %50, align 4 - %51 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 1 - store i32 2, ptr %51, align 4 - %52 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 2 - store i32 4, ptr %52, align 4 - %53 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 3 - store i32 5, ptr %53, align 4 - %54 = getelementptr inbounds %"int[]", ptr %vararg14, i32 0, i32 1 - store i64 4, ptr %54, align 8 - %55 = getelementptr inbounds %"int[]", ptr %vararg14, i32 0, i32 0 - store ptr %varargslots, ptr %55, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg15, ptr align 8 %vararg14, i32 16, i1 false) - %56 = call i32 @test_sum_us(ptr align 8 %indirectarg15) - %57 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %56) - %58 = getelementptr inbounds [1 x i32], ptr %varargslots17, i64 0, i64 0 - store i32 1, ptr %58, align 4 - %59 = getelementptr inbounds %"int[]", ptr %vararg16, i32 0, i32 1 - store i64 1, ptr %59, align 8 - %60 = getelementptr inbounds %"int[]", ptr %vararg16, i32 0, i32 0 - store ptr %varargslots17, ptr %60, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg18, ptr align 8 %vararg16, i32 16, i1 false) - %61 = call i32 @test_sum_us(ptr align 8 %indirectarg18) - %62 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %61) - %63 = getelementptr inbounds %"int[]", ptr %vararg19, i32 0, i32 1 - store i64 0, ptr %63, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg20, ptr align 8 %vararg19, i32 16, i1 false) - %64 = call i32 @test_sum_us(ptr align 8 %indirectarg20) - %65 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %64) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg11, ptr align 8 %z, i32 16, i1 false) + %46 = call i32 @test_sum_us(ptr align 8 %indirectarg11) + %47 = call i32 (ptr, ...) @printf(ptr @.str.17, i32 %46) + %48 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 0 + store i32 1, ptr %48, align 4 + %49 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 1 + store i32 2, ptr %49, align 4 + %50 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 2 + store i32 4, ptr %50, align 4 + %51 = getelementptr inbounds [4 x i32], ptr %varargslots, i64 0, i64 3 + store i32 5, ptr %51, align 4 + %52 = insertvalue %"int[]" undef, ptr %varargslots, 0 + %53 = insertvalue %"int[]" %52, i64 4, 1 + store %"int[]" %53, ptr %indirectarg12, align 8 + %54 = call i32 @test_sum_us(ptr align 8 %indirectarg12) + %55 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %54) + %56 = getelementptr inbounds [1 x i32], ptr %varargslots13, i64 0, i64 0 + store i32 1, ptr %56, align 4 + %57 = insertvalue %"int[]" undef, ptr %varargslots13, 0 + %58 = insertvalue %"int[]" %57, i64 1, 1 + store %"int[]" %58, ptr %indirectarg14, align 8 + %59 = call i32 @test_sum_us(ptr align 8 %indirectarg14) + %60 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %59) + store %"int[]" zeroinitializer, ptr %indirectarg15, align 8 + %61 = call i32 @test_sum_us(ptr align 8 %indirectarg15) + %62 = call i32 (ptr, ...) @printf(ptr @.str.20, i32 %61) store ptr null, ptr %a1, align 8 store ptr null, ptr %b2, align 8 ret void diff --git a/test/test_suite2/functions/typeless_varargs.c3t b/test/test_suite2/functions/typeless_varargs.c3t index b830fecbd..3bb818d89 100644 --- a/test/test_suite2/functions/typeless_varargs.c3t +++ b/test/test_suite2/functions/typeless_varargs.c3t @@ -27,17 +27,14 @@ fn int main() define void @test_retest(ptr %0, i64 %1) #0 { entry: %foo = alloca %"variant[]", align 8 - %vararg = alloca %"variant[]", align 8 %2 = getelementptr inbounds { ptr, i64 }, ptr %foo, i32 0, i32 0 store ptr %0, ptr %2, align 8 %3 = getelementptr inbounds { ptr, i64 }, ptr %foo, i32 0, i32 1 store i64 %1, ptr %3, align 8 - %4 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - %5 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - %6 = getelementptr inbounds { ptr, i64 }, ptr %foo, i32 0, i32 0 - %lo = load ptr, ptr %6, align 8 - %7 = getelementptr inbounds { ptr, i64 }, ptr %foo, i32 0, i32 1 - %hi = load i64, ptr %7, align 8 + %4 = getelementptr inbounds %"variant[]", ptr %foo, i32 0, i32 0 + %lo = load ptr, ptr %4, align 8 + %5 = getelementptr inbounds %"variant[]", ptr %foo, i32 0, i32 1 + %hi = load i64, ptr %5, align 8 call void @test_test(ptr %lo, i64 %hi) ret void } @@ -62,40 +59,22 @@ entry: define i32 @main() #0 { entry: %i = alloca i32, align 4 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 %taddr = alloca i32, align 4 - %vararg1 = alloca %"variant[]", align 8 - %varargslots2 = alloca [1 x %variant], align 16 - %taddr3 = alloca i32, align 4 + %varargslots1 = alloca [1 x %variant], align 16 + %taddr2 = alloca i32, align 4 store i32 1, ptr %i, align 4 store i32 1, ptr %taddr, align 4 %0 = insertvalue %variant undef, ptr %taddr, 0 %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$int" to i64), 1 %2 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 store %variant %1, ptr %2, align 16 - %3 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %3, align 8 - %4 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo = load ptr, ptr %5, align 8 - %6 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi = load i64, ptr %6, align 8 - call void @test_test(ptr %lo, i64 %hi) - store i32 1, ptr %taddr3, align 4 - %7 = insertvalue %variant undef, ptr %taddr3, 0 - %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %9 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0 - store %variant %8, ptr %9, align 16 - %10 = getelementptr inbounds %"variant[]", ptr %vararg1, i32 0, i32 1 - store i64 1, ptr %10, align 8 - %11 = getelementptr inbounds %"variant[]", ptr %vararg1, i32 0, i32 0 - store ptr %varargslots2, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %vararg1, i32 0, i32 0 - %lo4 = load ptr, ptr %12, align 8 - %13 = getelementptr inbounds { ptr, i64 }, ptr %vararg1, i32 0, i32 1 - %hi5 = load i64, ptr %13, align 8 - call void @test_retest(ptr %lo4, i64 %hi5) + call void @test_test(ptr %varargslots, i64 1) + store i32 1, ptr %taddr2, align 4 + %3 = insertvalue %variant undef, ptr %taddr2, 0 + %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %5 = getelementptr inbounds [1 x %variant], ptr %varargslots1, i64 0, i64 0 + store %variant %4, ptr %5, align 16 + call void @test_retest(ptr %varargslots1, i64 1) ret i32 1 } \ No newline at end of file diff --git a/test/test_suite2/functions/varargs_followed_by_named.c3t b/test/test_suite2/functions/varargs_followed_by_named.c3t index 7d9fdc324..10eb6f76e 100644 --- a/test/test_suite2/functions/varargs_followed_by_named.c3t +++ b/test/test_suite2/functions/varargs_followed_by_named.c3t @@ -40,6 +40,7 @@ entry: ret void } +; Function Attrs: nounwind define void @foo_test2(i32 %0, ptr %1, i64 %2, i32 %3) #0 { entry: %y = alloca %"variant[]", align 8 @@ -54,83 +55,48 @@ entry: ret void } +; Function Attrs: nounwind define void @foo_main() #0 { entry: - %vararg = alloca %"int[]", align 8 %varargslots = alloca [2 x i32], align 4 - %vararg1 = alloca %"variant[]", align 8 - %varargslots2 = alloca [2 x %variant], align 16 + %varargslots1 = alloca [2 x %variant], align 16 %taddr = alloca i32, align 4 - %taddr3 = alloca i32, align 4 - %vararg6 = alloca %"int[]", align 8 - %varargslots7 = alloca [2 x i32], align 4 - %vararg10 = alloca %"variant[]", align 8 - %varargslots11 = alloca [2 x %variant], align 16 - %taddr12 = alloca i32, align 4 - %taddr13 = alloca i32, align 4 + %taddr2 = alloca i32, align 4 + %varargslots3 = alloca [2 x i32], align 4 + %varargslots4 = alloca [2 x %variant], align 16 + %taddr5 = alloca i32, align 4 + %taddr6 = alloca i32, align 4 %0 = getelementptr inbounds [2 x i32], ptr %varargslots, i64 0, i64 0 store i32 4, ptr %0, align 4 %1 = getelementptr inbounds [2 x i32], ptr %varargslots, i64 0, i64 1 store i32 5, ptr %1, align 4 - %2 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 1 - store i64 2, ptr %2, align 8 - %3 = getelementptr inbounds %"int[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %3, align 8 - %4 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo = load ptr, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi = load i64, ptr %5, align 8 - call void @foo_test(i32 3, ptr %lo, i64 %hi, i32 123) + call void @foo_test(i32 3, ptr %varargslots, i64 2, i32 123) store i32 4, ptr %taddr, align 4 - %6 = insertvalue %variant undef, ptr %taddr, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %8 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 0 - store %variant %7, ptr %8, align 16 - store i32 5, ptr %taddr3, align 4 - %9 = insertvalue %variant undef, ptr %taddr3, 0 - %10 = insertvalue %variant %9, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %11 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 1 - store %variant %10, ptr %11, align 16 - %12 = getelementptr inbounds %"variant[]", ptr %vararg1, i32 0, i32 1 - store i64 2, ptr %12, align 8 - %13 = getelementptr inbounds %"variant[]", ptr %vararg1, i32 0, i32 0 - store ptr %varargslots2, ptr %13, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %vararg1, i32 0, i32 0 - %lo4 = load ptr, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %vararg1, i32 0, i32 1 - %hi5 = load i64, ptr %15, align 8 - call void @foo_test2(i32 3, ptr %lo4, i64 %hi5, i32 123) - %16 = getelementptr inbounds [2 x i32], ptr %varargslots7, i64 0, i64 0 - store i32 4, ptr %16, align 4 - %17 = getelementptr inbounds [2 x i32], ptr %varargslots7, i64 0, i64 1 - store i32 5, ptr %17, align 4 - %18 = getelementptr inbounds %"int[]", ptr %vararg6, i32 0, i32 1 - store i64 2, ptr %18, align 8 - %19 = getelementptr inbounds %"int[]", ptr %vararg6, i32 0, i32 0 - store ptr %varargslots7, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg6, i32 0, i32 0 - %lo8 = load ptr, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg6, i32 0, i32 1 - %hi9 = load i64, ptr %21, align 8 - call void @foo_test(i32 3, ptr %lo8, i64 %hi9, i32 2) - store i32 4, ptr %taddr12, align 4 - %22 = insertvalue %variant undef, ptr %taddr12, 0 - %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %24 = getelementptr inbounds [2 x %variant], ptr %varargslots11, i64 0, i64 0 - store %variant %23, ptr %24, align 16 - store i32 5, ptr %taddr13, align 4 - %25 = insertvalue %variant undef, ptr %taddr13, 0 - %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %27 = getelementptr inbounds [2 x %variant], ptr %varargslots11, i64 0, i64 1 - store %variant %26, ptr %27, align 16 - %28 = getelementptr inbounds %"variant[]", ptr %vararg10, i32 0, i32 1 - store i64 2, ptr %28, align 8 - %29 = getelementptr inbounds %"variant[]", ptr %vararg10, i32 0, i32 0 - store ptr %varargslots11, ptr %29, align 8 - %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg10, i32 0, i32 0 - %lo14 = load ptr, ptr %30, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg10, i32 0, i32 1 - %hi15 = load i64, ptr %31, align 8 - call void @foo_test2(i32 3, ptr %lo14, i64 %hi15, i32 2) + %2 = insertvalue %variant undef, ptr %taddr, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %4 = getelementptr inbounds [2 x %variant], ptr %varargslots1, i64 0, i64 0 + store %variant %3, ptr %4, align 16 + store i32 5, ptr %taddr2, align 4 + %5 = insertvalue %variant undef, ptr %taddr2, 0 + %6 = insertvalue %variant %5, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %7 = getelementptr inbounds [2 x %variant], ptr %varargslots1, i64 0, i64 1 + store %variant %6, ptr %7, align 16 + call void @foo_test2(i32 3, ptr %varargslots1, i64 2, i32 123) + %8 = getelementptr inbounds [2 x i32], ptr %varargslots3, i64 0, i64 0 + store i32 4, ptr %8, align 4 + %9 = getelementptr inbounds [2 x i32], ptr %varargslots3, i64 0, i64 1 + store i32 5, ptr %9, align 4 + call void @foo_test(i32 3, ptr %varargslots3, i64 2, i32 2) + store i32 4, ptr %taddr5, align 4 + %10 = insertvalue %variant undef, ptr %taddr5, 0 + %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %12 = getelementptr inbounds [2 x %variant], ptr %varargslots4, i64 0, i64 0 + store %variant %11, ptr %12, align 16 + store i32 5, ptr %taddr6, align 4 + %13 = insertvalue %variant undef, ptr %taddr6, 0 + %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %15 = getelementptr inbounds [2 x %variant], ptr %varargslots4, i64 0, i64 1 + store %variant %14, ptr %15, align 16 + call void @foo_test2(i32 3, ptr %varargslots4, i64 2, i32 2) ret void } \ No newline at end of file diff --git a/test/test_suite2/generic/enum_set_test.c3t b/test/test_suite2/generic/enum_set_test.c3t index 1eefab8ad..88ba51c23 100644 --- a/test/test_suite2/generic/enum_set_test.c3t +++ b/test/test_suite2/generic/enum_set_test.c3t @@ -31,53 +31,30 @@ define void @test_main() #0 { entry: %set = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i8, align 1 - %retparam4 = alloca i64, align 8 - %taddr5 = alloca %"char[]", align 8 - %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 - %taddr10 = alloca i8, align 1 - %retparam16 = alloca i64, align 8 - %taddr17 = alloca %"char[]", align 8 - %vararg20 = alloca %"variant[]", align 8 - %varargslots21 = alloca [1 x %variant], align 16 - %taddr22 = alloca i8, align 1 + %taddr = alloca i8, align 1 + %retparam1 = alloca i64, align 8 + %varargslots2 = alloca [1 x %variant], align 16 + %taddr3 = alloca i8, align 1 + %retparam7 = alloca i64, align 8 + %varargslots8 = alloca [1 x %variant], align 16 + %taddr9 = alloca i8, align 1 %set2 = alloca i32, align 4 - %retparam28 = alloca i64, align 8 - %taddr29 = alloca %"char[]", align 8 - %vararg32 = alloca %"variant[]", align 8 - %varargslots33 = alloca [1 x %variant], align 16 - %taddr34 = alloca i8, align 1 - %retparam40 = alloca i64, align 8 - %taddr41 = alloca %"char[]", align 8 - %vararg44 = alloca %"variant[]", align 8 - %varargslots45 = alloca [1 x %variant], align 16 - %taddr46 = alloca i8, align 1 + %retparam13 = alloca i64, align 8 + %varargslots14 = alloca [1 x %variant], align 16 + %taddr15 = alloca i8, align 1 + %retparam19 = alloca i64, align 8 + %varargslots20 = alloca [1 x %variant], align 16 + %taddr21 = alloca i8, align 1 store i32 0, ptr %set, align 4 - store %"char[]" { ptr @.str, i64 14 }, ptr %taddr, align 8 - %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - %2 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1) - store i8 %2, ptr %taddr1, align 1 - %3 = insertvalue %variant undef, ptr %taddr1, 0 - %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %4, ptr %5, align 16 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %6, align 8 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %9, align 8 - %10 = call i64 @std_io_printf(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %10, 0 + %0 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1) + store i8 %0, ptr %taddr, align 1 + %1 = insertvalue %variant undef, ptr %taddr, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %2, ptr %3, align 16 + %4 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 14, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %4, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -85,119 +62,67 @@ after_check: ; preds = %entry voiderr: ; preds = %after_check, %entry call void @"std_enumset$$test_Abc_EnumSet_add"(ptr %set, i32 0) - store %"char[]" { ptr @.str.1, i64 14 }, ptr %taddr5, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 0 - %lo6 = load ptr, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 1 - %hi7 = load i64, ptr %12, align 8 - %13 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1) - store i8 %13, ptr %taddr10, align 1 - %14 = insertvalue %variant undef, ptr %taddr10, 0 - %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %16 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0 - store %variant %15, ptr %16, align 16 - %17 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 1 - store i64 1, ptr %17, align 8 - %18 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 0 - store ptr %varargslots9, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 0 - %lo11 = load ptr, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 1 - %hi12 = load i64, ptr %20, align 8 - %21 = call i64 @std_io_printf(ptr %retparam4, ptr %lo6, i64 %hi7, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %21, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %5 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1) + store i8 %5, ptr %taddr3, align 1 + %6 = insertvalue %variant undef, ptr %taddr3, 0 + %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %8 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0 + store %variant %7, ptr %8, align 16 + %9 = call i64 @std_io_printf(ptr %retparam1, ptr @.str.1, i64 14, ptr %varargslots2, i64 1) + %not_err4 = icmp eq i64 %9, 0 + br i1 %not_err4, label %after_check5, label %voiderr6 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check5: ; preds = %voiderr + br label %voiderr6 -voiderr15: ; preds = %after_check14, %voiderr +voiderr6: ; preds = %after_check5, %voiderr call void @"std_enumset$$test_Abc_EnumSet_add"(ptr %set, i32 1) - store %"char[]" { ptr @.str.2, i64 14 }, ptr %taddr17, align 8 - %22 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 0 - %lo18 = load ptr, ptr %22, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 1 - %hi19 = load i64, ptr %23, align 8 - %24 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1) - store i8 %24, ptr %taddr22, align 1 - %25 = insertvalue %variant undef, ptr %taddr22, 0 - %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %27 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0 - store %variant %26, ptr %27, align 16 - %28 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 1 - store i64 1, ptr %28, align 8 - %29 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 0 - store ptr %varargslots21, ptr %29, align 8 - %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 0 - %lo23 = load ptr, ptr %30, align 8 - %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 1 - %hi24 = load i64, ptr %31, align 8 - %32 = call i64 @std_io_printf(ptr %retparam16, ptr %lo18, i64 %hi19, ptr %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %32, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 + %10 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1) + store i8 %10, ptr %taddr9, align 1 + %11 = insertvalue %variant undef, ptr %taddr9, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %13 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0 + store %variant %12, ptr %13, align 16 + %14 = call i64 @std_io_printf(ptr %retparam7, ptr @.str.2, i64 14, ptr %varargslots8, i64 1) + %not_err10 = icmp eq i64 %14, 0 + br i1 %not_err10, label %after_check11, label %voiderr12 -after_check26: ; preds = %voiderr15 - br label %voiderr27 +after_check11: ; preds = %voiderr6 + br label %voiderr12 -voiderr27: ; preds = %after_check26, %voiderr15 +voiderr12: ; preds = %after_check11, %voiderr6 store i32 0, ptr %set2, align 4 - %33 = load i32, ptr %set, align 4 - call void @"std_enumset$$test_Abc_EnumSet_add_all"(ptr %set2, i32 %33) - store %"char[]" { ptr @.str.3, i64 14 }, ptr %taddr29, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr29, i32 0, i32 0 - %lo30 = load ptr, ptr %34, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr29, i32 0, i32 1 - %hi31 = load i64, ptr %35, align 8 - %36 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set2, i32 1) - store i8 %36, ptr %taddr34, align 1 - %37 = insertvalue %variant undef, ptr %taddr34, 0 - %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %39 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0 - store %variant %38, ptr %39, align 16 - %40 = getelementptr inbounds %"variant[]", ptr %vararg32, i32 0, i32 1 - store i64 1, ptr %40, align 8 - %41 = getelementptr inbounds %"variant[]", ptr %vararg32, i32 0, i32 0 - store ptr %varargslots33, ptr %41, align 8 - %42 = getelementptr inbounds { ptr, i64 }, ptr %vararg32, i32 0, i32 0 - %lo35 = load ptr, ptr %42, align 8 - %43 = getelementptr inbounds { ptr, i64 }, ptr %vararg32, i32 0, i32 1 - %hi36 = load i64, ptr %43, align 8 - %44 = call i64 @std_io_printf(ptr %retparam28, ptr %lo30, i64 %hi31, ptr %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %44, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 + %15 = load i32, ptr %set, align 4 + call void @"std_enumset$$test_Abc_EnumSet_add_all"(ptr %set2, i32 %15) + %16 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set2, i32 1) + store i8 %16, ptr %taddr15, align 1 + %17 = insertvalue %variant undef, ptr %taddr15, 0 + %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %19 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0 + store %variant %18, ptr %19, align 16 + %20 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.3, i64 14, ptr %varargslots14, i64 1) + %not_err16 = icmp eq i64 %20, 0 + br i1 %not_err16, label %after_check17, label %voiderr18 -after_check38: ; preds = %voiderr27 - br label %voiderr39 +after_check17: ; preds = %voiderr12 + br label %voiderr18 -voiderr39: ; preds = %after_check38, %voiderr27 - %45 = load i32, ptr %set2, align 4 - call void @"std_enumset$$test_Abc_EnumSet_remove_all"(ptr %set, i32 %45) - store %"char[]" { ptr @.str.4, i64 14 }, ptr %taddr41, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 0 - %lo42 = load ptr, ptr %46, align 8 - %47 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 1 - %hi43 = load i64, ptr %47, align 8 - %48 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1) - store i8 %48, ptr %taddr46, align 1 - %49 = insertvalue %variant undef, ptr %taddr46, 0 - %50 = insertvalue %variant %49, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %51 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0 - store %variant %50, ptr %51, align 16 - %52 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 1 - store i64 1, ptr %52, align 8 - %53 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 0 - store ptr %varargslots45, ptr %53, align 8 - %54 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 0 - %lo47 = load ptr, ptr %54, align 8 - %55 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 1 - %hi48 = load i64, ptr %55, align 8 - %56 = call i64 @std_io_printf(ptr %retparam40, ptr %lo42, i64 %hi43, ptr %lo47, i64 %hi48) - %not_err49 = icmp eq i64 %56, 0 - br i1 %not_err49, label %after_check50, label %voiderr51 +voiderr18: ; preds = %after_check17, %voiderr12 + %21 = load i32, ptr %set2, align 4 + call void @"std_enumset$$test_Abc_EnumSet_remove_all"(ptr %set, i32 %21) + %22 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(ptr %set, i32 1) + store i8 %22, ptr %taddr21, align 1 + %23 = insertvalue %variant undef, ptr %taddr21, 0 + %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %25 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0 + store %variant %24, ptr %25, align 16 + %26 = call i64 @std_io_printf(ptr %retparam19, ptr @.str.4, i64 14, ptr %varargslots20, i64 1) + %not_err22 = icmp eq i64 %26, 0 + br i1 %not_err22, label %after_check23, label %voiderr24 -after_check50: ; preds = %voiderr39 - br label %voiderr51 +after_check23: ; preds = %voiderr18 + br label %voiderr24 -voiderr51: ; preds = %after_check50, %voiderr39 +voiderr24: ; preds = %after_check23, %voiderr18 ret void } diff --git a/test/test_suite2/generic/generic_num.c3t b/test/test_suite2/generic/generic_num.c3t index 557dfafd4..a7397e84e 100644 --- a/test/test_suite2/generic/generic_num.c3t +++ b/test/test_suite2/generic/generic_num.c3t @@ -22,31 +22,16 @@ fn void main() define void @test_main() #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 - store %"char[]" { ptr @.str, i64 2 }, ptr %taddr, align 8 - %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - %2 = call i32 @"hello$$int._123_x"(i32 4) - store i32 %2, ptr %taddr1, align 4 - %3 = insertvalue %variant undef, ptr %taddr1, 0 - %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %4, ptr %5, align 16 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %6, align 8 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %9, align 8 - %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %10, 0 + %taddr = alloca i32, align 4 + %0 = call i32 @"hello$$int._123_x"(i32 4) + store i32 %0, ptr %taddr, align 4 + %1 = insertvalue %variant undef, ptr %taddr, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %2, ptr %3, align 16 + %4 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %4, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry diff --git a/test/test_suite2/initializer_lists/fasta.c3t b/test/test_suite2/initializer_lists/fasta.c3t index cdbf0d1fc..d30a7c64b 100644 --- a/test/test_suite2/initializer_lists/fasta.c3t +++ b/test/test_suite2/initializer_lists/fasta.c3t @@ -343,23 +343,23 @@ 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 ({ ptr, i64 }, ptr @fasta_alu, i32 0, i32 1), 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 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 ({ ptr, i64 }, ptr @fasta_iub, i32 0, i32 1), 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 ({ ptr, i64 }, ptr @fasta_iub_p, i32 0, i32 1), 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) %8 = call i32 (ptr, ...) @printf(ptr @.str.16) %lo6 = load ptr, ptr @fasta_homosapiens, align 8 - %hi7 = load i64, ptr getelementptr inbounds ({ ptr, i64 }, ptr @fasta_homosapiens, i32 0, i32 1), 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 ({ ptr, i64 }, ptr @fasta_homosapiens_p, i32 0, i32 1), 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) diff --git a/test/test_suite2/literals/bin_literal.c3t b/test/test_suite2/literals/bin_literal.c3t index 731c923be..f25a8170c 100644 --- a/test/test_suite2/literals/bin_literal.c3t +++ b/test/test_suite2/literals/bin_literal.c3t @@ -22,20 +22,16 @@ entry: %c = alloca i32, align 4 %d = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 %z = alloca i8, align 1 - %retparam3 = alloca i64, align 8 - %taddr4 = alloca %"char[]", align 8 - %vararg7 = alloca %"variant[]", align 8 - %varargslots8 = alloca [3 x %variant], align 16 + %retparam1 = alloca i64, align 8 + %varargslots2 = alloca [3 x %variant], align 16 %i = alloca i8, align 1 %shift = alloca i8, align 1 - %taddr9 = alloca i8, align 1 - %i10 = alloca i8, align 1 - %shift11 = alloca i8, align 1 - %taddr12 = alloca i8, align 1 + %taddr = alloca i8, align 1 + %i3 = alloca i8, align 1 + %shift4 = alloca i8, align 1 + %taddr5 = alloca i8, align 1 store i32 123, ptr %a, align 4 store i32 -23, ptr %b, align 4 %0 = load i32, ptr %a, align 4 @@ -46,29 +42,16 @@ entry: %4 = load i32, ptr %b, align 4 %5 = call i32 @llvm.smax.i32(i32 %3, i32 %4) store i32 %5, ptr %d, align 4 - store %"char[]" { ptr @.str, i64 5 }, ptr %taddr, align 8 - %6 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %6, align 8 - %7 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %7, align 8 - %8 = insertvalue %variant undef, ptr %c, 0 - %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %9, ptr %10, align 16 - %11 = insertvalue %variant undef, ptr %d, 0 - %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %13 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %12, ptr %13, align 16 - %14 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 2, ptr %14, align 8 - %15 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %15, align 8 - %16 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo1 = load ptr, ptr %16, align 8 - %17 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi2 = load i64, ptr %17, align 8 - %18 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) - %not_err = icmp eq i64 %18, 0 + %6 = insertvalue %variant undef, ptr %c, 0 + %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %8 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %7, ptr %8, align 16 + %9 = insertvalue %variant undef, ptr %d, 0 + %10 = insertvalue %variant %9, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %11 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %10, ptr %11, align 16 + %12 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2) + %not_err = icmp eq i64 %12, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -76,54 +59,41 @@ after_check: ; preds = %entry voiderr: ; preds = %after_check, %entry store i8 -35, ptr %z, align 1 - store %"char[]" { ptr @.str.1, i64 8 }, ptr %taddr4, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %taddr4, i32 0, i32 0 - %lo5 = load ptr, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %taddr4, i32 0, i32 1 - %hi6 = load i64, ptr %20, align 8 - %21 = insertvalue %variant undef, ptr %z, 0 + %13 = insertvalue %variant undef, ptr %z, 0 + %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$char" to i64), 1 + %15 = getelementptr inbounds [3 x %variant], ptr %varargslots2, i64 0, i64 0 + store %variant %14, ptr %15, align 16 + %16 = load i8, ptr %z, align 1 + store i8 %16, ptr %i, align 1 + store i8 1, ptr %shift, align 1 + %17 = load i8, ptr %i, align 1 + %18 = load i8, ptr %i, align 1 + %19 = load i8, ptr %shift, align 1 + %20 = call i8 @llvm.fshr.i8(i8 %17, i8 %18, i8 %19) + store i8 %20, ptr %taddr, align 1 + %21 = insertvalue %variant undef, ptr %taddr, 0 %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$char" to i64), 1 - %23 = getelementptr inbounds [3 x %variant], ptr %varargslots8, i64 0, i64 0 + %23 = getelementptr inbounds [3 x %variant], ptr %varargslots2, i64 0, i64 1 store %variant %22, ptr %23, align 16 %24 = load i8, ptr %z, align 1 - store i8 %24, ptr %i, align 1 - store i8 1, ptr %shift, align 1 - %25 = load i8, ptr %i, align 1 - %26 = load i8, ptr %i, align 1 - %27 = load i8, ptr %shift, align 1 - %28 = call i8 @llvm.fshr.i8(i8 %25, i8 %26, i8 %27) - store i8 %28, ptr %taddr9, align 1 - %29 = insertvalue %variant undef, ptr %taddr9, 0 + store i8 %24, ptr %i3, align 1 + store i8 1, ptr %shift4, align 1 + %25 = load i8, ptr %i3, align 1 + %26 = load i8, ptr %i3, align 1 + %27 = load i8, ptr %shift4, align 1 + %28 = call i8 @llvm.fshl.i8(i8 %25, i8 %26, i8 %27) + store i8 %28, ptr %taddr5, align 1 + %29 = insertvalue %variant undef, ptr %taddr5, 0 %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$char" to i64), 1 - %31 = getelementptr inbounds [3 x %variant], ptr %varargslots8, i64 0, i64 1 + %31 = getelementptr inbounds [3 x %variant], ptr %varargslots2, i64 0, i64 2 store %variant %30, ptr %31, align 16 - %32 = load i8, ptr %z, align 1 - store i8 %32, ptr %i10, align 1 - store i8 1, ptr %shift11, align 1 - %33 = load i8, ptr %i10, align 1 - %34 = load i8, ptr %i10, align 1 - %35 = load i8, ptr %shift11, align 1 - %36 = call i8 @llvm.fshl.i8(i8 %33, i8 %34, i8 %35) - store i8 %36, ptr %taddr12, align 1 - %37 = insertvalue %variant undef, ptr %taddr12, 0 - %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"ct$char" to i64), 1 - %39 = getelementptr inbounds [3 x %variant], ptr %varargslots8, i64 0, i64 2 - store %variant %38, ptr %39, align 16 - %40 = getelementptr inbounds %"variant[]", ptr %vararg7, i32 0, i32 1 - store i64 3, ptr %40, align 8 - %41 = getelementptr inbounds %"variant[]", ptr %vararg7, i32 0, i32 0 - store ptr %varargslots8, ptr %41, align 8 - %42 = getelementptr inbounds { ptr, i64 }, ptr %vararg7, i32 0, i32 0 - %lo13 = load ptr, ptr %42, align 8 - %43 = getelementptr inbounds { ptr, i64 }, ptr %vararg7, i32 0, i32 1 - %hi14 = load i64, ptr %43, align 8 - %44 = call i64 @std_io_printfln(ptr %retparam3, ptr %lo5, i64 %hi6, ptr %lo13, i64 %hi14) - %not_err15 = icmp eq i64 %44, 0 - br i1 %not_err15, label %after_check16, label %voiderr17 + %32 = call i64 @std_io_printfln(ptr %retparam1, ptr @.str.1, i64 8, ptr %varargslots2, i64 3) + %not_err6 = icmp eq i64 %32, 0 + br i1 %not_err6, label %after_check7, label %voiderr8 -after_check16: ; preds = %voiderr - br label %voiderr17 +after_check7: ; preds = %voiderr + br label %voiderr8 -voiderr17: ; preds = %after_check16, %voiderr +voiderr8: ; preds = %after_check7, %voiderr ret void } diff --git a/test/test_suite2/macros/macro_typed_varargs.c3t b/test/test_suite2/macros/macro_typed_varargs.c3t index 11733b4e1..90031117d 100644 --- a/test/test_suite2/macros/macro_typed_varargs.c3t +++ b/test/test_suite2/macros/macro_typed_varargs.c3t @@ -36,22 +36,18 @@ entry: %.anon1 = alloca i64, align 8 %i = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %x4 = alloca %"variant[]", align 8 - %literal5 = alloca [4 x %variant], align 16 + %x2 = alloca %"variant[]", align 8 + %literal3 = alloca [4 x %variant], align 16 + %taddr = alloca i32, align 4 + %taddr4 = alloca i32, align 4 + %taddr5 = alloca i32, align 4 %taddr6 = alloca i32, align 4 - %taddr7 = alloca i32, align 4 - %taddr8 = alloca i32, align 4 - %taddr9 = alloca i32, align 4 - %.anon10 = alloca i64, align 8 - %.anon11 = alloca i64, align 8 - %i15 = alloca %variant, align 8 - %retparam17 = alloca i64, align 8 - %taddr18 = alloca %"char[]", align 8 - %vararg21 = alloca %"variant[]", align 8 - %varargslots22 = alloca [1 x %variant], align 16 + %.anon7 = alloca i64, align 8 + %.anon8 = alloca i64, align 8 + %i12 = alloca %variant, align 8 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [1 x %variant], align 16 %0 = getelementptr inbounds [4 x i32], ptr %literal, i64 0, i64 0 store i32 1, ptr %0, align 4 %1 = getelementptr inbounds [4 x i32], ptr %literal, i64 0, i64 1 @@ -82,110 +78,84 @@ loop.body: ; preds = %loop.cond %ptroffset = getelementptr inbounds i32, ptr %11, i64 %12 %13 = load i32, ptr %ptroffset, align 4 store i32 %13, ptr %i, align 4 - store %"char[]" { ptr @.str, i64 2 }, ptr %taddr, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %15, align 8 - %16 = insertvalue %variant undef, ptr %i, 0 - %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %18 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %17, ptr %18, align 16 - %19 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %19, align 8 - %20 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %21, align 8 - %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %22, align 8 - %23 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %23, 0 + %14 = insertvalue %variant undef, ptr %i, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %15, ptr %16, align 16 + %17 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %17, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %loop.body br label %voiderr voiderr: ; preds = %after_check, %loop.body - %24 = load i64, ptr %.anon1, align 8 - %add = add i64 %24, 1 + %18 = load i64, ptr %.anon1, align 8 + %add = add i64 %18, 1 store i64 %add, ptr %.anon1, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - %25 = getelementptr inbounds [4 x %variant], ptr %literal5, i64 0, i64 0 - store i32 1, ptr %taddr6, align 4 - %26 = insertvalue %variant undef, ptr %taddr6, 0 + %19 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 0 + store i32 1, ptr %taddr, align 4 + %20 = insertvalue %variant undef, ptr %taddr, 0 + %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$int" to i64), 1 + store %variant %21, ptr %19, align 8 + %22 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 1 + store i32 -1, ptr %taddr4, align 4 + %23 = insertvalue %variant undef, ptr %taddr4, 0 + %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"ct$int" to i64), 1 + store %variant %24, ptr %22, align 8 + %25 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 2 + store i32 3141, ptr %taddr5, align 4 + %26 = insertvalue %variant undef, ptr %taddr5, 0 %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$int" to i64), 1 store %variant %27, ptr %25, align 8 - %28 = getelementptr inbounds [4 x %variant], ptr %literal5, i64 0, i64 1 - store i32 -1, ptr %taddr7, align 4 - %29 = insertvalue %variant undef, ptr %taddr7, 0 + %28 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 3 + store i32 1000, ptr %taddr6, align 4 + %29 = insertvalue %variant undef, ptr %taddr6, 0 %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1 store %variant %30, ptr %28, align 8 - %31 = getelementptr inbounds [4 x %variant], ptr %literal5, i64 0, i64 2 - store i32 3141, ptr %taddr8, align 4 - %32 = insertvalue %variant undef, ptr %taddr8, 0 - %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$int" to i64), 1 - store %variant %33, ptr %31, align 8 - %34 = getelementptr inbounds [4 x %variant], ptr %literal5, i64 0, i64 3 - store i32 1000, ptr %taddr9, align 4 - %35 = insertvalue %variant undef, ptr %taddr9, 0 - %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$int" to i64), 1 - store %variant %36, ptr %34, align 8 - %37 = insertvalue %"variant[]" undef, ptr %literal5, 0 - %38 = insertvalue %"variant[]" %37, i64 4, 1 - store %"variant[]" %38, ptr %x4, align 8 - %39 = getelementptr inbounds %"variant[]", ptr %x4, i32 0, i32 1 - %40 = load i64, ptr %39, align 8 - store i64 %40, ptr %.anon10, align 8 - store i64 0, ptr %.anon11, align 8 - br label %loop.cond12 + %31 = insertvalue %"variant[]" undef, ptr %literal3, 0 + %32 = insertvalue %"variant[]" %31, i64 4, 1 + store %"variant[]" %32, ptr %x2, align 8 + %33 = getelementptr inbounds %"variant[]", ptr %x2, i32 0, i32 1 + %34 = load i64, ptr %33, align 8 + store i64 %34, ptr %.anon7, align 8 + store i64 0, ptr %.anon8, align 8 + br label %loop.cond9 -loop.cond12: ; preds = %voiderr27, %loop.exit - %41 = load i64, ptr %.anon11, align 8 - %42 = load i64, ptr %.anon10, align 8 - %lt13 = icmp ult i64 %41, %42 - br i1 %lt13, label %loop.body14, label %loop.exit29 +loop.cond9: ; preds = %voiderr18, %loop.exit + %35 = load i64, ptr %.anon8, align 8 + %36 = load i64, ptr %.anon7, align 8 + %lt10 = icmp ult i64 %35, %36 + br i1 %lt10, label %loop.body11, label %loop.exit20 -loop.body14: ; preds = %loop.cond12 - %43 = getelementptr inbounds %"variant[]", ptr %x4, i32 0, i32 0 - %44 = load ptr, ptr %43, align 8 - %45 = load i64, ptr %.anon11, align 8 - %ptroffset16 = getelementptr inbounds %variant, ptr %44, i64 %45 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %i15, ptr align 8 %ptroffset16, i32 16, i1 false) - store %"char[]" { ptr @.str.1, i64 2 }, ptr %taddr18, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 0 - %lo19 = load ptr, ptr %46, align 8 - %47 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 1 - %hi20 = load i64, ptr %47, align 8 - %48 = getelementptr inbounds %variant, ptr %i15, i32 0, i32 0 - %49 = load ptr, ptr %48, align 8 - %50 = insertvalue %variant undef, ptr %49, 0 - %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %52 = getelementptr inbounds [1 x %variant], ptr %varargslots22, i64 0, i64 0 - store %variant %51, ptr %52, align 16 - %53 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 1 - store i64 1, ptr %53, align 8 - %54 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 0 - store ptr %varargslots22, ptr %54, align 8 - %55 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 0 - %lo23 = load ptr, ptr %55, align 8 - %56 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 1 - %hi24 = load i64, ptr %56, align 8 - %57 = call i64 @std_io_printfln(ptr %retparam17, ptr %lo19, i64 %hi20, ptr %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %57, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 +loop.body11: ; preds = %loop.cond9 + %37 = getelementptr inbounds %"variant[]", ptr %x2, i32 0, i32 0 + %38 = load ptr, ptr %37, align 8 + %39 = load i64, ptr %.anon8, align 8 + %ptroffset13 = getelementptr inbounds %variant, ptr %38, i64 %39 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %i12, ptr align 8 %ptroffset13, i32 16, i1 false) + %40 = getelementptr inbounds %variant, ptr %i12, i32 0, i32 0 + %41 = load ptr, ptr %40, align 8 + %42 = insertvalue %variant undef, ptr %41, 0 + %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %44 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0 + store %variant %43, ptr %44, align 16 + %45 = call i64 @std_io_printfln(ptr %retparam14, ptr @.str.1, i64 2, ptr %varargslots15, i64 1) + %not_err16 = icmp eq i64 %45, 0 + br i1 %not_err16, label %after_check17, label %voiderr18 -after_check26: ; preds = %loop.body14 - br label %voiderr27 +after_check17: ; preds = %loop.body11 + br label %voiderr18 -voiderr27: ; preds = %after_check26, %loop.body14 - %58 = load i64, ptr %.anon11, align 8 - %add28 = add i64 %58, 1 - store i64 %add28, ptr %.anon11, align 8 - br label %loop.cond12 +voiderr18: ; preds = %after_check17, %loop.body11 + %46 = load i64, ptr %.anon8, align 8 + %add19 = add i64 %46, 1 + store i64 %add19, ptr %.anon8, align 8 + br label %loop.cond9 -loop.exit29: ; preds = %loop.cond12 +loop.exit20: ; preds = %loop.cond9 ret void } diff --git a/test/test_suite2/macros/macro_untyped_varargs_2.c3t b/test/test_suite2/macros/macro_untyped_varargs_2.c3t index 446092049..0caf223f7 100644 --- a/test/test_suite2/macros/macro_untyped_varargs_2.c3t +++ b/test/test_suite2/macros/macro_untyped_varargs_2.c3t @@ -63,30 +63,15 @@ fn void main() define i32 @test_ping(i32 %0) #0 { entry: %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %taddr1 = alloca i32, align 4 - store %"char[]" { ptr @.str, i64 8 }, ptr %taddr, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %1, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %2, align 8 - store i32 %0, ptr %taddr1, align 4 - %3 = insertvalue %variant undef, ptr %taddr1, 0 - %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %4, ptr %5, align 16 - %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %6, align 8 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %9, align 8 - %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %10, 0 + %taddr = alloca i32, align 4 + store i32 %0, ptr %taddr, align 4 + %1 = insertvalue %variant undef, ptr %taddr, 0 + %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %2, ptr %3, align 16 + %4 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %4, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry @@ -105,50 +90,32 @@ entry: %i = alloca i32, align 4 %j = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %retparam7 = alloca i64, align 8 - %taddr8 = alloca %"char[]", align 8 - %vararg11 = alloca %"variant[]", align 8 - %varargslots12 = alloca [1 x %variant], align 16 - %retparam18 = alloca i64, align 8 - %taddr19 = alloca %"char[]", align 8 - %vararg22 = alloca %"variant[]", align 8 - %varargslots23 = alloca [1 x %variant], align 16 - %retparam29 = alloca i64, align 8 - %taddr30 = alloca %"char[]", align 8 - %vararg33 = alloca %"variant[]", align 8 - %varargslots34 = alloca [1 x %variant], align 16 + %retparam5 = alloca i64, align 8 + %varargslots6 = alloca [1 x %variant], align 16 + %retparam10 = alloca i64, align 8 + %varargslots11 = alloca [1 x %variant], align 16 + %retparam15 = alloca i64, align 8 + %varargslots16 = alloca [1 x %variant], align 16 %x = alloca i32, align 4 - %retparam40 = alloca i64, align 8 - %taddr41 = alloca %"char[]", align 8 - %vararg44 = alloca %"variant[]", align 8 - %varargslots45 = alloca [1 x %variant], align 16 - %taddr46 = alloca ptr, align 8 - %x52 = alloca double, align 8 - %retparam53 = alloca i64, align 8 - %taddr54 = alloca %"char[]", align 8 - %vararg57 = alloca %"variant[]", align 8 - %varargslots58 = alloca [1 x %variant], align 16 - %taddr59 = alloca ptr, align 8 - %retparam65 = alloca i64, align 8 - %taddr66 = alloca %"char[]", align 8 - %vararg69 = alloca %"variant[]", align 8 - %varargslots70 = alloca [1 x %variant], align 16 - %taddr71 = alloca i32, align 4 - %x77 = alloca i32, align 4 + %retparam20 = alloca i64, align 8 + %varargslots21 = alloca [1 x %variant], align 16 + %taddr = alloca ptr, align 8 + %x25 = alloca double, align 8 + %retparam26 = alloca i64, align 8 + %varargslots27 = alloca [1 x %variant], align 16 + %taddr28 = alloca ptr, align 8 + %retparam32 = alloca i64, align 8 + %varargslots33 = alloca [1 x %variant], align 16 + %taddr34 = alloca i32, align 4 + %x38 = alloca i32, align 4 %y = alloca i32, align 4 %a = alloca i32, align 4 - %retparam78 = alloca i64, align 8 - %taddr79 = alloca %"char[]", align 8 - %vararg82 = alloca %"variant[]", align 8 - %varargslots83 = alloca [2 x %variant], align 16 - %a89 = alloca i32, align 4 - %retparam90 = alloca i64, align 8 - %taddr91 = alloca %"char[]", align 8 - %vararg94 = alloca %"variant[]", align 8 - %varargslots95 = alloca [2 x %variant], align 16 + %retparam39 = alloca i64, align 8 + %varargslots40 = alloca [2 x %variant], align 16 + %a44 = alloca i32, align 4 + %retparam45 = alloca i64, align 8 + %varargslots46 = alloca [2 x %variant], align 16 %0 = call i32 @test_ping(i32 -1) store i32 %0, ptr %.anon, align 4 %1 = call i32 @test_ping(i32 1) @@ -165,257 +132,140 @@ entry: %7 = call i32 @test_ping(i32 3141) %add4 = add i32 %6, %7 store i32 %add4, ptr %j, align 4 - store %"char[]" { ptr @.str.1, i64 2 }, ptr %taddr, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %9, align 8 - %10 = insertvalue %variant undef, ptr %.anon1, 0 - %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %12 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %11, ptr %12, align 16 - %13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %13, align 8 - %14 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo5 = load ptr, ptr %15, align 8 - %16 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi6 = load i64, ptr %16, align 8 - %17 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo5, i64 %hi6) - %not_err = icmp eq i64 %17, 0 + %8 = insertvalue %variant undef, ptr %.anon1, 0 + %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %10 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %9, ptr %10, align 16 + %11 = call i64 @std_io_printfln(ptr %retparam, ptr @.str.1, i64 2, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { ptr @.str.2, i64 2 }, ptr %taddr8, align 8 - %18 = getelementptr inbounds { ptr, i64 }, ptr %taddr8, i32 0, i32 0 - %lo9 = load ptr, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %taddr8, i32 0, i32 1 - %hi10 = load i64, ptr %19, align 8 - %20 = insertvalue %variant undef, ptr %.anon, 0 + %12 = insertvalue %variant undef, ptr %.anon, 0 + %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %14 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0 + store %variant %13, ptr %14, align 16 + %15 = call i64 @std_io_printfln(ptr %retparam5, ptr @.str.2, i64 2, ptr %varargslots6, i64 1) + %not_err7 = icmp eq i64 %15, 0 + br i1 %not_err7, label %after_check8, label %voiderr9 + +after_check8: ; preds = %voiderr + br label %voiderr9 + +voiderr9: ; preds = %after_check8, %voiderr + %16 = insertvalue %variant undef, ptr %.anon2, 0 + %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %18 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0 + store %variant %17, ptr %18, align 16 + %19 = call i64 @std_io_printfln(ptr %retparam10, ptr @.str.3, i64 2, ptr %varargslots11, i64 1) + %not_err12 = icmp eq i64 %19, 0 + br i1 %not_err12, label %after_check13, label %voiderr14 + +after_check13: ; preds = %voiderr9 + br label %voiderr14 + +voiderr14: ; preds = %after_check13, %voiderr9 + %20 = insertvalue %variant undef, ptr %.anon3, 0 %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %22 = getelementptr inbounds [1 x %variant], ptr %varargslots12, i64 0, i64 0 + %22 = getelementptr inbounds [1 x %variant], ptr %varargslots16, i64 0, i64 0 store %variant %21, ptr %22, align 16 - %23 = getelementptr inbounds %"variant[]", ptr %vararg11, i32 0, i32 1 - store i64 1, ptr %23, align 8 - %24 = getelementptr inbounds %"variant[]", ptr %vararg11, i32 0, i32 0 - store ptr %varargslots12, ptr %24, align 8 - %25 = getelementptr inbounds { ptr, i64 }, ptr %vararg11, i32 0, i32 0 - %lo13 = load ptr, ptr %25, align 8 - %26 = getelementptr inbounds { ptr, i64 }, ptr %vararg11, i32 0, i32 1 - %hi14 = load i64, ptr %26, align 8 - %27 = call i64 @std_io_printfln(ptr %retparam7, ptr %lo9, i64 %hi10, ptr %lo13, i64 %hi14) - %not_err15 = icmp eq i64 %27, 0 - br i1 %not_err15, label %after_check16, label %voiderr17 + %23 = call i64 @std_io_printfln(ptr %retparam15, ptr @.str.4, i64 2, ptr %varargslots16, i64 1) + %not_err17 = icmp eq i64 %23, 0 + br i1 %not_err17, label %after_check18, label %voiderr19 -after_check16: ; preds = %voiderr - br label %voiderr17 +after_check18: ; preds = %voiderr14 + br label %voiderr19 -voiderr17: ; preds = %after_check16, %voiderr - store %"char[]" { ptr @.str.3, i64 2 }, ptr %taddr19, align 8 - %28 = getelementptr inbounds { ptr, i64 }, ptr %taddr19, i32 0, i32 0 - %lo20 = load ptr, ptr %28, align 8 - %29 = getelementptr inbounds { ptr, i64 }, ptr %taddr19, i32 0, i32 1 - %hi21 = load i64, ptr %29, align 8 - %30 = insertvalue %variant undef, ptr %.anon2, 0 - %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %32 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0 - store %variant %31, ptr %32, align 16 - %33 = getelementptr inbounds %"variant[]", ptr %vararg22, i32 0, i32 1 - store i64 1, ptr %33, align 8 - %34 = getelementptr inbounds %"variant[]", ptr %vararg22, i32 0, i32 0 - store ptr %varargslots23, ptr %34, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %vararg22, i32 0, i32 0 - %lo24 = load ptr, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %vararg22, i32 0, i32 1 - %hi25 = load i64, ptr %36, align 8 - %37 = call i64 @std_io_printfln(ptr %retparam18, ptr %lo20, i64 %hi21, ptr %lo24, i64 %hi25) - %not_err26 = icmp eq i64 %37, 0 - br i1 %not_err26, label %after_check27, label %voiderr28 - -after_check27: ; preds = %voiderr17 - br label %voiderr28 - -voiderr28: ; preds = %after_check27, %voiderr17 - store %"char[]" { ptr @.str.4, i64 2 }, ptr %taddr30, align 8 - %38 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 0 - %lo31 = load ptr, ptr %38, align 8 - %39 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 1 - %hi32 = load i64, ptr %39, align 8 - %40 = insertvalue %variant undef, ptr %.anon3, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %42 = getelementptr inbounds [1 x %variant], ptr %varargslots34, i64 0, i64 0 - store %variant %41, ptr %42, align 16 - %43 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 1 - store i64 1, ptr %43, align 8 - %44 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 0 - store ptr %varargslots34, ptr %44, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 0 - %lo35 = load ptr, ptr %45, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 1 - %hi36 = load i64, ptr %46, align 8 - %47 = call i64 @std_io_printfln(ptr %retparam29, ptr %lo31, i64 %hi32, ptr %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %47, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 - -after_check38: ; preds = %voiderr28 - br label %voiderr39 - -voiderr39: ; preds = %after_check38, %voiderr28 +voiderr19: ; preds = %after_check18, %voiderr14 store i32 0, ptr %x, align 4 - store %"char[]" { ptr @.str.5, i64 2 }, ptr %taddr41, align 8 - %48 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 0 - %lo42 = load ptr, ptr %48, align 8 - %49 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 1 - %hi43 = load i64, ptr %49, align 8 - store ptr @.str.6, ptr %taddr46, align 8 - %50 = insertvalue %variant undef, ptr %taddr46, 0 - %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %52 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0 - store %variant %51, ptr %52, align 16 - %53 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 1 - store i64 1, ptr %53, align 8 - %54 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 0 - store ptr %varargslots45, ptr %54, align 8 - %55 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 0 - %lo47 = load ptr, ptr %55, align 8 - %56 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 1 - %hi48 = load i64, ptr %56, align 8 - %57 = call i64 @std_io_printfln(ptr %retparam40, ptr %lo42, i64 %hi43, ptr %lo47, i64 %hi48) - %not_err49 = icmp eq i64 %57, 0 - br i1 %not_err49, label %after_check50, label %voiderr51 + store ptr @.str.6, ptr %taddr, align 8 + %24 = insertvalue %variant undef, ptr %taddr, 0 + %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 + %26 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0 + store %variant %25, ptr %26, align 16 + %27 = call i64 @std_io_printfln(ptr %retparam20, ptr @.str.5, i64 2, ptr %varargslots21, i64 1) + %not_err22 = icmp eq i64 %27, 0 + br i1 %not_err22, label %after_check23, label %voiderr24 -after_check50: ; preds = %voiderr39 - br label %voiderr51 +after_check23: ; preds = %voiderr19 + br label %voiderr24 -voiderr51: ; preds = %after_check50, %voiderr39 - store double 0.000000e+00, ptr %x52, align 8 - store %"char[]" { ptr @.str.7, i64 2 }, ptr %taddr54, align 8 - %58 = getelementptr inbounds { ptr, i64 }, ptr %taddr54, i32 0, i32 0 - %lo55 = load ptr, ptr %58, align 8 - %59 = getelementptr inbounds { ptr, i64 }, ptr %taddr54, i32 0, i32 1 - %hi56 = load i64, ptr %59, align 8 - store ptr @.str.8, ptr %taddr59, align 8 - %60 = insertvalue %variant undef, ptr %taddr59, 0 - %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1 - %62 = getelementptr inbounds [1 x %variant], ptr %varargslots58, i64 0, i64 0 - store %variant %61, ptr %62, align 16 - %63 = getelementptr inbounds %"variant[]", ptr %vararg57, i32 0, i32 1 - store i64 1, ptr %63, align 8 - %64 = getelementptr inbounds %"variant[]", ptr %vararg57, i32 0, i32 0 - store ptr %varargslots58, ptr %64, align 8 - %65 = getelementptr inbounds { ptr, i64 }, ptr %vararg57, i32 0, i32 0 - %lo60 = load ptr, ptr %65, align 8 - %66 = getelementptr inbounds { ptr, i64 }, ptr %vararg57, i32 0, i32 1 - %hi61 = load i64, ptr %66, align 8 - %67 = call i64 @std_io_printfln(ptr %retparam53, ptr %lo55, i64 %hi56, ptr %lo60, i64 %hi61) - %not_err62 = icmp eq i64 %67, 0 - br i1 %not_err62, label %after_check63, label %voiderr64 +voiderr24: ; preds = %after_check23, %voiderr19 + store double 0.000000e+00, ptr %x25, align 8 + store ptr @.str.8, ptr %taddr28, align 8 + %28 = insertvalue %variant undef, ptr %taddr28, 0 + %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1 + %30 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0 + store %variant %29, ptr %30, align 16 + %31 = call i64 @std_io_printfln(ptr %retparam26, ptr @.str.7, i64 2, ptr %varargslots27, i64 1) + %not_err29 = icmp eq i64 %31, 0 + br i1 %not_err29, label %after_check30, label %voiderr31 -after_check63: ; preds = %voiderr51 - br label %voiderr64 +after_check30: ; preds = %voiderr24 + br label %voiderr31 -voiderr64: ; preds = %after_check63, %voiderr51 - store %"char[]" { ptr @.str.9, i64 2 }, ptr %taddr66, align 8 - %68 = getelementptr inbounds { ptr, i64 }, ptr %taddr66, i32 0, i32 0 - %lo67 = load ptr, ptr %68, align 8 - %69 = getelementptr inbounds { ptr, i64 }, ptr %taddr66, i32 0, i32 1 - %hi68 = load i64, ptr %69, align 8 - store i32 105, ptr %taddr71, align 4 - %70 = insertvalue %variant undef, ptr %taddr71, 0 - %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %72 = getelementptr inbounds [1 x %variant], ptr %varargslots70, i64 0, i64 0 - store %variant %71, ptr %72, align 16 - %73 = getelementptr inbounds %"variant[]", ptr %vararg69, i32 0, i32 1 - store i64 1, ptr %73, align 8 - %74 = getelementptr inbounds %"variant[]", ptr %vararg69, i32 0, i32 0 - store ptr %varargslots70, ptr %74, align 8 - %75 = getelementptr inbounds { ptr, i64 }, ptr %vararg69, i32 0, i32 0 - %lo72 = load ptr, ptr %75, align 8 - %76 = getelementptr inbounds { ptr, i64 }, ptr %vararg69, i32 0, i32 1 - %hi73 = load i64, ptr %76, align 8 - %77 = call i64 @std_io_printfln(ptr %retparam65, ptr %lo67, i64 %hi68, ptr %lo72, i64 %hi73) - %not_err74 = icmp eq i64 %77, 0 - br i1 %not_err74, label %after_check75, label %voiderr76 +voiderr31: ; preds = %after_check30, %voiderr24 + store i32 105, ptr %taddr34, align 4 + %32 = insertvalue %variant undef, ptr %taddr34, 0 + %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %34 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0 + store %variant %33, ptr %34, align 16 + %35 = call i64 @std_io_printfln(ptr %retparam32, ptr @.str.9, i64 2, ptr %varargslots33, i64 1) + %not_err35 = icmp eq i64 %35, 0 + br i1 %not_err35, label %after_check36, label %voiderr37 -after_check75: ; preds = %voiderr64 - br label %voiderr76 +after_check36: ; preds = %voiderr31 + br label %voiderr37 -voiderr76: ; preds = %after_check75, %voiderr64 - store i32 123, ptr %x77, align 4 +voiderr37: ; preds = %after_check36, %voiderr31 + store i32 123, ptr %x38, align 4 store i32 33, ptr %y, align 4 - %78 = load i32, ptr %x77, align 4 - store i32 %78, ptr %a, align 4 - %79 = load i32, ptr %y, align 4 - store i32 %79, ptr %x77, align 4 - %80 = load i32, ptr %a, align 4 - store i32 %80, ptr %y, align 4 - store %"char[]" { ptr @.str.10, i64 6 }, ptr %taddr79, align 8 - %81 = getelementptr inbounds { ptr, i64 }, ptr %taddr79, i32 0, i32 0 - %lo80 = load ptr, ptr %81, align 8 - %82 = getelementptr inbounds { ptr, i64 }, ptr %taddr79, i32 0, i32 1 - %hi81 = load i64, ptr %82, align 8 - %83 = insertvalue %variant undef, ptr %x77, 0 - %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %85 = getelementptr inbounds [2 x %variant], ptr %varargslots83, i64 0, i64 0 - store %variant %84, ptr %85, align 16 - %86 = insertvalue %variant undef, ptr %y, 0 - %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %88 = getelementptr inbounds [2 x %variant], ptr %varargslots83, i64 0, i64 1 - store %variant %87, ptr %88, align 16 - %89 = getelementptr inbounds %"variant[]", ptr %vararg82, i32 0, i32 1 - store i64 2, ptr %89, align 8 - %90 = getelementptr inbounds %"variant[]", ptr %vararg82, i32 0, i32 0 - store ptr %varargslots83, ptr %90, align 8 - %91 = getelementptr inbounds { ptr, i64 }, ptr %vararg82, i32 0, i32 0 - %lo84 = load ptr, ptr %91, align 8 - %92 = getelementptr inbounds { ptr, i64 }, ptr %vararg82, i32 0, i32 1 - %hi85 = load i64, ptr %92, align 8 - %93 = call i64 @std_io_printfln(ptr %retparam78, ptr %lo80, i64 %hi81, ptr %lo84, i64 %hi85) - %not_err86 = icmp eq i64 %93, 0 - br i1 %not_err86, label %after_check87, label %voiderr88 + %36 = load i32, ptr %x38, align 4 + store i32 %36, ptr %a, align 4 + %37 = load i32, ptr %y, align 4 + store i32 %37, ptr %x38, align 4 + %38 = load i32, ptr %a, align 4 + store i32 %38, ptr %y, align 4 + %39 = insertvalue %variant undef, ptr %x38, 0 + %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %41 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0 + store %variant %40, ptr %41, align 16 + %42 = insertvalue %variant undef, ptr %y, 0 + %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %44 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1 + store %variant %43, ptr %44, align 16 + %45 = call i64 @std_io_printfln(ptr %retparam39, ptr @.str.10, i64 6, ptr %varargslots40, i64 2) + %not_err41 = icmp eq i64 %45, 0 + br i1 %not_err41, label %after_check42, label %voiderr43 -after_check87: ; preds = %voiderr76 - br label %voiderr88 +after_check42: ; preds = %voiderr37 + br label %voiderr43 -voiderr88: ; preds = %after_check87, %voiderr76 - %94 = load i32, ptr %x77, align 4 - store i32 %94, ptr %a89, align 4 - %95 = load i32, ptr %y, align 4 - store i32 %95, ptr %x77, align 4 - %96 = load i32, ptr %a89, align 4 - store i32 %96, ptr %y, align 4 - store %"char[]" { ptr @.str.11, i64 6 }, ptr %taddr91, align 8 - %97 = getelementptr inbounds { ptr, i64 }, ptr %taddr91, i32 0, i32 0 - %lo92 = load ptr, ptr %97, align 8 - %98 = getelementptr inbounds { ptr, i64 }, ptr %taddr91, i32 0, i32 1 - %hi93 = load i64, ptr %98, align 8 - %99 = insertvalue %variant undef, ptr %x77, 0 - %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %101 = getelementptr inbounds [2 x %variant], ptr %varargslots95, i64 0, i64 0 - store %variant %100, ptr %101, align 16 - %102 = insertvalue %variant undef, ptr %y, 0 - %103 = insertvalue %variant %102, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %104 = getelementptr inbounds [2 x %variant], ptr %varargslots95, i64 0, i64 1 - store %variant %103, ptr %104, align 16 - %105 = getelementptr inbounds %"variant[]", ptr %vararg94, i32 0, i32 1 - store i64 2, ptr %105, align 8 - %106 = getelementptr inbounds %"variant[]", ptr %vararg94, i32 0, i32 0 - store ptr %varargslots95, ptr %106, align 8 - %107 = getelementptr inbounds { ptr, i64 }, ptr %vararg94, i32 0, i32 0 - %lo96 = load ptr, ptr %107, align 8 - %108 = getelementptr inbounds { ptr, i64 }, ptr %vararg94, i32 0, i32 1 - %hi97 = load i64, ptr %108, align 8 - %109 = call i64 @std_io_printfln(ptr %retparam90, ptr %lo92, i64 %hi93, ptr %lo96, i64 %hi97) - %not_err98 = icmp eq i64 %109, 0 - br i1 %not_err98, label %after_check99, label %voiderr100 +voiderr43: ; preds = %after_check42, %voiderr37 + %46 = load i32, ptr %x38, align 4 + store i32 %46, ptr %a44, align 4 + %47 = load i32, ptr %y, align 4 + store i32 %47, ptr %x38, align 4 + %48 = load i32, ptr %a44, align 4 + store i32 %48, ptr %y, align 4 + %49 = insertvalue %variant undef, ptr %x38, 0 + %50 = insertvalue %variant %49, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %51 = getelementptr inbounds [2 x %variant], ptr %varargslots46, i64 0, i64 0 + store %variant %50, ptr %51, align 16 + %52 = insertvalue %variant undef, ptr %y, 0 + %53 = insertvalue %variant %52, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %54 = getelementptr inbounds [2 x %variant], ptr %varargslots46, i64 0, i64 1 + store %variant %53, ptr %54, align 16 + %55 = call i64 @std_io_printfln(ptr %retparam45, ptr @.str.11, i64 6, ptr %varargslots46, i64 2) + %not_err47 = icmp eq i64 %55, 0 + br i1 %not_err47, label %after_check48, label %voiderr49 -after_check99: ; preds = %voiderr88 - br label %voiderr100 +after_check48: ; preds = %voiderr43 + br label %voiderr49 -voiderr100: ; preds = %after_check99, %voiderr88 +voiderr49: ; preds = %after_check48, %voiderr43 ret void -} +} \ No newline at end of file diff --git a/test/test_suite2/macros/macro_vasplat.c3t b/test/test_suite2/macros/macro_vasplat.c3t index be0822805..6dcb4eb79 100644 --- a/test/test_suite2/macros/macro_vasplat.c3t +++ b/test/test_suite2/macros/macro_vasplat.c3t @@ -69,97 +69,73 @@ entry: %i = alloca i64, align 8 %x = alloca i32, align 4 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 - %a3 = alloca [1 x i32], align 4 - %.anon4 = alloca i64, align 8 - %i8 = alloca i64, align 8 - %x9 = alloca i32, align 4 - %retparam10 = alloca i64, align 8 - %taddr11 = alloca %"char[]", align 8 - %vararg14 = alloca %"variant[]", align 8 - %varargslots15 = alloca [2 x %variant], align 16 - %a23 = alloca [4 x i32], align 16 - %.anon24 = alloca i64, align 8 - %i28 = alloca i64, align 8 - %x29 = alloca i32, align 4 - %retparam30 = alloca i64, align 8 - %taddr31 = alloca %"char[]", align 8 - %vararg34 = alloca %"variant[]", align 8 - %varargslots35 = alloca [2 x %variant], align 16 - %a43 = alloca [2 x i32], align 4 + %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 %variant], align 16 + %a15 = alloca [4 x i32], align 16 + %.anon16 = alloca i64, align 8 + %i20 = alloca i64, align 8 + %x21 = alloca i32, align 4 + %retparam22 = alloca i64, align 8 + %varargslots23 = alloca [2 x %variant], align 16 + %a29 = alloca [2 x i32], align 4 + %.anon30 = alloca i64, align 8 + %i34 = alloca i64, align 8 + %x35 = alloca i32, align 4 + %retparam36 = alloca i64, align 8 + %varargslots37 = alloca [2 x %variant], align 16 + %a43 = alloca [3 x i32], align 4 %.anon44 = alloca i64, align 8 %i48 = alloca i64, align 8 %x49 = alloca i32, align 4 %retparam50 = alloca i64, align 8 - %taddr51 = alloca %"char[]", align 8 - %vararg54 = alloca %"variant[]", align 8 - %varargslots55 = alloca [2 x %variant], align 16 - %a63 = alloca [3 x i32], align 4 - %.anon64 = alloca i64, align 8 - %i68 = alloca i64, align 8 - %x69 = alloca i32, align 4 - %retparam70 = alloca i64, align 8 - %taddr71 = alloca %"char[]", align 8 - %vararg74 = alloca %"variant[]", align 8 - %varargslots75 = alloca [2 x %variant], align 16 - %a83 = alloca [1 x i32], align 4 - %.anon84 = alloca i64, align 8 - %i88 = alloca i64, align 8 - %x89 = alloca i32, align 4 - %retparam90 = alloca i64, align 8 - %taddr91 = alloca %"char[]", align 8 - %vararg94 = alloca %"variant[]", align 8 - %varargslots95 = alloca [2 x %variant], align 16 - %a103 = alloca [2 x i32], align 4 - %.anon104 = alloca i64, align 8 - %i108 = alloca i64, align 8 - %x109 = alloca i32, align 4 - %retparam110 = alloca i64, align 8 - %taddr111 = alloca %"char[]", align 8 - %vararg114 = alloca %"variant[]", align 8 - %varargslots115 = alloca [2 x %variant], align 16 - %a123 = alloca [5 x i32], align 16 - %.anon124 = alloca i64, align 8 - %i128 = alloca i64, align 8 - %x129 = alloca i32, align 4 - %retparam130 = alloca i64, align 8 - %taddr131 = alloca %"char[]", align 8 - %vararg134 = alloca %"variant[]", align 8 - %varargslots135 = alloca [2 x %variant], align 16 - %a143 = alloca [8 x i32], align 16 - %.anon144 = alloca i64, align 8 - %i148 = alloca i64, align 8 - %x149 = alloca i32, align 4 - %retparam150 = alloca i64, align 8 - %taddr151 = alloca %"char[]", align 8 - %vararg154 = alloca %"variant[]", align 8 - %varargslots155 = alloca [2 x %variant], align 16 + %varargslots51 = alloca [2 x %variant], align 16 + %a57 = alloca [1 x i32], align 4 + %.anon58 = alloca i64, align 8 + %i62 = alloca i64, align 8 + %x63 = alloca i32, align 4 + %retparam64 = alloca i64, align 8 + %varargslots65 = alloca [2 x %variant], align 16 + %a71 = alloca [2 x i32], align 4 + %.anon72 = alloca i64, align 8 + %i76 = alloca i64, align 8 + %x77 = alloca i32, align 4 + %retparam78 = alloca i64, align 8 + %varargslots79 = alloca [2 x %variant], align 16 + %a85 = alloca [5 x i32], align 16 + %.anon86 = alloca i64, align 8 + %i90 = alloca i64, align 8 + %x91 = alloca i32, align 4 + %retparam92 = alloca i64, align 8 + %varargslots93 = alloca [2 x %variant], align 16 + %a99 = alloca [8 x i32], align 16 + %.anon100 = alloca i64, align 8 + %i104 = alloca i64, align 8 + %x105 = alloca i32, align 4 + %retparam106 = alloca i64, align 8 + %varargslots107 = alloca [2 x %variant], align 16 %b = alloca [7 x i32], align 16 - %.anon163 = alloca i64, align 8 - %i167 = alloca i64, align 8 - %x168 = alloca i32, align 4 - %retparam169 = alloca i64, align 8 - %taddr170 = alloca %"char[]", align 8 - %vararg173 = alloca %"variant[]", align 8 - %varargslots174 = alloca [2 x %variant], align 16 + %.anon113 = alloca i64, align 8 + %i117 = alloca i64, align 8 + %x118 = alloca i32, align 4 + %retparam119 = alloca i64, align 8 + %varargslots120 = alloca [2 x %variant], align 16 %c = alloca [8 x i32], align 16 - %.anon182 = alloca i64, align 8 - %i186 = alloca i64, align 8 - %x187 = alloca i32, align 4 - %retparam188 = alloca i64, align 8 - %taddr189 = alloca %"char[]", align 8 - %vararg192 = alloca %"variant[]", align 8 - %varargslots193 = alloca [2 x %variant], align 16 - %a201 = alloca [6 x i32], align 16 - %.anon202 = alloca i64, align 8 - %i206 = alloca i64, align 8 - %x207 = alloca i32, align 4 - %retparam208 = alloca i64, align 8 - %taddr209 = alloca %"char[]", align 8 - %vararg212 = alloca %"variant[]", align 8 - %varargslots213 = alloca [2 x %variant], align 16 + %.anon126 = alloca i64, align 8 + %i130 = alloca i64, align 8 + %x131 = alloca i32, align 4 + %retparam132 = alloca i64, align 8 + %varargslots133 = alloca [2 x %variant], align 16 + %a139 = alloca [6 x i32], align 16 + %.anon140 = alloca i64, align 8 + %i144 = alloca i64, align 8 + %x145 = alloca i32, align 4 + %retparam146 = alloca i64, align 8 + %varargslots147 = alloca [2 x %variant], align 16 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 @@ -176,602 +152,445 @@ loop.body: ; preds = %loop.cond %3 = getelementptr inbounds [3 x i32], ptr %a, i64 0, i64 %2 %4 = load i32, ptr %3, align 4 store i32 %4, ptr %x, align 4 - store %"char[]" { ptr @.str, i64 8 }, ptr %taddr, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %5, align 8 - %6 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %6, align 8 - %7 = insertvalue %variant undef, ptr %i, 0 - %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %8, ptr %9, align 16 - %10 = insertvalue %variant undef, ptr %x, 0 - %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %12 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %11, ptr %12, align 16 - %13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 2, ptr %13, align 8 - %14 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo1 = load ptr, ptr %15, align 8 - %16 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi2 = load i64, ptr %16, align 8 - %17 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) - %not_err = icmp eq i64 %17, 0 + %5 = insertvalue %variant undef, ptr %i, 0 + %6 = insertvalue %variant %5, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %7 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %6, ptr %7, align 16 + %8 = insertvalue %variant undef, ptr %x, 0 + %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %9, ptr %10, align 16 + %11 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 2) + %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %loop.body br label %voiderr voiderr: ; preds = %after_check, %loop.body - %18 = load i64, ptr %.anon, align 8 - %add = add i64 %18, 1 + %12 = load i64, ptr %.anon, align 8 + %add = add i64 %12, 1 store i64 %add, ptr %.anon, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a3, ptr align 4 @.__const.1, i32 4, i1 false) - store i64 0, ptr %.anon4, align 8 - br label %loop.cond5 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a1, ptr align 4 @.__const.1, i32 4, i1 false) + store i64 0, ptr %.anon2, align 8 + br label %loop.cond3 -loop.cond5: ; preds = %voiderr20, %loop.exit - %19 = load i64, ptr %.anon4, align 8 - %gt6 = icmp ugt i64 1, %19 - br i1 %gt6, label %loop.body7, label %loop.exit22 +loop.cond3: ; preds = %voiderr12, %loop.exit + %13 = load i64, ptr %.anon2, align 8 + %gt4 = icmp ugt i64 1, %13 + br i1 %gt4, label %loop.body5, label %loop.exit14 -loop.body7: ; preds = %loop.cond5 - %20 = load i64, ptr %.anon4, align 8 - store i64 %20, ptr %i8, align 8 - %21 = load i64, ptr %.anon4, align 8 - %22 = getelementptr inbounds [1 x i32], ptr %a3, i64 0, i64 %21 - %23 = load i32, ptr %22, align 4 - store i32 %23, ptr %x9, align 4 - store %"char[]" { ptr @.str.2, i64 8 }, ptr %taddr11, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr11, i32 0, i32 0 - %lo12 = load ptr, ptr %24, align 8 - %25 = getelementptr inbounds { ptr, i64 }, ptr %taddr11, i32 0, i32 1 - %hi13 = load i64, ptr %25, align 8 - %26 = insertvalue %variant undef, ptr %i8, 0 - %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %28 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 0 - store %variant %27, ptr %28, align 16 - %29 = insertvalue %variant undef, ptr %x9, 0 - %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %31 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 1 - store %variant %30, ptr %31, align 16 - %32 = getelementptr inbounds %"variant[]", ptr %vararg14, i32 0, i32 1 - store i64 2, ptr %32, align 8 - %33 = getelementptr inbounds %"variant[]", ptr %vararg14, i32 0, i32 0 - store ptr %varargslots15, ptr %33, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %vararg14, i32 0, i32 0 - %lo16 = load ptr, ptr %34, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %vararg14, i32 0, i32 1 - %hi17 = load i64, ptr %35, align 8 - %36 = call i64 @std_io_printfln(ptr %retparam10, ptr %lo12, i64 %hi13, ptr %lo16, i64 %hi17) - %not_err18 = icmp eq i64 %36, 0 - br i1 %not_err18, label %after_check19, label %voiderr20 +loop.body5: ; preds = %loop.cond3 + %14 = load i64, ptr %.anon2, align 8 + store i64 %14, ptr %i6, align 8 + %15 = load i64, ptr %.anon2, align 8 + %16 = getelementptr inbounds [1 x i32], ptr %a1, i64 0, i64 %15 + %17 = load i32, ptr %16, align 4 + store i32 %17, ptr %x7, align 4 + %18 = insertvalue %variant undef, ptr %i6, 0 + %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %20 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0 + store %variant %19, ptr %20, align 16 + %21 = insertvalue %variant undef, ptr %x7, 0 + %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %23 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1 + store %variant %22, ptr %23, align 16 + %24 = call i64 @std_io_printfln(ptr %retparam8, ptr @.str.2, i64 8, ptr %varargslots9, i64 2) + %not_err10 = icmp eq i64 %24, 0 + br i1 %not_err10, label %after_check11, label %voiderr12 -after_check19: ; preds = %loop.body7 - br label %voiderr20 +after_check11: ; preds = %loop.body5 + br label %voiderr12 -voiderr20: ; preds = %after_check19, %loop.body7 - %37 = load i64, ptr %.anon4, align 8 - %add21 = add i64 %37, 1 - store i64 %add21, ptr %.anon4, align 8 - br label %loop.cond5 +voiderr12: ; preds = %after_check11, %loop.body5 + %25 = load i64, ptr %.anon2, align 8 + %add13 = add i64 %25, 1 + store i64 %add13, ptr %.anon2, align 8 + br label %loop.cond3 -loop.exit22: ; preds = %loop.cond5 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a23, ptr align 16 @.__const.3, i32 16, i1 false) - store i64 0, ptr %.anon24, align 8 - br label %loop.cond25 +loop.exit14: ; preds = %loop.cond3 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a15, ptr align 16 @.__const.3, i32 16, i1 false) + store i64 0, ptr %.anon16, align 8 + br label %loop.cond17 -loop.cond25: ; preds = %voiderr40, %loop.exit22 - %38 = load i64, ptr %.anon24, align 8 - %gt26 = icmp ugt i64 4, %38 - br i1 %gt26, label %loop.body27, label %loop.exit42 +loop.cond17: ; preds = %voiderr26, %loop.exit14 + %26 = load i64, ptr %.anon16, align 8 + %gt18 = icmp ugt i64 4, %26 + br i1 %gt18, label %loop.body19, label %loop.exit28 -loop.body27: ; preds = %loop.cond25 - %39 = load i64, ptr %.anon24, align 8 - store i64 %39, ptr %i28, align 8 - %40 = load i64, ptr %.anon24, align 8 - %41 = getelementptr inbounds [4 x i32], ptr %a23, i64 0, i64 %40 - %42 = load i32, ptr %41, align 4 - store i32 %42, ptr %x29, align 4 - store %"char[]" { ptr @.str.4, i64 6 }, ptr %taddr31, align 8 - %43 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 0 - %lo32 = load ptr, ptr %43, align 8 - %44 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 1 - %hi33 = load i64, ptr %44, align 8 - %45 = insertvalue %variant undef, ptr %i28, 0 - %46 = insertvalue %variant %45, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %47 = getelementptr inbounds [2 x %variant], ptr %varargslots35, i64 0, i64 0 - store %variant %46, ptr %47, align 16 - %48 = insertvalue %variant undef, ptr %x29, 0 - %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %50 = getelementptr inbounds [2 x %variant], ptr %varargslots35, i64 0, i64 1 - store %variant %49, ptr %50, align 16 - %51 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 1 - store i64 2, ptr %51, align 8 - %52 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 0 - store ptr %varargslots35, ptr %52, align 8 - %53 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 0 - %lo36 = load ptr, ptr %53, align 8 - %54 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 1 - %hi37 = load i64, ptr %54, align 8 - %55 = call i64 @std_io_printfln(ptr %retparam30, ptr %lo32, i64 %hi33, ptr %lo36, i64 %hi37) - %not_err38 = icmp eq i64 %55, 0 +loop.body19: ; preds = %loop.cond17 + %27 = load i64, ptr %.anon16, align 8 + store i64 %27, ptr %i20, align 8 + %28 = load i64, ptr %.anon16, align 8 + %29 = getelementptr inbounds [4 x i32], ptr %a15, i64 0, i64 %28 + %30 = load i32, ptr %29, align 4 + store i32 %30, ptr %x21, align 4 + %31 = insertvalue %variant undef, ptr %i20, 0 + %32 = insertvalue %variant %31, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %33 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 0 + store %variant %32, ptr %33, align 16 + %34 = insertvalue %variant undef, ptr %x21, 0 + %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %36 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 1 + store %variant %35, ptr %36, align 16 + %37 = call i64 @std_io_printfln(ptr %retparam22, ptr @.str.4, i64 6, ptr %varargslots23, i64 2) + %not_err24 = icmp eq i64 %37, 0 + br i1 %not_err24, label %after_check25, label %voiderr26 + +after_check25: ; preds = %loop.body19 + br label %voiderr26 + +voiderr26: ; preds = %after_check25, %loop.body19 + %38 = load i64, ptr %.anon16, align 8 + %add27 = add i64 %38, 1 + store i64 %add27, ptr %.anon16, align 8 + br label %loop.cond17 + +loop.exit28: ; preds = %loop.cond17 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a29, ptr align 4 @.__const.5, i32 8, i1 false) + store i64 0, ptr %.anon30, align 8 + br label %loop.cond31 + +loop.cond31: ; preds = %voiderr40, %loop.exit28 + %39 = load i64, ptr %.anon30, align 8 + %gt32 = icmp ugt i64 2, %39 + br i1 %gt32, label %loop.body33, label %loop.exit42 + +loop.body33: ; preds = %loop.cond31 + %40 = load i64, ptr %.anon30, align 8 + store i64 %40, ptr %i34, align 8 + %41 = load i64, ptr %.anon30, align 8 + %42 = getelementptr inbounds [2 x i32], ptr %a29, i64 0, i64 %41 + %43 = load i32, ptr %42, align 4 + store i32 %43, ptr %x35, align 4 + %44 = insertvalue %variant undef, ptr %i34, 0 + %45 = insertvalue %variant %44, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %46 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 0 + store %variant %45, ptr %46, align 16 + %47 = insertvalue %variant undef, ptr %x35, 0 + %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %49 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 1 + store %variant %48, ptr %49, align 16 + %50 = call i64 @std_io_printfln(ptr %retparam36, ptr @.str.6, i64 6, ptr %varargslots37, i64 2) + %not_err38 = icmp eq i64 %50, 0 br i1 %not_err38, label %after_check39, label %voiderr40 -after_check39: ; preds = %loop.body27 +after_check39: ; preds = %loop.body33 br label %voiderr40 -voiderr40: ; preds = %after_check39, %loop.body27 - %56 = load i64, ptr %.anon24, align 8 - %add41 = add i64 %56, 1 - store i64 %add41, ptr %.anon24, align 8 - br label %loop.cond25 +voiderr40: ; preds = %after_check39, %loop.body33 + %51 = load i64, ptr %.anon30, align 8 + %add41 = add i64 %51, 1 + store i64 %add41, ptr %.anon30, align 8 + br label %loop.cond31 -loop.exit42: ; preds = %loop.cond25 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a43, ptr align 4 @.__const.5, i32 8, i1 false) +loop.exit42: ; preds = %loop.cond31 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a43, ptr align 4 @.__const.7, i32 12, i1 false) store i64 0, ptr %.anon44, align 8 br label %loop.cond45 -loop.cond45: ; preds = %voiderr60, %loop.exit42 - %57 = load i64, ptr %.anon44, align 8 - %gt46 = icmp ugt i64 2, %57 - br i1 %gt46, label %loop.body47, label %loop.exit62 +loop.cond45: ; preds = %voiderr54, %loop.exit42 + %52 = load i64, ptr %.anon44, align 8 + %gt46 = icmp ugt i64 3, %52 + br i1 %gt46, label %loop.body47, label %loop.exit56 loop.body47: ; preds = %loop.cond45 - %58 = load i64, ptr %.anon44, align 8 - store i64 %58, ptr %i48, align 8 - %59 = load i64, ptr %.anon44, align 8 - %60 = getelementptr inbounds [2 x i32], ptr %a43, i64 0, i64 %59 - %61 = load i32, ptr %60, align 4 - store i32 %61, ptr %x49, align 4 - store %"char[]" { ptr @.str.6, i64 6 }, ptr %taddr51, align 8 - %62 = getelementptr inbounds { ptr, i64 }, ptr %taddr51, i32 0, i32 0 - %lo52 = load ptr, ptr %62, align 8 - %63 = getelementptr inbounds { ptr, i64 }, ptr %taddr51, i32 0, i32 1 - %hi53 = load i64, ptr %63, align 8 - %64 = insertvalue %variant undef, ptr %i48, 0 - %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %66 = getelementptr inbounds [2 x %variant], ptr %varargslots55, i64 0, i64 0 - store %variant %65, ptr %66, align 16 - %67 = insertvalue %variant undef, ptr %x49, 0 - %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %69 = getelementptr inbounds [2 x %variant], ptr %varargslots55, i64 0, i64 1 - store %variant %68, ptr %69, align 16 - %70 = getelementptr inbounds %"variant[]", ptr %vararg54, i32 0, i32 1 - store i64 2, ptr %70, align 8 - %71 = getelementptr inbounds %"variant[]", ptr %vararg54, i32 0, i32 0 - store ptr %varargslots55, ptr %71, align 8 - %72 = getelementptr inbounds { ptr, i64 }, ptr %vararg54, i32 0, i32 0 - %lo56 = load ptr, ptr %72, align 8 - %73 = getelementptr inbounds { ptr, i64 }, ptr %vararg54, i32 0, i32 1 - %hi57 = load i64, ptr %73, align 8 - %74 = call i64 @std_io_printfln(ptr %retparam50, ptr %lo52, i64 %hi53, ptr %lo56, i64 %hi57) - %not_err58 = icmp eq i64 %74, 0 - br i1 %not_err58, label %after_check59, label %voiderr60 + %53 = load i64, ptr %.anon44, align 8 + store i64 %53, ptr %i48, align 8 + %54 = load i64, ptr %.anon44, align 8 + %55 = getelementptr inbounds [3 x i32], ptr %a43, i64 0, i64 %54 + %56 = load i32, ptr %55, align 4 + store i32 %56, ptr %x49, align 4 + %57 = insertvalue %variant undef, ptr %i48, 0 + %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %59 = getelementptr inbounds [2 x %variant], ptr %varargslots51, i64 0, i64 0 + store %variant %58, ptr %59, align 16 + %60 = insertvalue %variant undef, ptr %x49, 0 + %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %62 = getelementptr inbounds [2 x %variant], ptr %varargslots51, i64 0, i64 1 + store %variant %61, ptr %62, align 16 + %63 = call i64 @std_io_printfln(ptr %retparam50, ptr @.str.8, i64 8, ptr %varargslots51, i64 2) + %not_err52 = icmp eq i64 %63, 0 + br i1 %not_err52, label %after_check53, label %voiderr54 -after_check59: ; preds = %loop.body47 - br label %voiderr60 +after_check53: ; preds = %loop.body47 + br label %voiderr54 -voiderr60: ; preds = %after_check59, %loop.body47 - %75 = load i64, ptr %.anon44, align 8 - %add61 = add i64 %75, 1 - store i64 %add61, ptr %.anon44, align 8 +voiderr54: ; preds = %after_check53, %loop.body47 + %64 = load i64, ptr %.anon44, align 8 + %add55 = add i64 %64, 1 + store i64 %add55, ptr %.anon44, align 8 br label %loop.cond45 -loop.exit62: ; preds = %loop.cond45 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a63, ptr align 4 @.__const.7, i32 12, i1 false) - store i64 0, ptr %.anon64, align 8 - br label %loop.cond65 +loop.exit56: ; preds = %loop.cond45 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a57, ptr align 4 @.__const.9, i32 4, i1 false) + store i64 0, ptr %.anon58, align 8 + br label %loop.cond59 -loop.cond65: ; preds = %voiderr80, %loop.exit62 - %76 = load i64, ptr %.anon64, align 8 - %gt66 = icmp ugt i64 3, %76 - br i1 %gt66, label %loop.body67, label %loop.exit82 +loop.cond59: ; preds = %voiderr68, %loop.exit56 + %65 = load i64, ptr %.anon58, align 8 + %gt60 = icmp ugt i64 1, %65 + br i1 %gt60, label %loop.body61, label %loop.exit70 -loop.body67: ; preds = %loop.cond65 - %77 = load i64, ptr %.anon64, align 8 - store i64 %77, ptr %i68, align 8 - %78 = load i64, ptr %.anon64, align 8 - %79 = getelementptr inbounds [3 x i32], ptr %a63, i64 0, i64 %78 - %80 = load i32, ptr %79, align 4 - store i32 %80, ptr %x69, align 4 - store %"char[]" { ptr @.str.8, i64 8 }, ptr %taddr71, align 8 - %81 = getelementptr inbounds { ptr, i64 }, ptr %taddr71, i32 0, i32 0 - %lo72 = load ptr, ptr %81, align 8 - %82 = getelementptr inbounds { ptr, i64 }, ptr %taddr71, i32 0, i32 1 - %hi73 = load i64, ptr %82, align 8 - %83 = insertvalue %variant undef, ptr %i68, 0 +loop.body61: ; preds = %loop.cond59 + %66 = load i64, ptr %.anon58, align 8 + store i64 %66, ptr %i62, align 8 + %67 = load i64, ptr %.anon58, align 8 + %68 = getelementptr inbounds [1 x i32], ptr %a57, i64 0, i64 %67 + %69 = load i32, ptr %68, align 4 + store i32 %69, ptr %x63, align 4 + %70 = insertvalue %variant undef, ptr %i62, 0 + %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %72 = getelementptr inbounds [2 x %variant], ptr %varargslots65, i64 0, i64 0 + store %variant %71, ptr %72, align 16 + %73 = insertvalue %variant undef, ptr %x63, 0 + %74 = insertvalue %variant %73, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %75 = getelementptr inbounds [2 x %variant], ptr %varargslots65, i64 0, i64 1 + store %variant %74, ptr %75, align 16 + %76 = call i64 @std_io_printfln(ptr %retparam64, ptr @.str.10, i64 8, ptr %varargslots65, i64 2) + %not_err66 = icmp eq i64 %76, 0 + br i1 %not_err66, label %after_check67, label %voiderr68 + +after_check67: ; preds = %loop.body61 + br label %voiderr68 + +voiderr68: ; preds = %after_check67, %loop.body61 + %77 = load i64, ptr %.anon58, align 8 + %add69 = add i64 %77, 1 + store i64 %add69, ptr %.anon58, align 8 + br label %loop.cond59 + +loop.exit70: ; preds = %loop.cond59 + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a71, ptr align 4 @.__const.11, i32 8, i1 false) + store i64 0, ptr %.anon72, align 8 + br label %loop.cond73 + +loop.cond73: ; preds = %voiderr82, %loop.exit70 + %78 = load i64, ptr %.anon72, align 8 + %gt74 = icmp ugt i64 2, %78 + br i1 %gt74, label %loop.body75, label %loop.exit84 + +loop.body75: ; preds = %loop.cond73 + %79 = load i64, ptr %.anon72, align 8 + store i64 %79, ptr %i76, align 8 + %80 = load i64, ptr %.anon72, align 8 + %81 = getelementptr inbounds [2 x i32], ptr %a71, i64 0, i64 %80 + %82 = load i32, ptr %81, align 4 + store i32 %82, ptr %x77, align 4 + %83 = insertvalue %variant undef, ptr %i76, 0 %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %85 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 0 + %85 = getelementptr inbounds [2 x %variant], ptr %varargslots79, i64 0, i64 0 store %variant %84, ptr %85, align 16 - %86 = insertvalue %variant undef, ptr %x69, 0 + %86 = insertvalue %variant undef, ptr %x77, 0 %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %88 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 1 + %88 = getelementptr inbounds [2 x %variant], ptr %varargslots79, i64 0, i64 1 store %variant %87, ptr %88, align 16 - %89 = getelementptr inbounds %"variant[]", ptr %vararg74, i32 0, i32 1 - store i64 2, ptr %89, align 8 - %90 = getelementptr inbounds %"variant[]", ptr %vararg74, i32 0, i32 0 - store ptr %varargslots75, ptr %90, align 8 - %91 = getelementptr inbounds { ptr, i64 }, ptr %vararg74, i32 0, i32 0 - %lo76 = load ptr, ptr %91, align 8 - %92 = getelementptr inbounds { ptr, i64 }, ptr %vararg74, i32 0, i32 1 - %hi77 = load i64, ptr %92, align 8 - %93 = call i64 @std_io_printfln(ptr %retparam70, ptr %lo72, i64 %hi73, ptr %lo76, i64 %hi77) - %not_err78 = icmp eq i64 %93, 0 - br i1 %not_err78, label %after_check79, label %voiderr80 + %89 = call i64 @std_io_printfln(ptr %retparam78, ptr @.str.12, i64 8, ptr %varargslots79, i64 2) + %not_err80 = icmp eq i64 %89, 0 + br i1 %not_err80, label %after_check81, label %voiderr82 -after_check79: ; preds = %loop.body67 - br label %voiderr80 +after_check81: ; preds = %loop.body75 + br label %voiderr82 -voiderr80: ; preds = %after_check79, %loop.body67 - %94 = load i64, ptr %.anon64, align 8 - %add81 = add i64 %94, 1 - store i64 %add81, ptr %.anon64, align 8 - br label %loop.cond65 +voiderr82: ; preds = %after_check81, %loop.body75 + %90 = load i64, ptr %.anon72, align 8 + %add83 = add i64 %90, 1 + store i64 %add83, ptr %.anon72, align 8 + br label %loop.cond73 -loop.exit82: ; preds = %loop.cond65 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a83, ptr align 4 @.__const.9, i32 4, i1 false) - store i64 0, ptr %.anon84, align 8 - br label %loop.cond85 +loop.exit84: ; preds = %loop.cond73 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a85, ptr align 16 @.__const.13, i32 20, i1 false) + store i64 0, ptr %.anon86, align 8 + br label %loop.cond87 -loop.cond85: ; preds = %voiderr100, %loop.exit82 - %95 = load i64, ptr %.anon84, align 8 - %gt86 = icmp ugt i64 1, %95 - br i1 %gt86, label %loop.body87, label %loop.exit102 +loop.cond87: ; preds = %voiderr96, %loop.exit84 + %91 = load i64, ptr %.anon86, align 8 + %gt88 = icmp ugt i64 5, %91 + br i1 %gt88, label %loop.body89, label %loop.exit98 -loop.body87: ; preds = %loop.cond85 - %96 = load i64, ptr %.anon84, align 8 - store i64 %96, ptr %i88, align 8 - %97 = load i64, ptr %.anon84, align 8 - %98 = getelementptr inbounds [1 x i32], ptr %a83, i64 0, i64 %97 - %99 = load i32, ptr %98, align 4 - store i32 %99, ptr %x89, align 4 - store %"char[]" { ptr @.str.10, i64 8 }, ptr %taddr91, align 8 - %100 = getelementptr inbounds { ptr, i64 }, ptr %taddr91, i32 0, i32 0 - %lo92 = load ptr, ptr %100, align 8 - %101 = getelementptr inbounds { ptr, i64 }, ptr %taddr91, i32 0, i32 1 - %hi93 = load i64, ptr %101, align 8 - %102 = insertvalue %variant undef, ptr %i88, 0 - %103 = insertvalue %variant %102, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %104 = getelementptr inbounds [2 x %variant], ptr %varargslots95, i64 0, i64 0 - store %variant %103, ptr %104, align 16 - %105 = insertvalue %variant undef, ptr %x89, 0 - %106 = insertvalue %variant %105, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %107 = getelementptr inbounds [2 x %variant], ptr %varargslots95, i64 0, i64 1 - store %variant %106, ptr %107, align 16 - %108 = getelementptr inbounds %"variant[]", ptr %vararg94, i32 0, i32 1 - store i64 2, ptr %108, align 8 - %109 = getelementptr inbounds %"variant[]", ptr %vararg94, i32 0, i32 0 - store ptr %varargslots95, ptr %109, align 8 - %110 = getelementptr inbounds { ptr, i64 }, ptr %vararg94, i32 0, i32 0 - %lo96 = load ptr, ptr %110, align 8 - %111 = getelementptr inbounds { ptr, i64 }, ptr %vararg94, i32 0, i32 1 - %hi97 = load i64, ptr %111, align 8 - %112 = call i64 @std_io_printfln(ptr %retparam90, ptr %lo92, i64 %hi93, ptr %lo96, i64 %hi97) - %not_err98 = icmp eq i64 %112, 0 - br i1 %not_err98, label %after_check99, label %voiderr100 +loop.body89: ; preds = %loop.cond87 + %92 = load i64, ptr %.anon86, align 8 + store i64 %92, ptr %i90, align 8 + %93 = load i64, ptr %.anon86, align 8 + %94 = getelementptr inbounds [5 x i32], ptr %a85, i64 0, i64 %93 + %95 = load i32, ptr %94, align 4 + store i32 %95, ptr %x91, align 4 + %96 = insertvalue %variant undef, ptr %i90, 0 + %97 = insertvalue %variant %96, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %98 = getelementptr inbounds [2 x %variant], ptr %varargslots93, i64 0, i64 0 + store %variant %97, ptr %98, align 16 + %99 = insertvalue %variant undef, ptr %x91, 0 + %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %101 = getelementptr inbounds [2 x %variant], ptr %varargslots93, i64 0, i64 1 + store %variant %100, ptr %101, align 16 + %102 = call i64 @std_io_printfln(ptr %retparam92, ptr @.str.14, i64 8, ptr %varargslots93, i64 2) + %not_err94 = icmp eq i64 %102, 0 + br i1 %not_err94, label %after_check95, label %voiderr96 -after_check99: ; preds = %loop.body87 - br label %voiderr100 +after_check95: ; preds = %loop.body89 + br label %voiderr96 -voiderr100: ; preds = %after_check99, %loop.body87 - %113 = load i64, ptr %.anon84, align 8 - %add101 = add i64 %113, 1 - store i64 %add101, ptr %.anon84, align 8 - br label %loop.cond85 +voiderr96: ; preds = %after_check95, %loop.body89 + %103 = load i64, ptr %.anon86, align 8 + %add97 = add i64 %103, 1 + store i64 %add97, ptr %.anon86, align 8 + br label %loop.cond87 -loop.exit102: ; preds = %loop.cond85 - call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a103, ptr align 4 @.__const.11, i32 8, i1 false) - store i64 0, ptr %.anon104, align 8 - br label %loop.cond105 +loop.exit98: ; preds = %loop.cond87 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a99, ptr align 16 @.__const.15, i32 32, i1 false) + store i64 0, ptr %.anon100, align 8 + br label %loop.cond101 -loop.cond105: ; preds = %voiderr120, %loop.exit102 - %114 = load i64, ptr %.anon104, align 8 - %gt106 = icmp ugt i64 2, %114 - br i1 %gt106, label %loop.body107, label %loop.exit122 +loop.cond101: ; preds = %voiderr110, %loop.exit98 + %104 = load i64, ptr %.anon100, align 8 + %gt102 = icmp ugt i64 8, %104 + br i1 %gt102, label %loop.body103, label %loop.exit112 -loop.body107: ; preds = %loop.cond105 - %115 = load i64, ptr %.anon104, align 8 - store i64 %115, ptr %i108, align 8 - %116 = load i64, ptr %.anon104, align 8 - %117 = getelementptr inbounds [2 x i32], ptr %a103, i64 0, i64 %116 - %118 = load i32, ptr %117, align 4 - store i32 %118, ptr %x109, align 4 - store %"char[]" { ptr @.str.12, i64 8 }, ptr %taddr111, align 8 - %119 = getelementptr inbounds { ptr, i64 }, ptr %taddr111, i32 0, i32 0 - %lo112 = load ptr, ptr %119, align 8 - %120 = getelementptr inbounds { ptr, i64 }, ptr %taddr111, i32 0, i32 1 - %hi113 = load i64, ptr %120, align 8 - %121 = insertvalue %variant undef, ptr %i108, 0 - %122 = insertvalue %variant %121, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %123 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 0 - store %variant %122, ptr %123, align 16 - %124 = insertvalue %variant undef, ptr %x109, 0 - %125 = insertvalue %variant %124, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %126 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 1 - store %variant %125, ptr %126, align 16 - %127 = getelementptr inbounds %"variant[]", ptr %vararg114, i32 0, i32 1 - store i64 2, ptr %127, align 8 - %128 = getelementptr inbounds %"variant[]", ptr %vararg114, i32 0, i32 0 - store ptr %varargslots115, ptr %128, align 8 - %129 = getelementptr inbounds { ptr, i64 }, ptr %vararg114, i32 0, i32 0 - %lo116 = load ptr, ptr %129, align 8 - %130 = getelementptr inbounds { ptr, i64 }, ptr %vararg114, i32 0, i32 1 - %hi117 = load i64, ptr %130, align 8 - %131 = call i64 @std_io_printfln(ptr %retparam110, ptr %lo112, i64 %hi113, ptr %lo116, i64 %hi117) - %not_err118 = icmp eq i64 %131, 0 - br i1 %not_err118, label %after_check119, label %voiderr120 +loop.body103: ; preds = %loop.cond101 + %105 = load i64, ptr %.anon100, align 8 + store i64 %105, ptr %i104, align 8 + %106 = load i64, ptr %.anon100, align 8 + %107 = getelementptr inbounds [8 x i32], ptr %a99, i64 0, i64 %106 + %108 = load i32, ptr %107, align 4 + store i32 %108, ptr %x105, align 4 + %109 = insertvalue %variant undef, ptr %i104, 0 + %110 = insertvalue %variant %109, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %111 = getelementptr inbounds [2 x %variant], ptr %varargslots107, i64 0, i64 0 + store %variant %110, ptr %111, align 16 + %112 = insertvalue %variant undef, ptr %x105, 0 + %113 = insertvalue %variant %112, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %114 = getelementptr inbounds [2 x %variant], ptr %varargslots107, i64 0, i64 1 + store %variant %113, ptr %114, align 16 + %115 = call i64 @std_io_printfln(ptr %retparam106, ptr @.str.16, i64 8, ptr %varargslots107, i64 2) + %not_err108 = icmp eq i64 %115, 0 + br i1 %not_err108, label %after_check109, label %voiderr110 -after_check119: ; preds = %loop.body107 - br label %voiderr120 +after_check109: ; preds = %loop.body103 + br label %voiderr110 -voiderr120: ; preds = %after_check119, %loop.body107 - %132 = load i64, ptr %.anon104, align 8 - %add121 = add i64 %132, 1 - store i64 %add121, ptr %.anon104, align 8 - br label %loop.cond105 +voiderr110: ; preds = %after_check109, %loop.body103 + %116 = load i64, ptr %.anon100, align 8 + %add111 = add i64 %116, 1 + store i64 %add111, ptr %.anon100, align 8 + br label %loop.cond101 -loop.exit122: ; preds = %loop.cond105 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a123, ptr align 16 @.__const.13, i32 20, i1 false) - store i64 0, ptr %.anon124, align 8 - br label %loop.cond125 - -loop.cond125: ; preds = %voiderr140, %loop.exit122 - %133 = load i64, ptr %.anon124, align 8 - %gt126 = icmp ugt i64 5, %133 - br i1 %gt126, label %loop.body127, label %loop.exit142 - -loop.body127: ; preds = %loop.cond125 - %134 = load i64, ptr %.anon124, align 8 - store i64 %134, ptr %i128, align 8 - %135 = load i64, ptr %.anon124, align 8 - %136 = getelementptr inbounds [5 x i32], ptr %a123, i64 0, i64 %135 - %137 = load i32, ptr %136, align 4 - store i32 %137, ptr %x129, align 4 - store %"char[]" { ptr @.str.14, i64 8 }, ptr %taddr131, align 8 - %138 = getelementptr inbounds { ptr, i64 }, ptr %taddr131, i32 0, i32 0 - %lo132 = load ptr, ptr %138, align 8 - %139 = getelementptr inbounds { ptr, i64 }, ptr %taddr131, i32 0, i32 1 - %hi133 = load i64, ptr %139, align 8 - %140 = insertvalue %variant undef, ptr %i128, 0 - %141 = insertvalue %variant %140, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %142 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 0 - store %variant %141, ptr %142, align 16 - %143 = insertvalue %variant undef, ptr %x129, 0 - %144 = insertvalue %variant %143, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %145 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 1 - store %variant %144, ptr %145, align 16 - %146 = getelementptr inbounds %"variant[]", ptr %vararg134, i32 0, i32 1 - store i64 2, ptr %146, align 8 - %147 = getelementptr inbounds %"variant[]", ptr %vararg134, i32 0, i32 0 - store ptr %varargslots135, ptr %147, align 8 - %148 = getelementptr inbounds { ptr, i64 }, ptr %vararg134, i32 0, i32 0 - %lo136 = load ptr, ptr %148, align 8 - %149 = getelementptr inbounds { ptr, i64 }, ptr %vararg134, i32 0, i32 1 - %hi137 = load i64, ptr %149, align 8 - %150 = call i64 @std_io_printfln(ptr %retparam130, ptr %lo132, i64 %hi133, ptr %lo136, i64 %hi137) - %not_err138 = icmp eq i64 %150, 0 - br i1 %not_err138, label %after_check139, label %voiderr140 - -after_check139: ; preds = %loop.body127 - br label %voiderr140 - -voiderr140: ; preds = %after_check139, %loop.body127 - %151 = load i64, ptr %.anon124, align 8 - %add141 = add i64 %151, 1 - store i64 %add141, ptr %.anon124, align 8 - br label %loop.cond125 - -loop.exit142: ; preds = %loop.cond125 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a143, ptr align 16 @.__const.15, i32 32, i1 false) - store i64 0, ptr %.anon144, align 8 - br label %loop.cond145 - -loop.cond145: ; preds = %voiderr160, %loop.exit142 - %152 = load i64, ptr %.anon144, align 8 - %gt146 = icmp ugt i64 8, %152 - br i1 %gt146, label %loop.body147, label %loop.exit162 - -loop.body147: ; preds = %loop.cond145 - %153 = load i64, ptr %.anon144, align 8 - store i64 %153, ptr %i148, align 8 - %154 = load i64, ptr %.anon144, align 8 - %155 = getelementptr inbounds [8 x i32], ptr %a143, i64 0, i64 %154 - %156 = load i32, ptr %155, align 4 - store i32 %156, ptr %x149, align 4 - store %"char[]" { ptr @.str.16, i64 8 }, ptr %taddr151, align 8 - %157 = getelementptr inbounds { ptr, i64 }, ptr %taddr151, i32 0, i32 0 - %lo152 = load ptr, ptr %157, align 8 - %158 = getelementptr inbounds { ptr, i64 }, ptr %taddr151, i32 0, i32 1 - %hi153 = load i64, ptr %158, align 8 - %159 = insertvalue %variant undef, ptr %i148, 0 - %160 = insertvalue %variant %159, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %161 = getelementptr inbounds [2 x %variant], ptr %varargslots155, i64 0, i64 0 - store %variant %160, ptr %161, align 16 - %162 = insertvalue %variant undef, ptr %x149, 0 - %163 = insertvalue %variant %162, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %164 = getelementptr inbounds [2 x %variant], ptr %varargslots155, i64 0, i64 1 - store %variant %163, ptr %164, align 16 - %165 = getelementptr inbounds %"variant[]", ptr %vararg154, i32 0, i32 1 - store i64 2, ptr %165, align 8 - %166 = getelementptr inbounds %"variant[]", ptr %vararg154, i32 0, i32 0 - store ptr %varargslots155, ptr %166, align 8 - %167 = getelementptr inbounds { ptr, i64 }, ptr %vararg154, i32 0, i32 0 - %lo156 = load ptr, ptr %167, align 8 - %168 = getelementptr inbounds { ptr, i64 }, ptr %vararg154, i32 0, i32 1 - %hi157 = load i64, ptr %168, align 8 - %169 = call i64 @std_io_printfln(ptr %retparam150, ptr %lo152, i64 %hi153, ptr %lo156, i64 %hi157) - %not_err158 = icmp eq i64 %169, 0 - br i1 %not_err158, label %after_check159, label %voiderr160 - -after_check159: ; preds = %loop.body147 - br label %voiderr160 - -voiderr160: ; preds = %after_check159, %loop.body147 - %170 = load i64, ptr %.anon144, align 8 - %add161 = add i64 %170, 1 - store i64 %add161, ptr %.anon144, align 8 - br label %loop.cond145 - -loop.exit162: ; preds = %loop.cond145 +loop.exit112: ; preds = %loop.cond101 call void @llvm.memcpy.p0.p0.i32(ptr align 16 %b, ptr align 16 @.__const.17, i32 28, i1 false) - store i64 0, ptr %.anon163, align 8 - br label %loop.cond164 + store i64 0, ptr %.anon113, align 8 + br label %loop.cond114 -loop.cond164: ; preds = %voiderr179, %loop.exit162 - %171 = load i64, ptr %.anon163, align 8 - %gt165 = icmp ugt i64 7, %171 - br i1 %gt165, label %loop.body166, label %loop.exit181 +loop.cond114: ; preds = %voiderr123, %loop.exit112 + %117 = load i64, ptr %.anon113, align 8 + %gt115 = icmp ugt i64 7, %117 + br i1 %gt115, label %loop.body116, label %loop.exit125 -loop.body166: ; preds = %loop.cond164 - %172 = load i64, ptr %.anon163, align 8 - store i64 %172, ptr %i167, align 8 - %173 = load i64, ptr %.anon163, align 8 - %174 = getelementptr inbounds [7 x i32], ptr %b, i64 0, i64 %173 - %175 = load i32, ptr %174, align 4 - store i32 %175, ptr %x168, align 4 - store %"char[]" { ptr @.str.18, i64 8 }, ptr %taddr170, align 8 - %176 = getelementptr inbounds { ptr, i64 }, ptr %taddr170, i32 0, i32 0 - %lo171 = load ptr, ptr %176, align 8 - %177 = getelementptr inbounds { ptr, i64 }, ptr %taddr170, i32 0, i32 1 - %hi172 = load i64, ptr %177, align 8 - %178 = insertvalue %variant undef, ptr %i167, 0 - %179 = insertvalue %variant %178, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %180 = getelementptr inbounds [2 x %variant], ptr %varargslots174, i64 0, i64 0 - store %variant %179, ptr %180, align 16 - %181 = insertvalue %variant undef, ptr %x168, 0 - %182 = insertvalue %variant %181, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %183 = getelementptr inbounds [2 x %variant], ptr %varargslots174, i64 0, i64 1 - store %variant %182, ptr %183, align 16 - %184 = getelementptr inbounds %"variant[]", ptr %vararg173, i32 0, i32 1 - store i64 2, ptr %184, align 8 - %185 = getelementptr inbounds %"variant[]", ptr %vararg173, i32 0, i32 0 - store ptr %varargslots174, ptr %185, align 8 - %186 = getelementptr inbounds { ptr, i64 }, ptr %vararg173, i32 0, i32 0 - %lo175 = load ptr, ptr %186, align 8 - %187 = getelementptr inbounds { ptr, i64 }, ptr %vararg173, i32 0, i32 1 - %hi176 = load i64, ptr %187, align 8 - %188 = call i64 @std_io_printfln(ptr %retparam169, ptr %lo171, i64 %hi172, ptr %lo175, i64 %hi176) - %not_err177 = icmp eq i64 %188, 0 - br i1 %not_err177, label %after_check178, label %voiderr179 +loop.body116: ; preds = %loop.cond114 + %118 = load i64, ptr %.anon113, align 8 + store i64 %118, ptr %i117, align 8 + %119 = load i64, ptr %.anon113, align 8 + %120 = getelementptr inbounds [7 x i32], ptr %b, i64 0, i64 %119 + %121 = load i32, ptr %120, align 4 + store i32 %121, ptr %x118, align 4 + %122 = insertvalue %variant undef, ptr %i117, 0 + %123 = insertvalue %variant %122, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %124 = getelementptr inbounds [2 x %variant], ptr %varargslots120, i64 0, i64 0 + store %variant %123, ptr %124, align 16 + %125 = insertvalue %variant undef, ptr %x118, 0 + %126 = insertvalue %variant %125, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %127 = getelementptr inbounds [2 x %variant], ptr %varargslots120, i64 0, i64 1 + store %variant %126, ptr %127, align 16 + %128 = call i64 @std_io_printfln(ptr %retparam119, ptr @.str.18, i64 8, ptr %varargslots120, i64 2) + %not_err121 = icmp eq i64 %128, 0 + br i1 %not_err121, label %after_check122, label %voiderr123 -after_check178: ; preds = %loop.body166 - br label %voiderr179 +after_check122: ; preds = %loop.body116 + br label %voiderr123 -voiderr179: ; preds = %after_check178, %loop.body166 - %189 = load i64, ptr %.anon163, align 8 - %add180 = add i64 %189, 1 - store i64 %add180, ptr %.anon163, align 8 - br label %loop.cond164 +voiderr123: ; preds = %after_check122, %loop.body116 + %129 = load i64, ptr %.anon113, align 8 + %add124 = add i64 %129, 1 + store i64 %add124, ptr %.anon113, align 8 + br label %loop.cond114 -loop.exit181: ; preds = %loop.cond164 +loop.exit125: ; preds = %loop.cond114 call void @llvm.memcpy.p0.p0.i32(ptr align 16 %c, ptr align 16 @.__const.19, i32 32, i1 false) - store i64 0, ptr %.anon182, align 8 - br label %loop.cond183 + store i64 0, ptr %.anon126, align 8 + br label %loop.cond127 -loop.cond183: ; preds = %voiderr198, %loop.exit181 - %190 = load i64, ptr %.anon182, align 8 - %gt184 = icmp ugt i64 8, %190 - br i1 %gt184, label %loop.body185, label %loop.exit200 +loop.cond127: ; preds = %voiderr136, %loop.exit125 + %130 = load i64, ptr %.anon126, align 8 + %gt128 = icmp ugt i64 8, %130 + br i1 %gt128, label %loop.body129, label %loop.exit138 -loop.body185: ; preds = %loop.cond183 - %191 = load i64, ptr %.anon182, align 8 - store i64 %191, ptr %i186, align 8 - %192 = load i64, ptr %.anon182, align 8 - %193 = getelementptr inbounds [8 x i32], ptr %c, i64 0, i64 %192 - %194 = load i32, ptr %193, align 4 - store i32 %194, ptr %x187, align 4 - store %"char[]" { ptr @.str.20, i64 9 }, ptr %taddr189, align 8 - %195 = getelementptr inbounds { ptr, i64 }, ptr %taddr189, i32 0, i32 0 - %lo190 = load ptr, ptr %195, align 8 - %196 = getelementptr inbounds { ptr, i64 }, ptr %taddr189, i32 0, i32 1 - %hi191 = load i64, ptr %196, align 8 - %197 = insertvalue %variant undef, ptr %i186, 0 - %198 = insertvalue %variant %197, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %199 = getelementptr inbounds [2 x %variant], ptr %varargslots193, i64 0, i64 0 - store %variant %198, ptr %199, align 16 - %200 = insertvalue %variant undef, ptr %x187, 0 - %201 = insertvalue %variant %200, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %202 = getelementptr inbounds [2 x %variant], ptr %varargslots193, i64 0, i64 1 - store %variant %201, ptr %202, align 16 - %203 = getelementptr inbounds %"variant[]", ptr %vararg192, i32 0, i32 1 - store i64 2, ptr %203, align 8 - %204 = getelementptr inbounds %"variant[]", ptr %vararg192, i32 0, i32 0 - store ptr %varargslots193, ptr %204, align 8 - %205 = getelementptr inbounds { ptr, i64 }, ptr %vararg192, i32 0, i32 0 - %lo194 = load ptr, ptr %205, align 8 - %206 = getelementptr inbounds { ptr, i64 }, ptr %vararg192, i32 0, i32 1 - %hi195 = load i64, ptr %206, align 8 - %207 = call i64 @std_io_printfln(ptr %retparam188, ptr %lo190, i64 %hi191, ptr %lo194, i64 %hi195) - %not_err196 = icmp eq i64 %207, 0 - br i1 %not_err196, label %after_check197, label %voiderr198 +loop.body129: ; preds = %loop.cond127 + %131 = load i64, ptr %.anon126, align 8 + store i64 %131, ptr %i130, align 8 + %132 = load i64, ptr %.anon126, align 8 + %133 = getelementptr inbounds [8 x i32], ptr %c, i64 0, i64 %132 + %134 = load i32, ptr %133, align 4 + store i32 %134, ptr %x131, align 4 + %135 = insertvalue %variant undef, ptr %i130, 0 + %136 = insertvalue %variant %135, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %137 = getelementptr inbounds [2 x %variant], ptr %varargslots133, i64 0, i64 0 + store %variant %136, ptr %137, align 16 + %138 = insertvalue %variant undef, ptr %x131, 0 + %139 = insertvalue %variant %138, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %140 = getelementptr inbounds [2 x %variant], ptr %varargslots133, i64 0, i64 1 + store %variant %139, ptr %140, align 16 + %141 = call i64 @std_io_printfln(ptr %retparam132, ptr @.str.20, i64 9, ptr %varargslots133, i64 2) + %not_err134 = icmp eq i64 %141, 0 + br i1 %not_err134, label %after_check135, label %voiderr136 -after_check197: ; preds = %loop.body185 - br label %voiderr198 +after_check135: ; preds = %loop.body129 + br label %voiderr136 -voiderr198: ; preds = %after_check197, %loop.body185 - %208 = load i64, ptr %.anon182, align 8 - %add199 = add i64 %208, 1 - store i64 %add199, ptr %.anon182, align 8 - br label %loop.cond183 +voiderr136: ; preds = %after_check135, %loop.body129 + %142 = load i64, ptr %.anon126, align 8 + %add137 = add i64 %142, 1 + store i64 %add137, ptr %.anon126, align 8 + br label %loop.cond127 -loop.exit200: ; preds = %loop.cond183 - call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a201, ptr align 16 @.__const.21, i32 24, i1 false) - store i64 0, ptr %.anon202, align 8 - br label %loop.cond203 +loop.exit138: ; preds = %loop.cond127 + call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a139, ptr align 16 @.__const.21, i32 24, i1 false) + store i64 0, ptr %.anon140, align 8 + br label %loop.cond141 -loop.cond203: ; preds = %voiderr218, %loop.exit200 - %209 = load i64, ptr %.anon202, align 8 - %gt204 = icmp ugt i64 6, %209 - br i1 %gt204, label %loop.body205, label %loop.exit220 +loop.cond141: ; preds = %voiderr150, %loop.exit138 + %143 = load i64, ptr %.anon140, align 8 + %gt142 = icmp ugt i64 6, %143 + br i1 %gt142, label %loop.body143, label %loop.exit152 -loop.body205: ; preds = %loop.cond203 - %210 = load i64, ptr %.anon202, align 8 - store i64 %210, ptr %i206, align 8 - %211 = load i64, ptr %.anon202, align 8 - %212 = getelementptr inbounds [6 x i32], ptr %a201, i64 0, i64 %211 - %213 = load i32, ptr %212, align 4 - store i32 %213, ptr %x207, align 4 - store %"char[]" { ptr @.str.22, i64 6 }, ptr %taddr209, align 8 - %214 = getelementptr inbounds { ptr, i64 }, ptr %taddr209, i32 0, i32 0 - %lo210 = load ptr, ptr %214, align 8 - %215 = getelementptr inbounds { ptr, i64 }, ptr %taddr209, i32 0, i32 1 - %hi211 = load i64, ptr %215, align 8 - %216 = insertvalue %variant undef, ptr %i206, 0 - %217 = insertvalue %variant %216, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 - %218 = getelementptr inbounds [2 x %variant], ptr %varargslots213, i64 0, i64 0 - store %variant %217, ptr %218, align 16 - %219 = insertvalue %variant undef, ptr %x207, 0 - %220 = insertvalue %variant %219, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %221 = getelementptr inbounds [2 x %variant], ptr %varargslots213, i64 0, i64 1 - store %variant %220, ptr %221, align 16 - %222 = getelementptr inbounds %"variant[]", ptr %vararg212, i32 0, i32 1 - store i64 2, ptr %222, align 8 - %223 = getelementptr inbounds %"variant[]", ptr %vararg212, i32 0, i32 0 - store ptr %varargslots213, ptr %223, align 8 - %224 = getelementptr inbounds { ptr, i64 }, ptr %vararg212, i32 0, i32 0 - %lo214 = load ptr, ptr %224, align 8 - %225 = getelementptr inbounds { ptr, i64 }, ptr %vararg212, i32 0, i32 1 - %hi215 = load i64, ptr %225, align 8 - %226 = call i64 @std_io_printfln(ptr %retparam208, ptr %lo210, i64 %hi211, ptr %lo214, i64 %hi215) - %not_err216 = icmp eq i64 %226, 0 - br i1 %not_err216, label %after_check217, label %voiderr218 +loop.body143: ; preds = %loop.cond141 + %144 = load i64, ptr %.anon140, align 8 + store i64 %144, ptr %i144, align 8 + %145 = load i64, ptr %.anon140, align 8 + %146 = getelementptr inbounds [6 x i32], ptr %a139, i64 0, i64 %145 + %147 = load i32, ptr %146, align 4 + store i32 %147, ptr %x145, align 4 + %148 = insertvalue %variant undef, ptr %i144, 0 + %149 = insertvalue %variant %148, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %150 = getelementptr inbounds [2 x %variant], ptr %varargslots147, i64 0, i64 0 + store %variant %149, ptr %150, align 16 + %151 = insertvalue %variant undef, ptr %x145, 0 + %152 = insertvalue %variant %151, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %153 = getelementptr inbounds [2 x %variant], ptr %varargslots147, i64 0, i64 1 + store %variant %152, ptr %153, align 16 + %154 = call i64 @std_io_printfln(ptr %retparam146, ptr @.str.22, i64 6, ptr %varargslots147, i64 2) + %not_err148 = icmp eq i64 %154, 0 + br i1 %not_err148, label %after_check149, label %voiderr150 -after_check217: ; preds = %loop.body205 - br label %voiderr218 +after_check149: ; preds = %loop.body143 + br label %voiderr150 -voiderr218: ; preds = %after_check217, %loop.body205 - %227 = load i64, ptr %.anon202, align 8 - %add219 = add i64 %227, 1 - store i64 %add219, ptr %.anon202, align 8 - br label %loop.cond203 +voiderr150: ; preds = %after_check149, %loop.body143 + %155 = load i64, ptr %.anon140, align 8 + %add151 = add i64 %155, 1 + store i64 %add151, ptr %.anon140, align 8 + br label %loop.cond141 -loop.exit220: ; preds = %loop.cond203 +loop.exit152: ; preds = %loop.cond141 ret void } - diff --git a/test/test_suite2/overloading/set_overload.c3t b/test/test_suite2/overloading/set_overload.c3t index 9d121162f..fa73fd475 100644 --- a/test/test_suite2/overloading/set_overload.c3t +++ b/test/test_suite2/overloading/set_overload.c3t @@ -17,20 +17,8 @@ fn void main() define void @test_main() #0 { entry: %map = alloca %HashMap, align 8 - %taddr = alloca %"char[]", align 8 - %taddr1 = alloca %"char[]", align 8 call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false) - store %"char[]" { ptr @.str, i64 5 }, ptr %taddr, align 8 - %0 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %0, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %1, align 8 - %2 = call i8 @"std_map$$sa$char.int_HashMap_set"(ptr %map, ptr %lo, i64 %hi, i32 4) - store %"char[]" { ptr @.str.1, i64 3 }, ptr %taddr1, align 8 - %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 0 - %lo2 = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 1 - %hi3 = load i64, ptr %4, align 8 - %5 = call i8 @"std_map$$sa$char.int_HashMap_set"(ptr %map, ptr %lo2, i64 %hi3, i32 5) + %0 = call i8 @"std_map$$sa$char.int_HashMap_set"(ptr %map, ptr @.str, i64 5, i32 4) + %1 = call i8 @"std_map$$sa$char.int_HashMap_set"(ptr %map, ptr @.str.1, i64 3, i32 5) ret void } \ No newline at end of file diff --git a/test/test_suite2/pointers/subarray_variant_to_ptr.c3t b/test/test_suite2/pointers/subarray_variant_to_ptr.c3t index 64b407af4..198403bd9 100644 --- a/test/test_suite2/pointers/subarray_variant_to_ptr.c3t +++ b/test/test_suite2/pointers/subarray_variant_to_ptr.c3t @@ -71,7 +71,6 @@ entry: %y = alloca i32, align 4 %w = alloca [2 x i32], align 4 %taddr = alloca %variant, align 8 - %taddr1 = alloca %"int[]", align 8 store i32 123, ptr %x, align 4 store i32 293483, ptr %y, align 4 call void @llvm.memcpy.p0.p0.i32(ptr align 4 %w, ptr align 4 @.__const, i32 8, i1 false) @@ -84,13 +83,6 @@ entry: %hi = load ptr, ptr %3, align 8 call void @foo_test1(i64 %lo, ptr %hi) %4 = getelementptr inbounds [2 x i32], ptr %w, i64 0, i64 0 - %5 = insertvalue %"int[]" undef, ptr %4, 0 - %6 = insertvalue %"int[]" %5, i64 2, 1 - store %"int[]" %6, ptr %taddr1, align 8 - %7 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 0 - %lo2 = load ptr, ptr %7, align 8 - %8 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 1 - %hi3 = load i64, ptr %8, align 8 - call void @foo_test2(ptr %lo2, i64 %hi3) + call void @foo_test2(ptr %4, i64 2) ret void } \ No newline at end of file diff --git a/test/test_suite2/safe/deref.c3t b/test/test_suite2/safe/deref.c3t index b50a49013..2760e9973 100644 --- a/test/test_suite2/safe/deref.c3t +++ b/test/test_suite2/safe/deref.c3t @@ -1,4 +1,5 @@ // #safe: yes +// #target: macos-x64 module foo; fn void main() @@ -19,12 +20,13 @@ entry: br i1 %checknull, label %panic, label %checkok panic: ; preds = %entry - call void @std_core_builtin_panic(ptr @.zstr, ptr @.zstr.1, ptr @.zstr.2, i32 6) + %1 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %1(ptr @.panic_msg, i64 27, ptr @.file, i64 8, ptr @.func, i64 4, i32 6) br label %checkok checkok: ; preds = %panic, %entry - %1 = load i32, ptr %0, align 8 - store i32 %1, ptr %y, align 4 + %2 = load i32, ptr %0, align 8 + store i32 %2, ptr %y, align 4 ret void } diff --git a/test/test_suite2/slices/slice_to_slice_assign.c3t b/test/test_suite2/slices/slice_to_slice_assign.c3t index 0ef7df15f..e293a4ae9 100644 --- a/test/test_suite2/slices/slice_to_slice_assign.c3t +++ b/test/test_suite2/slices/slice_to_slice_assign.c3t @@ -26,33 +26,23 @@ entry: %y = alloca [6 x i32], align 16 %taddr = alloca %"int[]", align 8 %retparam = alloca i64, align 8 - %taddr1 = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 - %taddr4 = alloca %"int[]", align 8 - %retparam5 = alloca i64, align 8 - %taddr6 = alloca %"char[]", align 8 - %vararg9 = alloca %"variant[]", align 8 - %varargslots10 = alloca [2 x %variant], align 16 + %taddr1 = alloca %"int[]", align 8 + %retparam2 = alloca i64, align 8 + %varargslots3 = alloca [2 x %variant], align 16 %a = alloca %"int[][]", align 8 %literal = alloca [1 x %"int[]"], align 16 - %literal16 = alloca [1 x i32], align 4 + %literal7 = alloca [1 x i32], align 4 %b = alloca %"int[][]", align 8 - %literal17 = alloca [1 x %"int[]"], align 16 - %literal18 = alloca [1 x i32], align 4 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 + %literal8 = alloca [1 x %"int[]"], align 16 + %literal9 = alloca [1 x i32], align 4 + %retparam10 = alloca i64, align 8 + %varargslots11 = alloca [1 x %variant], align 16 + %taddr16 = alloca %"int[][]", align 8 + %retparam17 = alloca i64, align 8 + %varargslots18 = alloca [1 x %variant], align 16 + %retparam23 = alloca i64, align 8 %varargslots24 = alloca [1 x %variant], align 16 - %taddr31 = alloca %"int[][]", align 8 - %retparam32 = alloca i64, align 8 - %taddr33 = alloca %"char[]", align 8 - %vararg36 = alloca %"variant[]", align 8 - %varargslots37 = alloca [1 x %variant], align 16 - %retparam44 = alloca i64, align 8 - %taddr45 = alloca %"char[]", align 8 - %vararg48 = alloca %"variant[]", align 8 - %varargslots49 = alloca [1 x %variant], align 16 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 @@ -68,193 +58,128 @@ entry: %9 = load i64, ptr %8, align 8 %10 = mul i64 %9, 4 call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %7, i64 %10, i1 false) - store %"char[]" { ptr @.str, i64 5 }, ptr %taddr1, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 0 - %lo = load ptr, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 1 - %hi = load i64, ptr %12, align 8 - %13 = insertvalue %variant undef, ptr %y, 0 - %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$a6$int" to i64), 1 - %15 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %14, ptr %15, align 16 - %16 = insertvalue %variant undef, ptr %z, 0 - %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$a7$int" to i64), 1 - %18 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %17, ptr %18, align 16 - %19 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 2, ptr %19, align 8 - %20 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %21, align 8 - %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %22, align 8 - %23 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %23, 0 + %11 = insertvalue %variant undef, ptr %y, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$a6$int" to i64), 1 + %13 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %12, ptr %13, align 16 + %14 = insertvalue %variant undef, ptr %z, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$a7$int" to i64), 1 + %16 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %15, ptr %16, align 16 + %17 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2) + %not_err = icmp eq i64 %17, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %24 = getelementptr inbounds [7 x i32], ptr %z, i64 0, i64 5 - %25 = insertvalue %"int[]" undef, ptr %24, 0 - %26 = insertvalue %"int[]" %25, i64 2, 1 - %27 = getelementptr inbounds [6 x i32], ptr %y, i64 0, i64 4 - %28 = insertvalue %"int[]" undef, ptr %27, 0 - %29 = insertvalue %"int[]" %28, i64 2, 1 - %30 = extractvalue %"int[]" %29, 0 - %31 = extractvalue %"int[]" %26, 0 - store %"int[]" %26, ptr %taddr4, align 8 - %32 = getelementptr inbounds %"int[]", ptr %taddr4, i32 0, i32 1 - %33 = load i64, ptr %32, align 8 - %34 = mul i64 %33, 4 - call void @llvm.memcpy.p0.p0.i64(ptr align 4 %30, ptr align 4 %31, i64 %34, i1 false) - store %"char[]" { ptr @.str.1, i64 5 }, ptr %taddr6, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 0 - %lo7 = load ptr, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 1 - %hi8 = load i64, ptr %36, align 8 - %37 = insertvalue %variant undef, ptr %y, 0 - %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"ct$a6$int" to i64), 1 - %39 = getelementptr inbounds [2 x %variant], ptr %varargslots10, i64 0, i64 0 - store %variant %38, ptr %39, align 16 - %40 = insertvalue %variant undef, ptr %z, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$a7$int" to i64), 1 - %42 = getelementptr inbounds [2 x %variant], ptr %varargslots10, i64 0, i64 1 - store %variant %41, ptr %42, align 16 - %43 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 1 - store i64 2, ptr %43, align 8 - %44 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 0 - store ptr %varargslots10, ptr %44, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 0 - %lo11 = load ptr, ptr %45, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 1 - %hi12 = load i64, ptr %46, align 8 - %47 = call i64 @std_io_printfln(ptr %retparam5, ptr %lo7, i64 %hi8, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %47, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %18 = getelementptr inbounds [7 x i32], ptr %z, i64 0, i64 5 + %19 = insertvalue %"int[]" undef, ptr %18, 0 + %20 = insertvalue %"int[]" %19, i64 2, 1 + %21 = getelementptr inbounds [6 x i32], ptr %y, i64 0, i64 4 + %22 = insertvalue %"int[]" undef, ptr %21, 0 + %23 = insertvalue %"int[]" %22, i64 2, 1 + %24 = extractvalue %"int[]" %23, 0 + %25 = extractvalue %"int[]" %20, 0 + store %"int[]" %20, ptr %taddr1, align 8 + %26 = getelementptr inbounds %"int[]", ptr %taddr1, i32 0, i32 1 + %27 = load i64, ptr %26, align 8 + %28 = mul i64 %27, 4 + call void @llvm.memcpy.p0.p0.i64(ptr align 4 %24, ptr align 4 %25, i64 %28, i1 false) + %29 = insertvalue %variant undef, ptr %y, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$a6$int" to i64), 1 + %31 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 0 + store %variant %30, ptr %31, align 16 + %32 = insertvalue %variant undef, ptr %z, 0 + %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$a7$int" to i64), 1 + %34 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 1 + store %variant %33, ptr %34, align 16 + %35 = call i64 @std_io_printfln(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2) + %not_err4 = icmp eq i64 %35, 0 + br i1 %not_err4, label %after_check5, label %voiderr6 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check5: ; preds = %voiderr + br label %voiderr6 -voiderr15: ; preds = %after_check14, %voiderr - %48 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0 - %49 = getelementptr inbounds [1 x i32], ptr %literal16, i64 0, i64 0 - store i32 1, ptr %49, align 4 - %50 = insertvalue %"int[]" undef, ptr %literal16, 0 - %51 = insertvalue %"int[]" %50, i64 1, 1 - store %"int[]" %51, ptr %48, align 8 - %52 = insertvalue %"int[][]" undef, ptr %literal, 0 - %53 = insertvalue %"int[][]" %52, i64 1, 1 - store %"int[][]" %53, ptr %a, align 8 - %54 = getelementptr inbounds [1 x %"int[]"], ptr %literal17, i64 0, i64 0 - %55 = getelementptr inbounds [1 x i32], ptr %literal18, i64 0, i64 0 - store i32 2, ptr %55, align 4 - %56 = insertvalue %"int[]" undef, ptr %literal18, 0 - %57 = insertvalue %"int[]" %56, i64 1, 1 - store %"int[]" %57, ptr %54, align 8 - %58 = insertvalue %"int[][]" undef, ptr %literal17, 0 +voiderr6: ; preds = %after_check5, %voiderr + %36 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0 + %37 = getelementptr inbounds [1 x i32], ptr %literal7, i64 0, i64 0 + store i32 1, ptr %37, align 4 + %38 = insertvalue %"int[]" undef, ptr %literal7, 0 + %39 = insertvalue %"int[]" %38, i64 1, 1 + store %"int[]" %39, ptr %36, align 8 + %40 = insertvalue %"int[][]" undef, ptr %literal, 0 + %41 = insertvalue %"int[][]" %40, i64 1, 1 + store %"int[][]" %41, ptr %a, align 8 + %42 = getelementptr inbounds [1 x %"int[]"], ptr %literal8, i64 0, i64 0 + %43 = getelementptr inbounds [1 x i32], ptr %literal9, i64 0, i64 0 + store i32 2, ptr %43, align 4 + %44 = insertvalue %"int[]" undef, ptr %literal9, 0 + %45 = insertvalue %"int[]" %44, i64 1, 1 + store %"int[]" %45, ptr %42, align 8 + %46 = insertvalue %"int[][]" undef, ptr %literal8, 0 + %47 = insertvalue %"int[][]" %46, i64 1, 1 + store %"int[][]" %47, ptr %b, align 8 + %48 = insertvalue %variant undef, ptr %a, 0 + %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 + %50 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0 + store %variant %49, ptr %50, align 16 + %51 = call i64 @std_io_printfln(ptr %retparam10, ptr @.str.2, i64 2, ptr %varargslots11, i64 1) + %not_err12 = icmp eq i64 %51, 0 + br i1 %not_err12, label %after_check13, label %voiderr14 + +after_check13: ; preds = %voiderr6 + br label %voiderr14 + +voiderr14: ; preds = %after_check13, %voiderr6 + %52 = load %"int[][]", ptr %b, align 8 + %53 = extractvalue %"int[][]" %52, 0 + %ptroffset = getelementptr inbounds %"int[]", ptr %53, i64 0 + %54 = insertvalue %"int[][]" undef, ptr %ptroffset, 0 + %55 = insertvalue %"int[][]" %54, i64 1, 1 + %56 = load %"int[][]", ptr %a, align 8 + %57 = extractvalue %"int[][]" %56, 0 + %ptroffset15 = getelementptr inbounds %"int[]", ptr %57, i64 0 + %58 = insertvalue %"int[][]" undef, ptr %ptroffset15, 0 %59 = insertvalue %"int[][]" %58, i64 1, 1 - store %"int[][]" %59, ptr %b, align 8 - store %"char[]" { ptr @.str.2, i64 2 }, ptr %taddr20, align 8 - %60 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0 - %lo21 = load ptr, ptr %60, align 8 - %61 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1 - %hi22 = load i64, ptr %61, align 8 - %62 = insertvalue %variant undef, ptr %a, 0 - %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 - %64 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 - store %variant %63, ptr %64, align 16 - %65 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1 - store i64 1, ptr %65, align 8 - %66 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0 - store ptr %varargslots24, ptr %66, align 8 - %67 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0 - %lo25 = load ptr, ptr %67, align 8 - %68 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1 - %hi26 = load i64, ptr %68, align 8 - %69 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %69, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 + %60 = extractvalue %"int[][]" %59, 0 + %61 = extractvalue %"int[][]" %55, 0 + store %"int[][]" %55, ptr %taddr16, align 8 + %62 = getelementptr inbounds %"int[][]", ptr %taddr16, i32 0, i32 1 + %63 = load i64, ptr %62, align 8 + %64 = mul i64 %63, 16 + call void @llvm.memcpy.p0.p0.i64(ptr align 8 %60, ptr align 8 %61, i64 %64, i1 false) + %65 = insertvalue %variant undef, ptr %a, 0 + %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 + %67 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0 + store %variant %66, ptr %67, align 16 + %68 = call i64 @std_io_printfln(ptr %retparam17, ptr @.str.3, i64 2, ptr %varargslots18, i64 1) + %not_err19 = icmp eq i64 %68, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 -after_check28: ; preds = %voiderr15 - br label %voiderr29 +after_check20: ; preds = %voiderr14 + br label %voiderr21 -voiderr29: ; preds = %after_check28, %voiderr15 - %70 = load %"int[][]", ptr %b, align 8 - %71 = extractvalue %"int[][]" %70, 0 - %ptroffset = getelementptr inbounds %"int[]", ptr %71, i64 0 - %72 = insertvalue %"int[][]" undef, ptr %ptroffset, 0 - %73 = insertvalue %"int[][]" %72, i64 1, 1 - %74 = load %"int[][]", ptr %a, align 8 - %75 = extractvalue %"int[][]" %74, 0 - %ptroffset30 = getelementptr inbounds %"int[]", ptr %75, i64 0 - %76 = insertvalue %"int[][]" undef, ptr %ptroffset30, 0 - %77 = insertvalue %"int[][]" %76, i64 1, 1 - %78 = extractvalue %"int[][]" %77, 0 - %79 = extractvalue %"int[][]" %73, 0 - store %"int[][]" %73, ptr %taddr31, align 8 - %80 = getelementptr inbounds %"int[][]", ptr %taddr31, i32 0, i32 1 - %81 = load i64, ptr %80, align 8 - %82 = mul i64 %81, 16 - call void @llvm.memcpy.p0.p0.i64(ptr align 8 %78, ptr align 8 %79, i64 %82, i1 false) - store %"char[]" { ptr @.str.3, i64 2 }, ptr %taddr33, align 8 - %83 = getelementptr inbounds { ptr, i64 }, ptr %taddr33, i32 0, i32 0 - %lo34 = load ptr, ptr %83, align 8 - %84 = getelementptr inbounds { ptr, i64 }, ptr %taddr33, i32 0, i32 1 - %hi35 = load i64, ptr %84, align 8 - %85 = insertvalue %variant undef, ptr %a, 0 - %86 = insertvalue %variant %85, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 - %87 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0 - store %variant %86, ptr %87, align 16 - %88 = getelementptr inbounds %"variant[]", ptr %vararg36, i32 0, i32 1 - store i64 1, ptr %88, align 8 - %89 = getelementptr inbounds %"variant[]", ptr %vararg36, i32 0, i32 0 - store ptr %varargslots37, ptr %89, align 8 - %90 = getelementptr inbounds { ptr, i64 }, ptr %vararg36, i32 0, i32 0 - %lo38 = load ptr, ptr %90, align 8 - %91 = getelementptr inbounds { ptr, i64 }, ptr %vararg36, i32 0, i32 1 - %hi39 = load i64, ptr %91, align 8 - %92 = call i64 @std_io_printfln(ptr %retparam32, ptr %lo34, i64 %hi35, ptr %lo38, i64 %hi39) - %not_err40 = icmp eq i64 %92, 0 - br i1 %not_err40, label %after_check41, label %voiderr42 +voiderr21: ; preds = %after_check20, %voiderr14 + %69 = getelementptr inbounds [6 x i32], ptr %y, i64 0, i64 2 + %70 = insertvalue %"int[]" undef, ptr %69, 0 + %71 = insertvalue %"int[]" %70, i64 3, 1 + %72 = load %"int[][]", ptr %a, align 8 + %73 = extractvalue %"int[][]" %72, 0 + %ptroffset22 = getelementptr inbounds %"int[]", ptr %73, i64 0 + store %"int[]" %71, ptr %ptroffset22, align 8 + %74 = insertvalue %variant undef, ptr %a, 0 + %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 + %76 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 + store %variant %75, ptr %76, align 16 + %77 = call i64 @std_io_printfln(ptr %retparam23, ptr @.str.4, i64 2, ptr %varargslots24, i64 1) + %not_err25 = icmp eq i64 %77, 0 + br i1 %not_err25, label %after_check26, label %voiderr27 -after_check41: ; preds = %voiderr29 - br label %voiderr42 +after_check26: ; preds = %voiderr21 + br label %voiderr27 -voiderr42: ; preds = %after_check41, %voiderr29 - %93 = getelementptr inbounds [6 x i32], ptr %y, i64 0, i64 2 - %94 = insertvalue %"int[]" undef, ptr %93, 0 - %95 = insertvalue %"int[]" %94, i64 3, 1 - %96 = load %"int[][]", ptr %a, align 8 - %97 = extractvalue %"int[][]" %96, 0 - %ptroffset43 = getelementptr inbounds %"int[]", ptr %97, i64 0 - store %"int[]" %95, ptr %ptroffset43, align 8 - store %"char[]" { ptr @.str.4, i64 2 }, ptr %taddr45, align 8 - %98 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 0 - %lo46 = load ptr, ptr %98, align 8 - %99 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 1 - %hi47 = load i64, ptr %99, align 8 - %100 = insertvalue %variant undef, ptr %a, 0 - %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 - %102 = getelementptr inbounds [1 x %variant], ptr %varargslots49, i64 0, i64 0 - store %variant %101, ptr %102, align 16 - %103 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 1 - store i64 1, ptr %103, align 8 - %104 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 0 - store ptr %varargslots49, ptr %104, align 8 - %105 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 0 - %lo50 = load ptr, ptr %105, align 8 - %106 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 1 - %hi51 = load i64, ptr %106, align 8 - %107 = call i64 @std_io_printfln(ptr %retparam44, ptr %lo46, i64 %hi47, ptr %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %107, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 - -after_check53: ; preds = %voiderr42 - br label %voiderr54 - -voiderr54: ; preds = %after_check53, %voiderr42 +voiderr27: ; preds = %after_check26, %voiderr21 ret void } diff --git a/test/test_suite2/slices/slice_to_slice_vector_assign.c3t b/test/test_suite2/slices/slice_to_slice_vector_assign.c3t index 8683db6fa..f3ab3c36d 100644 --- a/test/test_suite2/slices/slice_to_slice_vector_assign.c3t +++ b/test/test_suite2/slices/slice_to_slice_vector_assign.c3t @@ -27,33 +27,23 @@ entry: %y = alloca <6 x i32>, align 32 %taddr = alloca %"int[]", align 8 %retparam = alloca i64, align 8 - %taddr1 = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 - %taddr4 = alloca %"int[]", align 8 - %retparam5 = alloca i64, align 8 - %taddr6 = alloca %"char[]", align 8 - %vararg9 = alloca %"variant[]", align 8 - %varargslots10 = alloca [2 x %variant], align 16 + %taddr1 = alloca %"int[]", align 8 + %retparam2 = alloca i64, align 8 + %varargslots3 = alloca [2 x %variant], align 16 %a = alloca %"int[][]", align 8 %literal = alloca [1 x %"int[]"], align 16 - %literal16 = alloca [1 x i32], align 4 + %literal7 = alloca [1 x i32], align 4 %b = alloca %"int[][]", align 8 - %literal17 = alloca [1 x %"int[]"], align 16 - %literal18 = alloca [1 x i32], align 4 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 + %literal8 = alloca [1 x %"int[]"], align 16 + %literal9 = alloca [1 x i32], align 4 + %retparam10 = alloca i64, align 8 + %varargslots11 = alloca [1 x %variant], align 16 + %taddr16 = alloca %"int[][]", align 8 + %retparam17 = alloca i64, align 8 + %varargslots18 = alloca [1 x %variant], align 16 + %retparam23 = alloca i64, align 8 %varargslots24 = alloca [1 x %variant], align 16 - %taddr31 = alloca %"int[][]", align 8 - %retparam32 = alloca i64, align 8 - %taddr33 = alloca %"char[]", align 8 - %vararg36 = alloca %"variant[]", align 8 - %varargslots37 = alloca [1 x %variant], align 16 - %retparam44 = alloca i64, align 8 - %taddr45 = alloca %"char[]", align 8 - %vararg48 = alloca %"variant[]", align 8 - %varargslots49 = alloca [1 x %variant], align 16 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 @@ -69,193 +59,128 @@ entry: %9 = load i64, ptr %8, align 8 %10 = mul i64 %9, 4 call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %7, i64 %10, i1 false) - store %"char[]" { ptr @.str, i64 5 }, ptr %taddr1, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 0 - %lo = load ptr, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 1 - %hi = load i64, ptr %12, align 8 - %13 = insertvalue %variant undef, ptr %y, 0 - %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$v6$int" to i64), 1 - %15 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %14, ptr %15, align 16 - %16 = insertvalue %variant undef, ptr %z, 0 - %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$v7$int" to i64), 1 - %18 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %17, ptr %18, align 16 - %19 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 2, ptr %19, align 8 - %20 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo2 = load ptr, ptr %21, align 8 - %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi3 = load i64, ptr %22, align 8 - %23 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) - %not_err = icmp eq i64 %23, 0 + %11 = insertvalue %variant undef, ptr %y, 0 + %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$v6$int" to i64), 1 + %13 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %12, ptr %13, align 16 + %14 = insertvalue %variant undef, ptr %z, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$v7$int" to i64), 1 + %16 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %15, ptr %16, align 16 + %17 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2) + %not_err = icmp eq i64 %17, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %24 = getelementptr inbounds <7 x i32>, ptr %z, i64 0, i64 5 - %25 = insertvalue %"int[]" undef, ptr %24, 0 - %26 = insertvalue %"int[]" %25, i64 2, 1 - %27 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 4 - %28 = insertvalue %"int[]" undef, ptr %27, 0 - %29 = insertvalue %"int[]" %28, i64 2, 1 - %30 = extractvalue %"int[]" %29, 0 - %31 = extractvalue %"int[]" %26, 0 - store %"int[]" %26, ptr %taddr4, align 8 - %32 = getelementptr inbounds %"int[]", ptr %taddr4, i32 0, i32 1 - %33 = load i64, ptr %32, align 8 - %34 = mul i64 %33, 4 - call void @llvm.memcpy.p0.p0.i64(ptr align 4 %30, ptr align 4 %31, i64 %34, i1 false) - store %"char[]" { ptr @.str.1, i64 5 }, ptr %taddr6, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 0 - %lo7 = load ptr, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 1 - %hi8 = load i64, ptr %36, align 8 - %37 = insertvalue %variant undef, ptr %y, 0 - %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"ct$v6$int" to i64), 1 - %39 = getelementptr inbounds [2 x %variant], ptr %varargslots10, i64 0, i64 0 - store %variant %38, ptr %39, align 16 - %40 = insertvalue %variant undef, ptr %z, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$v7$int" to i64), 1 - %42 = getelementptr inbounds [2 x %variant], ptr %varargslots10, i64 0, i64 1 - store %variant %41, ptr %42, align 16 - %43 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 1 - store i64 2, ptr %43, align 8 - %44 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 0 - store ptr %varargslots10, ptr %44, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 0 - %lo11 = load ptr, ptr %45, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 1 - %hi12 = load i64, ptr %46, align 8 - %47 = call i64 @std_io_printfln(ptr %retparam5, ptr %lo7, i64 %hi8, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %47, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %18 = getelementptr inbounds <7 x i32>, ptr %z, i64 0, i64 5 + %19 = insertvalue %"int[]" undef, ptr %18, 0 + %20 = insertvalue %"int[]" %19, i64 2, 1 + %21 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 4 + %22 = insertvalue %"int[]" undef, ptr %21, 0 + %23 = insertvalue %"int[]" %22, i64 2, 1 + %24 = extractvalue %"int[]" %23, 0 + %25 = extractvalue %"int[]" %20, 0 + store %"int[]" %20, ptr %taddr1, align 8 + %26 = getelementptr inbounds %"int[]", ptr %taddr1, i32 0, i32 1 + %27 = load i64, ptr %26, align 8 + %28 = mul i64 %27, 4 + call void @llvm.memcpy.p0.p0.i64(ptr align 4 %24, ptr align 4 %25, i64 %28, i1 false) + %29 = insertvalue %variant undef, ptr %y, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$v6$int" to i64), 1 + %31 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 0 + store %variant %30, ptr %31, align 16 + %32 = insertvalue %variant undef, ptr %z, 0 + %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$v7$int" to i64), 1 + %34 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 1 + store %variant %33, ptr %34, align 16 + %35 = call i64 @std_io_printfln(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2) + %not_err4 = icmp eq i64 %35, 0 + br i1 %not_err4, label %after_check5, label %voiderr6 -after_check14: ; preds = %voiderr - br label %voiderr15 +after_check5: ; preds = %voiderr + br label %voiderr6 -voiderr15: ; preds = %after_check14, %voiderr - %48 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0 - %49 = getelementptr inbounds [1 x i32], ptr %literal16, i64 0, i64 0 - store i32 1, ptr %49, align 4 - %50 = insertvalue %"int[]" undef, ptr %literal16, 0 - %51 = insertvalue %"int[]" %50, i64 1, 1 - store %"int[]" %51, ptr %48, align 8 - %52 = insertvalue %"int[][]" undef, ptr %literal, 0 - %53 = insertvalue %"int[][]" %52, i64 1, 1 - store %"int[][]" %53, ptr %a, align 8 - %54 = getelementptr inbounds [1 x %"int[]"], ptr %literal17, i64 0, i64 0 - %55 = getelementptr inbounds [1 x i32], ptr %literal18, i64 0, i64 0 - store i32 2, ptr %55, align 4 - %56 = insertvalue %"int[]" undef, ptr %literal18, 0 - %57 = insertvalue %"int[]" %56, i64 1, 1 - store %"int[]" %57, ptr %54, align 8 - %58 = insertvalue %"int[][]" undef, ptr %literal17, 0 +voiderr6: ; preds = %after_check5, %voiderr + %36 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0 + %37 = getelementptr inbounds [1 x i32], ptr %literal7, i64 0, i64 0 + store i32 1, ptr %37, align 4 + %38 = insertvalue %"int[]" undef, ptr %literal7, 0 + %39 = insertvalue %"int[]" %38, i64 1, 1 + store %"int[]" %39, ptr %36, align 8 + %40 = insertvalue %"int[][]" undef, ptr %literal, 0 + %41 = insertvalue %"int[][]" %40, i64 1, 1 + store %"int[][]" %41, ptr %a, align 8 + %42 = getelementptr inbounds [1 x %"int[]"], ptr %literal8, i64 0, i64 0 + %43 = getelementptr inbounds [1 x i32], ptr %literal9, i64 0, i64 0 + store i32 2, ptr %43, align 4 + %44 = insertvalue %"int[]" undef, ptr %literal9, 0 + %45 = insertvalue %"int[]" %44, i64 1, 1 + store %"int[]" %45, ptr %42, align 8 + %46 = insertvalue %"int[][]" undef, ptr %literal8, 0 + %47 = insertvalue %"int[][]" %46, i64 1, 1 + store %"int[][]" %47, ptr %b, align 8 + %48 = insertvalue %variant undef, ptr %a, 0 + %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 + %50 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0 + store %variant %49, ptr %50, align 16 + %51 = call i64 @std_io_printfln(ptr %retparam10, ptr @.str.2, i64 2, ptr %varargslots11, i64 1) + %not_err12 = icmp eq i64 %51, 0 + br i1 %not_err12, label %after_check13, label %voiderr14 + +after_check13: ; preds = %voiderr6 + br label %voiderr14 + +voiderr14: ; preds = %after_check13, %voiderr6 + %52 = load %"int[][]", ptr %b, align 8 + %53 = extractvalue %"int[][]" %52, 0 + %ptroffset = getelementptr inbounds %"int[]", ptr %53, i64 0 + %54 = insertvalue %"int[][]" undef, ptr %ptroffset, 0 + %55 = insertvalue %"int[][]" %54, i64 1, 1 + %56 = load %"int[][]", ptr %a, align 8 + %57 = extractvalue %"int[][]" %56, 0 + %ptroffset15 = getelementptr inbounds %"int[]", ptr %57, i64 0 + %58 = insertvalue %"int[][]" undef, ptr %ptroffset15, 0 %59 = insertvalue %"int[][]" %58, i64 1, 1 - store %"int[][]" %59, ptr %b, align 8 - store %"char[]" { ptr @.str.2, i64 2 }, ptr %taddr20, align 8 - %60 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0 - %lo21 = load ptr, ptr %60, align 8 - %61 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1 - %hi22 = load i64, ptr %61, align 8 - %62 = insertvalue %variant undef, ptr %a, 0 - %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 - %64 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 - store %variant %63, ptr %64, align 16 - %65 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1 - store i64 1, ptr %65, align 8 - %66 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0 - store ptr %varargslots24, ptr %66, align 8 - %67 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0 - %lo25 = load ptr, ptr %67, align 8 - %68 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1 - %hi26 = load i64, ptr %68, align 8 - %69 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %69, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 + %60 = extractvalue %"int[][]" %59, 0 + %61 = extractvalue %"int[][]" %55, 0 + store %"int[][]" %55, ptr %taddr16, align 8 + %62 = getelementptr inbounds %"int[][]", ptr %taddr16, i32 0, i32 1 + %63 = load i64, ptr %62, align 8 + %64 = mul i64 %63, 16 + call void @llvm.memcpy.p0.p0.i64(ptr align 8 %60, ptr align 8 %61, i64 %64, i1 false) + %65 = insertvalue %variant undef, ptr %a, 0 + %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 + %67 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0 + store %variant %66, ptr %67, align 16 + %68 = call i64 @std_io_printfln(ptr %retparam17, ptr @.str.3, i64 2, ptr %varargslots18, i64 1) + %not_err19 = icmp eq i64 %68, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 -after_check28: ; preds = %voiderr15 - br label %voiderr29 +after_check20: ; preds = %voiderr14 + br label %voiderr21 -voiderr29: ; preds = %after_check28, %voiderr15 - %70 = load %"int[][]", ptr %b, align 8 - %71 = extractvalue %"int[][]" %70, 0 - %ptroffset = getelementptr inbounds %"int[]", ptr %71, i64 0 - %72 = insertvalue %"int[][]" undef, ptr %ptroffset, 0 - %73 = insertvalue %"int[][]" %72, i64 1, 1 - %74 = load %"int[][]", ptr %a, align 8 - %75 = extractvalue %"int[][]" %74, 0 - %ptroffset30 = getelementptr inbounds %"int[]", ptr %75, i64 0 - %76 = insertvalue %"int[][]" undef, ptr %ptroffset30, 0 - %77 = insertvalue %"int[][]" %76, i64 1, 1 - %78 = extractvalue %"int[][]" %77, 0 - %79 = extractvalue %"int[][]" %73, 0 - store %"int[][]" %73, ptr %taddr31, align 8 - %80 = getelementptr inbounds %"int[][]", ptr %taddr31, i32 0, i32 1 - %81 = load i64, ptr %80, align 8 - %82 = mul i64 %81, 16 - call void @llvm.memcpy.p0.p0.i64(ptr align 8 %78, ptr align 8 %79, i64 %82, i1 false) - store %"char[]" { ptr @.str.3, i64 2 }, ptr %taddr33, align 8 - %83 = getelementptr inbounds { ptr, i64 }, ptr %taddr33, i32 0, i32 0 - %lo34 = load ptr, ptr %83, align 8 - %84 = getelementptr inbounds { ptr, i64 }, ptr %taddr33, i32 0, i32 1 - %hi35 = load i64, ptr %84, align 8 - %85 = insertvalue %variant undef, ptr %a, 0 - %86 = insertvalue %variant %85, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 - %87 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0 - store %variant %86, ptr %87, align 16 - %88 = getelementptr inbounds %"variant[]", ptr %vararg36, i32 0, i32 1 - store i64 1, ptr %88, align 8 - %89 = getelementptr inbounds %"variant[]", ptr %vararg36, i32 0, i32 0 - store ptr %varargslots37, ptr %89, align 8 - %90 = getelementptr inbounds { ptr, i64 }, ptr %vararg36, i32 0, i32 0 - %lo38 = load ptr, ptr %90, align 8 - %91 = getelementptr inbounds { ptr, i64 }, ptr %vararg36, i32 0, i32 1 - %hi39 = load i64, ptr %91, align 8 - %92 = call i64 @std_io_printfln(ptr %retparam32, ptr %lo34, i64 %hi35, ptr %lo38, i64 %hi39) - %not_err40 = icmp eq i64 %92, 0 - br i1 %not_err40, label %after_check41, label %voiderr42 +voiderr21: ; preds = %after_check20, %voiderr14 + %69 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 2 + %70 = insertvalue %"int[]" undef, ptr %69, 0 + %71 = insertvalue %"int[]" %70, i64 3, 1 + %72 = load %"int[][]", ptr %a, align 8 + %73 = extractvalue %"int[][]" %72, 0 + %ptroffset22 = getelementptr inbounds %"int[]", ptr %73, i64 0 + store %"int[]" %71, ptr %ptroffset22, align 8 + %74 = insertvalue %variant undef, ptr %a, 0 + %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 + %76 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 + store %variant %75, ptr %76, align 16 + %77 = call i64 @std_io_printfln(ptr %retparam23, ptr @.str.4, i64 2, ptr %varargslots24, i64 1) + %not_err25 = icmp eq i64 %77, 0 + br i1 %not_err25, label %after_check26, label %voiderr27 -after_check41: ; preds = %voiderr29 - br label %voiderr42 +after_check26: ; preds = %voiderr21 + br label %voiderr27 -voiderr42: ; preds = %after_check41, %voiderr29 - %93 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 2 - %94 = insertvalue %"int[]" undef, ptr %93, 0 - %95 = insertvalue %"int[]" %94, i64 3, 1 - %96 = load %"int[][]", ptr %a, align 8 - %97 = extractvalue %"int[][]" %96, 0 - %ptroffset43 = getelementptr inbounds %"int[]", ptr %97, i64 0 - store %"int[]" %95, ptr %ptroffset43, align 8 - store %"char[]" { ptr @.str.4, i64 2 }, ptr %taddr45, align 8 - %98 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 0 - %lo46 = load ptr, ptr %98, align 8 - %99 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 1 - %hi47 = load i64, ptr %99, align 8 - %100 = insertvalue %variant undef, ptr %a, 0 - %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1 - %102 = getelementptr inbounds [1 x %variant], ptr %varargslots49, i64 0, i64 0 - store %variant %101, ptr %102, align 16 - %103 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 1 - store i64 1, ptr %103, align 8 - %104 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 0 - store ptr %varargslots49, ptr %104, align 8 - %105 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 0 - %lo50 = load ptr, ptr %105, align 8 - %106 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 1 - %hi51 = load i64, ptr %106, align 8 - %107 = call i64 @std_io_printfln(ptr %retparam44, ptr %lo46, i64 %hi47, ptr %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %107, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 - -after_check53: ; preds = %voiderr42 - br label %voiderr54 - -voiderr54: ; preds = %after_check53, %voiderr42 +voiderr27: ; preds = %after_check26, %voiderr21 ret void } diff --git a/test/test_suite2/statements/foreach_more_implementations.c3t b/test/test_suite2/statements/foreach_more_implementations.c3t index 858d6bbc9..1be5fb012 100644 --- a/test/test_suite2/statements/foreach_more_implementations.c3t +++ b/test/test_suite2/statements/foreach_more_implementations.c3t @@ -51,19 +51,15 @@ entry: %vector2 = alloca ptr, align 8 %element = alloca i64, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 + %.anon4 = alloca i64, align 8 + %vector5 = alloca %Vector, align 8 %.anon6 = alloca i64, align 8 - %vector7 = alloca %Vector, align 8 - %.anon8 = alloca i64, align 8 %i = alloca i32, align 4 - %vector12 = alloca ptr, align 8 - %element13 = alloca i64, align 8 - %retparam15 = alloca i64, align 8 - %taddr16 = alloca %"char[]", align 8 - %vararg19 = alloca %"variant[]", align 8 - %varargslots20 = alloca [1 x %variant], align 16 + %vector10 = alloca ptr, align 8 + %element11 = alloca i64, align 8 + %retparam13 = alloca i64, align 8 + %varargslots14 = alloca [1 x %variant], align 16 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 @@ -92,96 +88,70 @@ loop.body: ; preds = %loop.cond %10 = load i64, ptr %element, align 8 %ptroffset = getelementptr inbounds i32, ptr %9, i64 %10 store ptr %ptroffset, ptr %ref, align 8 - store %"char[]" { ptr @.str, i64 3 }, ptr %taddr, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %12, align 8 - %13 = load ptr, ptr %ref, align 8 - %14 = insertvalue %variant undef, ptr %13, 0 - %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %15, ptr %16, align 16 - %17 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %17, align 8 - %18 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %18, align 8 - %19 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo3 = load ptr, ptr %19, align 8 - %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi4 = load i64, ptr %20, align 8 - %21 = call i64 @std_io_printf(ptr %retparam, ptr %lo, i64 %hi, ptr %lo3, i64 %hi4) - %not_err = icmp eq i64 %21, 0 + %11 = load ptr, ptr %ref, align 8 + %12 = insertvalue %variant undef, ptr %11, 0 + %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %14 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %13, ptr %14, align 16 + %15 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 3, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %15, 0 br i1 %not_err, label %after_check, label %voiderr after_check: ; preds = %loop.body br label %voiderr voiderr: ; preds = %after_check, %loop.body - %22 = load ptr, ptr %ref, align 8 - %23 = load i32, ptr %22, align 8 - %add = add i32 %23, 2 - store i32 %add, ptr %22, align 8 - %24 = load i64, ptr %.anon1, align 8 - %add5 = add i64 %24, 1 - store i64 %add5, ptr %.anon1, align 8 + %16 = load ptr, ptr %ref, align 8 + %17 = load i32, ptr %16, align 8 + %add = add i32 %17, 2 + store i32 %add, ptr %16, align 8 + %18 = load i64, ptr %.anon1, align 8 + %add3 = add i64 %18, 1 + store i64 %add3, ptr %.anon1, align 8 br label %loop.cond loop.exit: ; preds = %loop.cond - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %vector7, ptr align 8 %v, i32 16, i1 false) - %25 = getelementptr inbounds %Vector, ptr %vector7, i32 0, i32 0 - %26 = load i64, ptr %25, align 8 - store i64 %26, ptr %.anon6, align 8 - store i64 0, ptr %.anon8, align 8 - br label %loop.cond9 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %vector5, ptr align 8 %v, i32 16, i1 false) + %19 = getelementptr inbounds %Vector, ptr %vector5, i32 0, i32 0 + %20 = load i64, ptr %19, align 8 + store i64 %20, ptr %.anon4, align 8 + store i64 0, ptr %.anon6, align 8 + br label %loop.cond7 -loop.cond9: ; preds = %voiderr25, %loop.exit - %27 = load i64, ptr %.anon8, align 8 - %28 = load i64, ptr %.anon6, align 8 - %lt10 = icmp ult i64 %27, %28 - br i1 %lt10, label %loop.body11, label %loop.exit27 +loop.cond7: ; preds = %voiderr17, %loop.exit + %21 = load i64, ptr %.anon6, align 8 + %22 = load i64, ptr %.anon4, align 8 + %lt8 = icmp ult i64 %21, %22 + br i1 %lt8, label %loop.body9, label %loop.exit19 -loop.body11: ; preds = %loop.cond9 - store ptr %v, ptr %vector12, align 8 - %29 = load i64, ptr %.anon8, align 8 - store i64 %29, ptr %element13, align 8 - %30 = load ptr, ptr %vector12, align 8 - %31 = getelementptr inbounds %Vector, ptr %30, i32 0, i32 1 - %32 = load ptr, ptr %31, align 8 - %33 = load i64, ptr %element13, align 8 - %ptroffset14 = getelementptr inbounds i32, ptr %32, i64 %33 - %34 = load i32, ptr %ptroffset14, align 4 - store i32 %34, ptr %i, align 4 - store %"char[]" { ptr @.str.1, i64 3 }, ptr %taddr16, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr16, i32 0, i32 0 - %lo17 = load ptr, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %taddr16, i32 0, i32 1 - %hi18 = load i64, ptr %36, align 8 - %37 = insertvalue %variant undef, ptr %i, 0 - %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %39 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0 - store %variant %38, ptr %39, align 16 - %40 = getelementptr inbounds %"variant[]", ptr %vararg19, i32 0, i32 1 - store i64 1, ptr %40, align 8 - %41 = getelementptr inbounds %"variant[]", ptr %vararg19, i32 0, i32 0 - store ptr %varargslots20, ptr %41, align 8 - %42 = getelementptr inbounds { ptr, i64 }, ptr %vararg19, i32 0, i32 0 - %lo21 = load ptr, ptr %42, align 8 - %43 = getelementptr inbounds { ptr, i64 }, ptr %vararg19, i32 0, i32 1 - %hi22 = load i64, ptr %43, align 8 - %44 = call i64 @std_io_printf(ptr %retparam15, ptr %lo17, i64 %hi18, ptr %lo21, i64 %hi22) - %not_err23 = icmp eq i64 %44, 0 - br i1 %not_err23, label %after_check24, label %voiderr25 +loop.body9: ; preds = %loop.cond7 + store ptr %v, ptr %vector10, align 8 + %23 = load i64, ptr %.anon6, align 8 + store i64 %23, ptr %element11, align 8 + %24 = load ptr, ptr %vector10, align 8 + %25 = getelementptr inbounds %Vector, ptr %24, i32 0, i32 1 + %26 = load ptr, ptr %25, align 8 + %27 = load i64, ptr %element11, align 8 + %ptroffset12 = getelementptr inbounds i32, ptr %26, i64 %27 + %28 = load i32, ptr %ptroffset12, align 4 + store i32 %28, ptr %i, align 4 + %29 = insertvalue %variant undef, ptr %i, 0 + %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0 + store %variant %30, ptr %31, align 16 + %32 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.1, i64 3, ptr %varargslots14, i64 1) + %not_err15 = icmp eq i64 %32, 0 + br i1 %not_err15, label %after_check16, label %voiderr17 -after_check24: ; preds = %loop.body11 - br label %voiderr25 +after_check16: ; preds = %loop.body9 + br label %voiderr17 -voiderr25: ; preds = %after_check24, %loop.body11 - %45 = load i64, ptr %.anon8, align 8 - %add26 = add i64 %45, 1 - store i64 %add26, ptr %.anon8, align 8 - br label %loop.cond9 +voiderr17: ; preds = %after_check16, %loop.body9 + %33 = load i64, ptr %.anon6, align 8 + %add18 = add i64 %33, 1 + store i64 %add18, ptr %.anon6, align 8 + br label %loop.cond7 -loop.exit27: ; preds = %loop.cond9 +loop.exit19: ; preds = %loop.cond7 ret void } \ No newline at end of file diff --git a/test/test_suite2/stdlib/map.c3t b/test/test_suite2/stdlib/map.c3t index 83421f078..457eb2b4a 100644 --- a/test/test_suite2/stdlib/map.c3t +++ b/test/test_suite2/stdlib/map.c3t @@ -77,142 +77,21 @@ define { ptr, i64 } @test_Foo_to_string(ptr %0, ptr %1) #0 { entry: %s = alloca ptr, align 8 %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [2 x %variant], align 16 %result = alloca %"char[]", align 8 %2 = call ptr @std_core_string_new_with_capacity(i64 128, ptr %1) store ptr %2, ptr %s, align 8 - store %"char[]" { ptr @.str.14, i64 8 }, ptr %taddr, align 8 - %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %3, align 8 - %4 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %4, align 8 - %5 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 0 - %6 = insertvalue %variant undef, ptr %5, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %8 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %7, ptr %8, align 16 - %9 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 1 - %10 = insertvalue %variant undef, ptr %9, 0 - %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$p$void" to i64), 1 - %12 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 - store %variant %11, ptr %12, align 16 - %13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 2, ptr %13, align 8 - %14 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo1 = load ptr, ptr %15, align 8 - %16 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi2 = load i64, ptr %16, align 8 - %17 = call i64 @std_core_string_String_printf(ptr %retparam, ptr %s, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) - %not_err = icmp eq i64 %17, 0 - br i1 %not_err, label %after_check, label %voiderr - -after_check: ; preds = %entry - br label %voiderr - -voiderr: ; preds = %after_check, %entry - %18 = load ptr, ptr %s, align 8 - %19 = call { ptr, i64 } @std_core_string_String_str(ptr %18) - store { ptr, i64 } %19, ptr %result, align 8 - %20 = load { ptr, i64 }, ptr %result, align 8 - ret { ptr, i64 } %20 -} - -; Function Attrs: nounwind -define void @test_main() #0 { -entry: - %map = alloca %HashMap.0, align 8 - %retparam = alloca i64, align 8 - %taddr = alloca %"char[]", align 8 - %vararg = alloca %"variant[]", align 8 - %varargslots = alloca [1 x %variant], align 16 - %literal = alloca %Foo, align 8 - %retparam5 = alloca i64, align 8 - %taddr6 = alloca %"char[]", align 8 - %vararg9 = alloca %"variant[]", align 8 - %varargslots10 = alloca [1 x %variant], align 16 - %literal16 = alloca %Foo, align 8 - %retparam19 = alloca i64, align 8 - %taddr20 = alloca %"char[]", align 8 - %vararg23 = alloca %"variant[]", align 8 - %varargslots24 = alloca [1 x %variant], align 16 - %retparam30 = alloca i64, align 8 - %taddr31 = alloca %"char[]", align 8 - %vararg34 = alloca %"variant[]", align 8 - %varargslots35 = alloca [1 x %variant], align 16 - %retparam36 = alloca %Foo, align 8 - %retparam44 = alloca i64, align 8 - %taddr45 = alloca %"char[]", align 8 - %vararg48 = alloca %"variant[]", align 8 - %varargslots49 = alloca [1 x %variant], align 16 - %taddr50 = alloca i8, align 1 - %retparam56 = alloca i64, align 8 - %taddr57 = alloca %"char[]", align 8 - %vararg60 = alloca %"variant[]", align 8 - %varargslots61 = alloca [1 x %variant], align 16 - %taddr62 = alloca i8, align 1 - %literal68 = alloca %Foo, align 8 - %retparam71 = alloca i64, align 8 - %taddr72 = alloca %"char[]", align 8 - %vararg75 = alloca %"variant[]", align 8 - %varargslots76 = alloca [1 x %variant], align 16 - %result = alloca %"Foo[]", align 8 - %map2 = alloca %HashMap.3, align 8 - %retparam82 = alloca i64, align 8 - %taddr83 = alloca %"char[]", align 8 - %vararg86 = alloca %"variant[]", align 8 - %varargslots87 = alloca [1 x %variant], align 16 - %taddr88 = alloca i8, align 1 - %retparam94 = alloca i64, align 8 - %taddr95 = alloca %"char[]", align 8 - %vararg98 = alloca %"variant[]", align 8 - %varargslots99 = alloca [1 x %variant], align 16 - %taddr100 = alloca i8, align 1 - %retparam106 = alloca i64, align 8 - %taddr107 = alloca %"char[]", align 8 - %vararg110 = alloca %"variant[]", align 8 - %varargslots111 = alloca [1 x %variant], align 16 - %result112 = alloca %"int[]", align 8 - %retparam118 = alloca i64, align 8 - %taddr119 = alloca %"char[]", align 8 - %vararg122 = alloca %"variant[]", align 8 - %varargslots123 = alloca [1 x %variant], align 16 - %result124 = alloca %"double[]", align 8 - %temp = alloca ptr, align 8 - %error_var = alloca i64, align 8 - %retparam130 = alloca ptr, align 8 - %mark = alloca i64, align 8 - %map3 = alloca %HashMap.3, align 8 - %retparam133 = alloca i64, align 8 - %taddr134 = alloca %"char[]", align 8 - %vararg137 = alloca %"variant[]", align 8 - %varargslots138 = alloca [1 x %variant], align 16 - %result139 = alloca %"int[]", align 8 - call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false) - %0 = load ptr, ptr @std_core_mem_thread_allocator, align 8 - call void @"std_map$$int.test_Foo_HashMap_init"(ptr %map, i32 16, float 7.500000e-01, ptr %0) - store %"char[]" { ptr @.str, i64 12 }, ptr %taddr, align 8 - %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 - %lo = load ptr, ptr %1, align 8 - %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %2, align 8 - %3 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2 + %3 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 0 %4 = insertvalue %variant undef, ptr %3, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %6 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0 store %variant %5, ptr %6, align 16 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %7, align 8 - %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo1 = load ptr, ptr %9, align 8 - %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi2 = load i64, ptr %10, align 8 - %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) + %7 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 1 + %8 = insertvalue %variant undef, ptr %7, 0 + %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$p$void" to i64), 1 + %10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1 + store %variant %9, ptr %10, align 16 + %11 = call i64 @std_core_string_String_printf(ptr %retparam, ptr %s, ptr @.str.12, i64 8, ptr %varargslots, i64 2) %not_err = icmp eq i64 %11, 0 br i1 %not_err, label %after_check, label %voiderr @@ -220,381 +99,308 @@ after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - %12 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0 - store i32 1, ptr %12, align 8 - %13 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1 - store ptr null, ptr %13, align 8 - %14 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 0 - %lo3 = load i64, ptr %14, align 8 - %15 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 1 - %hi4 = load ptr, ptr %15, align 8 - %16 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo3, ptr %hi4) - store %"char[]" { ptr @.str.1, i64 12 }, ptr %taddr6, align 8 - %17 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 0 - %lo7 = load ptr, ptr %17, align 8 - %18 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 1 - %hi8 = load i64, ptr %18, align 8 - %19 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2 - %20 = insertvalue %variant undef, ptr %19, 0 - %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %22 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0 - store %variant %21, ptr %22, align 16 - %23 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 1 - store i64 1, ptr %23, align 8 - %24 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 0 - store ptr %varargslots10, ptr %24, align 8 - %25 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 0 - %lo11 = load ptr, ptr %25, align 8 - %26 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 1 - %hi12 = load i64, ptr %26, align 8 - %27 = call i64 @std_io_printfln(ptr %retparam5, ptr %lo7, i64 %hi8, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %27, 0 - br i1 %not_err13, label %after_check14, label %voiderr15 + %12 = load ptr, ptr %s, align 8 + %13 = call { ptr, i64 } @std_core_string_String_str(ptr %12) + store { ptr, i64 } %13, ptr %result, align 8 + %14 = load { ptr, i64 }, ptr %result, align 8 + ret { ptr, i64 } %14 +} -after_check14: ; preds = %voiderr - br label %voiderr15 +; Function Attrs: nounwind +define void @test_main() #0 { +entry: + %map = alloca %HashMap.0, align 8 + %retparam = alloca i64, align 8 + %varargslots = alloca [1 x %variant], align 16 + %literal = alloca %Foo, align 8 + %retparam1 = alloca i64, align 8 + %varargslots2 = alloca [1 x %variant], align 16 + %literal6 = alloca %Foo, align 8 + %retparam9 = alloca i64, align 8 + %varargslots10 = alloca [1 x %variant], align 16 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [1 x %variant], align 16 + %retparam16 = alloca %Foo, align 8 + %retparam22 = alloca i64, align 8 + %varargslots23 = alloca [1 x %variant], align 16 + %taddr = alloca i8, align 1 + %retparam27 = alloca i64, align 8 + %varargslots28 = alloca [1 x %variant], align 16 + %taddr29 = alloca i8, align 1 + %literal33 = alloca %Foo, align 8 + %retparam36 = alloca i64, align 8 + %varargslots37 = alloca [1 x %variant], align 16 + %result = alloca %"Foo[]", align 8 + %map2 = alloca %HashMap.3, align 8 + %retparam41 = alloca i64, align 8 + %varargslots42 = alloca [1 x %variant], align 16 + %taddr43 = alloca i8, align 1 + %retparam47 = alloca i64, align 8 + %varargslots48 = alloca [1 x %variant], align 16 + %taddr49 = alloca i8, align 1 + %retparam53 = alloca i64, align 8 + %varargslots54 = alloca [1 x %variant], align 16 + %result55 = alloca %"int[]", align 8 + %retparam59 = alloca i64, align 8 + %varargslots60 = alloca [1 x %variant], align 16 + %result61 = alloca %"double[]", align 8 + %temp = alloca ptr, align 8 + %error_var = alloca i64, align 8 + %retparam65 = alloca ptr, align 8 + %mark = alloca i64, align 8 + %map3 = alloca %HashMap.3, align 8 + %retparam68 = alloca i64, align 8 + %varargslots69 = alloca [1 x %variant], align 16 + %result70 = alloca %"int[]", align 8 + call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false) + %0 = load ptr, ptr @std_core_mem_thread_allocator, align 8 + call void @"std_map$$int.test_Foo_HashMap_init"(ptr %map, i32 16, float 7.500000e-01, ptr %0) + %1 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2 + %2 = insertvalue %variant undef, ptr %1, 0 + %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %3, ptr %4, align 16 + %5 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1) + %not_err = icmp eq i64 %5, 0 + br i1 %not_err, label %after_check, label %voiderr -voiderr15: ; preds = %after_check14, %voiderr - %28 = getelementptr inbounds %Foo, ptr %literal16, i32 0, i32 0 - store i32 2, ptr %28, align 8 - %29 = getelementptr inbounds %Foo, ptr %literal16, i32 0, i32 1 - store ptr null, ptr %29, align 8 - %30 = getelementptr inbounds { i64, ptr }, ptr %literal16, i32 0, i32 0 - %lo17 = load i64, ptr %30, align 8 - %31 = getelementptr inbounds { i64, ptr }, ptr %literal16, i32 0, i32 1 - %hi18 = load ptr, ptr %31, align 8 - %32 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo17, ptr %hi18) - store %"char[]" { ptr @.str.2, i64 12 }, ptr %taddr20, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0 - %lo21 = load ptr, ptr %33, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1 - %hi22 = load i64, ptr %34, align 8 - %35 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2 - %36 = insertvalue %variant undef, ptr %35, 0 - %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$uint" to i64), 1 - %38 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 - store %variant %37, ptr %38, align 16 - %39 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1 - store i64 1, ptr %39, align 8 - %40 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0 - store ptr %varargslots24, ptr %40, align 8 - %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0 - %lo25 = load ptr, ptr %41, align 8 - %42 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1 - %hi26 = load i64, ptr %42, align 8 - %43 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26) - %not_err27 = icmp eq i64 %43, 0 - br i1 %not_err27, label %after_check28, label %voiderr29 +after_check: ; preds = %entry + br label %voiderr -after_check28: ; preds = %voiderr15 - br label %voiderr29 +voiderr: ; preds = %after_check, %entry + %6 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0 + store i32 1, ptr %6, align 8 + %7 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1 + store ptr null, ptr %7, align 8 + %8 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 0 + %lo = load i64, ptr %8, align 8 + %9 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 1 + %hi = load ptr, ptr %9, align 8 + %10 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo, ptr %hi) + %11 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2 + %12 = insertvalue %variant undef, ptr %11, 0 + %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %14 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0 + store %variant %13, ptr %14, align 16 + %15 = call i64 @std_io_printfln(ptr %retparam1, ptr @.str.1, i64 12, ptr %varargslots2, i64 1) + %not_err3 = icmp eq i64 %15, 0 + br i1 %not_err3, label %after_check4, label %voiderr5 -voiderr29: ; preds = %after_check28, %voiderr15 - store %"char[]" { ptr @.str.3, i64 7 }, ptr %taddr31, align 8 - %44 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 0 - %lo32 = load ptr, ptr %44, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 1 - %hi33 = load i64, ptr %45, align 8 - %46 = call i64 @"std_map$$int.test_Foo_HashMap_get"(ptr %retparam36, ptr %map, i32 1) - %not_err37 = icmp eq i64 %46, 0 - br i1 %not_err37, label %after_check38, label %voiderr43 +after_check4: ; preds = %voiderr + br label %voiderr5 -after_check38: ; preds = %voiderr29 - %47 = getelementptr inbounds %Foo, ptr %retparam36, i32 0, i32 0 - %48 = insertvalue %variant undef, ptr %47, 0 - %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %50 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0 - store %variant %49, ptr %50, align 16 - %51 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 1 - store i64 1, ptr %51, align 8 - %52 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 0 - store ptr %varargslots35, ptr %52, align 8 - %53 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 0 - %lo39 = load ptr, ptr %53, align 8 - %54 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 1 - %hi40 = load i64, ptr %54, align 8 - %55 = call i64 @std_io_printfln(ptr %retparam30, ptr %lo32, i64 %hi33, ptr %lo39, i64 %hi40) - %not_err41 = icmp eq i64 %55, 0 - br i1 %not_err41, label %after_check42, label %voiderr43 +voiderr5: ; preds = %after_check4, %voiderr + %16 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 0 + store i32 2, ptr %16, align 8 + %17 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 1 + store ptr null, ptr %17, align 8 + %18 = getelementptr inbounds { i64, ptr }, ptr %literal6, i32 0, i32 0 + %lo7 = load i64, ptr %18, align 8 + %19 = getelementptr inbounds { i64, ptr }, ptr %literal6, i32 0, i32 1 + %hi8 = load ptr, ptr %19, align 8 + %20 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo7, ptr %hi8) + %21 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2 + %22 = insertvalue %variant undef, ptr %21, 0 + %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$uint" to i64), 1 + %24 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0 + store %variant %23, ptr %24, align 16 + %25 = call i64 @std_io_printfln(ptr %retparam9, ptr @.str.2, i64 12, ptr %varargslots10, i64 1) + %not_err11 = icmp eq i64 %25, 0 + br i1 %not_err11, label %after_check12, label %voiderr13 -after_check42: ; preds = %after_check38 - br label %voiderr43 +after_check12: ; preds = %voiderr5 + br label %voiderr13 -voiderr43: ; preds = %after_check42, %after_check38, %voiderr29 - store %"char[]" { ptr @.str.4, i64 9 }, ptr %taddr45, align 8 - %56 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 0 - %lo46 = load ptr, ptr %56, align 8 - %57 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 1 - %hi47 = load i64, ptr %57, align 8 - %58 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 1) - store i8 %58, ptr %taddr50, align 1 - %59 = insertvalue %variant undef, ptr %taddr50, 0 - %60 = insertvalue %variant %59, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %61 = getelementptr inbounds [1 x %variant], ptr %varargslots49, i64 0, i64 0 - store %variant %60, ptr %61, align 16 - %62 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 1 - store i64 1, ptr %62, align 8 - %63 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 0 - store ptr %varargslots49, ptr %63, align 8 - %64 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 0 - %lo51 = load ptr, ptr %64, align 8 - %65 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 1 - %hi52 = load i64, ptr %65, align 8 - %66 = call i64 @std_io_printfln(ptr %retparam44, ptr %lo46, i64 %hi47, ptr %lo51, i64 %hi52) - %not_err53 = icmp eq i64 %66, 0 - br i1 %not_err53, label %after_check54, label %voiderr55 +voiderr13: ; preds = %after_check12, %voiderr5 + %26 = call i64 @"std_map$$int.test_Foo_HashMap_get"(ptr %retparam16, ptr %map, i32 1) + %not_err17 = icmp eq i64 %26, 0 + br i1 %not_err17, label %after_check18, label %voiderr21 -after_check54: ; preds = %voiderr43 - br label %voiderr55 +after_check18: ; preds = %voiderr13 + %27 = getelementptr inbounds %Foo, ptr %retparam16, i32 0, i32 0 + %28 = insertvalue %variant undef, ptr %27, 0 + %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %30 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0 + store %variant %29, ptr %30, align 16 + %31 = call i64 @std_io_printfln(ptr %retparam14, ptr @.str.3, i64 7, ptr %varargslots15, i64 1) + %not_err19 = icmp eq i64 %31, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 -voiderr55: ; preds = %after_check54, %voiderr43 - store %"char[]" { ptr @.str.5, i64 9 }, ptr %taddr57, align 8 - %67 = getelementptr inbounds { ptr, i64 }, ptr %taddr57, i32 0, i32 0 - %lo58 = load ptr, ptr %67, align 8 - %68 = getelementptr inbounds { ptr, i64 }, ptr %taddr57, i32 0, i32 1 - %hi59 = load i64, ptr %68, align 8 - %69 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 2) - store i8 %69, ptr %taddr62, align 1 - %70 = insertvalue %variant undef, ptr %taddr62, 0 - %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %72 = getelementptr inbounds [1 x %variant], ptr %varargslots61, i64 0, i64 0 - store %variant %71, ptr %72, align 16 - %73 = getelementptr inbounds %"variant[]", ptr %vararg60, i32 0, i32 1 - store i64 1, ptr %73, align 8 - %74 = getelementptr inbounds %"variant[]", ptr %vararg60, i32 0, i32 0 - store ptr %varargslots61, ptr %74, align 8 - %75 = getelementptr inbounds { ptr, i64 }, ptr %vararg60, i32 0, i32 0 - %lo63 = load ptr, ptr %75, align 8 - %76 = getelementptr inbounds { ptr, i64 }, ptr %vararg60, i32 0, i32 1 - %hi64 = load i64, ptr %76, align 8 - %77 = call i64 @std_io_printfln(ptr %retparam56, ptr %lo58, i64 %hi59, ptr %lo63, i64 %hi64) - %not_err65 = icmp eq i64 %77, 0 - br i1 %not_err65, label %after_check66, label %voiderr67 +after_check20: ; preds = %after_check18 + br label %voiderr21 -after_check66: ; preds = %voiderr55 - br label %voiderr67 +voiderr21: ; preds = %after_check20, %after_check18, %voiderr13 + %32 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 1) + store i8 %32, ptr %taddr, align 1 + %33 = insertvalue %variant undef, ptr %taddr, 0 + %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %35 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0 + store %variant %34, ptr %35, align 16 + %36 = call i64 @std_io_printfln(ptr %retparam22, ptr @.str.4, i64 9, ptr %varargslots23, i64 1) + %not_err24 = icmp eq i64 %36, 0 + br i1 %not_err24, label %after_check25, label %voiderr26 -voiderr67: ; preds = %after_check66, %voiderr55 - %78 = getelementptr inbounds %Foo, ptr %literal68, i32 0, i32 0 - store i32 4, ptr %78, align 8 - %79 = getelementptr inbounds %Foo, ptr %literal68, i32 0, i32 1 - store ptr null, ptr %79, align 8 - %80 = getelementptr inbounds { i64, ptr }, ptr %literal68, i32 0, i32 0 - %lo69 = load i64, ptr %80, align 8 - %81 = getelementptr inbounds { i64, ptr }, ptr %literal68, i32 0, i32 1 - %hi70 = load ptr, ptr %81, align 8 - %82 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 7, i64 %lo69, ptr %hi70) - store %"char[]" { ptr @.str.6, i64 10 }, ptr %taddr72, align 8 - %83 = getelementptr inbounds { ptr, i64 }, ptr %taddr72, i32 0, i32 0 - %lo73 = load ptr, ptr %83, align 8 - %84 = getelementptr inbounds { ptr, i64 }, ptr %taddr72, i32 0, i32 1 - %hi74 = load i64, ptr %84, align 8 - %85 = load ptr, ptr @std_core_mem_thread_allocator, align 8 - %86 = call { ptr, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(ptr %map, ptr %85) - store { ptr, i64 } %86, ptr %result, align 8 - %87 = insertvalue %variant undef, ptr %result, 0 - %88 = insertvalue %variant %87, i64 ptrtoint (ptr @"ct$sa$test_Foo" to i64), 1 - %89 = getelementptr inbounds [1 x %variant], ptr %varargslots76, i64 0, i64 0 - store %variant %88, ptr %89, align 16 - %90 = getelementptr inbounds %"variant[]", ptr %vararg75, i32 0, i32 1 - store i64 1, ptr %90, align 8 - %91 = getelementptr inbounds %"variant[]", ptr %vararg75, i32 0, i32 0 - store ptr %varargslots76, ptr %91, align 8 - %92 = getelementptr inbounds { ptr, i64 }, ptr %vararg75, i32 0, i32 0 - %lo77 = load ptr, ptr %92, align 8 - %93 = getelementptr inbounds { ptr, i64 }, ptr %vararg75, i32 0, i32 1 - %hi78 = load i64, ptr %93, align 8 - %94 = call i64 @std_io_printfln(ptr %retparam71, ptr %lo73, i64 %hi74, ptr %lo77, i64 %hi78) - %not_err79 = icmp eq i64 %94, 0 - br i1 %not_err79, label %after_check80, label %voiderr81 +after_check25: ; preds = %voiderr21 + br label %voiderr26 -after_check80: ; preds = %voiderr67 - br label %voiderr81 +voiderr26: ; preds = %after_check25, %voiderr21 + %37 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 2) + store i8 %37, ptr %taddr29, align 1 + %38 = insertvalue %variant undef, ptr %taddr29, 0 + %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %40 = getelementptr inbounds [1 x %variant], ptr %varargslots28, i64 0, i64 0 + store %variant %39, ptr %40, align 16 + %41 = call i64 @std_io_printfln(ptr %retparam27, ptr @.str.5, i64 9, ptr %varargslots28, i64 1) + %not_err30 = icmp eq i64 %41, 0 + br i1 %not_err30, label %after_check31, label %voiderr32 -voiderr81: ; preds = %after_check80, %voiderr67 +after_check31: ; preds = %voiderr26 + br label %voiderr32 + +voiderr32: ; preds = %after_check31, %voiderr26 + %42 = getelementptr inbounds %Foo, ptr %literal33, i32 0, i32 0 + store i32 4, ptr %42, align 8 + %43 = getelementptr inbounds %Foo, ptr %literal33, i32 0, i32 1 + store ptr null, ptr %43, align 8 + %44 = getelementptr inbounds { i64, ptr }, ptr %literal33, i32 0, i32 0 + %lo34 = load i64, ptr %44, align 8 + %45 = getelementptr inbounds { i64, ptr }, ptr %literal33, i32 0, i32 1 + %hi35 = load ptr, ptr %45, align 8 + %46 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 7, i64 %lo34, ptr %hi35) + %47 = load ptr, ptr @std_core_mem_thread_allocator, align 8 + %48 = call { ptr, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(ptr %map, ptr %47) + store { ptr, i64 } %48, ptr %result, align 8 + %49 = insertvalue %variant undef, ptr %result, 0 + %50 = insertvalue %variant %49, i64 ptrtoint (ptr @"ct$sa$test_Foo" to i64), 1 + %51 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0 + store %variant %50, ptr %51, align 16 + %52 = call i64 @std_io_printfln(ptr %retparam36, ptr @.str.6, i64 10, ptr %varargslots37, i64 1) + %not_err38 = icmp eq i64 %52, 0 + br i1 %not_err38, label %after_check39, label %voiderr40 + +after_check39: ; preds = %voiderr32 + br label %voiderr40 + +voiderr40: ; preds = %after_check39, %voiderr32 call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 40, i1 false) - %95 = load ptr, ptr @std_core_mem_thread_allocator, align 8 - call void @"std_map$$int.double_HashMap_init"(ptr %map2, i32 16, float 7.500000e-01, ptr %95) - %96 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 4, double 1.300000e+00) - store %"char[]" { ptr @.str.7, i64 12 }, ptr %taddr83, align 8 - %97 = getelementptr inbounds { ptr, i64 }, ptr %taddr83, i32 0, i32 0 - %lo84 = load ptr, ptr %97, align 8 - %98 = getelementptr inbounds { ptr, i64 }, ptr %taddr83, i32 0, i32 1 - %hi85 = load i64, ptr %98, align 8 - %99 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.300000e+00) - store i8 %99, ptr %taddr88, align 1 - %100 = insertvalue %variant undef, ptr %taddr88, 0 - %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %102 = getelementptr inbounds [1 x %variant], ptr %varargslots87, i64 0, i64 0 - store %variant %101, ptr %102, align 16 - %103 = getelementptr inbounds %"variant[]", ptr %vararg86, i32 0, i32 1 - store i64 1, ptr %103, align 8 - %104 = getelementptr inbounds %"variant[]", ptr %vararg86, i32 0, i32 0 - store ptr %varargslots87, ptr %104, align 8 - %105 = getelementptr inbounds { ptr, i64 }, ptr %vararg86, i32 0, i32 0 - %lo89 = load ptr, ptr %105, align 8 - %106 = getelementptr inbounds { ptr, i64 }, ptr %vararg86, i32 0, i32 1 - %hi90 = load i64, ptr %106, align 8 - %107 = call i64 @std_io_printfln(ptr %retparam82, ptr %lo84, i64 %hi85, ptr %lo89, i64 %hi90) - %not_err91 = icmp eq i64 %107, 0 - br i1 %not_err91, label %after_check92, label %voiderr93 + %53 = load ptr, ptr @std_core_mem_thread_allocator, align 8 + call void @"std_map$$int.double_HashMap_init"(ptr %map2, i32 16, float 7.500000e-01, ptr %53) + %54 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 4, double 1.300000e+00) + %55 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.300000e+00) + store i8 %55, ptr %taddr43, align 1 + %56 = insertvalue %variant undef, ptr %taddr43, 0 + %57 = insertvalue %variant %56, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %58 = getelementptr inbounds [1 x %variant], ptr %varargslots42, i64 0, i64 0 + store %variant %57, ptr %58, align 16 + %59 = call i64 @std_io_printfln(ptr %retparam41, ptr @.str.7, i64 12, ptr %varargslots42, i64 1) + %not_err44 = icmp eq i64 %59, 0 + br i1 %not_err44, label %after_check45, label %voiderr46 -after_check92: ; preds = %voiderr81 - br label %voiderr93 +after_check45: ; preds = %voiderr40 + br label %voiderr46 -voiderr93: ; preds = %after_check92, %voiderr81 - store %"char[]" { ptr @.str.8, i64 12 }, ptr %taddr95, align 8 - %108 = getelementptr inbounds { ptr, i64 }, ptr %taddr95, i32 0, i32 0 - %lo96 = load ptr, ptr %108, align 8 - %109 = getelementptr inbounds { ptr, i64 }, ptr %taddr95, i32 0, i32 1 - %hi97 = load i64, ptr %109, align 8 - %110 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.200000e+00) - store i8 %110, ptr %taddr100, align 1 - %111 = insertvalue %variant undef, ptr %taddr100, 0 - %112 = insertvalue %variant %111, i64 ptrtoint (ptr @"ct$bool" to i64), 1 - %113 = getelementptr inbounds [1 x %variant], ptr %varargslots99, i64 0, i64 0 - store %variant %112, ptr %113, align 16 - %114 = getelementptr inbounds %"variant[]", ptr %vararg98, i32 0, i32 1 - store i64 1, ptr %114, align 8 - %115 = getelementptr inbounds %"variant[]", ptr %vararg98, i32 0, i32 0 - store ptr %varargslots99, ptr %115, align 8 - %116 = getelementptr inbounds { ptr, i64 }, ptr %vararg98, i32 0, i32 0 - %lo101 = load ptr, ptr %116, align 8 - %117 = getelementptr inbounds { ptr, i64 }, ptr %vararg98, i32 0, i32 1 - %hi102 = load i64, ptr %117, align 8 - %118 = call i64 @std_io_printfln(ptr %retparam94, ptr %lo96, i64 %hi97, ptr %lo101, i64 %hi102) - %not_err103 = icmp eq i64 %118, 0 - br i1 %not_err103, label %after_check104, label %voiderr105 +voiderr46: ; preds = %after_check45, %voiderr40 + %60 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.200000e+00) + store i8 %60, ptr %taddr49, align 1 + %61 = insertvalue %variant undef, ptr %taddr49, 0 + %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$bool" to i64), 1 + %63 = getelementptr inbounds [1 x %variant], ptr %varargslots48, i64 0, i64 0 + store %variant %62, ptr %63, align 16 + %64 = call i64 @std_io_printfln(ptr %retparam47, ptr @.str.8, i64 12, ptr %varargslots48, i64 1) + %not_err50 = icmp eq i64 %64, 0 + br i1 %not_err50, label %after_check51, label %voiderr52 -after_check104: ; preds = %voiderr93 - br label %voiderr105 +after_check51: ; preds = %voiderr46 + br label %voiderr52 -voiderr105: ; preds = %after_check104, %voiderr93 - %119 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 100, double 3.400000e+00) - store %"char[]" { ptr @.str.9, i64 2 }, ptr %taddr107, align 8 - %120 = getelementptr inbounds { ptr, i64 }, ptr %taddr107, i32 0, i32 0 - %lo108 = load ptr, ptr %120, align 8 - %121 = getelementptr inbounds { ptr, i64 }, ptr %taddr107, i32 0, i32 1 - %hi109 = load i64, ptr %121, align 8 - %122 = load ptr, ptr @std_core_mem_thread_allocator, align 8 - %123 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map2, ptr %122) - store { ptr, i64 } %123, ptr %result112, align 8 - %124 = insertvalue %variant undef, ptr %result112, 0 - %125 = insertvalue %variant %124, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1 - %126 = getelementptr inbounds [1 x %variant], ptr %varargslots111, i64 0, i64 0 - store %variant %125, ptr %126, align 16 - %127 = getelementptr inbounds %"variant[]", ptr %vararg110, i32 0, i32 1 - store i64 1, ptr %127, align 8 - %128 = getelementptr inbounds %"variant[]", ptr %vararg110, i32 0, i32 0 - store ptr %varargslots111, ptr %128, align 8 - %129 = getelementptr inbounds { ptr, i64 }, ptr %vararg110, i32 0, i32 0 - %lo113 = load ptr, ptr %129, align 8 - %130 = getelementptr inbounds { ptr, i64 }, ptr %vararg110, i32 0, i32 1 - %hi114 = load i64, ptr %130, align 8 - %131 = call i64 @std_io_printfln(ptr %retparam106, ptr %lo108, i64 %hi109, ptr %lo113, i64 %hi114) - %not_err115 = icmp eq i64 %131, 0 - br i1 %not_err115, label %after_check116, label %voiderr117 +voiderr52: ; preds = %after_check51, %voiderr46 + %65 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 100, double 3.400000e+00) + %66 = load ptr, ptr @std_core_mem_thread_allocator, align 8 + %67 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map2, ptr %66) + store { ptr, i64 } %67, ptr %result55, align 8 + %68 = insertvalue %variant undef, ptr %result55, 0 + %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1 + %70 = getelementptr inbounds [1 x %variant], ptr %varargslots54, i64 0, i64 0 + store %variant %69, ptr %70, align 16 + %71 = call i64 @std_io_printfln(ptr %retparam53, ptr @.str.9, i64 2, ptr %varargslots54, i64 1) + %not_err56 = icmp eq i64 %71, 0 + br i1 %not_err56, label %after_check57, label %voiderr58 -after_check116: ; preds = %voiderr105 - br label %voiderr117 +after_check57: ; preds = %voiderr52 + br label %voiderr58 -voiderr117: ; preds = %after_check116, %voiderr105 - store %"char[]" { ptr @.str.10, i64 2 }, ptr %taddr119, align 8 - %132 = getelementptr inbounds { ptr, i64 }, ptr %taddr119, i32 0, i32 0 - %lo120 = load ptr, ptr %132, align 8 - %133 = getelementptr inbounds { ptr, i64 }, ptr %taddr119, i32 0, i32 1 - %hi121 = load i64, ptr %133, align 8 - %134 = load ptr, ptr @std_core_mem_thread_allocator, align 8 - %135 = call { ptr, i64 } @"std_map$$int.double_HashMap_value_list"(ptr %map2, ptr %134) - store { ptr, i64 } %135, ptr %result124, align 8 - %136 = insertvalue %variant undef, ptr %result124, 0 - %137 = insertvalue %variant %136, i64 ptrtoint (ptr @"ct$sa$double" to i64), 1 - %138 = getelementptr inbounds [1 x %variant], ptr %varargslots123, i64 0, i64 0 - store %variant %137, ptr %138, align 16 - %139 = getelementptr inbounds %"variant[]", ptr %vararg122, i32 0, i32 1 - store i64 1, ptr %139, align 8 - %140 = getelementptr inbounds %"variant[]", ptr %vararg122, i32 0, i32 0 - store ptr %varargslots123, ptr %140, align 8 - %141 = getelementptr inbounds { ptr, i64 }, ptr %vararg122, i32 0, i32 0 - %lo125 = load ptr, ptr %141, align 8 - %142 = getelementptr inbounds { ptr, i64 }, ptr %vararg122, i32 0, i32 1 - %hi126 = load i64, ptr %142, align 8 - %143 = call i64 @std_io_printfln(ptr %retparam118, ptr %lo120, i64 %hi121, ptr %lo125, i64 %hi126) - %not_err127 = icmp eq i64 %143, 0 - br i1 %not_err127, label %after_check128, label %voiderr129 +voiderr58: ; preds = %after_check57, %voiderr52 + %72 = load ptr, ptr @std_core_mem_thread_allocator, align 8 + %73 = call { ptr, i64 } @"std_map$$int.double_HashMap_value_list"(ptr %map2, ptr %72) + store { ptr, i64 } %73, ptr %result61, align 8 + %74 = insertvalue %variant undef, ptr %result61, 0 + %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$double" to i64), 1 + %76 = getelementptr inbounds [1 x %variant], ptr %varargslots60, i64 0, i64 0 + store %variant %75, ptr %76, align 16 + %77 = call i64 @std_io_printfln(ptr %retparam59, ptr @.str.10, i64 2, ptr %varargslots60, i64 1) + %not_err62 = icmp eq i64 %77, 0 + br i1 %not_err62, label %after_check63, label %voiderr64 -after_check128: ; preds = %voiderr117 - br label %voiderr129 +after_check63: ; preds = %voiderr58 + br label %voiderr64 -voiderr129: ; preds = %after_check128, %voiderr117 - %144 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8 - %not = icmp eq ptr %144, null +voiderr64: ; preds = %after_check63, %voiderr58 + %78 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8 + %not = icmp eq ptr %78, null br i1 %not, label %if.then, label %if.exit -if.then: ; preds = %voiderr129 - %145 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam130, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR) - %not_err131 = icmp eq i64 %145, 0 - br i1 %not_err131, label %after_check132, label %assign_optional +if.then: ; preds = %voiderr64 + %79 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam65, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR) + %not_err66 = icmp eq i64 %79, 0 + br i1 %not_err66, label %after_check67, label %assign_optional assign_optional: ; preds = %if.then - store i64 %145, ptr %error_var, align 8 + store i64 %79, ptr %error_var, align 8 br label %panic_block -after_check132: ; preds = %if.then - %146 = load ptr, ptr %retparam130, align 8 +after_check67: ; preds = %if.then + %80 = load ptr, ptr %retparam65, align 8 br label %noerr_block panic_block: ; preds = %assign_optional - call void @std_core_builtin_panic(ptr @.zstr, ptr @.zstr.11, ptr @.zstr.12, i32 245) + %81 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %81(ptr @.panic_msg, i64 27, ptr @.file, i64 6, ptr @.func, i64 4, i32 245) unreachable -noerr_block: ; preds = %after_check132 - store ptr %146, ptr @std_core_mem_thread_temp_allocator, align 8 +noerr_block: ; preds = %after_check67 + store ptr %80, ptr @std_core_mem_thread_temp_allocator, align 8 br label %if.exit -if.exit: ; preds = %noerr_block, %voiderr129 - %147 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8 - store ptr %147, ptr %temp, align 8 - %148 = load ptr, ptr %temp, align 8 - %149 = getelementptr inbounds %TempAllocator, ptr %148, i32 0, i32 3 - %150 = load i64, ptr %149, align 8 - store i64 %150, ptr %mark, align 8 +if.exit: ; preds = %noerr_block, %voiderr64 + %82 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8 + store ptr %82, ptr %temp, align 8 + %83 = load ptr, ptr %temp, align 8 + %84 = getelementptr inbounds %TempAllocator, ptr %83, i32 0, i32 3 + %85 = load i64, ptr %84, align 8 + store i64 %85, ptr %mark, align 8 call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 40, i1 false) - %151 = load ptr, ptr @std_core_mem_thread_allocator, align 8 - call void @"std_map$$int.double_HashMap_init"(ptr %map3, i32 16, float 7.500000e-01, ptr %151) - %152 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 5, double 3.200000e+00) - %153 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 7, double 5.200000e+00) - store %"char[]" { ptr @.str.13, i64 2 }, ptr %taddr134, align 8 - %154 = getelementptr inbounds { ptr, i64 }, ptr %taddr134, i32 0, i32 0 - %lo135 = load ptr, ptr %154, align 8 - %155 = getelementptr inbounds { ptr, i64 }, ptr %taddr134, i32 0, i32 1 - %hi136 = load i64, ptr %155, align 8 - %156 = load ptr, ptr @std_core_mem_thread_allocator, align 8 - %157 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map3, ptr %156) - store { ptr, i64 } %157, ptr %result139, align 8 - %158 = insertvalue %variant undef, ptr %result139, 0 - %159 = insertvalue %variant %158, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1 - %160 = getelementptr inbounds [1 x %variant], ptr %varargslots138, i64 0, i64 0 - store %variant %159, ptr %160, align 16 - %161 = getelementptr inbounds %"variant[]", ptr %vararg137, i32 0, i32 1 - store i64 1, ptr %161, align 8 - %162 = getelementptr inbounds %"variant[]", ptr %vararg137, i32 0, i32 0 - store ptr %varargslots138, ptr %162, align 8 - %163 = getelementptr inbounds { ptr, i64 }, ptr %vararg137, i32 0, i32 0 - %lo140 = load ptr, ptr %163, align 8 - %164 = getelementptr inbounds { ptr, i64 }, ptr %vararg137, i32 0, i32 1 - %hi141 = load i64, ptr %164, align 8 - %165 = call i64 @std_io_printfln(ptr %retparam133, ptr %lo135, i64 %hi136, ptr %lo140, i64 %hi141) - %not_err142 = icmp eq i64 %165, 0 - br i1 %not_err142, label %after_check143, label %voiderr144 + %86 = load ptr, ptr @std_core_mem_thread_allocator, align 8 + call void @"std_map$$int.double_HashMap_init"(ptr %map3, i32 16, float 7.500000e-01, ptr %86) + %87 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 5, double 3.200000e+00) + %88 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 7, double 5.200000e+00) + %89 = load ptr, ptr @std_core_mem_thread_allocator, align 8 + %90 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map3, ptr %89) + store { ptr, i64 } %90, ptr %result70, align 8 + %91 = insertvalue %variant undef, ptr %result70, 0 + %92 = insertvalue %variant %91, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1 + %93 = getelementptr inbounds [1 x %variant], ptr %varargslots69, i64 0, i64 0 + store %variant %92, ptr %93, align 16 + %94 = call i64 @std_io_printfln(ptr %retparam68, ptr @.str.11, i64 2, ptr %varargslots69, i64 1) + %not_err71 = icmp eq i64 %94, 0 + br i1 %not_err71, label %after_check72, label %voiderr73 -after_check143: ; preds = %if.exit - br label %voiderr144 +after_check72: ; preds = %if.exit + br label %voiderr73 -voiderr144: ; preds = %after_check143, %if.exit - %166 = load ptr, ptr %temp, align 8 - %167 = getelementptr inbounds %TempAllocator, ptr %166, i32 0, i32 0 - %168 = load i64, ptr %mark, align 8 - call void @std_core_mem_allocator_Allocator_reset(ptr %167, i64 %168) +voiderr73: ; preds = %after_check72, %if.exit + %95 = load ptr, ptr %temp, align 8 + %96 = getelementptr inbounds %TempAllocator, ptr %95, i32 0, i32 0 + %97 = load i64, ptr %mark, align 8 + call void @std_core_mem_allocator_Allocator_reset(ptr %96, i64 %97) ret void } diff --git a/test/test_suite2/variant/variant_test.c3t b/test/test_suite2/variant/variant_test.c3t index 9c806fa55..dfdee6d08 100644 --- a/test/test_suite2/variant/variant_test.c3t +++ b/test/test_suite2/variant/variant_test.c3t @@ -189,7 +189,6 @@ entry: %taddr19 = alloca i8, align 1 %taddr20 = alloca %variant, align 8 %df = alloca ptr, align 8 - %vararg = alloca %"variant[]", align 8 %varargslots = alloca [5 x %variant], align 16 %taddr23 = alloca double, align 8 store i32 1, ptr %taddr, align 4 @@ -304,14 +303,6 @@ if.exit10: ; preds = %if.then9, %if.exit7 %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"ct$p$int" to i64), 1 %44 = getelementptr inbounds [5 x %variant], ptr %varargslots, i64 0, i64 4 store %variant %43, ptr %44, align 16 - %45 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 5, ptr %45, align 8 - %46 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %46, align 8 - %47 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo24 = load ptr, ptr %47, align 8 - %48 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi25 = load i64, ptr %48, align 8 - call void @foo_test_all(ptr %lo24, i64 %hi25) + call void @foo_test_all(ptr %varargslots, i64 5) ret void } diff --git a/test/test_suite2/vector/vector_ops2.c3t b/test/test_suite2/vector/vector_ops2.c3t index 9e353746c..6d964ad3a 100644 --- a/test/test_suite2/vector/vector_ops2.c3t +++ b/test/test_suite2/vector/vector_ops2.c3t @@ -149,126 +149,127 @@ entry: br i1 %zero, label %panic, label %checkok panic: ; preds = %entry - call void @std_core_builtin_panic(ptr @.zstr, ptr @.zstr.2, ptr @.zstr.3, i32 12) + %26 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %26(ptr @.panic_msg, i64 17, ptr @.file, i64 14, ptr @.func, i64 5, i32 12) br label %checkok checkok: ; preds = %panic, %entry %fdiv = fdiv <4 x float> %22, %23 store <4 x float> %fdiv, ptr %w, align 16 - %26 = load <4 x float>, ptr %w, align 16 - %27 = extractelement <4 x float> %26, i64 0 - %fpfpext8 = fpext float %27 to double - %28 = load <4 x float>, ptr %w, align 16 - %29 = extractelement <4 x float> %28, i64 1 - %fpfpext9 = fpext float %29 to double - %30 = load <4 x float>, ptr %w, align 16 - %31 = extractelement <4 x float> %30, i64 2 - %fpfpext10 = fpext float %31 to double - %32 = load <4 x float>, ptr %w, align 16 - %33 = extractelement <4 x float> %32, i64 3 - %fpfpext11 = fpext float %33 to double - %34 = call i32 (ptr, ...) @printf(ptr @.str.4, double %fpfpext8, double %fpfpext9, double %fpfpext10, double %fpfpext11) - %35 = load <4 x float>, ptr %y, align 16 - %36 = load <4 x float>, ptr %z, align 16 - %fsub = fsub <4 x float> %35, %36 + %27 = load <4 x float>, ptr %w, align 16 + %28 = extractelement <4 x float> %27, i64 0 + %fpfpext8 = fpext float %28 to double + %29 = load <4 x float>, ptr %w, align 16 + %30 = extractelement <4 x float> %29, i64 1 + %fpfpext9 = fpext float %30 to double + %31 = load <4 x float>, ptr %w, align 16 + %32 = extractelement <4 x float> %31, i64 2 + %fpfpext10 = fpext float %32 to double + %33 = load <4 x float>, ptr %w, align 16 + %34 = extractelement <4 x float> %33, i64 3 + %fpfpext11 = fpext float %34 to double + %35 = call i32 (ptr, ...) @printf(ptr @.str.2, double %fpfpext8, double %fpfpext9, double %fpfpext10, double %fpfpext11) + %36 = load <4 x float>, ptr %y, align 16 + %37 = load <4 x float>, ptr %z, align 16 + %fsub = fsub <4 x float> %36, %37 store <4 x float> %fsub, ptr %w, align 16 - %37 = load <4 x float>, ptr %w, align 16 - %38 = extractelement <4 x float> %37, i64 0 - %fpfpext12 = fpext float %38 to double - %39 = load <4 x float>, ptr %w, align 16 - %40 = extractelement <4 x float> %39, i64 1 - %fpfpext13 = fpext float %40 to double - %41 = load <4 x float>, ptr %w, align 16 - %42 = extractelement <4 x float> %41, i64 2 - %fpfpext14 = fpext float %42 to double - %43 = load <4 x float>, ptr %w, align 16 - %44 = extractelement <4 x float> %43, i64 3 - %fpfpext15 = fpext float %44 to double - %45 = call i32 (ptr, ...) @printf(ptr @.str.5, double %fpfpext12, double %fpfpext13, double %fpfpext14, double %fpfpext15) - %46 = load <4 x float>, ptr %y, align 16 - %47 = load <4 x float>, ptr %z, align 16 - %lt = fcmp olt <4 x float> %46, %47 - %48 = sext <4 x i1> %lt to <4 x i32> - store <4 x i32> %48, ptr %ww, align 16 - %49 = load <4 x i32>, ptr %ww, align 16 - %50 = extractelement <4 x i32> %49, i64 0 - %51 = load <4 x i32>, ptr %ww, align 16 - %52 = extractelement <4 x i32> %51, i64 1 - %53 = load <4 x i32>, ptr %ww, align 16 - %54 = extractelement <4 x i32> %53, i64 2 - %55 = load <4 x i32>, ptr %ww, align 16 - %56 = extractelement <4 x i32> %55, i64 3 - %57 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %50, i32 %52, i32 %54, i32 %56) - %58 = load <4 x float>, ptr %y, align 16 - %59 = load <4 x float>, ptr %z, align 16 - %le = fcmp ole <4 x float> %58, %59 - %60 = sext <4 x i1> %le to <4 x i32> - store <4 x i32> %60, ptr %ww, align 16 - %61 = load <4 x i32>, ptr %ww, align 16 - %62 = extractelement <4 x i32> %61, i64 0 - %63 = load <4 x i32>, ptr %ww, align 16 - %64 = extractelement <4 x i32> %63, i64 1 - %65 = load <4 x i32>, ptr %ww, align 16 - %66 = extractelement <4 x i32> %65, i64 2 - %67 = load <4 x i32>, ptr %ww, align 16 - %68 = extractelement <4 x i32> %67, i64 3 - %69 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %62, i32 %64, i32 %66, i32 %68) - %70 = load <4 x float>, ptr %y, align 16 - %71 = load <4 x float>, ptr %z, align 16 - %gt = fcmp ogt <4 x float> %70, %71 - %72 = sext <4 x i1> %gt to <4 x i32> - store <4 x i32> %72, ptr %ww, align 16 - %73 = load <4 x i32>, ptr %ww, align 16 - %74 = extractelement <4 x i32> %73, i64 0 - %75 = load <4 x i32>, ptr %ww, align 16 - %76 = extractelement <4 x i32> %75, i64 1 - %77 = load <4 x i32>, ptr %ww, align 16 - %78 = extractelement <4 x i32> %77, i64 2 - %79 = load <4 x i32>, ptr %ww, align 16 - %80 = extractelement <4 x i32> %79, i64 3 - %81 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %74, i32 %76, i32 %78, i32 %80) - %82 = load <4 x float>, ptr %y, align 16 - %83 = load <4 x float>, ptr %z, align 16 - %ge = fcmp oge <4 x float> %82, %83 - %84 = sext <4 x i1> %ge to <4 x i32> - store <4 x i32> %84, ptr %ww, align 16 - %85 = load <4 x i32>, ptr %ww, align 16 - %86 = extractelement <4 x i32> %85, i64 0 - %87 = load <4 x i32>, ptr %ww, align 16 - %88 = extractelement <4 x i32> %87, i64 1 - %89 = load <4 x i32>, ptr %ww, align 16 - %90 = extractelement <4 x i32> %89, i64 2 - %91 = load <4 x i32>, ptr %ww, align 16 - %92 = extractelement <4 x i32> %91, i64 3 - %93 = call i32 (ptr, ...) @printf(ptr @.str.9, i32 %86, i32 %88, i32 %90, i32 %92) - %94 = load <4 x float>, ptr %y, align 16 - %95 = load <4 x float>, ptr %z, align 16 - %eq = fcmp oeq <4 x float> %94, %95 - %96 = sext <4 x i1> %eq to <4 x i32> - store <4 x i32> %96, ptr %ww, align 16 - %97 = load <4 x i32>, ptr %ww, align 16 - %98 = extractelement <4 x i32> %97, i64 0 - %99 = load <4 x i32>, ptr %ww, align 16 - %100 = extractelement <4 x i32> %99, i64 1 - %101 = load <4 x i32>, ptr %ww, align 16 - %102 = extractelement <4 x i32> %101, i64 2 - %103 = load <4 x i32>, ptr %ww, align 16 - %104 = extractelement <4 x i32> %103, i64 3 - %105 = call i32 (ptr, ...) @printf(ptr @.str.10, i32 %98, i32 %100, i32 %102, i32 %104) - %106 = load <4 x float>, ptr %y, align 16 - %107 = load <4 x float>, ptr %z, align 16 - %neq = fcmp one <4 x float> %106, %107 - %108 = sext <4 x i1> %neq to <4 x i32> - store <4 x i32> %108, ptr %ww, align 16 - %109 = load <4 x i32>, ptr %ww, align 16 - %110 = extractelement <4 x i32> %109, i64 0 - %111 = load <4 x i32>, ptr %ww, align 16 - %112 = extractelement <4 x i32> %111, i64 1 - %113 = load <4 x i32>, ptr %ww, align 16 - %114 = extractelement <4 x i32> %113, i64 2 - %115 = load <4 x i32>, ptr %ww, align 16 - %116 = extractelement <4 x i32> %115, i64 3 - %117 = call i32 (ptr, ...) @printf(ptr @.str.11, i32 %110, i32 %112, i32 %114, i32 %116) + %38 = load <4 x float>, ptr %w, align 16 + %39 = extractelement <4 x float> %38, i64 0 + %fpfpext12 = fpext float %39 to double + %40 = load <4 x float>, ptr %w, align 16 + %41 = extractelement <4 x float> %40, i64 1 + %fpfpext13 = fpext float %41 to double + %42 = load <4 x float>, ptr %w, align 16 + %43 = extractelement <4 x float> %42, i64 2 + %fpfpext14 = fpext float %43 to double + %44 = load <4 x float>, ptr %w, align 16 + %45 = extractelement <4 x float> %44, i64 3 + %fpfpext15 = fpext float %45 to double + %46 = call i32 (ptr, ...) @printf(ptr @.str.3, double %fpfpext12, double %fpfpext13, double %fpfpext14, double %fpfpext15) + %47 = load <4 x float>, ptr %y, align 16 + %48 = load <4 x float>, ptr %z, align 16 + %lt = fcmp olt <4 x float> %47, %48 + %49 = sext <4 x i1> %lt to <4 x i32> + store <4 x i32> %49, ptr %ww, align 16 + %50 = load <4 x i32>, ptr %ww, align 16 + %51 = extractelement <4 x i32> %50, i64 0 + %52 = load <4 x i32>, ptr %ww, align 16 + %53 = extractelement <4 x i32> %52, i64 1 + %54 = load <4 x i32>, ptr %ww, align 16 + %55 = extractelement <4 x i32> %54, i64 2 + %56 = load <4 x i32>, ptr %ww, align 16 + %57 = extractelement <4 x i32> %56, i64 3 + %58 = call i32 (ptr, ...) @printf(ptr @.str.4, i32 %51, i32 %53, i32 %55, i32 %57) + %59 = load <4 x float>, ptr %y, align 16 + %60 = load <4 x float>, ptr %z, align 16 + %le = fcmp ole <4 x float> %59, %60 + %61 = sext <4 x i1> %le to <4 x i32> + store <4 x i32> %61, ptr %ww, align 16 + %62 = load <4 x i32>, ptr %ww, align 16 + %63 = extractelement <4 x i32> %62, i64 0 + %64 = load <4 x i32>, ptr %ww, align 16 + %65 = extractelement <4 x i32> %64, i64 1 + %66 = load <4 x i32>, ptr %ww, align 16 + %67 = extractelement <4 x i32> %66, i64 2 + %68 = load <4 x i32>, ptr %ww, align 16 + %69 = extractelement <4 x i32> %68, i64 3 + %70 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %63, i32 %65, i32 %67, i32 %69) + %71 = load <4 x float>, ptr %y, align 16 + %72 = load <4 x float>, ptr %z, align 16 + %gt = fcmp ogt <4 x float> %71, %72 + %73 = sext <4 x i1> %gt to <4 x i32> + store <4 x i32> %73, ptr %ww, align 16 + %74 = load <4 x i32>, ptr %ww, align 16 + %75 = extractelement <4 x i32> %74, i64 0 + %76 = load <4 x i32>, ptr %ww, align 16 + %77 = extractelement <4 x i32> %76, i64 1 + %78 = load <4 x i32>, ptr %ww, align 16 + %79 = extractelement <4 x i32> %78, i64 2 + %80 = load <4 x i32>, ptr %ww, align 16 + %81 = extractelement <4 x i32> %80, i64 3 + %82 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %75, i32 %77, i32 %79, i32 %81) + %83 = load <4 x float>, ptr %y, align 16 + %84 = load <4 x float>, ptr %z, align 16 + %ge = fcmp oge <4 x float> %83, %84 + %85 = sext <4 x i1> %ge to <4 x i32> + store <4 x i32> %85, ptr %ww, align 16 + %86 = load <4 x i32>, ptr %ww, align 16 + %87 = extractelement <4 x i32> %86, i64 0 + %88 = load <4 x i32>, ptr %ww, align 16 + %89 = extractelement <4 x i32> %88, i64 1 + %90 = load <4 x i32>, ptr %ww, align 16 + %91 = extractelement <4 x i32> %90, i64 2 + %92 = load <4 x i32>, ptr %ww, align 16 + %93 = extractelement <4 x i32> %92, i64 3 + %94 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %87, i32 %89, i32 %91, i32 %93) + %95 = load <4 x float>, ptr %y, align 16 + %96 = load <4 x float>, ptr %z, align 16 + %eq = fcmp oeq <4 x float> %95, %96 + %97 = sext <4 x i1> %eq to <4 x i32> + store <4 x i32> %97, ptr %ww, align 16 + %98 = load <4 x i32>, ptr %ww, align 16 + %99 = extractelement <4 x i32> %98, i64 0 + %100 = load <4 x i32>, ptr %ww, align 16 + %101 = extractelement <4 x i32> %100, i64 1 + %102 = load <4 x i32>, ptr %ww, align 16 + %103 = extractelement <4 x i32> %102, i64 2 + %104 = load <4 x i32>, ptr %ww, align 16 + %105 = extractelement <4 x i32> %104, i64 3 + %106 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %99, i32 %101, i32 %103, i32 %105) + %107 = load <4 x float>, ptr %y, align 16 + %108 = load <4 x float>, ptr %z, align 16 + %neq = fcmp one <4 x float> %107, %108 + %109 = sext <4 x i1> %neq to <4 x i32> + store <4 x i32> %109, ptr %ww, align 16 + %110 = load <4 x i32>, ptr %ww, align 16 + %111 = extractelement <4 x i32> %110, i64 0 + %112 = load <4 x i32>, ptr %ww, align 16 + %113 = extractelement <4 x i32> %112, i64 1 + %114 = load <4 x i32>, ptr %ww, align 16 + %115 = extractelement <4 x i32> %114, i64 2 + %116 = load <4 x i32>, ptr %ww, align 16 + %117 = extractelement <4 x i32> %116, i64 3 + %118 = call i32 (ptr, ...) @printf(ptr @.str.9, i32 %111, i32 %113, i32 %115, i32 %117) ret void } @@ -297,7 +298,7 @@ entry: %9 = load <4 x i8>, ptr %ww, align 4 %10 = extractelement <4 x i8> %9, i64 3 %sisiext3 = sext i8 %10 to i32 - %11 = call i32 (ptr, ...) @printf(ptr @.str.12, i32 %sisiext, i32 %sisiext1, i32 %sisiext2, i32 %sisiext3) + %11 = call i32 (ptr, ...) @printf(ptr @.str.10, i32 %sisiext, i32 %sisiext1, i32 %sisiext2, i32 %sisiext3) %12 = load <4 x i8>, ptr %y, align 4 %13 = load <4 x i8>, ptr %z, align 4 %le = icmp ule <4 x i8> %12, %13 @@ -315,7 +316,7 @@ entry: %21 = load <4 x i8>, ptr %ww, align 4 %22 = extractelement <4 x i8> %21, i64 3 %sisiext7 = sext i8 %22 to i32 - %23 = call i32 (ptr, ...) @printf(ptr @.str.13, i32 %sisiext4, i32 %sisiext5, i32 %sisiext6, i32 %sisiext7) + %23 = call i32 (ptr, ...) @printf(ptr @.str.11, i32 %sisiext4, i32 %sisiext5, i32 %sisiext6, i32 %sisiext7) %24 = load <4 x i8>, ptr %y, align 4 %25 = load <4 x i8>, ptr %z, align 4 %gt = icmp ugt <4 x i8> %24, %25 @@ -333,7 +334,7 @@ entry: %33 = load <4 x i8>, ptr %ww, align 4 %34 = extractelement <4 x i8> %33, i64 3 %sisiext11 = sext i8 %34 to i32 - %35 = call i32 (ptr, ...) @printf(ptr @.str.14, i32 %sisiext8, i32 %sisiext9, i32 %sisiext10, i32 %sisiext11) + %35 = call i32 (ptr, ...) @printf(ptr @.str.12, i32 %sisiext8, i32 %sisiext9, i32 %sisiext10, i32 %sisiext11) %36 = load <4 x i8>, ptr %y, align 4 %37 = load <4 x i8>, ptr %z, align 4 %ge = icmp uge <4 x i8> %36, %37 @@ -351,7 +352,7 @@ entry: %45 = load <4 x i8>, ptr %ww, align 4 %46 = extractelement <4 x i8> %45, i64 3 %sisiext15 = sext i8 %46 to i32 - %47 = call i32 (ptr, ...) @printf(ptr @.str.15, i32 %sisiext12, i32 %sisiext13, i32 %sisiext14, i32 %sisiext15) + %47 = call i32 (ptr, ...) @printf(ptr @.str.13, i32 %sisiext12, i32 %sisiext13, i32 %sisiext14, i32 %sisiext15) %48 = load <4 x i8>, ptr %y, align 4 %49 = load <4 x i8>, ptr %z, align 4 %eq = icmp eq <4 x i8> %48, %49 @@ -369,7 +370,7 @@ entry: %57 = load <4 x i8>, ptr %ww, align 4 %58 = extractelement <4 x i8> %57, i64 3 %sisiext19 = sext i8 %58 to i32 - %59 = call i32 (ptr, ...) @printf(ptr @.str.16, i32 %sisiext16, i32 %sisiext17, i32 %sisiext18, i32 %sisiext19) + %59 = call i32 (ptr, ...) @printf(ptr @.str.14, i32 %sisiext16, i32 %sisiext17, i32 %sisiext18, i32 %sisiext19) %60 = load <4 x i8>, ptr %y, align 4 %61 = load <4 x i8>, ptr %z, align 4 %neq = icmp ne <4 x i8> %60, %61 @@ -387,7 +388,7 @@ entry: %69 = load <4 x i8>, ptr %ww, align 4 %70 = extractelement <4 x i8> %69, i64 3 %sisiext23 = sext i8 %70 to i32 - %71 = call i32 (ptr, ...) @printf(ptr @.str.17, i32 %sisiext20, i32 %sisiext21, i32 %sisiext22, i32 %sisiext23) + %71 = call i32 (ptr, ...) @printf(ptr @.str.15, i32 %sisiext20, i32 %sisiext21, i32 %sisiext22, i32 %sisiext23) ret void } @@ -412,7 +413,7 @@ entry: %7 = extractelement <4 x i32> %6, i64 2 %8 = load <4 x i32>, ptr %w, align 16 %9 = extractelement <4 x i32> %8, i64 3 - %10 = call i32 (ptr, ...) @printf(ptr @.str.18, i32 %3, i32 %5, i32 %7, i32 %9) + %10 = call i32 (ptr, ...) @printf(ptr @.str.16, i32 %3, i32 %5, i32 %7, i32 %9) %11 = load <4 x i32>, ptr %y, align 16 %12 = load <4 x i32>, ptr %z, align 16 %mul = mul <4 x i32> %11, %12 @@ -425,7 +426,7 @@ entry: %18 = extractelement <4 x i32> %17, i64 2 %19 = load <4 x i32>, ptr %w, align 16 %20 = extractelement <4 x i32> %19, i64 3 - %21 = call i32 (ptr, ...) @printf(ptr @.str.19, i32 %14, i32 %16, i32 %18, i32 %20) + %21 = call i32 (ptr, ...) @printf(ptr @.str.17, i32 %14, i32 %16, i32 %18, i32 %20) %22 = load <4 x i32>, ptr %y, align 16 %23 = load <4 x i32>, ptr %z, align 16 %24 = call i32 @llvm.vector.reduce.umin.v4i32(<4 x i32> %23) @@ -433,278 +434,283 @@ entry: br i1 %zero, label %panic, label %checkok panic: ; preds = %entry - call void @std_core_builtin_panic(ptr @.zstr.20, ptr @.zstr.21, ptr @.zstr.22, i32 56) + %25 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %25(ptr @.panic_msg.18, i64 17, ptr @.file.19, i64 14, ptr @.func.20, i64 5, i32 56) br label %checkok checkok: ; preds = %panic, %entry %sdiv = sdiv <4 x i32> %22, %23 store <4 x i32> %sdiv, ptr %w, align 16 - %25 = load <4 x i32>, ptr %w, align 16 - %26 = extractelement <4 x i32> %25, i64 0 - %27 = load <4 x i32>, ptr %w, align 16 - %28 = extractelement <4 x i32> %27, i64 1 - %29 = load <4 x i32>, ptr %w, align 16 - %30 = extractelement <4 x i32> %29, i64 2 - %31 = load <4 x i32>, ptr %w, align 16 - %32 = extractelement <4 x i32> %31, i64 3 - %33 = call i32 (ptr, ...) @printf(ptr @.str.23, i32 %26, i32 %28, i32 %30, i32 %32) - %34 = load <4 x i32>, ptr %y, align 16 - %35 = load <4 x i32>, ptr %z, align 16 - %sub = sub <4 x i32> %34, %35 + %26 = load <4 x i32>, ptr %w, align 16 + %27 = extractelement <4 x i32> %26, i64 0 + %28 = load <4 x i32>, ptr %w, align 16 + %29 = extractelement <4 x i32> %28, i64 1 + %30 = load <4 x i32>, ptr %w, align 16 + %31 = extractelement <4 x i32> %30, i64 2 + %32 = load <4 x i32>, ptr %w, align 16 + %33 = extractelement <4 x i32> %32, i64 3 + %34 = call i32 (ptr, ...) @printf(ptr @.str.21, i32 %27, i32 %29, i32 %31, i32 %33) + %35 = load <4 x i32>, ptr %y, align 16 + %36 = load <4 x i32>, ptr %z, align 16 + %sub = sub <4 x i32> %35, %36 store <4 x i32> %sub, ptr %w, align 16 - %36 = load <4 x i32>, ptr %w, align 16 - %37 = extractelement <4 x i32> %36, i64 0 - %38 = load <4 x i32>, ptr %w, align 16 - %39 = extractelement <4 x i32> %38, i64 1 - %40 = load <4 x i32>, ptr %w, align 16 - %41 = extractelement <4 x i32> %40, i64 2 - %42 = load <4 x i32>, ptr %w, align 16 - %43 = extractelement <4 x i32> %42, i64 3 - %44 = call i32 (ptr, ...) @printf(ptr @.str.24, i32 %37, i32 %39, i32 %41, i32 %43) - %45 = load <4 x i32>, ptr %z, align 16 - %46 = load <4 x i32>, ptr %y, align 16 - %47 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %46) - %shift_underflow = icmp slt i32 %47, 0 + %37 = load <4 x i32>, ptr %w, align 16 + %38 = extractelement <4 x i32> %37, i64 0 + %39 = load <4 x i32>, ptr %w, align 16 + %40 = extractelement <4 x i32> %39, i64 1 + %41 = load <4 x i32>, ptr %w, align 16 + %42 = extractelement <4 x i32> %41, i64 2 + %43 = load <4 x i32>, ptr %w, align 16 + %44 = extractelement <4 x i32> %43, i64 3 + %45 = call i32 (ptr, ...) @printf(ptr @.str.22, i32 %38, i32 %40, i32 %42, i32 %44) + %46 = load <4 x i32>, ptr %z, align 16 + %47 = load <4 x i32>, ptr %y, align 16 + %48 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %47) + %shift_underflow = icmp slt i32 %48, 0 br i1 %shift_underflow, label %panic1, label %checkok2 panic1: ; preds = %checkok - call void @std_core_builtin_panic(ptr @.zstr.25, ptr @.zstr.26, ptr @.zstr.27, i32 60) + %49 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %49(ptr @.panic_msg.23, i64 26, ptr @.file.24, i64 14, ptr @.func.25, i64 5, i32 60) br label %checkok2 checkok2: ; preds = %panic1, %checkok - %48 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %46) - %shift_exceeds = icmp sge i32 %48, 32 + %50 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %47) + %shift_exceeds = icmp sge i32 %50, 32 br i1 %shift_exceeds, label %panic3, label %checkok4 panic3: ; preds = %checkok2 - call void @std_core_builtin_panic(ptr @.zstr.28, ptr @.zstr.29, ptr @.zstr.30, i32 60) + %51 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %51(ptr @.panic_msg.26, i64 26, ptr @.file.27, i64 14, ptr @.func.28, i64 5, i32 60) br label %checkok4 checkok4: ; preds = %panic3, %checkok2 - %ashr = ashr <4 x i32> %45, %46 - %49 = freeze <4 x i32> %ashr - store <4 x i32> %49, ptr %w, align 16 - %50 = load <4 x i32>, ptr %w, align 16 - %51 = extractelement <4 x i32> %50, i64 0 - %52 = load <4 x i32>, ptr %w, align 16 - %53 = extractelement <4 x i32> %52, i64 1 - %54 = load <4 x i32>, ptr %w, align 16 - %55 = extractelement <4 x i32> %54, i64 2 - %56 = load <4 x i32>, ptr %w, align 16 - %57 = extractelement <4 x i32> %56, i64 3 - %58 = call i32 (ptr, ...) @printf(ptr @.str.31, i32 %51, i32 %53, i32 %55, i32 %57) - %59 = load <4 x i32>, ptr %z, align 16 - %60 = load <4 x i32>, ptr %y, align 16 - %61 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %60) - %shift_underflow5 = icmp slt i32 %61, 0 + %ashr = ashr <4 x i32> %46, %47 + %52 = freeze <4 x i32> %ashr + store <4 x i32> %52, ptr %w, align 16 + %53 = load <4 x i32>, ptr %w, align 16 + %54 = extractelement <4 x i32> %53, i64 0 + %55 = load <4 x i32>, ptr %w, align 16 + %56 = extractelement <4 x i32> %55, i64 1 + %57 = load <4 x i32>, ptr %w, align 16 + %58 = extractelement <4 x i32> %57, i64 2 + %59 = load <4 x i32>, ptr %w, align 16 + %60 = extractelement <4 x i32> %59, i64 3 + %61 = call i32 (ptr, ...) @printf(ptr @.str.29, i32 %54, i32 %56, i32 %58, i32 %60) + %62 = load <4 x i32>, ptr %z, align 16 + %63 = load <4 x i32>, ptr %y, align 16 + %64 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %63) + %shift_underflow5 = icmp slt i32 %64, 0 br i1 %shift_underflow5, label %panic6, label %checkok7 panic6: ; preds = %checkok4 - call void @std_core_builtin_panic(ptr @.zstr.32, ptr @.zstr.33, ptr @.zstr.34, i32 62) + %65 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %65(ptr @.panic_msg.30, i64 26, ptr @.file.31, i64 14, ptr @.func.32, i64 5, i32 62) br label %checkok7 checkok7: ; preds = %panic6, %checkok4 - %62 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %60) - %shift_exceeds8 = icmp sge i32 %62, 32 + %66 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %63) + %shift_exceeds8 = icmp sge i32 %66, 32 br i1 %shift_exceeds8, label %panic9, label %checkok10 panic9: ; preds = %checkok7 - call void @std_core_builtin_panic(ptr @.zstr.35, ptr @.zstr.36, ptr @.zstr.37, i32 62) + %67 = load ptr, ptr @std_core_builtin_panic, align 8 + call void %67(ptr @.panic_msg.33, i64 26, ptr @.file.34, i64 14, ptr @.func.35, i64 5, i32 62) br label %checkok10 checkok10: ; preds = %panic9, %checkok7 - %shl = shl <4 x i32> %59, %60 - %63 = freeze <4 x i32> %shl - store <4 x i32> %63, ptr %w, align 16 - %64 = load <4 x i32>, ptr %w, align 16 - %65 = extractelement <4 x i32> %64, i64 0 - %66 = load <4 x i32>, ptr %w, align 16 - %67 = extractelement <4 x i32> %66, i64 1 - %68 = load <4 x i32>, ptr %w, align 16 - %69 = extractelement <4 x i32> %68, i64 2 - %70 = load <4 x i32>, ptr %w, align 16 - %71 = extractelement <4 x i32> %70, i64 3 - %72 = call i32 (ptr, ...) @printf(ptr @.str.38, i32 %65, i32 %67, i32 %69, i32 %71) - %73 = load <4 x i32>, ptr %z, align 16 - %74 = load <4 x i32>, ptr %y, align 16 - %gt = icmp sgt <4 x i32> %73, %74 - %75 = sext <4 x i1> %gt to <4 x i32> - store <4 x i32> %75, ptr %w, align 16 - %76 = load <4 x i32>, ptr %w, align 16 - %77 = extractelement <4 x i32> %76, i64 0 - %78 = load <4 x i32>, ptr %w, align 16 - %79 = extractelement <4 x i32> %78, i64 1 - %80 = load <4 x i32>, ptr %w, align 16 - %81 = extractelement <4 x i32> %80, i64 2 - %82 = load <4 x i32>, ptr %w, align 16 - %83 = extractelement <4 x i32> %82, i64 3 - %84 = call i32 (ptr, ...) @printf(ptr @.str.39, i32 %77, i32 %79, i32 %81, i32 %83) - %85 = load <4 x i32>, ptr %z, align 16 - %86 = load <4 x i32>, ptr %y, align 16 - %ge = icmp sge <4 x i32> %85, %86 - %87 = sext <4 x i1> %ge to <4 x i32> - store <4 x i32> %87, ptr %w, align 16 - %88 = load <4 x i32>, ptr %w, align 16 - %89 = extractelement <4 x i32> %88, i64 0 - %90 = load <4 x i32>, ptr %w, align 16 - %91 = extractelement <4 x i32> %90, i64 1 - %92 = load <4 x i32>, ptr %w, align 16 - %93 = extractelement <4 x i32> %92, i64 2 - %94 = load <4 x i32>, ptr %w, align 16 - %95 = extractelement <4 x i32> %94, i64 3 - %96 = call i32 (ptr, ...) @printf(ptr @.str.40, i32 %89, i32 %91, i32 %93, i32 %95) - %97 = load <4 x i32>, ptr %z, align 16 - %98 = load <4 x i32>, ptr %y, align 16 - %lt = icmp slt <4 x i32> %97, %98 - %99 = sext <4 x i1> %lt to <4 x i32> - store <4 x i32> %99, ptr %w, align 16 - %100 = load <4 x i32>, ptr %w, align 16 - %101 = extractelement <4 x i32> %100, i64 0 - %102 = load <4 x i32>, ptr %w, align 16 - %103 = extractelement <4 x i32> %102, i64 1 - %104 = load <4 x i32>, ptr %w, align 16 - %105 = extractelement <4 x i32> %104, i64 2 - %106 = load <4 x i32>, ptr %w, align 16 - %107 = extractelement <4 x i32> %106, i64 3 - %108 = call i32 (ptr, ...) @printf(ptr @.str.41, i32 %101, i32 %103, i32 %105, i32 %107) - %109 = load <4 x i32>, ptr %z, align 16 - %110 = load <4 x i32>, ptr %y, align 16 - %le = icmp sle <4 x i32> %109, %110 - %111 = sext <4 x i1> %le to <4 x i32> - store <4 x i32> %111, ptr %w, align 16 - %112 = load <4 x i32>, ptr %w, align 16 - %113 = extractelement <4 x i32> %112, i64 0 - %114 = load <4 x i32>, ptr %w, align 16 - %115 = extractelement <4 x i32> %114, i64 1 - %116 = load <4 x i32>, ptr %w, align 16 - %117 = extractelement <4 x i32> %116, i64 2 - %118 = load <4 x i32>, ptr %w, align 16 - %119 = extractelement <4 x i32> %118, i64 3 - %120 = call i32 (ptr, ...) @printf(ptr @.str.42, i32 %113, i32 %115, i32 %117, i32 %119) - %121 = load <4 x i32>, ptr %z, align 16 - %122 = load <4 x i32>, ptr %y, align 16 - %eq = icmp eq <4 x i32> %121, %122 - %123 = sext <4 x i1> %eq to <4 x i32> - store <4 x i32> %123, ptr %w, align 16 - %124 = load <4 x i32>, ptr %w, align 16 - %125 = extractelement <4 x i32> %124, i64 0 - %126 = load <4 x i32>, ptr %w, align 16 - %127 = extractelement <4 x i32> %126, i64 1 - %128 = load <4 x i32>, ptr %w, align 16 - %129 = extractelement <4 x i32> %128, i64 2 - %130 = load <4 x i32>, ptr %w, align 16 - %131 = extractelement <4 x i32> %130, i64 3 - %132 = call i32 (ptr, ...) @printf(ptr @.str.43, i32 %125, i32 %127, i32 %129, i32 %131) - %133 = load <4 x i32>, ptr %z, align 16 - %134 = load <4 x i32>, ptr %y, align 16 - %neq = icmp ne <4 x i32> %133, %134 - %135 = sext <4 x i1> %neq to <4 x i32> - store <4 x i32> %135, ptr %w, align 16 - %136 = load <4 x i32>, ptr %w, align 16 - %137 = extractelement <4 x i32> %136, i64 0 - %138 = load <4 x i32>, ptr %w, align 16 - %139 = extractelement <4 x i32> %138, i64 1 - %140 = load <4 x i32>, ptr %w, align 16 - %141 = extractelement <4 x i32> %140, i64 2 - %142 = load <4 x i32>, ptr %w, align 16 - %143 = extractelement <4 x i32> %142, i64 3 - %144 = call i32 (ptr, ...) @printf(ptr @.str.44, i32 %137, i32 %139, i32 %141, i32 %143) + %shl = shl <4 x i32> %62, %63 + %68 = freeze <4 x i32> %shl + store <4 x i32> %68, ptr %w, align 16 + %69 = load <4 x i32>, ptr %w, align 16 + %70 = extractelement <4 x i32> %69, i64 0 + %71 = load <4 x i32>, ptr %w, align 16 + %72 = extractelement <4 x i32> %71, i64 1 + %73 = load <4 x i32>, ptr %w, align 16 + %74 = extractelement <4 x i32> %73, i64 2 + %75 = load <4 x i32>, ptr %w, align 16 + %76 = extractelement <4 x i32> %75, i64 3 + %77 = call i32 (ptr, ...) @printf(ptr @.str.36, i32 %70, i32 %72, i32 %74, i32 %76) + %78 = load <4 x i32>, ptr %z, align 16 + %79 = load <4 x i32>, ptr %y, align 16 + %gt = icmp sgt <4 x i32> %78, %79 + %80 = sext <4 x i1> %gt to <4 x i32> + store <4 x i32> %80, ptr %w, align 16 + %81 = load <4 x i32>, ptr %w, align 16 + %82 = extractelement <4 x i32> %81, i64 0 + %83 = load <4 x i32>, ptr %w, align 16 + %84 = extractelement <4 x i32> %83, i64 1 + %85 = load <4 x i32>, ptr %w, align 16 + %86 = extractelement <4 x i32> %85, i64 2 + %87 = load <4 x i32>, ptr %w, align 16 + %88 = extractelement <4 x i32> %87, i64 3 + %89 = call i32 (ptr, ...) @printf(ptr @.str.37, i32 %82, i32 %84, i32 %86, i32 %88) + %90 = load <4 x i32>, ptr %z, align 16 + %91 = load <4 x i32>, ptr %y, align 16 + %ge = icmp sge <4 x i32> %90, %91 + %92 = sext <4 x i1> %ge to <4 x i32> + store <4 x i32> %92, ptr %w, align 16 + %93 = load <4 x i32>, ptr %w, align 16 + %94 = extractelement <4 x i32> %93, i64 0 + %95 = load <4 x i32>, ptr %w, align 16 + %96 = extractelement <4 x i32> %95, i64 1 + %97 = load <4 x i32>, ptr %w, align 16 + %98 = extractelement <4 x i32> %97, i64 2 + %99 = load <4 x i32>, ptr %w, align 16 + %100 = extractelement <4 x i32> %99, i64 3 + %101 = call i32 (ptr, ...) @printf(ptr @.str.38, i32 %94, i32 %96, i32 %98, i32 %100) + %102 = load <4 x i32>, ptr %z, align 16 + %103 = load <4 x i32>, ptr %y, align 16 + %lt = icmp slt <4 x i32> %102, %103 + %104 = sext <4 x i1> %lt to <4 x i32> + store <4 x i32> %104, ptr %w, align 16 + %105 = load <4 x i32>, ptr %w, align 16 + %106 = extractelement <4 x i32> %105, i64 0 + %107 = load <4 x i32>, ptr %w, align 16 + %108 = extractelement <4 x i32> %107, i64 1 + %109 = load <4 x i32>, ptr %w, align 16 + %110 = extractelement <4 x i32> %109, i64 2 + %111 = load <4 x i32>, ptr %w, align 16 + %112 = extractelement <4 x i32> %111, i64 3 + %113 = call i32 (ptr, ...) @printf(ptr @.str.39, i32 %106, i32 %108, i32 %110, i32 %112) + %114 = load <4 x i32>, ptr %z, align 16 + %115 = load <4 x i32>, ptr %y, align 16 + %le = icmp sle <4 x i32> %114, %115 + %116 = sext <4 x i1> %le to <4 x i32> + store <4 x i32> %116, ptr %w, align 16 + %117 = load <4 x i32>, ptr %w, align 16 + %118 = extractelement <4 x i32> %117, i64 0 + %119 = load <4 x i32>, ptr %w, align 16 + %120 = extractelement <4 x i32> %119, i64 1 + %121 = load <4 x i32>, ptr %w, align 16 + %122 = extractelement <4 x i32> %121, i64 2 + %123 = load <4 x i32>, ptr %w, align 16 + %124 = extractelement <4 x i32> %123, i64 3 + %125 = call i32 (ptr, ...) @printf(ptr @.str.40, i32 %118, i32 %120, i32 %122, i32 %124) + %126 = load <4 x i32>, ptr %z, align 16 + %127 = load <4 x i32>, ptr %y, align 16 + %eq = icmp eq <4 x i32> %126, %127 + %128 = sext <4 x i1> %eq to <4 x i32> + store <4 x i32> %128, ptr %w, align 16 + %129 = load <4 x i32>, ptr %w, align 16 + %130 = extractelement <4 x i32> %129, i64 0 + %131 = load <4 x i32>, ptr %w, align 16 + %132 = extractelement <4 x i32> %131, i64 1 + %133 = load <4 x i32>, ptr %w, align 16 + %134 = extractelement <4 x i32> %133, i64 2 + %135 = load <4 x i32>, ptr %w, align 16 + %136 = extractelement <4 x i32> %135, i64 3 + %137 = call i32 (ptr, ...) @printf(ptr @.str.41, i32 %130, i32 %132, i32 %134, i32 %136) + %138 = load <4 x i32>, ptr %z, align 16 + %139 = load <4 x i32>, ptr %y, align 16 + %neq = icmp ne <4 x i32> %138, %139 + %140 = sext <4 x i1> %neq to <4 x i32> + store <4 x i32> %140, ptr %w, align 16 + %141 = load <4 x i32>, ptr %w, align 16 + %142 = extractelement <4 x i32> %141, i64 0 + %143 = load <4 x i32>, ptr %w, align 16 + %144 = extractelement <4 x i32> %143, i64 1 + %145 = load <4 x i32>, ptr %w, align 16 + %146 = extractelement <4 x i32> %145, i64 2 + %147 = load <4 x i32>, ptr %w, align 16 + %148 = extractelement <4 x i32> %147, i64 3 + %149 = call i32 (ptr, ...) @printf(ptr @.str.42, i32 %142, i32 %144, i32 %146, i32 %148) store <4 x i32> , ptr %uz, align 16 - %145 = load <4 x i32>, ptr %uz, align 16 - %146 = load <4 x i32>, ptr %y, align 16 - %lt11 = icmp slt <4 x i32> %146, %145 - %check = icmp slt <4 x i32> %145, zeroinitializer + %150 = load <4 x i32>, ptr %uz, align 16 + %151 = load <4 x i32>, ptr %y, align 16 + %lt11 = icmp slt <4 x i32> %151, %150 + %check = icmp slt <4 x i32> %150, zeroinitializer %siui-lt = or <4 x i1> %check, %lt11 - %147 = sext <4 x i1> %siui-lt to <4 x i32> - store <4 x i32> %147, ptr %w, align 16 - %148 = load <4 x i32>, ptr %w, align 16 - %149 = extractelement <4 x i32> %148, i64 0 - %150 = load <4 x i32>, ptr %w, align 16 - %151 = extractelement <4 x i32> %150, i64 1 - %152 = load <4 x i32>, ptr %w, align 16 - %153 = extractelement <4 x i32> %152, i64 2 - %154 = load <4 x i32>, ptr %w, align 16 - %155 = extractelement <4 x i32> %154, i64 3 - %156 = call i32 (ptr, ...) @printf(ptr @.str.45, i32 %149, i32 %151, i32 %153, i32 %155) - %157 = load <4 x i32>, ptr %uz, align 16 - %158 = load <4 x i32>, ptr %y, align 16 - %le12 = icmp sle <4 x i32> %158, %157 - %check13 = icmp slt <4 x i32> %157, zeroinitializer + %152 = sext <4 x i1> %siui-lt to <4 x i32> + store <4 x i32> %152, ptr %w, align 16 + %153 = load <4 x i32>, ptr %w, align 16 + %154 = extractelement <4 x i32> %153, i64 0 + %155 = load <4 x i32>, ptr %w, align 16 + %156 = extractelement <4 x i32> %155, i64 1 + %157 = load <4 x i32>, ptr %w, align 16 + %158 = extractelement <4 x i32> %157, i64 2 + %159 = load <4 x i32>, ptr %w, align 16 + %160 = extractelement <4 x i32> %159, i64 3 + %161 = call i32 (ptr, ...) @printf(ptr @.str.43, i32 %154, i32 %156, i32 %158, i32 %160) + %162 = load <4 x i32>, ptr %uz, align 16 + %163 = load <4 x i32>, ptr %y, align 16 + %le12 = icmp sle <4 x i32> %163, %162 + %check13 = icmp slt <4 x i32> %162, zeroinitializer %siui-le = or <4 x i1> %check13, %le12 - %159 = sext <4 x i1> %siui-le to <4 x i32> - store <4 x i32> %159, ptr %w, align 16 - %160 = load <4 x i32>, ptr %w, align 16 - %161 = extractelement <4 x i32> %160, i64 0 - %162 = load <4 x i32>, ptr %w, align 16 - %163 = extractelement <4 x i32> %162, i64 1 - %164 = load <4 x i32>, ptr %w, align 16 - %165 = extractelement <4 x i32> %164, i64 2 - %166 = load <4 x i32>, ptr %w, align 16 - %167 = extractelement <4 x i32> %166, i64 3 - %168 = call i32 (ptr, ...) @printf(ptr @.str.46, i32 %161, i32 %163, i32 %165, i32 %167) - %169 = load <4 x i32>, ptr %uz, align 16 - %170 = load <4 x i32>, ptr %y, align 16 - %gt14 = icmp sgt <4 x i32> %170, %169 - %check15 = icmp sge <4 x i32> %169, zeroinitializer + %164 = sext <4 x i1> %siui-le to <4 x i32> + store <4 x i32> %164, ptr %w, align 16 + %165 = load <4 x i32>, ptr %w, align 16 + %166 = extractelement <4 x i32> %165, i64 0 + %167 = load <4 x i32>, ptr %w, align 16 + %168 = extractelement <4 x i32> %167, i64 1 + %169 = load <4 x i32>, ptr %w, align 16 + %170 = extractelement <4 x i32> %169, i64 2 + %171 = load <4 x i32>, ptr %w, align 16 + %172 = extractelement <4 x i32> %171, i64 3 + %173 = call i32 (ptr, ...) @printf(ptr @.str.44, i32 %166, i32 %168, i32 %170, i32 %172) + %174 = load <4 x i32>, ptr %uz, align 16 + %175 = load <4 x i32>, ptr %y, align 16 + %gt14 = icmp sgt <4 x i32> %175, %174 + %check15 = icmp sge <4 x i32> %174, zeroinitializer %siui-gt = and <4 x i1> %check15, %gt14 - %171 = sext <4 x i1> %siui-gt to <4 x i32> - store <4 x i32> %171, ptr %w, align 16 - %172 = load <4 x i32>, ptr %w, align 16 - %173 = extractelement <4 x i32> %172, i64 0 - %174 = load <4 x i32>, ptr %w, align 16 - %175 = extractelement <4 x i32> %174, i64 1 - %176 = load <4 x i32>, ptr %w, align 16 - %177 = extractelement <4 x i32> %176, i64 2 - %178 = load <4 x i32>, ptr %w, align 16 - %179 = extractelement <4 x i32> %178, i64 3 - %180 = call i32 (ptr, ...) @printf(ptr @.str.47, i32 %173, i32 %175, i32 %177, i32 %179) - %181 = load <4 x i32>, ptr %uz, align 16 - %182 = load <4 x i32>, ptr %y, align 16 - %ge16 = icmp sge <4 x i32> %182, %181 - %check17 = icmp sge <4 x i32> %181, zeroinitializer + %176 = sext <4 x i1> %siui-gt to <4 x i32> + store <4 x i32> %176, ptr %w, align 16 + %177 = load <4 x i32>, ptr %w, align 16 + %178 = extractelement <4 x i32> %177, i64 0 + %179 = load <4 x i32>, ptr %w, align 16 + %180 = extractelement <4 x i32> %179, i64 1 + %181 = load <4 x i32>, ptr %w, align 16 + %182 = extractelement <4 x i32> %181, i64 2 + %183 = load <4 x i32>, ptr %w, align 16 + %184 = extractelement <4 x i32> %183, i64 3 + %185 = call i32 (ptr, ...) @printf(ptr @.str.45, i32 %178, i32 %180, i32 %182, i32 %184) + %186 = load <4 x i32>, ptr %uz, align 16 + %187 = load <4 x i32>, ptr %y, align 16 + %ge16 = icmp sge <4 x i32> %187, %186 + %check17 = icmp sge <4 x i32> %186, zeroinitializer %siui-ge = and <4 x i1> %check17, %ge16 - %183 = sext <4 x i1> %siui-ge to <4 x i32> - store <4 x i32> %183, ptr %w, align 16 - %184 = load <4 x i32>, ptr %w, align 16 - %185 = extractelement <4 x i32> %184, i64 0 - %186 = load <4 x i32>, ptr %w, align 16 - %187 = extractelement <4 x i32> %186, i64 1 - %188 = load <4 x i32>, ptr %w, align 16 - %189 = extractelement <4 x i32> %188, i64 2 - %190 = load <4 x i32>, ptr %w, align 16 - %191 = extractelement <4 x i32> %190, i64 3 - %192 = call i32 (ptr, ...) @printf(ptr @.str.48, i32 %185, i32 %187, i32 %189, i32 %191) - %193 = load <4 x i32>, ptr %uz, align 16 - %194 = load <4 x i32>, ptr %y, align 16 - %eq18 = icmp eq <4 x i32> %194, %193 - %check19 = icmp sge <4 x i32> %194, zeroinitializer + %188 = sext <4 x i1> %siui-ge to <4 x i32> + store <4 x i32> %188, ptr %w, align 16 + %189 = load <4 x i32>, ptr %w, align 16 + %190 = extractelement <4 x i32> %189, i64 0 + %191 = load <4 x i32>, ptr %w, align 16 + %192 = extractelement <4 x i32> %191, i64 1 + %193 = load <4 x i32>, ptr %w, align 16 + %194 = extractelement <4 x i32> %193, i64 2 + %195 = load <4 x i32>, ptr %w, align 16 + %196 = extractelement <4 x i32> %195, i64 3 + %197 = call i32 (ptr, ...) @printf(ptr @.str.46, i32 %190, i32 %192, i32 %194, i32 %196) + %198 = load <4 x i32>, ptr %uz, align 16 + %199 = load <4 x i32>, ptr %y, align 16 + %eq18 = icmp eq <4 x i32> %199, %198 + %check19 = icmp sge <4 x i32> %199, zeroinitializer %siui-eq = and <4 x i1> %check19, %eq18 - %195 = sext <4 x i1> %siui-eq to <4 x i32> - store <4 x i32> %195, ptr %w, align 16 - %196 = load <4 x i32>, ptr %w, align 16 - %197 = extractelement <4 x i32> %196, i64 0 - %198 = load <4 x i32>, ptr %w, align 16 - %199 = extractelement <4 x i32> %198, i64 1 - %200 = load <4 x i32>, ptr %w, align 16 - %201 = extractelement <4 x i32> %200, i64 2 - %202 = load <4 x i32>, ptr %w, align 16 - %203 = extractelement <4 x i32> %202, i64 3 - %204 = call i32 (ptr, ...) @printf(ptr @.str.49, i32 %197, i32 %199, i32 %201, i32 %203) - %205 = load <4 x i32>, ptr %uz, align 16 - %206 = load <4 x i32>, ptr %y, align 16 - %neq20 = icmp ne <4 x i32> %206, %205 - %check21 = icmp slt <4 x i32> %206, zeroinitializer + %200 = sext <4 x i1> %siui-eq to <4 x i32> + store <4 x i32> %200, ptr %w, align 16 + %201 = load <4 x i32>, ptr %w, align 16 + %202 = extractelement <4 x i32> %201, i64 0 + %203 = load <4 x i32>, ptr %w, align 16 + %204 = extractelement <4 x i32> %203, i64 1 + %205 = load <4 x i32>, ptr %w, align 16 + %206 = extractelement <4 x i32> %205, i64 2 + %207 = load <4 x i32>, ptr %w, align 16 + %208 = extractelement <4 x i32> %207, i64 3 + %209 = call i32 (ptr, ...) @printf(ptr @.str.47, i32 %202, i32 %204, i32 %206, i32 %208) + %210 = load <4 x i32>, ptr %uz, align 16 + %211 = load <4 x i32>, ptr %y, align 16 + %neq20 = icmp ne <4 x i32> %211, %210 + %check21 = icmp slt <4 x i32> %211, zeroinitializer %siui-ne = or <4 x i1> %check21, %neq20 - %207 = sext <4 x i1> %siui-ne to <4 x i32> - store <4 x i32> %207, ptr %w, align 16 - %208 = load <4 x i32>, ptr %w, align 16 - %209 = extractelement <4 x i32> %208, i64 0 - %210 = load <4 x i32>, ptr %w, align 16 - %211 = extractelement <4 x i32> %210, i64 1 - %212 = load <4 x i32>, ptr %w, align 16 - %213 = extractelement <4 x i32> %212, i64 2 - %214 = load <4 x i32>, ptr %w, align 16 - %215 = extractelement <4 x i32> %214, i64 3 - %216 = call i32 (ptr, ...) @printf(ptr @.str.50, i32 %209, i32 %211, i32 %213, i32 %215) + %212 = sext <4 x i1> %siui-ne to <4 x i32> + store <4 x i32> %212, ptr %w, align 16 + %213 = load <4 x i32>, ptr %w, align 16 + %214 = extractelement <4 x i32> %213, i64 0 + %215 = load <4 x i32>, ptr %w, align 16 + %216 = extractelement <4 x i32> %215, i64 1 + %217 = load <4 x i32>, ptr %w, align 16 + %218 = extractelement <4 x i32> %217, i64 2 + %219 = load <4 x i32>, ptr %w, align 16 + %220 = extractelement <4 x i32> %219, i64 3 + %221 = call i32 (ptr, ...) @printf(ptr @.str.48, i32 %214, i32 %216, i32 %218, i32 %220) ret void }