From bb20a38cdb856cc0baf9012194634738d4e3da0c Mon Sep 17 00:00:00 2001 From: Christoffer Lerno Date: Fri, 7 Oct 2022 14:34:15 +0200 Subject: [PATCH] Updated membersof. "Type.kind" renamed "Type.kindof" --- lib/std/core/builtin.c3 | 2 +- lib/std/core/mem.c3 | 10 +- lib/std/core/types.c3 | 26 +- lib/std/io_formatter_private.c3 | 6 +- lib/std/io_printf.c3 | 4 +- src/compiler/ast.c | 35 + src/compiler/compiler_internal.h | 76 +- src/compiler/copying.c | 3 + src/compiler/enums.h | 70 +- src/compiler/expr.c | 53 +- src/compiler/llvm_codegen_expr.c | 1 + src/compiler/llvm_codegen_type.c | 1 + src/compiler/number.c | 2 + src/compiler/sema_casts.c | 3 +- src/compiler/sema_decls.c | 16 +- src/compiler/sema_expr.c | 242 +++- src/compiler/sema_types.c | 1 + src/compiler/symtab.c | 5 +- src/compiler/types.c | 16 +- src/version.h | 2 +- test/test_suite/compile_time/ct_memberof.c3t | 1176 +++++++++++++---- test/test_suite2/compile_time/ct_memberof.c3t | 1068 ++++++++++++--- 22 files changed, 2212 insertions(+), 606 deletions(-) diff --git a/lib/std/core/builtin.c3 b/lib/std/core/builtin.c3 index f504360d1..3b6f725bb 100644 --- a/lib/std/core/builtin.c3 +++ b/lib/std/core/builtin.c3 @@ -103,7 +103,7 @@ macro bitcast(expr, $Type) @builtin } /** - * @require $Type.kind == TypeKind.ENUM `Only enums may be used` + * @require $Type.kindof == TypeKind.ENUM `Only enums may be used` **/ macro enum_by_name($Type, char[] enum_name) @builtin { diff --git a/lib/std/core/mem.c3 b/lib/std/core/mem.c3 index 3f372be40..f07f2b08f 100644 --- a/lib/std/core/mem.c3 +++ b/lib/std/core/mem.c3 @@ -51,10 +51,10 @@ macro void clear(void* dst, usize len, usize $dst_align = 0, bool $is_volatile = } /** - * @require $typeof(a).kind == TypeKind.SUBARRAY || $typeof(a).kind == TypeKind.POINTER - * @require $typeof(b).kind == TypeKind.SUBARRAY || $typeof(b).kind == TypeKind.POINTER - * @require $typeof(a).kind != TypeKind.SUBARRAY || len == -1 - * @require $typeof(a).kind != TypeKind.POINTER || len > -1 + * @require $typeof(a).kindof == TypeKind.SUBARRAY || $typeof(a).kindof == TypeKind.POINTER + * @require $typeof(b).kindof == TypeKind.SUBARRAY || $typeof(b).kindof == TypeKind.POINTER + * @require $typeof(a).kindof != TypeKind.SUBARRAY || len == -1 + * @require $typeof(a).kindof != TypeKind.POINTER || len > -1 * @checked (a = b), (b = a) **/ macro bool equals(a, b, isize len = -1, usize $align = 0) @@ -64,7 +64,7 @@ macro bool equals(a, b, isize len = -1, usize $align = 0) $endif; void* x = void; void* y = void; - $if ($typeof(a).kind == TypeKind.SUBARRAY): + $if ($typeof(a).kindof == TypeKind.SUBARRAY): len = a.len; if (len != b.len) return false; x = a.ptr; diff --git a/lib/std/core/types.c3 b/lib/std/core/types.c3 index 253c5d4a2..e2f360571 100644 --- a/lib/std/core/types.c3 +++ b/lib/std/core/types.c3 @@ -8,18 +8,18 @@ fault ConversionResult VALUE_OUT_OF_UNSIGNED_RANGE, } /** - * @require $Type.kind.is_int() || $Type.kind == TypeKind.ENUM "Argument was not an integer" + * @require $Type.kindof.is_int() || $Type.kindof == TypeKind.ENUM "Argument was not an integer" **/ macro variant_to_int(variant v, $Type) { typeid variant_type = v.type; - TypeKind kind = variant_type.kind; + TypeKind kind = variant_type.kindof; if (kind == TypeKind.ENUM) { variant_type = variant_type.inner; - kind = variant_type.kind; + kind = variant_type.kindof; } - bool is_mixed_signed = $Type.kind != variant_type.kind; + bool is_mixed_signed = $Type.kindof != variant_type.kindof; $Type max = $Type.max; $Type min = $Type.min; switch (variant_type) @@ -83,7 +83,7 @@ macro variant_to_int(variant v, $Type) macro bool is_numerical($Type) { - var $kind = $Type.kind; + var $kind = $Type.kindof; $if ($kind == TypeKind.DISTINCT): return is_numerical($Type.inner); $else: @@ -104,7 +104,7 @@ macro bool is_indexable($Type) macro bool is_comparable($Type) { - var $kind = $Type.kind; + var $kind = $Type.kindof; $if ($kind == TypeKind.DISTINCT): return is_comparable($Type.inner); $else: @@ -121,11 +121,11 @@ macro bool is_equatable($Type) macro bool is_subarray_convertable($Type) { - $switch ($Type.kind): + $switch ($Type.kindof): $case SUBARRAY: return true; $case POINTER: - return $Type.inner.kind == TypeKind.ARRAY; + return $Type.inner.kindof == TypeKind.ARRAY; $default: return false; $endswitch; @@ -133,12 +133,12 @@ macro bool is_subarray_convertable($Type) macro bool is_intlike($Type) { - $switch ($Type.kind): + $switch ($Type.kindof): $case SIGNED_INT: $case UNSIGNED_INT: return true; $case VECTOR: - return $Type.inner.kind == TypeKind.SIGNED_INT || $Type.inner.kind == TypeKind.UNSIGNED_INT; + return $Type.inner.kindof == TypeKind.SIGNED_INT || $Type.inner.kindof == TypeKind.UNSIGNED_INT; $default: return false; $endswitch; @@ -146,11 +146,11 @@ macro bool is_intlike($Type) macro bool is_floatlike($Type) { - $switch ($Type.kind): + $switch ($Type.kindof): $case FLOAT: return true; $case VECTOR: - return $Type.inner.kind == TypeKind.FLOAT; + return $Type.inner.kindof == TypeKind.FLOAT; $default: return false; $endswitch; @@ -158,7 +158,7 @@ macro bool is_floatlike($Type) macro bool is_vector($Type) { - return $Type.kind == TypeKind.VECTOR; + return $Type.kindof == TypeKind.VECTOR; } macro bool is_same($TypeA, $TypeB) diff --git a/lib/std/io_formatter_private.c3 b/lib/std/io_formatter_private.c3 index 2ff0c6a74..229da00ae 100644 --- a/lib/std/io_formatter_private.c3 +++ b/lib/std/io_formatter_private.c3 @@ -27,7 +27,7 @@ private fn NtoaType int_from_variant(variant arg, bool *is_neg) } $endif; - if (arg.type.kind == TypeKind.POINTER) + if (arg.type.kindof == TypeKind.POINTER) { return (NtoaType)(uptr)*(void**)arg.ptr; } @@ -84,7 +84,7 @@ private fn FloatType float_from_variant(variant arg) if (arg.type == float16.typeid) return *((float16*)arg.ptr); $endif; - if (arg.type.kind == TypeKind.POINTER) + if (arg.type.kindof == TypeKind.POINTER) { return (FloatType)(uptr)(void*)arg.ptr; } @@ -565,7 +565,7 @@ private fn int! printf_parse_format_field(variant* args_ptr, usize args_len, usi if (c != '*') return 0; printf_advance_format(format_len, index_ptr)?; variant val = next_variant(args_ptr, args_len, args_index_ptr)?; - if (!val.type.kind.is_int()) return FormattingFault.INVALID_WIDTH_ARG!; + if (!val.type.kindof.is_int()) return FormattingFault.INVALID_WIDTH_ARG!; uint! intval = types::variant_to_int(val, int); if (catch intval) return FormattingFault.INVALID_WIDTH_ARG!; return intval; diff --git a/lib/std/io_printf.c3 b/lib/std/io_printf.c3 index 3629af1fb..2484ab7f2 100644 --- a/lib/std/io_printf.c3 +++ b/lib/std/io_printf.c3 @@ -133,7 +133,7 @@ macro bool! Formatter.print_with_function(Formatter* this, variant arg) } private fn void! Formatter.out_str(Formatter* this, variant arg) { - switch (arg.type.kind) + switch (arg.type.kindof) { case TYPEID: return this.out_substr(""); @@ -171,7 +171,7 @@ private fn void! Formatter.out_str(Formatter* this, variant arg) case POINTER: if (this.print_with_function(arg)?) return; typeid inner = arg.type.inner; - if (inner.kind == TypeKind.ARRAY && inner.inner == char.typeid) + if (inner.kindof == TypeKind.ARRAY && inner.inner == char.typeid) { char *ptr = *(char**)arg.ptr; return this.out_substr(ptr[:inner.len]); diff --git a/src/compiler/ast.c b/src/compiler/ast.c index 593868660..e26843ba7 100644 --- a/src/compiler/ast.c +++ b/src/compiler/ast.c @@ -435,6 +435,41 @@ Decl *decl_find_enum_constant(Decl *decl, const char *name) return NULL; } +AlignSize decl_find_member_offset(Decl *decl, Decl *member) +{ + static const AlignSize NO_MATCH = ~(AlignSize)0; + while (decl->decl_kind == DECL_DISTINCT) decl = decl->distinct_decl.base_type->decl; + Decl **members = NULL; + switch (decl->decl_kind) + { + case DECL_BITSTRUCT: + members = decl->bitstruct.members; + break; + case DECL_STRUCT: + case DECL_UNION: + members = decl->strukt.members; + break; + default: + return NO_MATCH; + } + assert(members); + unsigned list = vec_size(members); + for (unsigned i = 0; i < list; i++) + { + Decl *m = members[i]; + if (m == member) + { + return member->offset; + } + if (m->decl_kind != DECL_VAR) + { + AlignSize possible_offset = decl_find_member_offset(m, member); + if (possible_offset != NO_MATCH) return possible_offset + m->offset; + } + } + return NO_MATCH; +} + bool ast_supports_continue(Ast *stmt) { if (stmt->ast_kind != AST_FOR_STMT) return false; diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h index 38ae9d292..fa0100232 100644 --- a/src/compiler/compiler_internal.h +++ b/src/compiler/compiler_internal.h @@ -204,6 +204,12 @@ typedef struct Type *typeid; ConstInitializer *initializer; Expr **untyped_list; + struct + { + AlignSize offset; + AlignSize align; + Decl *decl; + } member; }; } ExprConst; @@ -1795,7 +1801,7 @@ extern Type *type_ichar, *type_short, *type_int, *type_long, *type_isize; extern Type *type_char, *type_ushort, *type_uint, *type_ulong, *type_usize; extern Type *type_iptr, *type_uptr, *type_iptrdiff, *type_uptrdiff; extern Type *type_u128, *type_i128; -extern Type *type_typeid, *type_anyerr, *type_typeinfo; +extern Type *type_typeid, *type_anyerr, *type_typeinfo, *type_member; extern Type *type_any; extern Type *type_untypedlist; extern Type *type_anyfail; @@ -1812,38 +1818,39 @@ extern const char *kw_std__core; extern const char *kw_std__core__types; extern const char *kw_typekind; -extern const char *kw_std; -extern const char *kw_finalize; extern const char *kw_align; -extern const char *kw_nameof; -extern const char *kw_in; -extern const char *kw_initialize; -extern const char *kw_out; -extern const char *kw_inout; -extern const char *kw_deprecated; -extern const char *kw_distinct; -extern const char *kw_inline; -extern const char *kw_kind; -extern const char *kw_len; -extern const char *kw_noinline; -extern const char *kw_main; -extern const char *kw_ordinal; -extern const char *kw_pure; -extern const char *kw_ptr; -extern const char *kw_return; -extern const char *kw_type; -extern const char *kw_incr; -extern const char *kw_check_assign; extern const char *kw_argc; extern const char *kw_argv; -extern const char *kw_mainstub; +extern const char *kw_at_checked; extern const char *kw_at_ensure; -extern const char *kw_at_require; -extern const char *kw_at_pure; extern const char *kw_at_optreturn; extern const char *kw_at_param; +extern const char *kw_at_pure; +extern const char *kw_at_require; extern const char *kw_at_return; -extern const char *kw_at_checked; +extern const char *kw_check_assign; +extern const char *kw_deprecated; +extern const char *kw_distinct; +extern const char *kw_finalize; +extern const char *kw_in; +extern const char *kw_incr; +extern const char *kw_initialize; +extern const char *kw_inline; +extern const char *kw_inout; +extern const char *kw_kind; +extern const char *kw_len; +extern const char *kw_main; +extern const char *kw_mainstub; +extern const char *kw_nameof; +extern const char *kw_noinline; +extern const char *kw_offsetof; +extern const char *kw_ordinal; +extern const char *kw_out; +extern const char *kw_ptr; +extern const char *kw_pure; +extern const char *kw_return; +extern const char *kw_std; +extern const char *kw_type; extern ArchOsTarget default_target; ARENA_DEF(chars, char) @@ -2065,6 +2072,7 @@ static inline Decl *decl_raw(Decl *decl); static inline DeclKind decl_from_token(TokenType type); static inline bool decl_is_local(Decl *decl); Decl *decl_find_enum_constant(Decl *decl, const char *name); +AlignSize decl_find_member_offset(Decl *decl, Decl *member); // --- Expression functions @@ -2098,9 +2106,11 @@ INLINE bool exprid_is_constant_eval(ExprId expr, ConstantEvalKind eval_kind); INLINE bool expr_is_init_list(Expr *expr); INLINE bool expr_is_deref(Expr *expr); INLINE bool expr_is_const(Expr *expr); +INLINE bool expr_is_const_int(Expr *expr); INLINE bool expr_is_const_string(Expr *expr); INLINE bool expr_is_const_initializer(Expr *expr); INLINE bool expr_is_const_untyped_list(Expr *expr); +INLINE bool expr_is_const_member(Expr *expr); INLINE void expr_rewrite_const_null(Expr *expr, Type *type); INLINE void expr_rewrite_const_bool(Expr *expr, Type *type, bool b); @@ -3017,10 +3027,6 @@ static inline Clobbers clobbers_make(unsigned index, ...) return clobbers; } -static inline bool expr_is_const_int(Expr *expr) -{ - return expr->expr_kind == EXPR_CONST && expr->const_expr.const_kind == CONST_INTEGER; -} INLINE unsigned arg_bits_max(AsmArgBits bits, unsigned limit) { @@ -3069,3 +3075,13 @@ INLINE bool expr_is_const_untyped_list(Expr *expr) { return expr->expr_kind == EXPR_CONST && expr->const_expr.const_kind == CONST_UNTYPED_LIST; } + +INLINE bool expr_is_const_int(Expr *expr) +{ + return expr->expr_kind == EXPR_CONST && expr->const_expr.const_kind == CONST_INTEGER; +} + +INLINE bool expr_is_const_member(Expr *expr) +{ + return expr->expr_kind == EXPR_CONST && expr->const_expr.const_kind == CONST_MEMBER; +} diff --git a/src/compiler/copying.c b/src/compiler/copying.c index f5b3ab2ba..f5e61e352 100644 --- a/src/compiler/copying.c +++ b/src/compiler/copying.c @@ -275,6 +275,9 @@ INLINE Expr *copy_const_expr(CopyStruct *c, Expr *expr) case CONST_UNTYPED_LIST: expr->const_expr.untyped_list = copy_expr_list(c, expr->const_expr.untyped_list); break; + case CONST_MEMBER: + fixup_decl(c, &expr->const_expr.member.decl); + break; } return expr; } diff --git a/src/compiler/enums.h b/src/compiler/enums.h index 2e69a0939..40c8c3d5f 100644 --- a/src/compiler/enums.h +++ b/src/compiler/enums.h @@ -201,64 +201,64 @@ typedef enum { EXPR_POISONED, EXPR_ACCESS, + EXPR_ARGV_TO_SUBARRAY, + EXPR_ASM, + EXPR_BINARY, EXPR_BITACCESS, EXPR_BITASSIGN, - EXPR_BINARY, EXPR_BUILTIN, - EXPR_COMPILER_CONST, - EXPR_MACRO_BODY_EXPANSION, + EXPR_BUILTIN_ACCESS, EXPR_CALL, EXPR_CAST, EXPR_CATCH, EXPR_CATCH_UNWRAP, + EXPR_COMPILER_CONST, EXPR_COMPOUND_LITERAL, - EXPR_CONST, - EXPR_CT_CHECKS, - EXPR_CT_CALL, - EXPR_CT_IDENT, - EXPR_CT_EVAL, - EXPR_CT_ARG, EXPR_COND, + EXPR_CONST, + EXPR_CT_ARG, + EXPR_CT_CALL, + EXPR_CT_CHECKS, + EXPR_CT_EVAL, + EXPR_CT_IDENT, EXPR_DECL, - EXPR_DESIGNATOR, - EXPR_EXPR_BLOCK, - EXPR_EXPRESSION_LIST, - EXPR_FAILABLE, - EXPR_GROUP, - EXPR_RETHROW, - EXPR_FORCE_UNWRAP, - EXPR_HASH_IDENT, - EXPR_MACRO_BLOCK, - EXPR_IDENTIFIER, - EXPR_RETVAL, - EXPR_FLATPATH, - EXPR_INITIALIZER_LIST, EXPR_DESIGNATED_INITIALIZER_LIST, + EXPR_DESIGNATOR, + EXPR_EXPRESSION_LIST, + EXPR_EXPR_BLOCK, + EXPR_FAILABLE, + EXPR_FLATPATH, + EXPR_FORCE_UNWRAP, + EXPR_GROUP, + EXPR_HASH_IDENT, + EXPR_IDENTIFIER, + EXPR_INITIALIZER_LIST, + EXPR_MACRO_BLOCK, + EXPR_MACRO_BODY_EXPANSION, + EXPR_NOP, + EXPR_OPERATOR_CHARS, + EXPR_POINTER_OFFSET, EXPR_POST_UNARY, + EXPR_RETHROW, + EXPR_RETVAL, EXPR_SLICE, EXPR_SLICE_ASSIGN, EXPR_SLICE_COPY, + EXPR_STRINGIFY, EXPR_SUBSCRIPT, EXPR_SUBSCRIPT_ADDR, EXPR_SUBSCRIPT_ASSIGN, - EXPR_POINTER_OFFSET, - EXPR_STRINGIFY, - EXPR_ARGV_TO_SUBARRAY, EXPR_TERNARY, EXPR_TRY, EXPR_TRY_UNWRAP, EXPR_TRY_UNWRAP_CHAIN, EXPR_TYPEID, + EXPR_TYPEID_INFO, EXPR_TYPEINFO, EXPR_UNARY, + EXPR_VARIANT, EXPR_VARIANTSWITCH, EXPR_VASPLAT, - EXPR_NOP, - EXPR_TYPEID_INFO, - EXPR_VARIANT, - EXPR_BUILTIN_ACCESS, - EXPR_ASM, - EXPR_OPERATOR_CHARS, } ExprKind; typedef enum @@ -316,6 +316,7 @@ typedef enum CONST_TYPEID, CONST_INITIALIZER, CONST_UNTYPED_LIST, + CONST_MEMBER, } ConstKind; typedef enum @@ -654,13 +655,15 @@ typedef enum TYPE_OPTIONAL, TYPE_FAILABLE_ANY, TYPE_TYPEINFO, + TYPE_MEMBER, TYPE_INFERRED_VECTOR, TYPE_SCALED_VECTOR, TYPE_VECTOR, TYPE_LAST = TYPE_ANY } TypeKind; -#define CT_TYPES TYPE_TYPEINFO: case TYPE_INFERRED_ARRAY: case TYPE_INFERRED_VECTOR: case TYPE_UNTYPED_LIST: case TYPE_POISONED +#define CT_TYPES TYPE_TYPEINFO: case TYPE_INFERRED_ARRAY: case TYPE_INFERRED_VECTOR: case TYPE_UNTYPED_LIST: \ +case TYPE_POISONED: case TYPE_MEMBER #define ALL_INTS TYPE_I8: case TYPE_I16: case TYPE_I32: case TYPE_I64: case TYPE_I128: \ case TYPE_U8: case TYPE_U16: case TYPE_U32: case TYPE_U64: case TYPE_U128 #define ALL_SIGNED_INTS TYPE_I8: case TYPE_I16: case TYPE_I32: case TYPE_I64: case TYPE_I128 @@ -880,6 +883,7 @@ typedef enum typedef enum { + TYPE_PROPERTY_ALIGNOF, TYPE_PROPERTY_ELEMENTS, TYPE_PROPERTY_EXTNAMEOF, TYPE_PROPERTY_INF, @@ -889,7 +893,7 @@ typedef enum TYPE_PROPERTY_MIN, TYPE_PROPERTY_NAN, TYPE_PROPERTY_INNER, - TYPE_PROPERTY_KIND, + TYPE_PROPERTY_KINDOF, TYPE_PROPERTY_NAMES, TYPE_PROPERTY_NAMEOF, TYPE_PROPERTY_PARAMS, diff --git a/src/compiler/expr.c b/src/compiler/expr.c index 787375c47..ba5cecf5d 100644 --- a/src/compiler/expr.c +++ b/src/compiler/expr.c @@ -80,59 +80,59 @@ bool expr_may_addr(Expr *expr) case EXPR_SUBSCRIPT: case EXPR_SLICE: return true; - case EXPR_SUBSCRIPT_ADDR: - case EXPR_POISONED: - case EXPR_BITASSIGN: + case EXPR_ARGV_TO_SUBARRAY: + case EXPR_ASM: case EXPR_BINARY: + case EXPR_BITASSIGN: case EXPR_BUILTIN: - case EXPR_COMPILER_CONST: - case EXPR_MACRO_BODY_EXPANSION: + case EXPR_BUILTIN_ACCESS: case EXPR_CALL: case EXPR_CAST: case EXPR_CATCH: case EXPR_CATCH_UNWRAP: + case EXPR_COMPILER_CONST: case EXPR_COMPOUND_LITERAL: - case EXPR_CONST: - case EXPR_CT_CALL: - case EXPR_CT_IDENT: - case EXPR_CT_EVAL: case EXPR_COND: + case EXPR_CONST: + case EXPR_CT_ARG: + case EXPR_CT_CALL: + case EXPR_CT_CHECKS: + case EXPR_CT_EVAL: + case EXPR_CT_IDENT: case EXPR_DECL: + case EXPR_DESIGNATED_INITIALIZER_LIST: case EXPR_DESIGNATOR: - case EXPR_EXPR_BLOCK: case EXPR_EXPRESSION_LIST: + case EXPR_EXPR_BLOCK: case EXPR_FAILABLE: - case EXPR_RETHROW: + case EXPR_FLATPATH: case EXPR_FORCE_UNWRAP: case EXPR_HASH_IDENT: - case EXPR_MACRO_BLOCK: - case EXPR_RETVAL: - case EXPR_FLATPATH: case EXPR_INITIALIZER_LIST: - case EXPR_DESIGNATED_INITIALIZER_LIST: + case EXPR_MACRO_BLOCK: + case EXPR_MACRO_BODY_EXPANSION: + case EXPR_NOP: + case EXPR_OPERATOR_CHARS: + case EXPR_POINTER_OFFSET: + case EXPR_POISONED: case EXPR_POST_UNARY: + case EXPR_RETHROW: + case EXPR_RETVAL: case EXPR_SLICE_ASSIGN: case EXPR_SLICE_COPY: case EXPR_STRINGIFY: - case EXPR_ARGV_TO_SUBARRAY: + case EXPR_SUBSCRIPT_ADDR: + case EXPR_SUBSCRIPT_ASSIGN: case EXPR_TERNARY: case EXPR_TRY: case EXPR_TRY_UNWRAP: case EXPR_TRY_UNWRAP_CHAIN: case EXPR_TYPEID: - case EXPR_TYPEINFO: - case EXPR_VARIANTSWITCH: - case EXPR_NOP: case EXPR_TYPEID_INFO: + case EXPR_TYPEINFO: case EXPR_VARIANT: - case EXPR_BUILTIN_ACCESS: - case EXPR_POINTER_OFFSET: - case EXPR_CT_ARG: - case EXPR_ASM: + case EXPR_VARIANTSWITCH: case EXPR_VASPLAT: - case EXPR_OPERATOR_CHARS: - case EXPR_CT_CHECKS: - case EXPR_SUBSCRIPT_ASSIGN: return false; } UNREACHABLE @@ -573,6 +573,7 @@ void expr_rewrite_to_const_zero(Expr *expr, Type *type) case TYPE_FAILABLE_ANY: case TYPE_OPTIONAL: case TYPE_TYPEINFO: + case TYPE_MEMBER: UNREACHABLE case TYPE_STRUCT: case TYPE_UNION: diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c index 93ba77231..459e5f99d 100644 --- a/src/compiler/llvm_codegen_expr.c +++ b/src/compiler/llvm_codegen_expr.c @@ -3977,6 +3977,7 @@ static void llvm_emit_const_expr(GenContext *c, BEValue *be_value, Expr *expr) case CONST_ENUM: llvm_value_set(be_value, llvm_const_int(c, type, expr->const_expr.enum_val->enum_constant.ordinal), type); return; + case CONST_MEMBER: case CONST_UNTYPED_LIST: UNREACHABLE } diff --git a/src/compiler/llvm_codegen_type.c b/src/compiler/llvm_codegen_type.c index eb002da16..5961ab143 100644 --- a/src/compiler/llvm_codegen_type.c +++ b/src/compiler/llvm_codegen_type.c @@ -716,6 +716,7 @@ LLVMValueRef llvm_get_typeid(GenContext *c, Type *type) case TYPE_UNTYPED_LIST: case TYPE_FAILABLE_ANY: case TYPE_TYPEINFO: + case TYPE_MEMBER: UNREACHABLE case TYPE_VOID: return llvm_get_introspection_for_builtin_type(c, type, INTROSPECT_TYPE_VOID, 0); diff --git a/src/compiler/number.c b/src/compiler/number.c index f20cf54d2..da4966334 100644 --- a/src/compiler/number.c +++ b/src/compiler/number.c @@ -210,6 +210,8 @@ const char *expr_const_to_error_string(const ExprConst *expr) return expr->err_val->name; case CONST_TYPEID: return type_to_error_string(expr->typeid); + case CONST_MEMBER: + return "member"; case CONST_INITIALIZER: return "constant list"; case CONST_UNTYPED_LIST: diff --git a/src/compiler/sema_casts.c b/src/compiler/sema_casts.c index 1ed117c5e..4b3ab8c1f 100644 --- a/src/compiler/sema_casts.c +++ b/src/compiler/sema_casts.c @@ -400,6 +400,7 @@ CastKind cast_to_bool_kind(Type *type) case TYPE_FLEXIBLE_ARRAY: case TYPE_SCALED_VECTOR: case TYPE_INFERRED_VECTOR: + case TYPE_MEMBER: return CAST_ERROR; } UNREACHABLE @@ -458,6 +459,7 @@ bool cast_may_explicit(Type *from_type, Type *to_type, bool ignore_failability, case TYPE_FLEXIBLE_ARRAY: case TYPE_INFERRED_VECTOR: case TYPE_SCALED_VECTOR: + case TYPE_MEMBER: return false; case TYPE_TYPEID: // May convert to anything pointer sized or larger, no enums @@ -852,7 +854,6 @@ Expr *recursive_may_narrow_float(Expr *expr, Type *type) case EXPR_SUBSCRIPT_ASSIGN: UNREACHABLE case EXPR_BUILTIN_ACCESS: - return false; case EXPR_POST_UNARY: return recursive_may_narrow_float(expr->unary_expr.expr, type); diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c index a90981abe..a6f4da3f2 100644 --- a/src/compiler/sema_decls.c +++ b/src/compiler/sema_decls.c @@ -2234,12 +2234,20 @@ static bool sema_analyse_attributes_for_var(SemaContext *context, Decl *decl) bool sema_analyse_decl_type(SemaContext *context, Type *type, SourceSpan span) { - if (type == type_void) + switch (type->type_kind) { - sema_error_at(span, "The use of 'void' as a variable type is not permitted."); - return false; + case TYPE_VOID: + sema_error_at(span, "The use of 'void' as a variable type is not permitted."); + return false; + case TYPE_UNTYPED_LIST: + case TYPE_MEMBER: + case TYPE_TYPEINFO: + sema_error_at(span, "The variable cannot have an compile time %s type.", + type_quoted_error_string(type)); + return false; + default: + break; } - if (!type_is_optional(type)) return true; if (type_is_optional_any(type) || type_flatten_distinct(type->failable) == type_void) { diff --git a/src/compiler/sema_expr.c b/src/compiler/sema_expr.c index acfe25d1e..a076824de 100644 --- a/src/compiler/sema_expr.c +++ b/src/compiler/sema_expr.c @@ -160,7 +160,8 @@ static Type *sema_expr_check_type_exists(SemaContext *context, TypeInfo *type_in static inline Expr *sema_ct_checks_exprlist_compiles(SemaContext *context, Expr *exprlist); static inline bool sema_cast_ct_ident_rvalue(SemaContext *context, Expr *expr); static bool sema_expr_rewrite_to_typeid_property(SemaContext *context, Expr *expr, Expr *typeid, const char *kw); -static bool sema_expr_rewrite_to_type_property(SemaContext *context, Expr *expr, Type *type, TypeProperty property); +static bool sema_expr_rewrite_to_type_property(SemaContext *context, Expr *expr, Type *type, TypeProperty property, + AlignSize alignment, AlignSize offset); static bool sema_expr_rewrite_typeid_call(Expr *expr, Expr *typeid, TypeIdInfoKind kind, Type *result_type); static inline void sema_expr_rewrite_typeid_kind(Expr *expr, Expr *parent); static inline void sema_expr_replace_with_enum_array(Expr *enum_array_expr, Decl *enum_decl); @@ -173,7 +174,8 @@ static inline bool sema_create_const_inner(SemaContext *context, Expr *expr, Typ static inline bool sema_create_const_min(SemaContext *context, Expr *expr, Type *type, Type *flat); static inline bool sema_create_const_max(SemaContext *context, Expr *expr, Type *type, Type *flat); static inline bool sema_create_const_params(SemaContext *context, Expr *expr, Type *type); -static inline bool sema_create_const_membersof(SemaContext *context, Expr *expr, Type *type); +static inline void sema_create_const_membersof(SemaContext *context, Expr *expr, Type *type, AlignSize alignment, + AlignSize offset); void expr_insert_widening_type(Expr *expr, Type *infer_type); static Expr *expr_access_inline_member(Expr *parent, Decl *parent_decl); @@ -186,6 +188,7 @@ static inline bool sema_cast_ident_rvalue(SemaContext *context, Expr *expr); static inline bool sema_cast_rvalue(SemaContext *context, Expr *expr); static inline bool sema_expr_analyse_type_access(SemaContext *context, Expr *expr, TypeInfo *parent, bool was_group, Expr *identifier); +static inline bool sema_expr_analyse_member_access(SemaContext *context, Expr *expr, Expr *parent, bool was_group, Expr *identifier); static inline bool sema_expr_fold_to_member(Expr *expr, Expr *parent, Decl *member); // -- implementations @@ -425,54 +428,54 @@ static bool sema_binary_is_expr_lvalue(Expr *top_expr, Expr *expr) SEMA_ERROR(top_expr, "You cannot assign to an unevaluated expression."); return false; case EXPR_POISONED: - case EXPR_BITASSIGN: + case EXPR_ARGV_TO_SUBARRAY: + case EXPR_ASM: case EXPR_BINARY: + case EXPR_BITASSIGN: case EXPR_BUILTIN: - case EXPR_COMPILER_CONST: - case EXPR_MACRO_BODY_EXPANSION: + case EXPR_BUILTIN_ACCESS: case EXPR_CALL: case EXPR_CAST: case EXPR_CATCH: case EXPR_CATCH_UNWRAP: + case EXPR_COMPILER_CONST: case EXPR_COMPOUND_LITERAL: - case EXPR_CONST: - case EXPR_CT_CALL: - case EXPR_CT_EVAL: case EXPR_COND: + case EXPR_CONST: + case EXPR_CT_ARG: + case EXPR_CT_CALL: + case EXPR_CT_CHECKS: + case EXPR_CT_EVAL: case EXPR_DECL: - case EXPR_DESIGNATOR: - case EXPR_EXPR_BLOCK: - case EXPR_EXPRESSION_LIST: - case EXPR_FAILABLE: - case EXPR_RETHROW: - case EXPR_FORCE_UNWRAP: - case EXPR_MACRO_BLOCK: - case EXPR_RETVAL: - case EXPR_FLATPATH: - case EXPR_INITIALIZER_LIST: case EXPR_DESIGNATED_INITIALIZER_LIST: + case EXPR_DESIGNATOR: + case EXPR_EXPRESSION_LIST: + case EXPR_EXPR_BLOCK: + case EXPR_FAILABLE: + case EXPR_FLATPATH: + case EXPR_FORCE_UNWRAP: + case EXPR_INITIALIZER_LIST: + case EXPR_MACRO_BLOCK: + case EXPR_MACRO_BODY_EXPANSION: + case EXPR_NOP: + case EXPR_OPERATOR_CHARS: + case EXPR_POINTER_OFFSET: case EXPR_POST_UNARY: + case EXPR_RETHROW: + case EXPR_RETVAL: case EXPR_SLICE_ASSIGN: case EXPR_SLICE_COPY: case EXPR_STRINGIFY: - case EXPR_ARGV_TO_SUBARRAY: case EXPR_TERNARY: case EXPR_TRY: case EXPR_TRY_UNWRAP: case EXPR_TRY_UNWRAP_CHAIN: case EXPR_TYPEID: - case EXPR_TYPEINFO: - case EXPR_VARIANTSWITCH: - case EXPR_NOP: case EXPR_TYPEID_INFO: + case EXPR_TYPEINFO: case EXPR_VARIANT: - case EXPR_BUILTIN_ACCESS: - case EXPR_POINTER_OFFSET: - case EXPR_CT_ARG: - case EXPR_ASM: + case EXPR_VARIANTSWITCH: case EXPR_VASPLAT: - case EXPR_OPERATOR_CHARS: - case EXPR_CT_CHECKS: goto ERR; } UNREACHABLE @@ -2698,7 +2701,8 @@ static inline bool sema_expr_analyse_type_access(SemaContext *context, Expr *exp if (!is_const) { - if (sema_expr_rewrite_to_type_property(context, expr, canonical, type_property_by_name(name))) return true; + if (sema_expr_rewrite_to_type_property(context, expr, canonical, type_property_by_name(name), + type_abi_alignment(parent->type), 0)) return true; } if (!type_may_have_sub_elements(canonical)) @@ -2750,25 +2754,19 @@ static inline bool sema_expr_analyse_type_access(SemaContext *context, Expr *exp return false; } - if (member->decl_kind == DECL_VAR) + if (member->decl_kind == DECL_VAR || member->decl_kind == DECL_UNION || member->decl_kind == DECL_STRUCT || member->decl_kind == DECL_BITSTRUCT) { - expr->expr_kind = EXPR_TYPEINFO; - expr->type_expr->type = member->type; - expr->type_expr->resolve_status = RESOLVE_DONE; - expr->type = type_typeinfo; + expr->expr_kind = EXPR_CONST; + expr->const_expr = (ExprConst) { + .member.decl = member, + .member.align = type_abi_alignment(decl->type), + .member.offset = decl_find_member_offset(decl, member), + .const_kind = CONST_MEMBER + }; + expr->type = type_member; return true; } - if (member->decl_kind == DECL_UNION || member->decl_kind == DECL_STRUCT || member->decl_kind == DECL_BITSTRUCT) - { - expr->expr_kind = EXPR_TYPEINFO; - expr->type_expr->type = member->type; - expr->type_expr->resolve_status = RESOLVE_DONE; - expr->type = type_typeinfo; - return true; - } - - expr->identifier_expr.ident = name; expr->expr_kind = EXPR_IDENTIFIER; expr->identifier_expr.decl = member; @@ -2776,6 +2774,91 @@ static inline bool sema_expr_analyse_type_access(SemaContext *context, Expr *exp return true; } +static inline bool sema_expr_analyse_member_access(SemaContext *context, Expr *expr, Expr *parent, bool was_group, Expr *identifier) +{ + assert(identifier->expr_kind == EXPR_IDENTIFIER); + + Decl *decl = parent->const_expr.member.decl; + const char *name = identifier->identifier_expr.ident; + bool is_const = identifier->identifier_expr.is_const; + + if (is_const) + { + SEMA_ERROR(expr, "There is no member '%s' for %s.", name, type_to_error_string(decl->type)); + return false; + } + + if (name == kw_offsetof) + { + expr_rewrite_const_int(expr, type_usize, parent->const_expr.member.offset, true); + return true; + } + TypeProperty type_property = type_property_by_name(name); + switch (type_property) + { + case TYPE_PROPERTY_NONE: + break; + case TYPE_PROPERTY_QNAMEOF: + break; + case TYPE_PROPERTY_NAMEOF: + expr_rewrite_to_string(expr, decl->name ? decl->name : ""); + return true; + case TYPE_PROPERTY_ALIGNOF: + expr_rewrite_const_int(expr, type_usize, + type_min_alignment(parent->const_expr.member.offset, parent->const_expr.member.align), + true); + return true; + case TYPE_PROPERTY_MEMBERSOF: + sema_create_const_membersof(context, expr, decl->type->canonical, parent->const_expr.member.align, parent->const_expr.member.offset); + return true; + case TYPE_PROPERTY_KINDOF: + case TYPE_PROPERTY_SIZEOF: + if (sema_expr_rewrite_to_type_property(context, expr, decl->type, type_property, + parent->const_expr.member.align, + parent->const_expr.member.offset)) return true; + return true; + case TYPE_PROPERTY_ELEMENTS: + case TYPE_PROPERTY_EXTNAMEOF: + case TYPE_PROPERTY_PARAMS: + case TYPE_PROPERTY_RETURNS: + case TYPE_PROPERTY_INF: + case TYPE_PROPERTY_LEN: + case TYPE_PROPERTY_MAX: + case TYPE_PROPERTY_MIN: + case TYPE_PROPERTY_NAN: + case TYPE_PROPERTY_INNER: + case TYPE_PROPERTY_NAMES: + case TYPE_PROPERTY_VALUES: + break; + } + + Type *underlying_type = type_flatten_distinct(decl->type); + + if (!type_is_union_or_strukt(underlying_type) && underlying_type->type_kind != TYPE_BITSTRUCT) + { + SEMA_ERROR(parent, "No member or property '%s' was found.", name); + return false; + } + + Decl *underlying_type_decl = underlying_type->decl; + Decl *member = sema_decl_stack_find_decl_member(underlying_type_decl, name); + if (!member || !(decl_is_struct_type(member) || member->decl_kind == DECL_VAR || member->decl_kind == DECL_BITSTRUCT)) + { + SEMA_ERROR(expr, "No member '%s' found.", name); + return false; + } + + expr->expr_kind = EXPR_CONST; + expr->const_expr = (ExprConst) { + .member.decl = member, + .member.align = parent->const_expr.member.align, + .member.offset = parent->const_expr.member.offset + decl_find_member_offset(decl, member), + .const_kind = CONST_MEMBER + }; + expr->type = type_member; + return true; +} + static inline void sema_expr_rewrite_typeid_kind(Expr *expr, Expr *parent) { Module *module = global_context_find_module(kw_std__core__types); @@ -2939,7 +3022,8 @@ static inline bool sema_create_const_params(SemaContext *context, Expr *expr, Ty return true; } -static inline bool sema_create_const_membersof(SemaContext *context, Expr *expr, Type *type) +static inline void sema_create_const_membersof(SemaContext *context, Expr *expr, Type *type, AlignSize alignment, + AlignSize offset) { Decl **members = NULL; if (type_is_union_or_strukt(type)) @@ -2952,18 +3036,25 @@ static inline bool sema_create_const_membersof(SemaContext *context, Expr *expr, } else { - return false; + expr_rewrite_const_untyped_list(expr, NULL); + return; } unsigned count = vec_size(members); Expr **member_exprs = count ? VECNEW(Expr*, count) : NULL; for (unsigned i = 0; i < count; i++) { Decl *decl = members[i]; - Expr *expr_element = expr_new_const_typeid(expr->span, decl->type->canonical); + Expr *expr_element = expr_new(EXPR_CONST, expr->span); + expr_element->type = type_member; + expr_element->const_expr = (ExprConst) { + .const_kind = CONST_MEMBER, + .member.decl = decl, + .member.offset = offset + decl->offset, + .member.align = alignment + }; vec_add(member_exprs, expr_element); } expr_rewrite_const_untyped_list(expr, member_exprs); - return true; } static inline bool sema_create_const_max(SemaContext *context, Expr *expr, Type *type, Type *flat) @@ -3055,7 +3146,8 @@ static bool sema_expr_rewrite_to_typeid_property(SemaContext *context, Expr *exp TypeProperty property = type_property_by_name(kw); if (typeid->expr_kind == EXPR_CONST) { - return sema_expr_rewrite_to_type_property(context, expr, typeid->const_expr.typeid, property); + Type *type = typeid->const_expr.typeid; + return sema_expr_rewrite_to_type_property(context, expr, type, property, type_abi_alignment(type), 0); } switch (property) { @@ -3065,11 +3157,12 @@ static bool sema_expr_rewrite_to_typeid_property(SemaContext *context, Expr *exp return sema_expr_rewrite_typeid_call(expr, typeid, TYPEID_INFO_LEN, type_usize); case TYPE_PROPERTY_INNER: return sema_expr_rewrite_typeid_call(expr, typeid, TYPEID_INFO_INNER, type_typeid); - case TYPE_PROPERTY_KIND: + case TYPE_PROPERTY_KINDOF: sema_expr_rewrite_typeid_kind(expr, typeid); return true; case TYPE_PROPERTY_NAMES: return sema_expr_rewrite_typeid_call(expr, typeid, TYPEID_INFO_NAMES, type_get_subarray(type_chars)); + case TYPE_PROPERTY_ALIGNOF: case TYPE_PROPERTY_INF: case TYPE_PROPERTY_MIN: case TYPE_PROPERTY_MAX: @@ -3146,7 +3239,8 @@ EVAL: return true; } -static bool sema_expr_rewrite_to_type_property(SemaContext *context, Expr *expr, Type *type, TypeProperty property) +static bool sema_expr_rewrite_to_type_property(SemaContext *context, Expr *expr, Type *type, TypeProperty property, + AlignSize alignment, AlignSize offset) { assert(type == type->canonical); if (property == TYPE_PROPERTY_NONE) return false; @@ -3164,7 +3258,7 @@ static bool sema_expr_rewrite_to_type_property(SemaContext *context, Expr *expr, return true; case TYPE_PROPERTY_INNER: return sema_create_const_inner(context, expr, type); - case TYPE_PROPERTY_KIND: + case TYPE_PROPERTY_KINDOF: return sema_create_const_kind(expr, type); case TYPE_PROPERTY_LEN: return sema_create_const_len(context, expr, flat); @@ -3193,7 +3287,8 @@ static bool sema_expr_rewrite_to_type_property(SemaContext *context, Expr *expr, expr->resolve_status = RESOLVE_DONE; return true; case TYPE_PROPERTY_MEMBERSOF: - return sema_create_const_membersof(context, expr, flat); + sema_create_const_membersof(context, expr, flat, alignment, offset); + return true; case TYPE_PROPERTY_PARAMS: return sema_create_const_params(context, expr, flat); case TYPE_PROPERTY_RETURNS: @@ -3210,6 +3305,9 @@ static bool sema_expr_rewrite_to_type_property(SemaContext *context, Expr *expr, case TYPE_PROPERTY_QNAMEOF: sema_expr_rewrite_to_type_nameof(expr, type, TOKEN_CT_QNAMEOF); return true; + case TYPE_PROPERTY_ALIGNOF: + expr_rewrite_const_int(expr, type_usize, type_abi_alignment(type), true); + return true; case TYPE_PROPERTY_EXTNAMEOF: if (type_is_builtin(type->type_kind)) { @@ -3247,19 +3345,26 @@ static inline bool sema_expr_analyse_access(SemaContext *context, Expr *expr) return false; } - if (parent->expr_kind != EXPR_TYPEINFO) + if (parent->expr_kind == EXPR_TYPEINFO) { - SEMA_ERROR(expr, "'typeid' can only be used with types, not values"); - return false; + expr->type = type_typeid; + expr->expr_kind = EXPR_CONST; + expr->const_expr.const_kind = CONST_TYPEID; + expr->const_expr.typeid = parent->type_expr->type->canonical; + expr->resolve_status = RESOLVE_DONE; + return true; } - - expr->type = type_typeid; - expr->expr_kind = EXPR_CONST; - expr->const_expr.const_kind = CONST_TYPEID; - expr->const_expr.typeid = parent->type_expr->type->canonical; - expr->resolve_status = RESOLVE_DONE; - return true; - + if (expr_is_const_member(parent)) + { + expr->type = type_typeid; + expr->expr_kind = EXPR_CONST; + expr->const_expr.const_kind = CONST_TYPEID; + expr->const_expr.typeid = parent->const_expr.member.decl->type->canonical; + expr->resolve_status = RESOLVE_DONE; + return true; + } + SEMA_ERROR(expr, "'typeid' can only be used with types, not values"); + return false; } // 3. Find the actual token. @@ -3272,6 +3377,10 @@ static inline bool sema_expr_analyse_access(SemaContext *context, Expr *expr) { return sema_expr_analyse_type_access(context, expr, parent->type_expr, was_group, identifier); } + if (expr_is_const_member(parent)) + { + return sema_expr_analyse_member_access(context, expr, parent, was_group, identifier); + } // 6. Copy failability bool failable = IS_OPTIONAL(parent); @@ -3316,6 +3425,11 @@ CHECK_DEEPER: expr_rewrite_const_int(expr, type_isize, flat_type->array.len, true); return true; } + if (flat_type->type_kind == TYPE_UNTYPED_LIST) + { + expr_rewrite_const_int(expr, type_isize, vec_size(current_parent->const_expr.untyped_list), true); + return true; + } } if (flat_type->type_kind == TYPE_TYPEID) { diff --git a/src/compiler/sema_types.c b/src/compiler/sema_types.c index c82f7a0aa..9e7f9b9f3 100644 --- a/src/compiler/sema_types.c +++ b/src/compiler/sema_types.c @@ -227,6 +227,7 @@ bool sema_resolve_type(SemaContext *context, Type *type) case TYPE_ANYERR: case TYPE_VECTOR: case TYPE_TYPEINFO: + case TYPE_MEMBER: case TYPE_UNTYPED_LIST: case TYPE_FAILABLE_ANY: return true; diff --git a/src/compiler/symtab.c b/src/compiler/symtab.c index 3daa14dc8..d9d892483 100644 --- a/src/compiler/symtab.c +++ b/src/compiler/symtab.c @@ -70,6 +70,7 @@ const char *kw_main; const char *kw_mainstub; const char *kw_nameof; const char *kw_noinline; +const char *kw_offsetof; const char *kw_ordinal; const char *kw_out; const char *kw_ptr; @@ -148,6 +149,7 @@ void symtab_init(uint32_t capacity) kw_main = KW_DEF("main"); kw_nameof = KW_DEF("nameof"); kw_noinline = KW_DEF("noinline"); + kw_offsetof = KW_DEF("offsetof"); kw_ordinal = KW_DEF("ordinal"); kw_out = KW_DEF("out"); kw_ptr = KW_DEF("ptr"); @@ -162,11 +164,12 @@ void symtab_init(uint32_t capacity) type_property_list[TYPE_PROPERTY_LEN] = kw_len = KW_DEF("len"); + type_property_list[TYPE_PROPERTY_ALIGNOF] = KW_DEF("alignof"); type_property_list[TYPE_PROPERTY_ELEMENTS] = KW_DEF("elements"); type_property_list[TYPE_PROPERTY_EXTNAMEOF] = KW_DEF("extnameof"); type_property_list[TYPE_PROPERTY_INF] = KW_DEF("inf"); type_property_list[TYPE_PROPERTY_INNER] = KW_DEF("inner"); - type_property_list[TYPE_PROPERTY_KIND] = KW_DEF("kind"); + type_property_list[TYPE_PROPERTY_KINDOF] = KW_DEF("kindof"); type_property_list[TYPE_PROPERTY_MEMBERSOF] = KW_DEF("membersof"); type_property_list[TYPE_PROPERTY_NAMEOF] = KW_DEF("nameof"); type_property_list[TYPE_PROPERTY_NAMES] = KW_DEF("names"); diff --git a/src/compiler/types.c b/src/compiler/types.c index 2f6b3ec1c..ac72889e4 100644 --- a/src/compiler/types.c +++ b/src/compiler/types.c @@ -12,7 +12,7 @@ static struct Type u8, u16, u32, u64, u128; Type f16, f32, f64, f128, fxx; Type usz, isz, uptr, iptr, uptrdiff, iptrdiff; - Type voidstar, typeid, anyerr, typeinfo, untyped_list; + Type voidstar, typeid, anyerr, member, typeinfo, untyped_list; Type any, anyfail; } t; @@ -45,6 +45,7 @@ Type *type_usize = &t.usz; Type *type_anyerr = &t.anyerr; Type *type_untypedlist = &t.untyped_list; Type *type_anyfail = &t.anyfail; +Type *type_member = &t.member; Type *type_chars = NULL; static unsigned size_subarray; @@ -165,6 +166,7 @@ static void type_append_name_to_scratch(Type *type) case TYPE_INFERRED_ARRAY: case TYPE_INFERRED_VECTOR: case TYPE_TYPEINFO: + case TYPE_MEMBER: UNREACHABLE break; case TYPE_FUNC: @@ -223,6 +225,7 @@ const char *type_to_error_string(Type *type) case TYPE_ANYERR: case TYPE_UNTYPED_LIST: case TYPE_ANY: + case TYPE_MEMBER: return type->name; case TYPE_FUNC: scratch_buffer_clear(); @@ -400,6 +403,7 @@ bool type_is_abi_aggregate(Type *type) case TYPE_UNTYPED_LIST: case TYPE_FLEXIBLE_ARRAY: case TYPE_SCALED_VECTOR: + case TYPE_MEMBER: UNREACHABLE } UNREACHABLE @@ -487,6 +491,7 @@ void type_mangle_introspect_name_to_buffer(Type *type) case TYPE_INFERRED_VECTOR: case TYPE_UNTYPED_LIST: case TYPE_FAILABLE_ANY: + case TYPE_MEMBER: UNREACHABLE case TYPE_VOID: case TYPE_BOOL: @@ -583,6 +588,7 @@ AlignSize type_abi_alignment(Type *type) case TYPE_POISONED: case TYPE_TYPEINFO: case TYPE_UNTYPED_LIST: + case TYPE_MEMBER: UNREACHABLE; case TYPE_BITSTRUCT: type = type->decl->bitstruct.base_type->type; @@ -1420,6 +1426,7 @@ void type_setup(PlatformTarget *target) type_init_int("void", &t.u0, TYPE_VOID, BITS8); type_create("typeinfo", &t.typeinfo, TYPE_TYPEINFO, 1, 1, 1); + type_create("member_ref", &t.member, TYPE_MEMBER, 1, 1, 1); type_create("untyped_list", &t.untyped_list, TYPE_UNTYPED_LIST, 1, 1, 1); type_create("void!", &t.anyfail, TYPE_FAILABLE_ANY, 1, 1, 1); type_init("typeid", &t.typeid, TYPE_TYPEID, target->width_pointer, target->align_pointer); @@ -1636,6 +1643,7 @@ bool type_may_have_method(Type *type) case TYPE_OPTIONAL: case TYPE_FAILABLE_ANY: case TYPE_TYPEINFO: + case TYPE_MEMBER: return false; } UNREACHABLE @@ -1857,10 +1865,12 @@ Type *type_find_max_type(Type *type, Type *other) type = other->function.prototype->raw_type; return other == type ? type : NULL; case TYPE_UNION: - case TYPE_TYPEID: case TYPE_STRUCT: case TYPE_UNTYPED_LIST: TODO + case TYPE_TYPEID: + case TYPE_MEMBER: + return NULL; case TYPE_TYPEDEF: UNREACHABLE case TYPE_DISTINCT: @@ -1985,6 +1995,7 @@ unsigned type_get_introspection_kind(TypeKind kind) case TYPE_FAILABLE_ANY: case TYPE_TYPEINFO: case TYPE_OPTIONAL: + case TYPE_MEMBER: UNREACHABLE return 0; } @@ -2035,6 +2046,7 @@ Module *type_base_module(Type *type) case TYPE_UNTYPED_LIST: case TYPE_FAILABLE_ANY: case TYPE_TYPEINFO: + case TYPE_MEMBER: UNREACHABLE } UNREACHABLE diff --git a/src/version.h b/src/version.h index a5c1e2fe1..bd1496ea7 100644 --- a/src/version.h +++ b/src/version.h @@ -1 +1 @@ -#define COMPILER_VERSION "0.3.73" \ No newline at end of file +#define COMPILER_VERSION "0.3.74" \ No newline at end of file diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t index 57fb15eb7..efa42ac51 100644 --- a/test/test_suite/compile_time/ct_memberof.c3t +++ b/test/test_suite/compile_time/ct_memberof.c3t @@ -12,7 +12,7 @@ macro print_args($Type) $endforeach } -bitstruct Bar : ulong +bitstruct Bark : ulong { int x : 1..4; short y : 6..10; @@ -36,7 +36,7 @@ macro print_fields($Type) io::printfln("Type: %s", $Type.nameof); var $params = $Type.membersof; $foreach ($param : $params): - io::printfln("Member: %s", $param.nameof); + io::printfln("%s: %s", $param.nameof, $param.typeid.nameof); $endforeach } @@ -46,20 +46,61 @@ fn void test(int x) print_args($typeof(&test)); print_args($typeof(&hell)); print_args($typeof(&hello)); - io::println($typeof(&test).returns.nameof); - io::println($typeof(&hell).returns.nameof); + io::println($nameof($typefrom($typeof(&test).returns))); + io::println($nameof($typefrom($typeof(&hell).returns))); print_fields(Foo); print_fields(Bar); + print_fields(Bark); } +struct BarInner +{ + char a; + char b; +} + +struct Bar +{ + char a; + short b; + struct + { + union + { + BarInner y; + char z; + struct { + char z1; + char z2; + } + } + } + struct baz + { + int foo; + } +} fn void main() { + var $x = Bar.a; + + io::printfln("len: %d", Bar.membersof.len); + io::printfln("len: %d", Bar.baz.membersof.len); + io::printfln("a: %d %d", Bar.a.offsetof, Bar.a.alignof); + io::printfln("b: %d %d", Bar.b.offsetof, Bar.b.alignof); + io::printfln("y: %d %d", Bar.y.offsetof, Bar.y.alignof); + io::printfln("z: %d %d", Bar.z.offsetof, Bar.z.alignof); + io::printfln("z1: %d %d", Bar.z1.offsetof, Bar.z1.alignof); + io::printfln("z2: %d %d", Bar.z2.offsetof, Bar.z2.alignof); + io::printfln("baz: %d %d", Bar.baz.offsetof, Bar.baz.alignof); + io::printfln("Bar: %d", $x.alignof); + io::printfln("foo: %d %d", Bar.baz.foo.offsetof, Bar.baz.foo.alignof); + test(10); } /* #expect: test.ll -; Function Attrs: nounwind define void @test_hello(i32 %0, double %1, i64 %2, i64 %3, i8* %4, i64 %5) #0 { entry: %d = alloca [4 x i32], align 4 @@ -88,52 +129,87 @@ entry: %retparam4 = alloca i64, align 8 %taddr5 = alloca %"char[]", align 8 %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 - %taddr10 = alloca [3 x i8]*, 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 [4 x i8]*, align 8 - %retparam28 = alloca i64, align 8 - %taddr29 = alloca %"char[]", align 8 - %vararg32 = alloca %"variant[]", align 8 - %varargslots33 = alloca [1 x %variant], align 16 - %taddr34 = alloca [5 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 [6 x i8]*, 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 [3 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 [3 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 [5 x i8]*, 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 + %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 %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.3, i32 0, i32 0)) #1 - %3 = call i32 @std_io_println(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i32 0, i32 0)) #1 - %4 = call i32 @std_io_println(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i32 0, i32 0)) #1 - %5 = call i32 @std_io_println(i8* getelementptr inbounds ([10 x i8], [10 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.7, i32 0, i32 0)) #1 - %7 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i32 0, i32 0)) #1 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8 + %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 + %4 = call i32 @std_io_println(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i32 0, i32 0)) #1 + %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.10 to [3 x i8]*), [3 x i8]** %taddr1, 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 @@ -157,215 +233,873 @@ after_check: ; preds = %entry br label %voiderr voiderr: ; preds = %after_check, %entry - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.11, i32 0, i32 0), i64 10 }, %"char[]"* %taddr5, align 8 + 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 [3 x i8]* bitcast ([4 x i8]* @.str.12 to [3 x i8]*), [3 x i8]** %taddr10, align 8 - %25 = bitcast [3 x i8]** %taddr10 to i8* + 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$a3$char" to i64), 1 - %28 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots9, i64 0, i64 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 - %29 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 1 - store i64 1, i64* %29, align 8 - %30 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 0 - %31 = bitcast [1 x %variant]* %varargslots9 to %variant* - store %variant* %31, %variant** %30, align 8 - %32 = bitcast %"variant[]"* %vararg8 to { i8*, i64 }* - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0 - %lo11 = load i8*, i8** %33, align 8 - %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1 - %hi12 = load i64, i64* %34, align 8 - %35 = call i64 @std_io_printfln(i64* %retparam4, i8* %lo6, i64 %hi7, i8* %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %35, 0 + 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 + +after_check15: ; preds = %voiderr + br label %voiderr16 + +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 + +after_check28: ; preds = %voiderr16 + br label %voiderr29 + +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 + +after_check41: ; preds = %voiderr29 + br label %voiderr42 + +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* + %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 + 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 + +after_check54: ; preds = %voiderr42 + br label %voiderr55 + +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 + +after_check66: ; preds = %voiderr55 + br label %voiderr67 + +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 + br i1 %not_err78, label %after_check79, label %voiderr80 + +after_check79: ; preds = %voiderr67 + 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 + +after_check92: ; preds = %voiderr80 + br label %voiderr93 + +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 + +after_check105: ; preds = %voiderr93 + br label %voiderr106 + +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* + %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 + 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 + br i1 %not_err117, label %after_check118, label %voiderr119 + +after_check118: ; preds = %voiderr106 + 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 + ret void +} + +; Function Attrs: nounwind +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 + %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 + %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[]" { 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 + 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 after_check14: ; preds = %voiderr br label %voiderr15 voiderr15: ; preds = %after_check14, %voiderr - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i32 0, i32 0), i64 10 }, %"char[]"* %taddr17, align 8 - %36 = bitcast %"char[]"* %taddr17 to { i8*, i64 }* - %37 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 0 - %lo18 = load i8*, i8** %37, align 8 - %38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 1 - %hi19 = load i64, i64* %38, align 8 - store [4 x i8]* bitcast ([5 x i8]* @.str.14 to [4 x i8]*), [4 x i8]** %taddr22, align 8 - %39 = bitcast [4 x i8]** %taddr22 to i8* - %40 = insertvalue %variant undef, i8* %39, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1 - %42 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots21, i64 0, i64 0 - store %variant %41, %variant* %42, align 16 - %43 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 1 - store i64 1, i64* %43, align 8 - %44 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 0 - %45 = bitcast [1 x %variant]* %varargslots21 to %variant* - store %variant* %45, %variant** %44, align 8 - %46 = bitcast %"variant[]"* %vararg20 to { i8*, i64 }* + 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 + +after_check27: ; preds = %voiderr15 + br label %voiderr28 + +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 - %lo23 = load i8*, i8** %47, align 8 + %lo31 = load i8*, i8** %47, align 8 %48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 1 - %hi24 = load i64, i64* %48, align 8 - %49 = call i64 @std_io_printfln(i64* %retparam16, i8* %lo18, i64 %hi19, i8* %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %49, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 - -after_check26: ; preds = %voiderr15 - br label %voiderr27 - -voiderr27: ; preds = %after_check26, %voiderr15 - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i32 0, i32 0), i64 10 }, %"char[]"* %taddr29, align 8 - %50 = bitcast %"char[]"* %taddr29 to { i8*, i64 }* - %51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %50, i32 0, i32 0 - %lo30 = load i8*, i8** %51, align 8 - %52 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %50, i32 0, i32 1 - %hi31 = load i64, i64* %52, align 8 - store [5 x i8]* bitcast ([6 x i8]* @.str.16 to [5 x i8]*), [5 x i8]** %taddr34, align 8 - %53 = bitcast [5 x i8]** %taddr34 to i8* + %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$p$a5$char" to i64), 1 - %56 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots33, i64 0, i64 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[]"* %vararg32, i32 0, i32 1 - store i64 1, i64* %57, align 8 - %58 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 0 - %59 = bitcast [1 x %variant]* %varargslots33 to %variant* + %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[]"* %vararg32 to { i8*, i64 }* + %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 + %lo37 = 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* %retparam28, i8* %lo30, i64 %hi31, i8* %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %63, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 + %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 -after_check38: ; preds = %voiderr27 - br label %voiderr39 +after_check40: ; preds = %voiderr28 + br label %voiderr41 -voiderr39: ; preds = %after_check38, %voiderr27 - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.17, i32 0, i32 0), i64 10 }, %"char[]"* %taddr41, align 8 - %64 = bitcast %"char[]"* %taddr41 to { i8*, i64 }* +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 - %lo42 = load i8*, i8** %65, align 8 + %lo44 = 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 [6 x i8]* bitcast ([7 x i8]* @.str.18 to [6 x i8]*), [6 x i8]** %taddr46, align 8 - %67 = bitcast [6 x i8]** %taddr46 to i8* + %hi45 = load i64, i64* %66, align 8 + store i64 4, i64* %taddr48, align 8 + %67 = bitcast i64* %taddr48 to i8* %68 = insertvalue %variant undef, i8* %67, 0 - %69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$p$a6$char" to i64), 1 - %70 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots45, i64 0, i64 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 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 - -after_check50: ; preds = %voiderr39 - br label %voiderr51 - -voiderr51: ; preds = %after_check50, %voiderr39 - store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.19, i32 0, i32 0), i64 8 }, %"char[]"* %taddr53, align 8 - %78 = bitcast %"char[]"* %taddr53 to { i8*, i64 }* + store i64 4, i64* %taddr49, align 8 + %71 = bitcast i64* %taddr49 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 + 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 }* %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0 - %lo54 = load i8*, i8** %79, align 8 + %lo50 = load i8*, i8** %79, align 8 %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1 - %hi55 = load i64, i64* %80, align 8 - store [3 x i8]* bitcast ([4 x i8]* @.str.20 to [3 x i8]*), [3 x i8]** %taddr58, align 8 - %81 = bitcast [3 x i8]** %taddr58 to i8* - %82 = insertvalue %variant undef, i8* %81, 0 - %83 = insertvalue %variant %82, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %84 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots57, i64 0, i64 0 - store %variant %83, %variant* %84, align 16 - %85 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg56, i32 0, i32 1 - store i64 1, i64* %85, align 8 - %86 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg56, i32 0, i32 0 - %87 = bitcast [1 x %variant]* %varargslots57 to %variant* - store %variant* %87, %variant** %86, align 8 - %88 = bitcast %"variant[]"* %vararg56 to { i8*, i64 }* - %89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 0 - %lo59 = load i8*, i8** %89, align 8 - %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 1 - %hi60 = load i64, i64* %90, align 8 - %91 = call i64 @std_io_printfln(i64* %retparam52, i8* %lo54, i64 %hi55, i8* %lo59, i64 %hi60) - %not_err61 = icmp eq i64 %91, 0 - br i1 %not_err61, label %after_check62, label %voiderr63 + %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 -after_check62: ; preds = %voiderr51 - br label %voiderr63 +after_check53: ; preds = %voiderr41 + br label %voiderr54 -voiderr63: ; preds = %after_check62, %voiderr51 - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.21, i32 0, i32 0), i64 10 }, %"char[]"* %taddr65, align 8 - %92 = bitcast %"char[]"* %taddr65 to { i8*, i64 }* - %93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 0 - %lo66 = load i8*, i8** %93, align 8 - %94 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 1 - %hi67 = load i64, i64* %94, align 8 - store [3 x i8]* bitcast ([4 x i8]* @.str.22 to [3 x i8]*), [3 x i8]** %taddr70, align 8 - %95 = bitcast [3 x i8]** %taddr70 to i8* - %96 = insertvalue %variant undef, i8* %95, 0 - %97 = insertvalue %variant %96, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1 - %98 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots69, i64 0, i64 0 - store %variant %97, %variant* %98, align 16 - %99 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg68, i32 0, i32 1 - store i64 1, i64* %99, align 8 - %100 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg68, i32 0, i32 0 - %101 = bitcast [1 x %variant]* %varargslots69 to %variant* - store %variant* %101, %variant** %100, align 8 - %102 = bitcast %"variant[]"* %vararg68 to { i8*, i64 }* - %103 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %102, i32 0, i32 0 - %lo71 = load i8*, i8** %103, align 8 - %104 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %102, i32 0, i32 1 - %hi72 = load i64, i64* %104, align 8 - %105 = call i64 @std_io_printfln(i64* %retparam64, i8* %lo66, i64 %hi67, i8* %lo71, i64 %hi72) - %not_err73 = icmp eq i64 %105, 0 - br i1 %not_err73, label %after_check74, label %voiderr75 +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 -after_check74: ; preds = %voiderr63 - br label %voiderr75 +after_check66: ; preds = %voiderr54 + br label %voiderr67 -voiderr75: ; preds = %after_check74, %voiderr63 - store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.23, i32 0, i32 0), i64 10 }, %"char[]"* %taddr77, align 8 - %106 = bitcast %"char[]"* %taddr77 to { i8*, i64 }* - %107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 0 - %lo78 = load i8*, i8** %107, align 8 - %108 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 1 - %hi79 = load i64, i64* %108, align 8 - store [5 x i8]* bitcast ([6 x i8]* @.str.24 to [5 x i8]*), [5 x i8]** %taddr82, align 8 - %109 = bitcast [5 x i8]** %taddr82 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 [1 x %variant], [1 x %variant]* %varargslots81, i64 0, i64 0 - store %variant %111, %variant* %112, align 16 - %113 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg80, i32 0, i32 1 - store i64 1, i64* %113, align 8 - %114 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg80, i32 0, i32 0 - %115 = bitcast [1 x %variant]* %varargslots81 to %variant* - store %variant* %115, %variant** %114, align 8 - %116 = bitcast %"variant[]"* %vararg80 to { i8*, i64 }* - %117 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %116, i32 0, i32 0 - %lo83 = load i8*, i8** %117, align 8 - %118 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %116, i32 0, i32 1 - %hi84 = load i64, i64* %118, align 8 - %119 = call i64 @std_io_printfln(i64* %retparam76, i8* %lo78, i64 %hi79, i8* %lo83, i64 %hi84) - %not_err85 = icmp eq i64 %119, 0 - br i1 %not_err85, label %after_check86, label %voiderr87 +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 + 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 + br i1 %not_err78, label %after_check79, label %voiderr80 -after_check86: ; preds = %voiderr75 - br label %voiderr87 +after_check79: ; preds = %voiderr67 + br label %voiderr80 -voiderr87: ; preds = %after_check86, %voiderr75 +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 + +after_check92: ; preds = %voiderr80 + br label %voiderr93 + +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 + +after_check105: ; preds = %voiderr93 + br label %voiderr106 + +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 + call void @test_test(i32 10) ret void } diff --git a/test/test_suite2/compile_time/ct_memberof.c3t b/test/test_suite2/compile_time/ct_memberof.c3t index f2bbceeb9..238ef4b29 100644 --- a/test/test_suite2/compile_time/ct_memberof.c3t +++ b/test/test_suite2/compile_time/ct_memberof.c3t @@ -12,7 +12,7 @@ macro print_args($Type) $endforeach } -bitstruct Bar : ulong +bitstruct Bark : ulong { int x : 1..4; short y : 6..10; @@ -36,7 +36,7 @@ macro print_fields($Type) io::printfln("Type: %s", $Type.nameof); var $params = $Type.membersof; $foreach ($param : $params): - io::printfln("Member: %s", $param.nameof); + io::printfln("%s: %s", $param.nameof, $param.typeid.nameof); $endforeach } @@ -46,14 +46,56 @@ fn void test(int x) print_args($typeof(&test)); print_args($typeof(&hell)); print_args($typeof(&hello)); - io::println($typeof(&test).returns.nameof); - io::println($typeof(&hell).returns.nameof); + io::println($nameof($typefrom($typeof(&test).returns))); + io::println($nameof($typefrom($typeof(&hell).returns))); print_fields(Foo); print_fields(Bar); + print_fields(Bark); } +struct BarInner +{ + char a; + char b; +} + +struct Bar +{ + char a; + short b; + struct + { + union + { + BarInner y; + char z; + struct { + char z1; + char z2; + } + } + } + struct baz + { + int foo; + } +} fn void main() { + var $x = Bar.a; + + io::printfln("len: %d", Bar.membersof.len); + io::printfln("len: %d", Bar.baz.membersof.len); + io::printfln("a: %d %d", Bar.a.offsetof, Bar.a.alignof); + io::printfln("b: %d %d", Bar.b.offsetof, Bar.b.alignof); + io::printfln("y: %d %d", Bar.y.offsetof, Bar.y.alignof); + io::printfln("z: %d %d", Bar.z.offsetof, Bar.z.alignof); + io::printfln("z1: %d %d", Bar.z1.offsetof, Bar.z1.alignof); + io::printfln("z2: %d %d", Bar.z2.offsetof, Bar.z2.alignof); + io::printfln("baz: %d %d", Bar.baz.offsetof, Bar.baz.alignof); + io::printfln("Bar: %d", $x.alignof); + io::printfln("foo: %d %d", Bar.baz.foo.offsetof, Bar.baz.foo.alignof); + test(10); } @@ -73,6 +115,7 @@ entry: store i64 %5, ptr %9, align 8 ret void } + ; Function Attrs: nounwind define void @test_test(i32 %0) #0 { entry: @@ -84,51 +127,86 @@ entry: %retparam4 = alloca i64, align 8 %taddr5 = alloca %"char[]", align 8 %vararg8 = alloca %"variant[]", align 8 - %varargslots9 = alloca [1 x %variant], align 16 + %varargslots9 = alloca [2 x %variant], align 16 %taddr10 = 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 ptr, align 8 - %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 + %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 + %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 + %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 + %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 %1 = call i32 @std_io_println(ptr @.str) #1 - %2 = call i32 @std_io_println(ptr @.str.3) #1 - %3 = call i32 @std_io_println(ptr @.str.4) #1 - %4 = call i32 @std_io_println(ptr @.str.5) #1 - %5 = call i32 @std_io_println(ptr @.str.6) #1 - %6 = call i32 @std_io_println(ptr @.str.7) #1 - %7 = call i32 @std_io_println(ptr @.str.8) #1 - store %"char[]" { ptr @.str.9, i64 8 }, ptr %taddr, align 8 + %2 = call i32 @std_io_println(ptr @.str.10) #1 + %3 = call i32 @std_io_println(ptr @.str.11) #1 + %4 = call i32 @std_io_println(ptr @.str.12) #1 + %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.10, ptr %taddr1, 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 @@ -144,176 +222,768 @@ entry: %17 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3) %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 - store %"char[]" { ptr @.str.11, i64 10 }, ptr %taddr5, align 8 + 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.12, ptr %taddr10, 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$a3$char" to i64), 1 - %22 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 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 - %23 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 1 - store i64 1, ptr %23, align 8 - %24 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 0 - store ptr %varargslots9, ptr %24, align 8 - %25 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 0 - %lo11 = load ptr, ptr %25, align 8 - %26 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 1 - %hi12 = load i64, ptr %26, align 8 - %27 = call i64 @std_io_printfln(ptr %retparam4, ptr %lo6, i64 %hi7, ptr %lo11, i64 %hi12) - %not_err13 = icmp eq i64 %27, 0 + 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 + +after_check15: ; preds = %voiderr + br label %voiderr16 + +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 + 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 %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 + +after_check28: ; preds = %voiderr16 + br label %voiderr29 + +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 + +after_check41: ; preds = %voiderr29 + br label %voiderr42 + +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 + br i1 %not_err53, label %after_check54, label %voiderr55 + +after_check54: ; preds = %voiderr42 + 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 + 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 + +after_check66: ; preds = %voiderr55 + br label %voiderr67 + +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 + +after_check79: ; preds = %voiderr67 + br label %voiderr80 + +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 + +after_check92: ; preds = %voiderr80 + br label %voiderr93 + +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 + ret void +} + +; Function Attrs: nounwind +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 + %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 + %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 + 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 + after_check14: ; preds = %voiderr br label %voiderr15 + voiderr15: ; preds = %after_check14, %voiderr - store %"char[]" { ptr @.str.13, i64 10 }, ptr %taddr17, align 8 - %28 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 0 - %lo18 = load ptr, ptr %28, align 8 - %29 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 1 - %hi19 = load i64, ptr %29, align 8 - store ptr @.str.14, ptr %taddr22, align 8 - %30 = insertvalue %variant undef, ptr %taddr22, 0 - %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1 - %32 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0 - store %variant %31, ptr %32, align 16 - %33 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 1 - store i64 1, ptr %33, align 8 - %34 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 0 - store ptr %varargslots21, ptr %34, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 0 - %lo23 = load ptr, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 1 - %hi24 = load i64, ptr %36, align 8 - %37 = call i64 @std_io_printfln(ptr %retparam16, ptr %lo18, i64 %hi19, ptr %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %37, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 -after_check26: ; preds = %voiderr15 - br label %voiderr27 -voiderr27: ; preds = %after_check26, %voiderr15 - store %"char[]" { ptr @.str.15, i64 10 }, ptr %taddr29, align 8 - %38 = getelementptr inbounds { ptr, i64 }, ptr %taddr29, i32 0, i32 0 - %lo30 = load ptr, ptr %38, align 8 - %39 = getelementptr inbounds { ptr, i64 }, ptr %taddr29, i32 0, i32 1 - %hi31 = load i64, ptr %39, align 8 - store ptr @.str.16, ptr %taddr34, align 8 - %40 = insertvalue %variant undef, ptr %taddr34, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 - %42 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0 - store %variant %41, ptr %42, align 16 - %43 = getelementptr inbounds %"variant[]", ptr %vararg32, i32 0, i32 1 - store i64 1, ptr %43, align 8 - %44 = getelementptr inbounds %"variant[]", ptr %vararg32, i32 0, i32 0 - store ptr %varargslots33, ptr %44, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg32, i32 0, i32 0 - %lo35 = load ptr, ptr %45, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg32, i32 0, i32 1 - %hi36 = load i64, ptr %46, align 8 - %47 = call i64 @std_io_printfln(ptr %retparam28, ptr %lo30, i64 %hi31, ptr %lo35, i64 %hi36) - %not_err37 = icmp eq i64 %47, 0 - br i1 %not_err37, label %after_check38, label %voiderr39 -after_check38: ; preds = %voiderr27 - br label %voiderr39 -voiderr39: ; preds = %after_check38, %voiderr27 - store %"char[]" { ptr @.str.17, i64 10 }, 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.18, ptr %taddr46, align 8 - %50 = insertvalue %variant undef, ptr %taddr46, 0 - %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$p$a6$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 -after_check50: ; preds = %voiderr39 - br label %voiderr51 -voiderr51: ; preds = %after_check50, %voiderr39 - store %"char[]" { ptr @.str.19, i64 8 }, ptr %taddr53, align 8 - %58 = getelementptr inbounds { ptr, i64 }, ptr %taddr53, i32 0, i32 0 - %lo54 = load ptr, ptr %58, align 8 - %59 = getelementptr inbounds { ptr, i64 }, ptr %taddr53, i32 0, i32 1 - %hi55 = load i64, ptr %59, align 8 - store ptr @.str.20, ptr %taddr58, align 8 - %60 = insertvalue %variant undef, ptr %taddr58, 0 - %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %62 = getelementptr inbounds [1 x %variant], ptr %varargslots57, i64 0, i64 0 - store %variant %61, ptr %62, align 16 - %63 = getelementptr inbounds %"variant[]", ptr %vararg56, i32 0, i32 1 - store i64 1, ptr %63, align 8 - %64 = getelementptr inbounds %"variant[]", ptr %vararg56, i32 0, i32 0 - store ptr %varargslots57, ptr %64, align 8 - %65 = getelementptr inbounds { ptr, i64 }, ptr %vararg56, i32 0, i32 0 - %lo59 = load ptr, ptr %65, align 8 - %66 = getelementptr inbounds { ptr, i64 }, ptr %vararg56, i32 0, i32 1 - %hi60 = load i64, ptr %66, align 8 - %67 = call i64 @std_io_printfln(ptr %retparam52, ptr %lo54, i64 %hi55, ptr %lo59, i64 %hi60) - %not_err61 = icmp eq i64 %67, 0 - br i1 %not_err61, label %after_check62, label %voiderr63 -after_check62: ; preds = %voiderr51 - br label %voiderr63 -voiderr63: ; preds = %after_check62, %voiderr51 - store %"char[]" { ptr @.str.21, i64 10 }, ptr %taddr65, align 8 - %68 = getelementptr inbounds { ptr, i64 }, ptr %taddr65, i32 0, i32 0 - %lo66 = load ptr, ptr %68, align 8 - %69 = getelementptr inbounds { ptr, i64 }, ptr %taddr65, i32 0, i32 1 - %hi67 = load i64, ptr %69, align 8 - store ptr @.str.22, ptr %taddr70, align 8 - %70 = insertvalue %variant undef, ptr %taddr70, 0 - %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1 - %72 = getelementptr inbounds [1 x %variant], ptr %varargslots69, i64 0, i64 0 - store %variant %71, ptr %72, align 16 - %73 = getelementptr inbounds %"variant[]", ptr %vararg68, i32 0, i32 1 - store i64 1, ptr %73, align 8 - %74 = getelementptr inbounds %"variant[]", ptr %vararg68, i32 0, i32 0 - store ptr %varargslots69, ptr %74, align 8 - %75 = getelementptr inbounds { ptr, i64 }, ptr %vararg68, i32 0, i32 0 - %lo71 = load ptr, ptr %75, align 8 - %76 = getelementptr inbounds { ptr, i64 }, ptr %vararg68, i32 0, i32 1 - %hi72 = load i64, ptr %76, align 8 - %77 = call i64 @std_io_printfln(ptr %retparam64, ptr %lo66, i64 %hi67, ptr %lo71, i64 %hi72) - %not_err73 = icmp eq i64 %77, 0 - br i1 %not_err73, label %after_check74, label %voiderr75 -after_check74: ; preds = %voiderr63 - br label %voiderr75 -voiderr75: ; preds = %after_check74, %voiderr63 - store %"char[]" { ptr @.str.23, i64 10 }, ptr %taddr77, align 8 - %78 = getelementptr inbounds { ptr, i64 }, ptr %taddr77, i32 0, i32 0 - %lo78 = load ptr, ptr %78, align 8 - %79 = getelementptr inbounds { ptr, i64 }, ptr %taddr77, i32 0, i32 1 - %hi79 = load i64, ptr %79, align 8 - store ptr @.str.24, ptr %taddr82, align 8 - %80 = insertvalue %variant undef, ptr %taddr82, 0 - %81 = insertvalue %variant %80, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1 - %82 = getelementptr inbounds [1 x %variant], ptr %varargslots81, i64 0, i64 0 - store %variant %81, ptr %82, align 16 - %83 = getelementptr inbounds %"variant[]", ptr %vararg80, i32 0, i32 1 - store i64 1, ptr %83, align 8 - %84 = getelementptr inbounds %"variant[]", ptr %vararg80, i32 0, i32 0 - store ptr %varargslots81, ptr %84, align 8 - %85 = getelementptr inbounds { ptr, i64 }, ptr %vararg80, i32 0, i32 0 + 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 + store i64 4, ptr %taddr23, align 8 + %25 = insertvalue %variant undef, ptr %taddr23, 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 + 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 + +after_check27: ; preds = %voiderr15 + br label %voiderr28 + +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 + br i1 %not_err39, label %after_check40, label %voiderr41 + +after_check40: ; preds = %voiderr28 + 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 + +after_check53: ; preds = %voiderr41 + br label %voiderr54 + +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 + %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %63 = getelementptr inbounds [2 x %variant], ptr %varargslots60, 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 + %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$ulong" to i64), 1 + %66 = getelementptr inbounds [2 x %variant], ptr %varargslots60, 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 + +after_check66: ; preds = %voiderr54 + br label %voiderr67 + +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 %vararg80, i32 0, i32 1 + %86 = getelementptr inbounds { ptr, i64 }, ptr %taddr82, i32 0, i32 1 %hi84 = load i64, ptr %86, align 8 - %87 = call i64 @std_io_printfln(ptr %retparam76, ptr %lo78, i64 %hi79, ptr %lo83, i64 %hi84) - %not_err85 = icmp eq i64 %87, 0 - br i1 %not_err85, label %after_check86, label %voiderr87 -after_check86: ; preds = %voiderr75 - br label %voiderr87 -voiderr87: ; preds = %after_check86, %voiderr75 + 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 + call void @test_test(i32 10) ret void } \ No newline at end of file