shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 12:01:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

$vasplat() implemented. $vacount removed (). Improved dynscope implementation. Version bump to 0.3.37.

Browse Source
This commit is contained in:
Christoffer Lerno
2022-09-08 20:51:32 +02:00
committed by Christoffer Lerno
parent e31967cc65
commit a0a2e27127
19 changed files with 1964 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
resources/examples/contextfree/dynscope.c3
View File

@@ -3,26 +3,30 @@ import std::io;
tlocal char[] context_user = "safe";
macro long perform(task)
macro long reallyPerform(task)
{
io::printf("%s: %s\n", context_user, task);
return task.len;
io::printfln("%s: %s", context_user, task);
return task.len;
}
macro @with_mode(char[] user, #action, arg)
macro long perform(task)
{
@scope(context_user)
{
context_user = user;
return #action(arg);
};
return reallyPerform(task);
}
macro @with_mode(char[] user, #action, ...)
{
@scope(context_user)
{
context_user = user;
return #action($vasplat());
};
}
fn void main()
{
long result = perform("something!");
result += @with_mode("faster", perform, "reliable");
result += perform(char[][] {"again", "more"});
result += perform(int[<2>] { 56, 99 });
io::printf("Result: %d\n", result);
}
long val1 = perform("something");
long val2 = @with_mode("faster", perform, "reliable");
long val3 = perform(char[][] {"something"});
io::printfln("%d %d %d", val1, val2, val3);
}

10
src/compiler/ast.c
View File

@@ -290,6 +290,8 @@ bool expr_is_pure(Expr *expr)
case EXPR_TYPEID:
case EXPR_CT_ARG:
return true;
case EXPR_VASPLAT:
return true;
case EXPR_ARGV_TO_SUBARRAY:
case EXPR_BITASSIGN:
return false;
@@ -354,13 +356,13 @@ bool expr_is_pure(Expr *expr)
case EXPR_TYPEID_INFO:
return exprid_is_pure(expr->typeid_info_expr.parent);
case EXPR_SLICE:
return exprid_is_pure(expr->slice_expr.expr)
&& exprid_is_pure(expr->slice_expr.start)
&& exprid_is_pure(expr->slice_expr.end);
return exprid_is_pure(expr->subscript_expr.expr)
&& exprid_is_pure(expr->subscript_expr.range.start)
&& exprid_is_pure(expr->subscript_expr.range.end);
case EXPR_SUBSCRIPT:
case EXPR_SUBSCRIPT_ADDR:
return exprid_is_pure(expr->subscript_expr.expr)
&& exprid_is_pure(expr->subscript_expr.index);
&& exprid_is_pure(expr->subscript_expr.range.start);
case EXPR_TERNARY:
return exprid_is_pure(expr->ternary_expr.cond)
&& exprid_is_pure(expr->ternary_expr.else_expr)

27
src/compiler/compiler_internal.h
View File

@@ -708,7 +708,15 @@ typedef struct Decl_
typedef struct
{
bool start_from_end : 1;
bool end_from_end : 1;
bool is_len : 1;
bool is_range : 1;
ExprId start;
ExprId end;
} Range;
typedef struct
{
@@ -763,21 +771,10 @@ typedef struct
typedef struct
{
bool from_back : 1;
ExprId expr;
ExprId index;
Range range;
} ExprSubscript;
typedef struct
{
bool start_from_back : 1;
bool end_from_back : 1;
bool is_lenrange : 1;
ExprId expr;
ExprId start;
ExprId end;
} ExprSlice;
typedef struct
{
ExprId left;
@@ -955,7 +952,7 @@ typedef struct
{
Expr **values;
Decl **declarations;
Ast *ast;
AstId first_stmt;
} ExprBodyExpansion;
@@ -1090,6 +1087,7 @@ struct Expr_
ExprKind expr_kind : 8;
ResolveStatus resolve_status : 4;
union {
Range vasplat_expr;
ExprTypeidInfo typeid_info_expr;
ExprVariantSwitch variant_switch; // 32
ExprCast cast_expr; // 12
@@ -1108,7 +1106,6 @@ struct Expr_
Expr** try_unwrap_chain_expr; // 8
ExprTryUnwrap try_unwrap_expr; // 24
ExprCall call_expr; // 32
ExprSlice slice_expr; // 16
Expr *inner_expr; // 8
ExprBuiltinAccess builtin_access_expr;
ExprCatchUnwrap catch_unwrap_expr; // 24

31
src/compiler/copying.c
View File

@@ -169,21 +169,34 @@ Expr *expr_macro_copy(Expr *source_expr)
return copy_expr(&copy_struct, source_expr);
}
void copy_range(CopyStruct *c, Range *range)
{
MACRO_COPY_EXPRID(range->start);
MACRO_COPY_EXPRID(range->end);
}
Expr *copy_expr(CopyStruct *c, Expr *source_expr)
{
if (!source_expr) return NULL;
Expr *expr = expr_copy(source_expr);
switch (source_expr->expr_kind)
{
case EXPR_MACRO_BODY_EXPANSION:
case EXPR_VARIANTSWITCH:
case EXPR_ARGV_TO_SUBARRAY:
UNREACHABLE
case EXPR_MACRO_BODY_EXPANSION:
MACRO_COPY_EXPR_LIST(expr->body_expansion_expr.values);
MACRO_COPY_DECL_LIST(expr->body_expansion_expr.declarations);
MACRO_COPY_ASTID(expr->body_expansion_expr.first_stmt);
return expr;
case EXPR_FLATPATH:
case EXPR_NOP:
case EXPR_BUILTIN:
case EXPR_RETVAL:
return expr;
case EXPR_VASPLAT:
copy_range(c, &expr->vasplat_expr);
return expr;
case EXPR_CT_ARG:
MACRO_COPY_EXPRID(expr->ct_arg_expr.arg);
return expr;
@@ -243,9 +256,10 @@ Expr *copy_expr(CopyStruct *c, Expr *source_expr)
MACRO_COPY_EXPRID(expr->slice_assign_expr.right);
return expr;
case EXPR_SLICE:
MACRO_COPY_EXPRID(expr->slice_expr.expr);
MACRO_COPY_EXPRID(expr->slice_expr.start);
MACRO_COPY_EXPRID(expr->slice_expr.end);
case EXPR_SUBSCRIPT:
case EXPR_SUBSCRIPT_ADDR:
MACRO_COPY_EXPRID(expr->subscript_expr.expr);
copy_range(c, &expr->subscript_expr.range);
return expr;
case EXPR_ASM:
switch (expr->expr_asm_arg.kind)
@@ -278,7 +292,9 @@ Expr *copy_expr(CopyStruct *c, Expr *source_expr)
MACRO_COPY_EXPR_LIST(expr->cond_expr);
return expr;
case EXPR_MACRO_BLOCK:
UNREACHABLE
MACRO_COPY_DECL_LIST(expr->macro_block.params);
MACRO_COPY_ASTID(expr->macro_block.first_stmt);
return expr;
case EXPR_COMPOUND_LITERAL:
MACRO_COPY_EXPR(expr->expr_compound_literal.initializer);
MACRO_COPY_TYPE(expr->expr_compound_literal.type_info);
@@ -335,11 +351,6 @@ Expr *copy_expr(CopyStruct *c, Expr *source_expr)
}
}
return expr;
case EXPR_SUBSCRIPT:
case EXPR_SUBSCRIPT_ADDR:
MACRO_COPY_EXPRID(expr->subscript_expr.expr);
MACRO_COPY_EXPRID(expr->subscript_expr.index);
return expr;
case EXPR_BITACCESS:
case EXPR_ACCESS:
MACRO_COPY_EXPR(expr->access_expr.parent);

2
src/compiler/enums.h
View File

@@ -247,6 +247,7 @@ typedef enum
EXPR_TYPEINFO,
EXPR_UNARY,
EXPR_VARIANTSWITCH,
EXPR_VASPLAT,
EXPR_NOP,
EXPR_TYPEID_INFO,
EXPR_VARIANT,
@@ -566,6 +567,7 @@ typedef enum
TOKEN_CT_VAREF, // $varef,
TOKEN_CT_VAARG, // $vaarg,
TOKEN_CT_VAEXPR, // $vaexpr,
TOKEN_CT_VASPLAT, // $vasplat,
TOKEN_DOCS_START, // /**
TOKEN_DOCS_END, // */ (may start with an arbitrary number of `*`
TOKEN_DOC_DIRECTIVE, // Any doc directive

36
src/compiler/llvm_codegen_expr.c
View File

@@ -512,10 +512,10 @@ static inline void llvm_emit_vector_subscript(GenContext *c, BEValue *value, Exp
assert(vec->type_kind == TYPE_VECTOR);
Type *element = vec->array.base;
LLVMValueRef vector = value->value;
llvm_emit_exprid(c, value, expr->subscript_expr.index);
llvm_emit_exprid(c, value, expr->subscript_expr.range.start);
llvm_value_rvalue(c, value);
LLVMValueRef index = value->value;
if (expr->subscript_expr.from_back)
if (expr->subscript_expr.range.start_from_end)
{
index = LLVMBuildNUWSub(c->builder, llvm_const_int(c, value->type, vec->array.len), index, "");
}
@@ -531,7 +531,7 @@ static inline void gencontext_emit_subscript(GenContext *c, BEValue *value, Expr
{
bool is_value = expr->expr_kind == EXPR_SUBSCRIPT;
Expr *parent_expr = exprptr(expr->subscript_expr.expr);
Expr *index_expr = exprptr(expr->subscript_expr.index);
Expr *index_expr = exprptr(expr->subscript_expr.range.start);
Type *parent_type = type_lowering(parent_expr->type);
if (is_value && parent_type->type_kind == TYPE_VECTOR)
{
@@ -548,13 +548,13 @@ static inline void gencontext_emit_subscript(GenContext *c, BEValue *value, Expr
bool needs_len = false;
if (parent_type_kind == TYPE_SUBARRAY)
{
needs_len = active_target.feature.safe_mode || expr->subscript_expr.from_back;
needs_len = active_target.feature.safe_mode || expr->subscript_expr.range.start_from_end;
}
else if (parent_type_kind == TYPE_ARRAY)
{
// From back should always be folded.
assert(expr->expr_kind != EXPR_CONST || !expr->subscript_expr.from_back);
needs_len = (active_target.feature.safe_mode && expr->expr_kind != EXPR_CONST) || expr->subscript_expr.from_back;
assert(expr->expr_kind != EXPR_CONST || !expr->subscript_expr.range.start_from_end);
needs_len = (active_target.feature.safe_mode && expr->expr_kind != EXPR_CONST) || expr->subscript_expr.range.start_from_end;
}
if (needs_len)
{
@@ -570,7 +570,7 @@ static inline void gencontext_emit_subscript(GenContext *c, BEValue *value, Expr
// It needs to be an rvalue.
llvm_value_rvalue(c, &index);
if (expr->subscript_expr.from_back)
if (expr->subscript_expr.range.start_from_end)
{
assert(needs_len);
index.value = LLVMBuildNUWSub(c->builder, llvm_zext_trunc(c, len.value, llvm_get_type(c, index.type)), index.value, "");
@@ -2250,9 +2250,9 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r
{
assert(slice->expr_kind == EXPR_SLICE);
Expr *parent_expr = exprptr(slice->slice_expr.expr);
Expr *start = exprptr(slice->slice_expr.start);
Expr *end = exprptrzero(slice->slice_expr.end);
Expr *parent_expr = exprptr(slice->subscript_expr.expr);
Expr *start = exprptr(slice->subscript_expr.range.start);
Expr *end = exprptrzero(slice->subscript_expr.range.end);
Type *parent_type = type_flatten_distinct(parent_expr->type);
BEValue parent_addr_x;
@@ -2288,7 +2288,9 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r
BEValue len = { .value = NULL };
bool check_end = true;
if (!end || slice->slice_expr.start_from_back || slice->slice_expr.end_from_back || active_target.feature.safe_mode)
bool start_from_end = slice->subscript_expr.range.start_from_end;
bool end_from_end = slice->subscript_expr.range.end_from_end;
if (!end || start_from_end || end_from_end || active_target.feature.safe_mode)
{
switch (parent_type->type_kind)
{
@@ -2310,7 +2312,7 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r
}
// Walk from end if it is slice from the back.
if (slice->slice_expr.start_from_back)
if (start_from_end)
{
start_index.value = llvm_emit_sub_int(c, start_type, len.value, start_index.value, slice->span);
}
@@ -2332,7 +2334,7 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r
Type *end_type;
BEValue end_index;
bool is_len_range = *is_exclusive = slice->slice_expr.is_lenrange;
bool is_len_range = *is_exclusive = slice->subscript_expr.range.is_len;
if (end)
{
// Get the index.
@@ -2341,7 +2343,7 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r
end_type = end->type->canonical;
// Reverse if it is "from back"
if (slice->slice_expr.end_from_back)
if (end_from_end)
{
end_index.value = llvm_emit_sub_int(c, end_type, len.value, end_index.value, slice->span);
llvm_value_rvalue(c, &end_index);
@@ -3541,7 +3543,7 @@ static void llvm_emit_vector_assign_expr(GenContext *c, BEValue *be_value, Expr
LLVMValueRef vector_value = llvm_load_value_store(c, &addr);
// Emit the index
llvm_emit_exprid(c, &index, left->subscript_expr.index);
llvm_emit_exprid(c, &index, left->subscript_expr.range.start);
LLVMValueRef index_val = llvm_load_value_store(c, &index);
if (binary_op > BINARYOP_ASSIGN)
@@ -5431,7 +5433,8 @@ static void llvm_emit_macro_body_expansion(GenContext *c, BEValue *value, Expr *
llvm_emit_expr(c, value, expr);
llvm_store_to_ptr_aligned(c, declarations[i]->backend_ref, value, declarations[i]->alignment);
}
llvm_emit_stmt(c, body_expr->body_expansion_expr.ast);
AstId body = body_expr->body_expansion_expr.first_stmt;
if (body) llvm_emit_stmt(c, astptr(body));
}
void llvm_emit_try_unwrap(GenContext *c, BEValue *value, Expr *expr)
@@ -5886,6 +5889,7 @@ void llvm_emit_expr(GenContext *c, BEValue *value, Expr *expr)
case EXPR_CT_CONV:
case EXPR_CT_ARG:
case EXPR_ASM:
case EXPR_VASPLAT:
UNREACHABLE
case EXPR_BUILTIN_ACCESS:
llvm_emit_builtin_access(c, value, expr);

110
src/compiler/parse_expr.c
View File

@@ -19,6 +19,41 @@ typedef struct
extern ParseRule rules[TOKEN_EOF + 1];
bool parse_range(ParseContext *c, Range *range)
{
// Not range with missing entry
if (tok_is(c, TOKEN_DOTDOT) || tok_is(c, TOKEN_COLON))
{
// ..123 and :123
range->start_from_end = false;
range->start = exprid(expr_new_const_int(c->span, type_uint, 0, true));
}
else
{
// Might be ^ prefix
range->start_from_end = try_consume(c, TOKEN_BIT_XOR);
ASSIGN_EXPRID_OR_RET(range->start, parse_expr(c), false);
}
bool is_len_range = range->is_len = try_consume(c, TOKEN_COLON);
if (!is_len_range && !try_consume(c, TOKEN_DOTDOT))
{
range->is_range = false;
return true;
}
range->is_range = true;
// ] ) are the possible ways to end a range.
if (tok_is(c, TOKEN_RBRACKET) || tok_is(c, TOKEN_RPAREN))
{
// So here we have [1..] or [3:]
range->end_from_end = false;
range->end = 0;
return true;
}
range->end_from_end = try_consume(c, TOKEN_BIT_XOR);
ASSIGN_EXPRID_OR_RET(range->end, parse_expr(c), false);
return true;
}
inline Expr *parse_precedence_with_left_side(ParseContext *c, Expr *left_side, Precedence precedence)
{
while (1)
@@ -236,6 +271,7 @@ Expr *parse_cond(ParseContext *c)
return decl_expr;
}
// These used to be explicitly inlined, but that seems to lead to confusing MSVC linker errors.
// They are probably still inlined by the compiler, though I haven't checked.
Expr* parse_expr(ParseContext *c)
@@ -293,12 +329,26 @@ static bool parse_param_path(ParseContext *c, DesignatorElement ***path)
return true;
}
}
Expr *parse_vasplat(ParseContext *c)
{
Expr *expr = EXPR_NEW_TOKEN(EXPR_VASPLAT);
advance_and_verify(c, TOKEN_CT_VASPLAT);
TRY_CONSUME_OR_RET(TOKEN_LPAREN, "'$vasplat' must be followed by '()'.", poisoned_expr);
if (!try_consume(c, TOKEN_RPAREN))
{
if (!parse_range(c, &expr->vasplat_expr)) return poisoned_expr;
CONSUME_OR_RET(TOKEN_RPAREN, poisoned_expr);
}
RANGE_EXTEND_PREV(expr);
return expr;
}
/**
* param_list ::= ('...' parameter | parameter (',' parameter)*)?
*
* parameter ::= (param_path '=')? expr
*/
bool parse_arg_list(ParseContext *c, Expr ***result, TokenType param_end, bool *splat)
bool parse_arg_list(ParseContext *c, Expr ***result, TokenType param_end, bool *splat, bool vasplat)
{
*result = NULL;
if (splat) *splat = false;
@@ -322,6 +372,10 @@ bool parse_arg_list(ParseContext *c, Expr ***result, TokenType param_end, bool *
RANGE_EXTEND_PREV(expr);
}
else if (vasplat && tok_is(c, TOKEN_CT_VASPLAT))
{
ASSIGN_EXPR_OR_RET(expr, parse_vasplat(c), false);
}
else
{
if (splat)
@@ -573,7 +627,7 @@ Expr *parse_initializer_list(ParseContext *c, Expr *left)
if (!try_consume(c, TOKEN_RBRACE))
{
Expr **exprs = NULL;
if (!parse_arg_list(c, &exprs, TOKEN_RBRACE, NULL)) return poisoned_expr;
if (!parse_arg_list(c, &exprs, TOKEN_RBRACE, NULL, true)) return poisoned_expr;
int designated = -1;
VECEACH(exprs, i)
{
@@ -663,7 +717,7 @@ static Expr *parse_call_expr(ParseContext *c, Expr *left)
{
// Pick a modest guess.
params = VECNEW(Expr*, 4);
if (!parse_arg_list(c, &params, TOKEN_RPAREN, &splat)) return poisoned_expr;
if (!parse_arg_list(c, &params, TOKEN_RPAREN, &splat, true)) return poisoned_expr;
}
if (try_consume(c, TOKEN_EOS) && !tok_is(c, TOKEN_RPAREN))
{
@@ -750,52 +804,14 @@ static Expr *parse_subscript_expr(ParseContext *c, Expr *left)
advance_and_verify(c, TOKEN_LBRACKET);
Expr *subs_expr = expr_new_expr(EXPR_SUBSCRIPT, left);
Expr *index = NULL;
bool is_range = false;
bool from_back = false;
bool end_from_back = false;
Expr *end = NULL;
// Not range with missing entry
if (!tok_is(c, TOKEN_DOTDOT) && !tok_is(c, TOKEN_COLON))
{
// Might be ^ prefix
from_back = try_consume(c, TOKEN_BIT_XOR);
ASSIGN_EXPR_OR_RET(index, parse_expr(c), poisoned_expr);
}
else
{
index = expr_new_const_int(c->span, type_uint, 0, true);
}
bool is_len_range = try_consume(c, TOKEN_COLON);
if (is_len_range || try_consume(c, TOKEN_DOTDOT))
{
is_range = true;
if (!tok_is(c, TOKEN_RBRACKET))
{
end_from_back = try_consume(c, TOKEN_BIT_XOR);
ASSIGN_EXPR_OR_RET(end, parse_expr(c), poisoned_expr);
}
}
subs_expr->subscript_expr.expr = exprid(left);
if (!parse_range(c, &subs_expr->subscript_expr.range)) return poisoned_expr;
CONSUME_OR_RET(TOKEN_RBRACKET, poisoned_expr);
RANGE_EXTEND_PREV(subs_expr);
if (is_range)
if (subs_expr->subscript_expr.range.is_range)
{
subs_expr->expr_kind = EXPR_SLICE;
subs_expr->slice_expr.expr = exprid(left);
subs_expr->slice_expr.start = exprid(index);
subs_expr->slice_expr.start_from_back = from_back;
subs_expr->slice_expr.end = end ? exprid(end) : 0;
subs_expr->slice_expr.end_from_back = end_from_back;
subs_expr->slice_expr.is_lenrange = is_len_range;
}
else
{
subs_expr->subscript_expr.expr = exprid(left);
subs_expr->subscript_expr.index = exprid(index);
subs_expr->subscript_expr.from_back = from_back;
}
RANGE_EXTEND_PREV(subs_expr);
return subs_expr;
}
@@ -920,12 +936,12 @@ static Expr *parse_ct_arg(ParseContext *c, Expr *left)
TokenType type = expr->ct_arg_expr.type = c->tok;
assert(type != TOKEN_CT_VATYPE);
advance(c);
CONSUME_OR_RET(TOKEN_LPAREN, poisoned_expr);
if (type != TOKEN_CT_VACOUNT)
{
CONSUME_OR_RET(TOKEN_LPAREN, poisoned_expr);
ASSIGN_EXPRID_OR_RET(expr->ct_arg_expr.arg, parse_expr(c), poisoned_expr);
CONSUME_OR_RET(TOKEN_RPAREN, poisoned_expr);
}
CONSUME_OR_RET(TOKEN_RPAREN, poisoned_expr);
RANGE_EXTEND_PREV(expr);
return expr;
}

2
src/compiler/parse_global.c
View File

@@ -2034,7 +2034,7 @@ static inline Decl *parse_enum_declaration(ParseContext *c, Visibility visibilit
if (try_consume(c, TOKEN_LPAREN))
{
Expr **result = NULL;
if (!parse_arg_list(c, &result, TOKEN_RPAREN, NULL)) return poisoned_decl;
if (!parse_arg_list(c, &result, TOKEN_RPAREN, NULL, false)) return poisoned_decl;
enum_const->enum_constant.args = result;
CONSUME_OR_RET(TOKEN_RPAREN, poisoned_decl);
}

1
src/compiler/parse_stmt.c
View File

@@ -1290,6 +1290,7 @@ Ast *parse_stmt(ParseContext *c)
case TOKEN_CT_ENDFOREACH:
case TOKEN_CT_CASTABLE:
case TOKEN_CT_CONVERTIBLE:
case TOKEN_CT_VASPLAT:
SEMA_ERROR_HERE("Unexpected '%s' found when expecting a statement.",
token_type_to_string(c->tok));
advance(c);

3
src/compiler/parser_internal.h
View File

@@ -48,7 +48,8 @@ Decl *parse_var_decl(ParseContext *c);
bool
parse_parameters(ParseContext *c, Visibility visibility, Decl ***params_ref, Decl **body_params, Variadic *variadic,
int *vararg_index_ref);
bool parse_arg_list(ParseContext *c, Expr ***result, TokenType param_end, bool *splat);
bool parse_arg_list(ParseContext *c, Expr ***result, TokenType param_end, bool *splat, bool vasplat);
Expr *parse_type_compound_literal_expr_after_type(ParseContext *c, TypeInfo *type_info);
bool parse_module(ParseContext *c);

2
src/compiler/sema_casts.c
View File

@@ -834,6 +834,7 @@ Expr *recursive_may_narrow_float(Expr *expr, Type *type)
case EXPR_POINTER_OFFSET:
case EXPR_CT_ARG:
case EXPR_ASM:
case EXPR_VASPLAT:
UNREACHABLE
case EXPR_BUILTIN_ACCESS:
@@ -1003,6 +1004,7 @@ Expr *recursive_may_narrow_int(Expr *expr, Type *type)
case EXPR_POINTER_OFFSET:
case EXPR_CT_ARG:
case EXPR_ASM:
case EXPR_VASPLAT:
UNREACHABLE
case EXPR_POST_UNARY:
return recursive_may_narrow_int(expr->unary_expr.expr, type);

272
src/compiler/sema_expr.c
View File

@@ -21,6 +21,7 @@ static bool sema_check_stmt_compile_time(SemaContext *context, Ast *ast);
static bool binary_arithmetic_promotion(SemaContext *context, Expr *left, Expr *right, Type *left_type, Type *right_type, Expr *parent, const char *error_message);
static inline bool expr_both_const(Expr *left, Expr *right);
static inline bool sema_expr_index_const_list(Expr *const_list, Expr *index, Expr *result);
static Expr **sema_expand_vasplat_exprs(SemaContext *c, Expr **exprs);
static bool sema_decay_array_pointers(Expr *expr)
{
@@ -361,6 +362,7 @@ bool expr_is_constant_eval(Expr *expr, ConstantEvalKind eval_kind)
return false;
case EXPR_BUILTIN:
case EXPR_CT_EVAL:
case EXPR_VASPLAT:
return false;
case EXPR_BITACCESS:
case EXPR_ACCESS:
@@ -447,11 +449,11 @@ bool expr_is_constant_eval(Expr *expr, ConstantEvalKind eval_kind)
if (expr->slice_expr.end && !exprid_is_constant_eval(expr->slice_expr.end, CONSTANT_EVAL_FOLDABLE)) return false;
return exprid_is_constant_eval(expr->slice_expr.expr, eval_kind);*/
case EXPR_SUBSCRIPT:
if (!exprid_is_constant_eval(expr->subscript_expr.index, eval_kind)) return false;
if (!exprid_is_constant_eval(expr->subscript_expr.range.start, eval_kind)) return false;
expr = exprptr(expr->subscript_expr.expr);
goto RETRY;
case EXPR_SUBSCRIPT_ADDR:
if (!exprid_is_constant_eval(expr->subscript_expr.index, eval_kind)) return false;
if (!exprid_is_constant_eval(expr->subscript_expr.range.start, eval_kind)) return false;
expr = exprptr(expr->subscript_expr.expr);
if (expr->expr_kind == EXPR_IDENTIFIER)
{
@@ -709,6 +711,7 @@ static bool sema_check_expr_lvalue(Expr *top_expr, Expr *expr)
case EXPR_POINTER_OFFSET:
case EXPR_CT_ARG:
case EXPR_ASM:
case EXPR_VASPLAT:
goto ERR;
}
UNREACHABLE
@@ -809,6 +812,7 @@ bool expr_may_addr(Expr *expr)
case EXPR_POINTER_OFFSET:
case EXPR_CT_ARG:
case EXPR_ASM:
case EXPR_VASPLAT:
return false;
}
UNREACHABLE
@@ -1141,7 +1145,7 @@ static inline bool sema_expr_analyse_identifier(SemaContext *context, Type *to,
if (expr->identifier_expr.ident == declptr(body_param)->name)
{
expr->expr_kind = EXPR_MACRO_BODY_EXPANSION;
expr->body_expansion_expr.ast = NULL;
expr->body_expansion_expr.first_stmt = 0;
expr->body_expansion_expr.declarations = NULL;
expr->resolve_status = RESOLVE_NOT_DONE;
expr->type = type_void;
@@ -1611,24 +1615,31 @@ INLINE bool sema_expand_call_arguments(SemaContext *context, CalledDecl *callee,
}
// 17c. Vararg not set? That's fine.
if (params[i]->var.vararg) continue;
if (param->var.vararg) continue;
// 17d. Argument missing, that's bad.
if (!has_named || !params[i]->name)
if (!has_named || !param->name)
{
if (func_param_count == 1)
{
SEMA_ERROR(call, "This call expected a parameter of type %s, did you forget it?", type_quoted_error_string(params[i]->type));
if (param->type)
{
SEMA_ERROR(call, "This call expected a parameter of type %s, did you forget it?", type_quoted_error_string(param->type));
}
else
{
SEMA_ERROR(call, "This call expected a parameter, did you forget it?");
}
return false;
}
if (variadic != VARIADIC_NONE && i > vararg_index)
{
if (!param[i].name)
if (!param)
{
sema_error_at_after(args[num_args - 1]->span, "Argument #%d is not set.", i);
return false;
}
sema_error_at_after(args[num_args - 1]->span, "Expected '.%s = ...' after this argument.", params[i]->name);
sema_error_at_after(args[num_args - 1]->span, "Expected '.%s = ...' after this argument.", param->name);
return false;
}
if (num_args)
@@ -1644,7 +1655,7 @@ INLINE bool sema_expand_call_arguments(SemaContext *context, CalledDecl *callee,
}
return false;
}
SEMA_ERROR(call, "The parameter '%s' must be set, did you forget it?", params[i]->name);
SEMA_ERROR(call, "The parameter '%s' must be set, did you forget it?", param->name);
return false;
}
call->call_expr.arguments = actual_args;
@@ -1662,6 +1673,9 @@ static inline bool sema_expr_analyse_call_invocation(SemaContext *context, Expr
unsigned vararg_index = sig->vararg_index;
Variadic variadic = sig->variadic;
Decl **decl_params = callee.params;
if (args) args = call->call_expr.arguments = sema_expand_vasplat_exprs(context, args);
unsigned num_args = vec_size(args);
// 3. If this is a type call, then we have an implicit first argument.
@@ -2401,7 +2415,8 @@ static bool sema_analyse_body_expansion(SemaContext *macro_context, Expr *call)
Decl *param = params[i];
if (!sema_add_local(context, param)) return SCOPE_POP_ERROR();
}
Ast *ast = call->body_expansion_expr.ast = ast_macro_copy(macro_context->yield_body);
Ast *ast = ast_macro_copy(macro_context->yield_body);
call->body_expansion_expr.first_stmt = astid(ast);
if (!sema_analyse_statement(context, ast)) return SCOPE_POP_ERROR();
assert(ast->ast_kind == AST_COMPOUND_STMT);
if (context->active_scope.jump_end)
@@ -3041,7 +3056,7 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
sema_deref_array_pointers(subscripted);
// 2. Evaluate the index.
Expr *index = exprptr(expr->subscript_expr.index);
Expr *index = exprptr(expr->subscript_expr.range.start);
if (!sema_analyse_expr(context, index)) return false;
// 3. Check failability due to value.
@@ -3053,6 +3068,7 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
Expr *current_expr = subscripted;
int64_t index_value = -1;
bool start_from_end = expr->subscript_expr.range.start_from_end;
if (expr_is_const_int(index) && (current_type->type_kind == TYPE_ARRAY || current_type == type_complist))
{
// 4c. And that it's in range.
@@ -3069,13 +3085,13 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
return false;
}
index_value = int_to_i64(index->const_expr.ixx);
if (expr->subscript_expr.from_back)
if (start_from_end)
{
index_value = size - index_value;
}
if (index_value < 0 || index_value >= size)
{
if (expr->subscript_expr.from_back)
if (start_from_end)
{
SEMA_ERROR(index,
size > 1
@@ -3156,8 +3172,11 @@ static inline bool sema_expr_analyse_subscript(SemaContext *context, Expr *expr,
// Check range
bool remove_from_back = false;
if (!expr_check_index_in_range(context, current_type, index, false, expr->subscript_expr.from_back, &remove_from_back)) return false;
if (remove_from_back) expr->subscript_expr.from_back = false;
if (!expr_check_index_in_range(context, current_type, index, false, start_from_end, &remove_from_back)) return false;
if (remove_from_back)
{
start_from_end = expr->subscript_expr.range.start_from_end = false;
}
if (is_addr)
{
@@ -3209,13 +3228,13 @@ static inline bool sema_expr_analyse_pointer_offset(SemaContext *context, Expr *
static inline bool sema_expr_analyse_slice(SemaContext *context, Expr *expr)
{
assert(expr->expr_kind == EXPR_SLICE);
Expr *subscripted = exprptr(expr->slice_expr.expr);
Expr *subscripted = exprptr(expr->subscript_expr.expr);
if (!sema_analyse_expr(context, subscripted)) return false;
bool failable = IS_OPTIONAL(subscripted);
Type *type = type_flatten(subscripted->type);
Type *original_type = type_no_optional(subscripted->type);
Expr *start = exprptr(expr->slice_expr.start);
Expr *end = exprptrzero(expr->slice_expr.end);
Expr *start = exprptr(expr->subscript_expr.range.start);
Expr *end = exprptrzero(expr->subscript_expr.range.end);
Expr *current_expr = subscripted;
@@ -3225,7 +3244,7 @@ static inline bool sema_expr_analyse_slice(SemaContext *context, Expr *expr)
SEMA_ERROR(subscripted, "Cannot index '%s'.", type_to_error_string(subscripted->type));
return false;
}
expr->slice_expr.expr = exprid(current_expr);
expr->subscript_expr.expr = exprid(current_expr);
if (!sema_analyse_expr(context, start)) return false;
if (end && !sema_analyse_expr(context, end)) return false;
@@ -3239,10 +3258,13 @@ static inline bool sema_expr_analyse_slice(SemaContext *context, Expr *expr)
if (!common || !cast_implicit(start, common) || !cast_implicit(end, common)) return false;
}
bool start_from_end = expr->subscript_expr.range.start_from_end;
bool end_from_end = expr->subscript_expr.range.end_from_end;
// Check range
if (type->type_kind == TYPE_POINTER)
{
if (expr->slice_expr.start_from_back)
if (start_from_end)
{
SEMA_ERROR(start, "Indexing from the end is not allowed for pointers.");
return false;
@@ -3252,33 +3274,39 @@ static inline bool sema_expr_analyse_slice(SemaContext *context, Expr *expr)
SEMA_ERROR(expr, "Omitting end index is not allowed for pointers.");
return false;
}
if (end && expr->slice_expr.end_from_back)
if (end && end_from_end)
{
SEMA_ERROR(end, "Indexing from the end is not allowed for pointers.");
return false;
}
}
bool is_lenrange = expr->slice_expr.is_lenrange;
bool is_lenrange = expr->subscript_expr.range.is_len;
bool remove_from_end = false;
if (!expr_check_index_in_range(context, type, start, false, expr->slice_expr.start_from_back, &remove_from_end)) return false;
if (remove_from_end) expr->slice_expr.start_from_back = false;
if (!expr_check_index_in_range(context, type, start, false, start_from_end, &remove_from_end)) return false;
if (remove_from_end)
{
start_from_end = expr->subscript_expr.range.start_from_end = false;
}
remove_from_end = false;
if (end)
{
if (is_lenrange)
{
if (!expr_check_len_in_range(context, type, end, expr->slice_expr.end_from_back, &remove_from_end)) return false;
if (!expr_check_len_in_range(context, type, end, end_from_end, &remove_from_end)) return false;
}
else
{
if (!expr_check_index_in_range(context, type, end, true, expr->slice_expr.end_from_back, &remove_from_end)) return false;
if (!expr_check_index_in_range(context, type, end, true, end_from_end, &remove_from_end)) return false;
}
}
if (remove_from_end) expr->slice_expr.end_from_back = false;
if (remove_from_end)
{
end_from_end = expr->subscript_expr.range.end_from_end = false;
}
if (start && end && start->expr_kind == EXPR_CONST && end->expr_kind == EXPR_CONST)
{
if (!is_lenrange && expr->slice_expr.start_from_back && expr->slice_expr.end_from_back)
if (!is_lenrange && start_from_end && end_from_end)
{
if (expr_const_compare(&start->const_expr, &end->const_expr, BINARYOP_LT))
{
@@ -3286,7 +3314,7 @@ static inline bool sema_expr_analyse_slice(SemaContext *context, Expr *expr)
return false;
}
}
else if (!is_lenrange && !expr->slice_expr.start_from_back && !expr->slice_expr.end_from_back)
else if (!is_lenrange && !start_from_end && !end_from_end)
{
if (expr_const_compare(&start->const_expr, &end->const_expr, BINARYOP_GT))
{
@@ -3297,12 +3325,12 @@ static inline bool sema_expr_analyse_slice(SemaContext *context, Expr *expr)
// If both are
if (type->type_kind == TYPE_ARRAY || type->type_kind == TYPE_VECTOR)
{
assert(!expr->slice_expr.start_from_back);
assert(!expr->slice_expr.end_from_back);
assert(!start_from_end);
assert(!end_from_end);
if (!is_lenrange)
{
end->const_expr.ixx = int_sub(int_add64(end->const_expr.ixx, 1), start->const_expr.ixx);
is_lenrange = expr->slice_expr.is_lenrange = true;
is_lenrange = expr->subscript_expr.range.is_len = true;
}
}
}
@@ -4936,6 +4964,175 @@ static inline bool sema_expr_analyse_untyped_initializer(SemaContext *context, E
return true;
}
static Expr **vasplat_append(SemaContext *c, Expr **init_expressions, Expr *expr)
{
Expr **args = c->macro_varargs;
unsigned param_count = vec_size(args);
Range *range = &expr->vasplat_expr;
Expr *start = exprptrzero(range->start);
unsigned start_idx = 0;
if (start)
{
if (!range->is_range)
{
SEMA_ERROR(expr, "$vasplat() expected a range.");
return NULL;
}
if (!sema_analyse_expr(c, start)) return NULL;
if (!expr_is_const_int(start))
{
SEMA_ERROR(expr, "Expected a constant integer.");
return NULL;
}
Int start_index = start->const_expr.ixx;
if (int_is_neg(start_index))
{
SEMA_ERROR(expr, "Expected a positive integer.");
return NULL;
}
if (int_bits_needed(start_index) > 31)
{
SEMA_ERROR(expr, "Start index is too big.");
return NULL;
}
start_idx = start_index.i.low;
if (range->start_from_end)
{
start_idx = param_count - start_idx;
}
if (param_count < start_idx)
{
SEMA_ERROR(expr, "Start index exceeds the number of parameters (%d).", start_idx);
return NULL;
}
}
Expr *end = exprptrzero(range->end);
unsigned end_idx = param_count;
if (end)
{
if (!sema_analyse_expr(c, end)) return NULL;
if (!expr_is_const_int(end))
{
SEMA_ERROR(expr, "Expected a constant integer.");
return NULL;
}
Int end_index = end->const_expr.ixx;
if (int_is_neg(end_index))
{
SEMA_ERROR(expr, "Expected a positive integer.");
return NULL;
}
if (int_bits_needed(end_index) > 31)
{
if (range->is_len)
{
SEMA_ERROR(expr, "End index is too large.");
}
else
{
SEMA_ERROR(expr, "Length is too large.");
}
return NULL;
}
end_idx = end_index.i.low;
if (range->end_from_end)
{
if (end_idx > param_count)
{
end_idx = 0;
}
else
{
end_idx = param_count - end_idx;
}
}
if (range->is_len)
{
end_idx = start_idx + end_idx;
}
else
{
end_idx++;
}
if (param_count <= end_idx)
{
SEMA_ERROR(expr, "End index would exceed the number of parameters.");
return NULL;
}
}
for (unsigned i = start_idx; i < end_idx; i++)
{
vec_add(init_expressions, args[i]);
}
return init_expressions;
}
INLINE Expr **sema_expand_vasplat(SemaContext *c, Expr **list, unsigned index)
{
unsigned size = vec_size(list);
// If it was the last element then just append.
if (index == size - 1)
{
vec_pop(list);
return vasplat_append(c, list, list[index]);
}
// Otherwise append to the end.
list = vasplat_append(c, list, list[index]);
if (!list) return NULL;
unsigned new_size = vec_size(list);
unsigned added_elements = new_size - size;
if (added_elements == 0)
{
for (unsigned i = index + 1; i < size; i++)
{
list[i - 1] = list[i];
}
vec_pop(list);
return list;
}
// Copy those elements
for (unsigned i = 0; i < added_elements; i++)
{
unsigned dest = index + i;
unsigned source = size + i;
// Copy the next element to the index position.
list[dest] = list[source];
// Copy the following into the place of the index.
list[source] = list[dest + 1];
}
vec_pop(list);
return list;
}
static Expr **sema_expand_vasplat_exprs(SemaContext *c, Expr **exprs)
{
if (!c->current_macro) return exprs;
unsigned count = vec_size(exprs);
bool expand;
do
{
expand = false;
for (unsigned i = 0; i < count; i++)
{
if (exprs[i]->expr_kind == EXPR_VASPLAT)
{
exprs = sema_expand_vasplat(c, exprs, i);
// If we have null back it failed.
if (!exprs) return NULL;
count = vec_size(exprs);
expand = true;
break;
}
}
} while (expand);
return exprs;
}
static inline bool sema_expr_analyse_initializer(SemaContext *context, Type *external_type, Type *assigned, Expr *expr)
{
// Note at this point this we either have
@@ -4953,6 +5150,11 @@ static inline bool sema_expr_analyse_initializer(SemaContext *context, Type *ext
// 2. Grab the expressions inside.
Expr **init_expressions = expr->initializer_list;
if (init_expressions)
{
expr->initializer_list = init_expressions = sema_expand_vasplat_exprs(context, init_expressions);
}
unsigned init_expression_count = vec_size(init_expressions);
// 3. Zero size init will initialize to empty.
@@ -4972,6 +5174,7 @@ static inline bool sema_expr_analyse_initializer(SemaContext *context, Type *ext
return true;
}
// 4. If we have an inferred array, we need to set the size.
external_type = sema_type_lower_by_size(external_type, init_expression_count);
assigned = sema_type_lower_by_size(assigned, init_expression_count);
@@ -7904,6 +8107,9 @@ static inline bool sema_analyse_expr_dispatch(SemaContext *context, Expr *expr)
case EXPR_TYPEID_INFO:
case EXPR_ASM:
UNREACHABLE
case EXPR_VASPLAT:
SEMA_ERROR(expr, "'$vasplat' can only be used inside of macros.");
return false;
case EXPR_CT_ARG:
return sema_expr_analyse_ct_arg(context, expr);
case EXPR_VARIANT:
@@ -8063,7 +8269,7 @@ static inline bool sema_cast_rvalue(SemaContext *context, Expr *expr)
switch (expr->expr_kind)
{
case EXPR_MACRO_BODY_EXPANSION:
if (!expr->body_expansion_expr.ast)
if (!expr->body_expansion_expr.first_stmt)
{
SEMA_ERROR(expr, "'@%s' must be followed by ().", declptr(context->current_macro->func_decl.body_param)->name);
return false;

2
src/compiler/sema_stmts.c
View File

@@ -1218,7 +1218,7 @@ static inline bool sema_analyse_foreach_stmt(SemaContext *context, Ast *statemen
enum_val = expr_variable(temp);
if (is_addr) expr_insert_deref(enum_val);
subscript->subscript_expr.expr = exprid(enum_val);
subscript->subscript_expr.index = exprid(expr_variable(idx_decl));
subscript->subscript_expr.range.start = exprid(expr_variable(idx_decl));
if (value_by_ref)
{
Expr *addr = expr_new(EXPR_UNARY, subscript->span);

2
src/compiler/tokens.c
View File

@@ -368,6 +368,8 @@ const char *token_type_to_string(TokenType type)
return "$varef";
case TOKEN_CT_VAEXPR:
return "$vaexpr";
case TOKEN_CT_VASPLAT:
return "$vasplat";
case TOKEN_CT_NAMEOF:
return "$nameof";
case TOKEN_CT_OFFSETOF:

2
src/version.h
View File

@@ -1 +1 @@
#define COMPILER_VERSION "0.3.36"
#define COMPILER_VERSION "0.3.37"

6
test/test_suite/macros/macro_untyped_varargs_2.c3t
View File

@@ -8,14 +8,14 @@ macro @foo(...)
{
int i = $vaarg(1) + $vaarg(1);
int j = $vaexpr(2) + $vaexpr(2);
$for (var $i = 0; $i < $vacount(); $i++):
$for (var $i = 0; $i < $vacount; $i++):
io::printfln("%d", $vaarg($i));
$endfor;
}
macro foo2(...)
{
$for (var $i = 0; $i < $vacount(); $i++):
$for (var $i = 0; $i < $vacount; $i++):
{
$vatype($i) x;
}
@@ -26,7 +26,7 @@ macro foo2(...)
macro foo3(...)
{
var $x = 0;
$for (var $i = 0; $i < $vacount(); $i++):
$for (var $i = 0; $i < $vacount; $i++):
$x += $vaconst($i);
$endfor;
return $x;

789
test/test_suite/macros/macro_vasplat.c3t Normal file
View File

@@ -0,0 +1,789 @@
// #target: macos-x64
module test;
import std::io;
macro @hello(...)
{
int[*] a = { 1, $vasplat(), 3 };
foreach (i, x : a) io::printfln("%d: %d", i, x);
}
macro @hello1(...)
{
int[*] a = { 1, $vasplat() };
foreach (i, x : a) io::printfln("x:%d: %d", i, x);
}
macro @hello2(...)
{
int[*] a = { $vasplat(), 888 };
foreach (i, x : a) io::printfln("x:%d: %d", i, x);
}
macro @hello3(...)
{
int[*] a = { $vasplat() };
foreach (i, x : a) io::printfln("x:%d: %d", i, x);
}
macro @hello4(...)
{
int[*] a = { 5, $vasplat(2..4), 77 };
foreach (i, x : a) io::printfln("y:%d: %d", i, x);
}
macro @hello5(...)
{
int[*] a = { 5, $vasplat(2..), 77 };
foreach (i, x : a) io::printfln("y:%d: %d", i, x);
int[*] b = { 55, $vasplat(2..^2), 88 };
foreach (i, x : b) io::printfln("z:%d: %d", i, x);
int[*] c = { 55, $vasplat(0:^2), 88 };
foreach (i, x : c) io::printfln("zz:%d: %d", i, x);
}
macro @hello6(...)
{
@hello(66, $vasplat());
}
fn void main()
{
@hello1(223, 326);
@hello1();
@hello(26, 36);
@hello();
@hello2(2123, 3326);
@hello2();
@hello3(2123, 3326);
@hello4(1, 2, 3, 4, 5, 6, 7, 8);
@hello5(1, 2, 3, 4, 5, 6, 7, 8);
@hello6(1, 2, 3);
}
/* #expect: test.ll
define void @test_main() #0 {
entry:
%a = alloca [3 x i32], align 4
%.anon = alloca i64, align 8
%i = alloca i64, align 8
%x = alloca i32, align 4
%retparam = alloca i64, align 8
%taddr = alloca %"char[]", align 8
%vararg = alloca %"variant[]", align 8
%varargslots = alloca [2 x %variant], align 16
%a3 = alloca [1 x i32], align 4
%.anon4 = alloca i64, align 8
%i8 = alloca i64, align 8
%x9 = alloca i32, align 4
%retparam10 = alloca i64, align 8
%taddr11 = alloca %"char[]", align 8
%vararg14 = alloca %"variant[]", align 8
%varargslots15 = alloca [2 x %variant], align 16
%a23 = alloca [4 x i32], align 16
%.anon24 = alloca i64, align 8
%i28 = alloca i64, align 8
%x29 = alloca i32, align 4
%retparam30 = alloca i64, align 8
%taddr31 = alloca %"char[]", align 8
%vararg34 = alloca %"variant[]", align 8
%varargslots35 = alloca [2 x %variant], align 16
%a43 = alloca [2 x i32], align 4
%.anon44 = alloca i64, align 8
%i48 = alloca i64, align 8
%x49 = alloca i32, align 4
%retparam50 = alloca i64, align 8
%taddr51 = alloca %"char[]", align 8
%vararg54 = alloca %"variant[]", align 8
%varargslots55 = alloca [2 x %variant], align 16
%a63 = alloca [3 x i32], align 4
%.anon64 = alloca i64, align 8
%i68 = alloca i64, align 8
%x69 = alloca i32, align 4
%retparam70 = alloca i64, align 8
%taddr71 = alloca %"char[]", align 8
%vararg74 = alloca %"variant[]", align 8
%varargslots75 = alloca [2 x %variant], align 16
%a83 = alloca [1 x i32], align 4
%.anon84 = alloca i64, align 8
%i88 = alloca i64, align 8
%x89 = alloca i32, align 4
%retparam90 = alloca i64, align 8
%taddr91 = alloca %"char[]", align 8
%vararg94 = alloca %"variant[]", align 8
%varargslots95 = alloca [2 x %variant], align 16
%a103 = alloca [2 x i32], align 4
%.anon104 = alloca i64, align 8
%i108 = alloca i64, align 8
%x109 = alloca i32, align 4
%retparam110 = alloca i64, align 8
%taddr111 = alloca %"char[]", align 8
%vararg114 = alloca %"variant[]", align 8
%varargslots115 = alloca [2 x %variant], align 16
%a123 = alloca [5 x i32], align 16
%.anon124 = alloca i64, align 8
%i128 = alloca i64, align 8
%x129 = alloca i32, align 4
%retparam130 = alloca i64, align 8
%taddr131 = alloca %"char[]", align 8
%vararg134 = alloca %"variant[]", align 8
%varargslots135 = alloca [2 x %variant], align 16
%a143 = alloca [8 x i32], align 16
%.anon144 = alloca i64, align 8
%i148 = alloca i64, align 8
%x149 = alloca i32, align 4
%retparam150 = alloca i64, align 8
%taddr151 = alloca %"char[]", align 8
%vararg154 = alloca %"variant[]", align 8
%varargslots155 = alloca [2 x %variant], align 16
%b = alloca [7 x i32], align 16
%.anon163 = alloca i64, align 8
%i167 = alloca i64, align 8
%x168 = alloca i32, align 4
%retparam169 = alloca i64, align 8
%taddr170 = alloca %"char[]", align 8
%vararg173 = alloca %"variant[]", align 8
%varargslots174 = alloca [2 x %variant], align 16
%c = alloca [8 x i32], align 16
%.anon182 = alloca i64, align 8
%i186 = alloca i64, align 8
%x187 = alloca i32, align 4
%retparam188 = alloca i64, align 8
%taddr189 = alloca %"char[]", align 8
%vararg192 = alloca %"variant[]", align 8
%varargslots193 = alloca [2 x %variant], align 16
%a201 = alloca [6 x i32], align 16
%.anon202 = alloca i64, align 8
%i206 = alloca i64, align 8
%x207 = alloca i32, align 4
%retparam208 = alloca i64, align 8
%taddr209 = alloca %"char[]", align 8
%vararg212 = alloca %"variant[]", align 8
%varargslots213 = alloca [2 x %variant], align 16
%0 = bitcast [3 x i32]* %a to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([3 x i32]* @.__const to i8*), i32 12, i1 false)
store i64 0, i64* %.anon, align 8
br label %loop.cond
loop.cond: ; preds = %voiderr, %entry
%1 = load i64, i64* %.anon, align 8
%gt = icmp ugt i64 3, %1
br i1 %gt, label %loop.body, label %loop.exit
loop.body: ; preds = %loop.cond
%2 = load i64, i64* %.anon, align 8
store i64 %2, i64* %i, align 8
%3 = load i64, i64* %.anon, align 8
%4 = getelementptr inbounds [3 x i32], [3 x i32]* %a, i64 0, i64 %3
%5 = load i32, i32* %4, align 4
store i32 %5, i32* %x, align 4
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8
%6 = bitcast %"char[]"* %taddr to { i8*, i64 }*
%7 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 0
%lo = load i8*, i8** %7, align 8
%8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %6, i32 0, i32 1
%hi = load i64, i64* %8, align 8
%9 = bitcast i64* %i to i8*
%10 = insertvalue %variant undef, i8* %9, 0
%11 = insertvalue %variant %10, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%12 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0
store %variant %11, %variant* %12, align 16
%13 = bitcast i32* %x to i8*
%14 = insertvalue %variant undef, i8* %13, 0
%15 = insertvalue %variant %14, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%16 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1
store %variant %15, %variant* %16, align 16
%17 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
store i64 2, i64* %17, align 8
%18 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
%19 = bitcast [2 x %variant]* %varargslots to %variant*
store %variant* %19, %variant** %18, align 8
%20 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
%21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 0
%lo1 = load i8*, i8** %21, align 8
%22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 1
%hi2 = load i64, i64* %22, align 8
%23 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2)
%not_err = icmp eq i64 %23, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %loop.body
br label %voiderr
voiderr: ; preds = %after_check, %loop.body
%24 = load i64, i64* %.anon, align 8
%add = add i64 %24, 1
store i64 %add, i64* %.anon, align 8
br label %loop.cond
loop.exit: ; preds = %loop.cond
%25 = bitcast [1 x i32]* %a3 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %25, i8* align 4 bitcast ([1 x i32]* @.__const.1 to i8*), i32 4, i1 false)
store i64 0, i64* %.anon4, align 8
br label %loop.cond5
loop.cond5: ; preds = %voiderr20, %loop.exit
%26 = load i64, i64* %.anon4, align 8
%gt6 = icmp ugt i64 1, %26
br i1 %gt6, label %loop.body7, label %loop.exit22
loop.body7: ; preds = %loop.cond5
%27 = load i64, i64* %.anon4, align 8
store i64 %27, i64* %i8, align 8
%28 = load i64, i64* %.anon4, align 8
%29 = getelementptr inbounds [1 x i32], [1 x i32]* %a3, i64 0, i64 %28
%30 = load i32, i32* %29, align 4
store i32 %30, i32* %x9, align 4
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8 }, %"char[]"* %taddr11, align 8
%31 = bitcast %"char[]"* %taddr11 to { i8*, i64 }*
%32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0
%lo12 = load i8*, i8** %32, align 8
%33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1
%hi13 = load i64, i64* %33, align 8
%34 = bitcast i64* %i8 to i8*
%35 = insertvalue %variant undef, i8* %34, 0
%36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%37 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots15, i64 0, i64 0
store %variant %36, %variant* %37, align 16
%38 = bitcast i32* %x9 to i8*
%39 = insertvalue %variant undef, i8* %38, 0
%40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%41 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots15, i64 0, i64 1
store %variant %40, %variant* %41, align 16
%42 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg14, i32 0, i32 1
store i64 2, i64* %42, align 8
%43 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg14, i32 0, i32 0
%44 = bitcast [2 x %variant]* %varargslots15 to %variant*
store %variant* %44, %variant** %43, align 8
%45 = bitcast %"variant[]"* %vararg14 to { i8*, i64 }*
%46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0
%lo16 = load i8*, i8** %46, align 8
%47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1
%hi17 = load i64, i64* %47, align 8
%48 = call i64 @std_io_printfln(i64* %retparam10, i8* %lo12, i64 %hi13, i8* %lo16, i64 %hi17)
%not_err18 = icmp eq i64 %48, 0
br i1 %not_err18, label %after_check19, label %voiderr20
after_check19: ; preds = %loop.body7
br label %voiderr20
voiderr20: ; preds = %after_check19, %loop.body7
%49 = load i64, i64* %.anon4, align 8
%add21 = add i64 %49, 1
store i64 %add21, i64* %.anon4, align 8
br label %loop.cond5
loop.exit22: ; preds = %loop.cond5
%50 = bitcast [4 x i32]* %a23 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %50, i8* align 16 bitcast ([4 x i32]* @.__const.3 to i8*), i32 16, i1 false)
store i64 0, i64* %.anon24, align 8
br label %loop.cond25
loop.cond25: ; preds = %voiderr40, %loop.exit22
%51 = load i64, i64* %.anon24, align 8
%gt26 = icmp ugt i64 4, %51
br i1 %gt26, label %loop.body27, label %loop.exit42
loop.body27: ; preds = %loop.cond25
%52 = load i64, i64* %.anon24, align 8
store i64 %52, i64* %i28, align 8
%53 = load i64, i64* %.anon24, align 8
%54 = getelementptr inbounds [4 x i32], [4 x i32]* %a23, i64 0, i64 %53
%55 = load i32, i32* %54, align 4
store i32 %55, i32* %x29, align 4
store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i32 0, i32 0), i64 6 }, %"char[]"* %taddr31, align 8
%56 = bitcast %"char[]"* %taddr31 to { i8*, i64 }*
%57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 0
%lo32 = load i8*, i8** %57, align 8
%58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 1
%hi33 = load i64, i64* %58, align 8
%59 = bitcast i64* %i28 to i8*
%60 = insertvalue %variant undef, i8* %59, 0
%61 = insertvalue %variant %60, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%62 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots35, i64 0, i64 0
store %variant %61, %variant* %62, align 16
%63 = bitcast i32* %x29 to i8*
%64 = insertvalue %variant undef, i8* %63, 0
%65 = insertvalue %variant %64, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%66 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots35, i64 0, i64 1
store %variant %65, %variant* %66, align 16
%67 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 1
store i64 2, i64* %67, align 8
%68 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 0
%69 = bitcast [2 x %variant]* %varargslots35 to %variant*
store %variant* %69, %variant** %68, align 8
%70 = bitcast %"variant[]"* %vararg34 to { i8*, i64 }*
%71 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 0
%lo36 = load i8*, i8** %71, align 8
%72 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 1
%hi37 = load i64, i64* %72, align 8
%73 = call i64 @std_io_printfln(i64* %retparam30, i8* %lo32, i64 %hi33, i8* %lo36, i64 %hi37)
%not_err38 = icmp eq i64 %73, 0
br i1 %not_err38, label %after_check39, label %voiderr40
after_check39: ; preds = %loop.body27
br label %voiderr40
voiderr40: ; preds = %after_check39, %loop.body27
%74 = load i64, i64* %.anon24, align 8
%add41 = add i64 %74, 1
store i64 %add41, i64* %.anon24, align 8
br label %loop.cond25
loop.exit42: ; preds = %loop.cond25
%75 = bitcast [2 x i32]* %a43 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %75, i8* align 4 bitcast ([2 x i32]* @.__const.5 to i8*), i32 8, i1 false)
store i64 0, i64* %.anon44, align 8
br label %loop.cond45
loop.cond45: ; preds = %voiderr60, %loop.exit42
%76 = load i64, i64* %.anon44, align 8
%gt46 = icmp ugt i64 2, %76
br i1 %gt46, label %loop.body47, label %loop.exit62
loop.body47: ; preds = %loop.cond45
%77 = load i64, i64* %.anon44, align 8
store i64 %77, i64* %i48, align 8
%78 = load i64, i64* %.anon44, align 8
%79 = getelementptr inbounds [2 x i32], [2 x i32]* %a43, i64 0, i64 %78
%80 = load i32, i32* %79, align 4
store i32 %80, i32* %x49, align 4
store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i64 6 }, %"char[]"* %taddr51, align 8
%81 = bitcast %"char[]"* %taddr51 to { i8*, i64 }*
%82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %81, i32 0, i32 0
%lo52 = load i8*, i8** %82, align 8
%83 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %81, i32 0, i32 1
%hi53 = load i64, i64* %83, align 8
%84 = bitcast i64* %i48 to i8*
%85 = insertvalue %variant undef, i8* %84, 0
%86 = insertvalue %variant %85, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%87 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots55, i64 0, i64 0
store %variant %86, %variant* %87, align 16
%88 = bitcast i32* %x49 to i8*
%89 = insertvalue %variant undef, i8* %88, 0
%90 = insertvalue %variant %89, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%91 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots55, i64 0, i64 1
store %variant %90, %variant* %91, align 16
%92 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg54, i32 0, i32 1
store i64 2, i64* %92, align 8
%93 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg54, i32 0, i32 0
%94 = bitcast [2 x %variant]* %varargslots55 to %variant*
store %variant* %94, %variant** %93, align 8
%95 = bitcast %"variant[]"* %vararg54 to { i8*, i64 }*
%96 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %95, i32 0, i32 0
%lo56 = load i8*, i8** %96, align 8
%97 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %95, i32 0, i32 1
%hi57 = load i64, i64* %97, align 8
%98 = call i64 @std_io_printfln(i64* %retparam50, i8* %lo52, i64 %hi53, i8* %lo56, i64 %hi57)
%not_err58 = icmp eq i64 %98, 0
br i1 %not_err58, label %after_check59, label %voiderr60
after_check59: ; preds = %loop.body47
br label %voiderr60
voiderr60: ; preds = %after_check59, %loop.body47
%99 = load i64, i64* %.anon44, align 8
%add61 = add i64 %99, 1
store i64 %add61, i64* %.anon44, align 8
br label %loop.cond45
loop.exit62: ; preds = %loop.cond45
%100 = bitcast [3 x i32]* %a63 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %100, i8* align 4 bitcast ([3 x i32]* @.__const.7 to i8*), i32 12, i1 false)
store i64 0, i64* %.anon64, align 8
br label %loop.cond65
loop.cond65: ; preds = %voiderr80, %loop.exit62
%101 = load i64, i64* %.anon64, align 8
%gt66 = icmp ugt i64 3, %101
br i1 %gt66, label %loop.body67, label %loop.exit82
loop.body67: ; preds = %loop.cond65
%102 = load i64, i64* %.anon64, align 8
store i64 %102, i64* %i68, align 8
%103 = load i64, i64* %.anon64, align 8
%104 = getelementptr inbounds [3 x i32], [3 x i32]* %a63, i64 0, i64 %103
%105 = load i32, i32* %104, align 4
store i32 %105, i32* %x69, align 4
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i32 0, i32 0), i64 8 }, %"char[]"* %taddr71, align 8
%106 = bitcast %"char[]"* %taddr71 to { i8*, i64 }*
%107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 0
%lo72 = load i8*, i8** %107, align 8
%108 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 1
%hi73 = load i64, i64* %108, align 8
%109 = bitcast i64* %i68 to i8*
%110 = insertvalue %variant undef, i8* %109, 0
%111 = insertvalue %variant %110, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%112 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots75, i64 0, i64 0
store %variant %111, %variant* %112, align 16
%113 = bitcast i32* %x69 to i8*
%114 = insertvalue %variant undef, i8* %113, 0
%115 = insertvalue %variant %114, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%116 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots75, i64 0, i64 1
store %variant %115, %variant* %116, align 16
%117 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg74, i32 0, i32 1
store i64 2, i64* %117, align 8
%118 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg74, i32 0, i32 0
%119 = bitcast [2 x %variant]* %varargslots75 to %variant*
store %variant* %119, %variant** %118, align 8
%120 = bitcast %"variant[]"* %vararg74 to { i8*, i64 }*
%121 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %120, i32 0, i32 0
%lo76 = load i8*, i8** %121, align 8
%122 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %120, i32 0, i32 1
%hi77 = load i64, i64* %122, align 8
%123 = call i64 @std_io_printfln(i64* %retparam70, i8* %lo72, i64 %hi73, i8* %lo76, i64 %hi77)
%not_err78 = icmp eq i64 %123, 0
br i1 %not_err78, label %after_check79, label %voiderr80
after_check79: ; preds = %loop.body67
br label %voiderr80
voiderr80: ; preds = %after_check79, %loop.body67
%124 = load i64, i64* %.anon64, align 8
%add81 = add i64 %124, 1
store i64 %add81, i64* %.anon64, align 8
br label %loop.cond65
loop.exit82: ; preds = %loop.cond65
%125 = bitcast [1 x i32]* %a83 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %125, i8* align 4 bitcast ([1 x i32]* @.__const.9 to i8*), i32 4, i1 false)
store i64 0, i64* %.anon84, align 8
br label %loop.cond85
loop.cond85: ; preds = %voiderr100, %loop.exit82
%126 = load i64, i64* %.anon84, align 8
%gt86 = icmp ugt i64 1, %126
br i1 %gt86, label %loop.body87, label %loop.exit102
loop.body87: ; preds = %loop.cond85
%127 = load i64, i64* %.anon84, align 8
store i64 %127, i64* %i88, align 8
%128 = load i64, i64* %.anon84, align 8
%129 = getelementptr inbounds [1 x i32], [1 x i32]* %a83, i64 0, i64 %128
%130 = load i32, i32* %129, align 4
store i32 %130, i32* %x89, align 4
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i32 0, i32 0), i64 8 }, %"char[]"* %taddr91, align 8
%131 = bitcast %"char[]"* %taddr91 to { i8*, i64 }*
%132 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %131, i32 0, i32 0
%lo92 = load i8*, i8** %132, align 8
%133 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %131, i32 0, i32 1
%hi93 = load i64, i64* %133, align 8
%134 = bitcast i64* %i88 to i8*
%135 = insertvalue %variant undef, i8* %134, 0
%136 = insertvalue %variant %135, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%137 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots95, i64 0, i64 0
store %variant %136, %variant* %137, align 16
%138 = bitcast i32* %x89 to i8*
%139 = insertvalue %variant undef, i8* %138, 0
%140 = insertvalue %variant %139, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%141 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots95, i64 0, i64 1
store %variant %140, %variant* %141, align 16
%142 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg94, i32 0, i32 1
store i64 2, i64* %142, align 8
%143 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg94, i32 0, i32 0
%144 = bitcast [2 x %variant]* %varargslots95 to %variant*
store %variant* %144, %variant** %143, align 8
%145 = bitcast %"variant[]"* %vararg94 to { i8*, i64 }*
%146 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %145, i32 0, i32 0
%lo96 = load i8*, i8** %146, align 8
%147 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %145, i32 0, i32 1
%hi97 = load i64, i64* %147, align 8
%148 = call i64 @std_io_printfln(i64* %retparam90, i8* %lo92, i64 %hi93, i8* %lo96, i64 %hi97)
%not_err98 = icmp eq i64 %148, 0
br i1 %not_err98, label %after_check99, label %voiderr100
after_check99: ; preds = %loop.body87
br label %voiderr100
voiderr100: ; preds = %after_check99, %loop.body87
%149 = load i64, i64* %.anon84, align 8
%add101 = add i64 %149, 1
store i64 %add101, i64* %.anon84, align 8
br label %loop.cond85
loop.exit102: ; preds = %loop.cond85
%150 = bitcast [2 x i32]* %a103 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %150, i8* align 4 bitcast ([2 x i32]* @.__const.11 to i8*), i32 8, i1 false)
store i64 0, i64* %.anon104, align 8
br label %loop.cond105
loop.cond105: ; preds = %voiderr120, %loop.exit102
%151 = load i64, i64* %.anon104, align 8
%gt106 = icmp ugt i64 2, %151
br i1 %gt106, label %loop.body107, label %loop.exit122
loop.body107: ; preds = %loop.cond105
%152 = load i64, i64* %.anon104, align 8
store i64 %152, i64* %i108, align 8
%153 = load i64, i64* %.anon104, align 8
%154 = getelementptr inbounds [2 x i32], [2 x i32]* %a103, i64 0, i64 %153
%155 = load i32, i32* %154, align 4
store i32 %155, i32* %x109, align 4
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i32 0, i32 0), i64 8 }, %"char[]"* %taddr111, align 8
%156 = bitcast %"char[]"* %taddr111 to { i8*, i64 }*
%157 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %156, i32 0, i32 0
%lo112 = load i8*, i8** %157, align 8
%158 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %156, i32 0, i32 1
%hi113 = load i64, i64* %158, align 8
%159 = bitcast i64* %i108 to i8*
%160 = insertvalue %variant undef, i8* %159, 0
%161 = insertvalue %variant %160, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%162 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots115, i64 0, i64 0
store %variant %161, %variant* %162, align 16
%163 = bitcast i32* %x109 to i8*
%164 = insertvalue %variant undef, i8* %163, 0
%165 = insertvalue %variant %164, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%166 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots115, i64 0, i64 1
store %variant %165, %variant* %166, align 16
%167 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg114, i32 0, i32 1
store i64 2, i64* %167, align 8
%168 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg114, i32 0, i32 0
%169 = bitcast [2 x %variant]* %varargslots115 to %variant*
store %variant* %169, %variant** %168, align 8
%170 = bitcast %"variant[]"* %vararg114 to { i8*, i64 }*
%171 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %170, i32 0, i32 0
%lo116 = load i8*, i8** %171, align 8
%172 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %170, i32 0, i32 1
%hi117 = load i64, i64* %172, align 8
%173 = call i64 @std_io_printfln(i64* %retparam110, i8* %lo112, i64 %hi113, i8* %lo116, i64 %hi117)
%not_err118 = icmp eq i64 %173, 0
br i1 %not_err118, label %after_check119, label %voiderr120
after_check119: ; preds = %loop.body107
br label %voiderr120
voiderr120: ; preds = %after_check119, %loop.body107
%174 = load i64, i64* %.anon104, align 8
%add121 = add i64 %174, 1
store i64 %add121, i64* %.anon104, align 8
br label %loop.cond105
loop.exit122: ; preds = %loop.cond105
%175 = bitcast [5 x i32]* %a123 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %175, i8* align 16 bitcast ([5 x i32]* @.__const.13 to i8*), i32 20, i1 false)
store i64 0, i64* %.anon124, align 8
br label %loop.cond125
loop.cond125: ; preds = %voiderr140, %loop.exit122
%176 = load i64, i64* %.anon124, align 8
%gt126 = icmp ugt i64 5, %176
br i1 %gt126, label %loop.body127, label %loop.exit142
loop.body127: ; preds = %loop.cond125
%177 = load i64, i64* %.anon124, align 8
store i64 %177, i64* %i128, align 8
%178 = load i64, i64* %.anon124, align 8
%179 = getelementptr inbounds [5 x i32], [5 x i32]* %a123, i64 0, i64 %178
%180 = load i32, i32* %179, align 4
store i32 %180, i32* %x129, align 4
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i32 0, i32 0), i64 8 }, %"char[]"* %taddr131, align 8
%181 = bitcast %"char[]"* %taddr131 to { i8*, i64 }*
%182 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %181, i32 0, i32 0
%lo132 = load i8*, i8** %182, align 8
%183 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %181, i32 0, i32 1
%hi133 = load i64, i64* %183, align 8
%184 = bitcast i64* %i128 to i8*
%185 = insertvalue %variant undef, i8* %184, 0
%186 = insertvalue %variant %185, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%187 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots135, i64 0, i64 0
store %variant %186, %variant* %187, align 16
%188 = bitcast i32* %x129 to i8*
%189 = insertvalue %variant undef, i8* %188, 0
%190 = insertvalue %variant %189, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%191 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots135, i64 0, i64 1
store %variant %190, %variant* %191, align 16
%192 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg134, i32 0, i32 1
store i64 2, i64* %192, align 8
%193 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg134, i32 0, i32 0
%194 = bitcast [2 x %variant]* %varargslots135 to %variant*
store %variant* %194, %variant** %193, align 8
%195 = bitcast %"variant[]"* %vararg134 to { i8*, i64 }*
%196 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %195, i32 0, i32 0
%lo136 = load i8*, i8** %196, align 8
%197 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %195, i32 0, i32 1
%hi137 = load i64, i64* %197, align 8
%198 = call i64 @std_io_printfln(i64* %retparam130, i8* %lo132, i64 %hi133, i8* %lo136, i64 %hi137)
%not_err138 = icmp eq i64 %198, 0
br i1 %not_err138, label %after_check139, label %voiderr140
after_check139: ; preds = %loop.body127
br label %voiderr140
voiderr140: ; preds = %after_check139, %loop.body127
%199 = load i64, i64* %.anon124, align 8
%add141 = add i64 %199, 1
store i64 %add141, i64* %.anon124, align 8
br label %loop.cond125
loop.exit142: ; preds = %loop.cond125
%200 = bitcast [8 x i32]* %a143 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %200, i8* align 16 bitcast ([8 x i32]* @.__const.15 to i8*), i32 32, i1 false)
store i64 0, i64* %.anon144, align 8
br label %loop.cond145
loop.cond145: ; preds = %voiderr160, %loop.exit142
%201 = load i64, i64* %.anon144, align 8
%gt146 = icmp ugt i64 8, %201
br i1 %gt146, label %loop.body147, label %loop.exit162
loop.body147: ; preds = %loop.cond145
%202 = load i64, i64* %.anon144, align 8
store i64 %202, i64* %i148, align 8
%203 = load i64, i64* %.anon144, align 8
%204 = getelementptr inbounds [8 x i32], [8 x i32]* %a143, i64 0, i64 %203
%205 = load i32, i32* %204, align 4
store i32 %205, i32* %x149, align 4
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.16, i32 0, i32 0), i64 8 }, %"char[]"* %taddr151, align 8
%206 = bitcast %"char[]"* %taddr151 to { i8*, i64 }*
%207 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %206, i32 0, i32 0
%lo152 = load i8*, i8** %207, align 8
%208 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %206, i32 0, i32 1
%hi153 = load i64, i64* %208, align 8
%209 = bitcast i64* %i148 to i8*
%210 = insertvalue %variant undef, i8* %209, 0
%211 = insertvalue %variant %210, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%212 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots155, i64 0, i64 0
store %variant %211, %variant* %212, align 16
%213 = bitcast i32* %x149 to i8*
%214 = insertvalue %variant undef, i8* %213, 0
%215 = insertvalue %variant %214, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%216 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots155, i64 0, i64 1
store %variant %215, %variant* %216, align 16
%217 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg154, i32 0, i32 1
store i64 2, i64* %217, align 8
%218 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg154, i32 0, i32 0
%219 = bitcast [2 x %variant]* %varargslots155 to %variant*
store %variant* %219, %variant** %218, align 8
%220 = bitcast %"variant[]"* %vararg154 to { i8*, i64 }*
%221 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %220, i32 0, i32 0
%lo156 = load i8*, i8** %221, align 8
%222 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %220, i32 0, i32 1
%hi157 = load i64, i64* %222, align 8
%223 = call i64 @std_io_printfln(i64* %retparam150, i8* %lo152, i64 %hi153, i8* %lo156, i64 %hi157)
%not_err158 = icmp eq i64 %223, 0
br i1 %not_err158, label %after_check159, label %voiderr160
after_check159: ; preds = %loop.body147
br label %voiderr160
voiderr160: ; preds = %after_check159, %loop.body147
%224 = load i64, i64* %.anon144, align 8
%add161 = add i64 %224, 1
store i64 %add161, i64* %.anon144, align 8
br label %loop.cond145
loop.exit162: ; preds = %loop.cond145
%225 = bitcast [7 x i32]* %b to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %225, i8* align 16 bitcast ([7 x i32]* @.__const.17 to i8*), i32 28, i1 false)
store i64 0, i64* %.anon163, align 8
br label %loop.cond164
loop.cond164: ; preds = %voiderr179, %loop.exit162
%226 = load i64, i64* %.anon163, align 8
%gt165 = icmp ugt i64 7, %226
br i1 %gt165, label %loop.body166, label %loop.exit181
loop.body166: ; preds = %loop.cond164
%227 = load i64, i64* %.anon163, align 8
store i64 %227, i64* %i167, align 8
%228 = load i64, i64* %.anon163, align 8
%229 = getelementptr inbounds [7 x i32], [7 x i32]* %b, i64 0, i64 %228
%230 = load i32, i32* %229, align 4
store i32 %230, i32* %x168, align 4
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.18, i32 0, i32 0), i64 8 }, %"char[]"* %taddr170, align 8
%231 = bitcast %"char[]"* %taddr170 to { i8*, i64 }*
%232 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %231, i32 0, i32 0
%lo171 = load i8*, i8** %232, align 8
%233 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %231, i32 0, i32 1
%hi172 = load i64, i64* %233, align 8
%234 = bitcast i64* %i167 to i8*
%235 = insertvalue %variant undef, i8* %234, 0
%236 = insertvalue %variant %235, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%237 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots174, i64 0, i64 0
store %variant %236, %variant* %237, align 16
%238 = bitcast i32* %x168 to i8*
%239 = insertvalue %variant undef, i8* %238, 0
%240 = insertvalue %variant %239, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%241 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots174, i64 0, i64 1
store %variant %240, %variant* %241, align 16
%242 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg173, i32 0, i32 1
store i64 2, i64* %242, align 8
%243 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg173, i32 0, i32 0
%244 = bitcast [2 x %variant]* %varargslots174 to %variant*
store %variant* %244, %variant** %243, align 8
%245 = bitcast %"variant[]"* %vararg173 to { i8*, i64 }*
%246 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %245, i32 0, i32 0
%lo175 = load i8*, i8** %246, align 8
%247 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %245, i32 0, i32 1
%hi176 = load i64, i64* %247, align 8
%248 = call i64 @std_io_printfln(i64* %retparam169, i8* %lo171, i64 %hi172, i8* %lo175, i64 %hi176)
%not_err177 = icmp eq i64 %248, 0
br i1 %not_err177, label %after_check178, label %voiderr179
after_check178: ; preds = %loop.body166
br label %voiderr179
voiderr179: ; preds = %after_check178, %loop.body166
%249 = load i64, i64* %.anon163, align 8
%add180 = add i64 %249, 1
store i64 %add180, i64* %.anon163, align 8
br label %loop.cond164
loop.exit181: ; preds = %loop.cond164
%250 = bitcast [8 x i32]* %c to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %250, i8* align 16 bitcast ([8 x i32]* @.__const.19 to i8*), i32 32, i1 false)
store i64 0, i64* %.anon182, align 8
br label %loop.cond183
loop.cond183: ; preds = %voiderr198, %loop.exit181
%251 = load i64, i64* %.anon182, align 8
%gt184 = icmp ugt i64 8, %251
br i1 %gt184, label %loop.body185, label %loop.exit200
loop.body185: ; preds = %loop.cond183
%252 = load i64, i64* %.anon182, align 8
store i64 %252, i64* %i186, align 8
%253 = load i64, i64* %.anon182, align 8
%254 = getelementptr inbounds [8 x i32], [8 x i32]* %c, i64 0, i64 %253
%255 = load i32, i32* %254, align 4
store i32 %255, i32* %x187, align 4
store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.20, i32 0, i32 0), i64 9 }, %"char[]"* %taddr189, align 8
%256 = bitcast %"char[]"* %taddr189 to { i8*, i64 }*
%257 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %256, i32 0, i32 0
%lo190 = load i8*, i8** %257, align 8
%258 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %256, i32 0, i32 1
%hi191 = load i64, i64* %258, align 8
%259 = bitcast i64* %i186 to i8*
%260 = insertvalue %variant undef, i8* %259, 0
%261 = insertvalue %variant %260, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%262 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots193, i64 0, i64 0
store %variant %261, %variant* %262, align 16
%263 = bitcast i32* %x187 to i8*
%264 = insertvalue %variant undef, i8* %263, 0
%265 = insertvalue %variant %264, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%266 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots193, i64 0, i64 1
store %variant %265, %variant* %266, align 16
%267 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg192, i32 0, i32 1
store i64 2, i64* %267, align 8
%268 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg192, i32 0, i32 0
%269 = bitcast [2 x %variant]* %varargslots193 to %variant*
store %variant* %269, %variant** %268, align 8
%270 = bitcast %"variant[]"* %vararg192 to { i8*, i64 }*
%271 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 0
%lo194 = load i8*, i8** %271, align 8
%272 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 1
%hi195 = load i64, i64* %272, align 8
%273 = call i64 @std_io_printfln(i64* %retparam188, i8* %lo190, i64 %hi191, i8* %lo194, i64 %hi195)
%not_err196 = icmp eq i64 %273, 0
br i1 %not_err196, label %after_check197, label %voiderr198
after_check197: ; preds = %loop.body185
br label %voiderr198
voiderr198: ; preds = %after_check197, %loop.body185
%274 = load i64, i64* %.anon182, align 8
%add199 = add i64 %274, 1
store i64 %add199, i64* %.anon182, align 8
br label %loop.cond183
loop.exit200: ; preds = %loop.cond183
%275 = bitcast [6 x i32]* %a201 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %275, i8* align 16 bitcast ([6 x i32]* @.__const.21 to i8*), i32 24, i1 false)
store i64 0, i64* %.anon202, align 8
br label %loop.cond203
loop.cond203: ; preds = %voiderr218, %loop.exit200
%276 = load i64, i64* %.anon202, align 8
%gt204 = icmp ugt i64 6, %276
br i1 %gt204, label %loop.body205, label %loop.exit220
loop.body205: ; preds = %loop.cond203
%277 = load i64, i64* %.anon202, align 8
store i64 %277, i64* %i206, align 8
%278 = load i64, i64* %.anon202, align 8
%279 = getelementptr inbounds [6 x i32], [6 x i32]* %a201, i64 0, i64 %278
%280 = load i32, i32* %279, align 4
store i32 %280, i32* %x207, align 4
store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i32 0, i32 0), i64 6 }, %"char[]"* %taddr209, align 8
%281 = bitcast %"char[]"* %taddr209 to { i8*, i64 }*
%282 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %281, i32 0, i32 0
%lo210 = load i8*, i8** %282, align 8
%283 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %281, i32 0, i32 1
%hi211 = load i64, i64* %283, align 8
%284 = bitcast i64* %i206 to i8*
%285 = insertvalue %variant undef, i8* %284, 0
%286 = insertvalue %variant %285, i64 ptrtoint (%.introspect* @"ct$ulong" to i64), 1
%287 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots213, i64 0, i64 0
store %variant %286, %variant* %287, align 16
%288 = bitcast i32* %x207 to i8*
%289 = insertvalue %variant undef, i8* %288, 0
%290 = insertvalue %variant %289, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%291 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots213, i64 0, i64 1
store %variant %290, %variant* %291, align 16
%292 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg212, i32 0, i32 1
store i64 2, i64* %292, align 8
%293 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg212, i32 0, i32 0
%294 = bitcast [2 x %variant]* %varargslots213 to %variant*
store %variant* %294, %variant** %293, align 8
%295 = bitcast %"variant[]"* %vararg212 to { i8*, i64 }*
%296 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %295, i32 0, i32 0
%lo214 = load i8*, i8** %296, align 8
%297 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %295, i32 0, i32 1
%hi215 = load i64, i64* %297, align 8
%298 = call i64 @std_io_printfln(i64* %retparam208, i8* %lo210, i64 %hi211, i8* %lo214, i64 %hi215)
%not_err216 = icmp eq i64 %298, 0
br i1 %not_err216, label %after_check217, label %voiderr218
after_check217: ; preds = %loop.body205
br label %voiderr218
voiderr218: ; preds = %after_check217, %loop.body205
%299 = load i64, i64* %.anon202, align 8
%add219 = add i64 %299, 1
store i64 %add219, i64* %.anon202, align 8
br label %loop.cond203
loop.exit220: ; preds = %loop.cond203
ret void
}

6
test/test_suite2/macros/macro_untyped_varargs_2.c3t
View File

@@ -8,14 +8,14 @@ macro @foo(...)
{
int i = $vaarg(1) + $vaarg(1);
int j = $vaexpr(2) + $vaexpr(2);
$for (var $i = 0; $i < $vacount(); $i++):
$for (var $i = 0; $i < $vacount; $i++):
io::printfln("%d", $vaarg($i));
$endfor;
}
macro foo2(...)
{
$for (var $i = 0; $i < $vacount(); $i++):
$for (var $i = 0; $i < $vacount; $i++):
{
$vatype($i) x;
}
@@ -26,7 +26,7 @@ macro foo2(...)
macro foo3(...)
{
var $x = 0;
$for (var $i = 0; $i < $vacount(); $i++):
$for (var $i = 0; $i < $vacount; $i++):
$x += $vaconst($i);
$endfor;
return $x;

777
test/test_suite2/macros/macro_vasplat.c3t Normal file
View File

@@ -0,0 +1,777 @@
// #target: macos-x64
module test;
import std::io;
macro @hello(...)
{
int[*] a = { 1, $vasplat(), 3 };
foreach (i, x : a) io::printfln("%d: %d", i, x);
}
macro @hello1(...)
{
int[*] a = { 1, $vasplat() };
foreach (i, x : a) io::printfln("x:%d: %d", i, x);
}
macro @hello2(...)
{
int[*] a = { $vasplat(), 888 };
foreach (i, x : a) io::printfln("x:%d: %d", i, x);
}
macro @hello3(...)
{
int[*] a = { $vasplat() };
foreach (i, x : a) io::printfln("x:%d: %d", i, x);
}
macro @hello4(...)
{
int[*] a = { 5, $vasplat(2..4), 77 };
foreach (i, x : a) io::printfln("y:%d: %d", i, x);
}
macro @hello5(...)
{
int[*] a = { 5, $vasplat(2..), 77 };
foreach (i, x : a) io::printfln("y:%d: %d", i, x);
int[*] b = { 55, $vasplat(2..^2), 88 };
foreach (i, x : b) io::printfln("z:%d: %d", i, x);
int[*] c = { 55, $vasplat(0:^2), 88 };
foreach (i, x : c) io::printfln("zz:%d: %d", i, x);
}
macro @hello6(...)
{
@hello(66, $vasplat());
}
fn void main()
{
@hello1(223, 326);
@hello1();
@hello(26, 36);
@hello();
@hello2(2123, 3326);
@hello2();
@hello3(2123, 3326);
@hello4(1, 2, 3, 4, 5, 6, 7, 8);
@hello5(1, 2, 3, 4, 5, 6, 7, 8);
@hello6(1, 2, 3);
}
/* #expect: test.ll
define void @test_main() #0 {
entry:
%a = alloca [3 x i32], align 4
%.anon = alloca i64, align 8
%i = alloca i64, align 8
%x = alloca i32, align 4
%retparam = alloca i64, align 8
%taddr = alloca %"char[]", align 8
%vararg = alloca %"variant[]", align 8
%varargslots = alloca [2 x %variant], align 16
%a3 = alloca [1 x i32], align 4
%.anon4 = alloca i64, align 8
%i8 = alloca i64, align 8
%x9 = alloca i32, align 4
%retparam10 = alloca i64, align 8
%taddr11 = alloca %"char[]", align 8
%vararg14 = alloca %"variant[]", align 8
%varargslots15 = alloca [2 x %variant], align 16
%a23 = alloca [4 x i32], align 16
%.anon24 = alloca i64, align 8
%i28 = alloca i64, align 8
%x29 = alloca i32, align 4
%retparam30 = alloca i64, align 8
%taddr31 = alloca %"char[]", align 8
%vararg34 = alloca %"variant[]", align 8
%varargslots35 = alloca [2 x %variant], align 16
%a43 = alloca [2 x i32], align 4
%.anon44 = alloca i64, align 8
%i48 = alloca i64, align 8
%x49 = alloca i32, align 4
%retparam50 = alloca i64, align 8
%taddr51 = alloca %"char[]", align 8
%vararg54 = alloca %"variant[]", align 8
%varargslots55 = alloca [2 x %variant], align 16
%a63 = alloca [3 x i32], align 4
%.anon64 = alloca i64, align 8
%i68 = alloca i64, align 8
%x69 = alloca i32, align 4
%retparam70 = alloca i64, align 8
%taddr71 = alloca %"char[]", align 8
%vararg74 = alloca %"variant[]", align 8
%varargslots75 = alloca [2 x %variant], align 16
%a83 = alloca [1 x i32], align 4
%.anon84 = alloca i64, align 8
%i88 = alloca i64, align 8
%x89 = alloca i32, align 4
%retparam90 = alloca i64, align 8
%taddr91 = alloca %"char[]", align 8
%vararg94 = alloca %"variant[]", align 8
%varargslots95 = alloca [2 x %variant], align 16
%a103 = alloca [2 x i32], align 4
%.anon104 = alloca i64, align 8
%i108 = alloca i64, align 8
%x109 = alloca i32, align 4
%retparam110 = alloca i64, align 8
%taddr111 = alloca %"char[]", align 8
%vararg114 = alloca %"variant[]", align 8
%varargslots115 = alloca [2 x %variant], align 16
%a123 = alloca [5 x i32], align 16
%.anon124 = alloca i64, align 8
%i128 = alloca i64, align 8
%x129 = alloca i32, align 4
%retparam130 = alloca i64, align 8
%taddr131 = alloca %"char[]", align 8
%vararg134 = alloca %"variant[]", align 8
%varargslots135 = alloca [2 x %variant], align 16
%a143 = alloca [8 x i32], align 16
%.anon144 = alloca i64, align 8
%i148 = alloca i64, align 8
%x149 = alloca i32, align 4
%retparam150 = alloca i64, align 8
%taddr151 = alloca %"char[]", align 8
%vararg154 = alloca %"variant[]", align 8
%varargslots155 = alloca [2 x %variant], align 16
%b = alloca [7 x i32], align 16
%.anon163 = alloca i64, align 8
%i167 = alloca i64, align 8
%x168 = alloca i32, align 4
%retparam169 = alloca i64, align 8
%taddr170 = alloca %"char[]", align 8
%vararg173 = alloca %"variant[]", align 8
%varargslots174 = alloca [2 x %variant], align 16
%c = alloca [8 x i32], align 16
%.anon182 = alloca i64, align 8
%i186 = alloca i64, align 8
%x187 = alloca i32, align 4
%retparam188 = alloca i64, align 8
%taddr189 = alloca %"char[]", align 8
%vararg192 = alloca %"variant[]", align 8
%varargslots193 = alloca [2 x %variant], align 16
%a201 = alloca [6 x i32], align 16
%.anon202 = alloca i64, align 8
%i206 = alloca i64, align 8
%x207 = alloca i32, align 4
%retparam208 = alloca i64, align 8
%taddr209 = alloca %"char[]", align 8
%vararg212 = alloca %"variant[]", align 8
%varargslots213 = alloca [2 x %variant], align 16
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const, i32 12, i1 false)
store i64 0, ptr %.anon, align 8
br label %loop.cond
loop.cond: ; preds = %voiderr, %entry
%0 = load i64, ptr %.anon, align 8
%gt = icmp ugt i64 3, %0
br i1 %gt, label %loop.body, label %loop.exit
loop.body: ; preds = %loop.cond
%1 = load i64, ptr %.anon, align 8
store i64 %1, ptr %i, align 8
%2 = load i64, ptr %.anon, align 8
%3 = getelementptr inbounds [3 x i32], ptr %a, i64 0, i64 %2
%4 = load i32, ptr %3, align 4
store i32 %4, ptr %x, align 4
store %"char[]" { ptr @.str, i64 8 }, ptr %taddr, align 8
%5 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
%lo = load ptr, ptr %5, align 8
%6 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
%hi = load i64, ptr %6, align 8
%7 = insertvalue %variant undef, ptr %i, 0
%8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %8, ptr %9, align 16
%10 = insertvalue %variant undef, ptr %x, 0
%11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$int" to i64), 1
%12 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
store %variant %11, ptr %12, align 16
%13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
store i64 2, ptr %13, align 8
%14 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
store ptr %varargslots, ptr %14, align 8
%15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
%lo1 = load ptr, ptr %15, align 8
%16 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
%hi2 = load i64, ptr %16, align 8
%17 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2)
%not_err = icmp eq i64 %17, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %loop.body
br label %voiderr
voiderr: ; preds = %after_check, %loop.body
%18 = load i64, ptr %.anon, align 8
%add = add i64 %18, 1
store i64 %add, ptr %.anon, align 8
br label %loop.cond
loop.exit: ; preds = %loop.cond
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a3, ptr align 4 @.__const.1, i32 4, i1 false)
store i64 0, ptr %.anon4, align 8
br label %loop.cond5
loop.cond5: ; preds = %voiderr20, %loop.exit
%19 = load i64, ptr %.anon4, align 8
%gt6 = icmp ugt i64 1, %19
br i1 %gt6, label %loop.body7, label %loop.exit22
loop.body7: ; preds = %loop.cond5
%20 = load i64, ptr %.anon4, align 8
store i64 %20, ptr %i8, align 8
%21 = load i64, ptr %.anon4, align 8
%22 = getelementptr inbounds [1 x i32], ptr %a3, i64 0, i64 %21
%23 = load i32, ptr %22, align 4
store i32 %23, ptr %x9, align 4
store %"char[]" { ptr @.str.2, i64 8 }, ptr %taddr11, align 8
%24 = getelementptr inbounds { ptr, i64 }, ptr %taddr11, i32 0, i32 0
%lo12 = load ptr, ptr %24, align 8
%25 = getelementptr inbounds { ptr, i64 }, ptr %taddr11, i32 0, i32 1
%hi13 = load i64, ptr %25, align 8
%26 = insertvalue %variant undef, ptr %i8, 0
%27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%28 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 0
store %variant %27, ptr %28, align 16
%29 = insertvalue %variant undef, ptr %x9, 0
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1
%31 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 1
store %variant %30, ptr %31, align 16
%32 = getelementptr inbounds %"variant[]", ptr %vararg14, i32 0, i32 1
store i64 2, ptr %32, align 8
%33 = getelementptr inbounds %"variant[]", ptr %vararg14, i32 0, i32 0
store ptr %varargslots15, ptr %33, align 8
%34 = getelementptr inbounds { ptr, i64 }, ptr %vararg14, i32 0, i32 0
%lo16 = load ptr, ptr %34, align 8
%35 = getelementptr inbounds { ptr, i64 }, ptr %vararg14, i32 0, i32 1
%hi17 = load i64, ptr %35, align 8
%36 = call i64 @std_io_printfln(ptr %retparam10, ptr %lo12, i64 %hi13, ptr %lo16, i64 %hi17)
%not_err18 = icmp eq i64 %36, 0
br i1 %not_err18, label %after_check19, label %voiderr20
after_check19: ; preds = %loop.body7
br label %voiderr20
voiderr20: ; preds = %after_check19, %loop.body7
%37 = load i64, ptr %.anon4, align 8
%add21 = add i64 %37, 1
store i64 %add21, ptr %.anon4, align 8
br label %loop.cond5
loop.exit22: ; preds = %loop.cond5
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a23, ptr align 16 @.__const.3, i32 16, i1 false)
store i64 0, ptr %.anon24, align 8
br label %loop.cond25
loop.cond25: ; preds = %voiderr40, %loop.exit22
%38 = load i64, ptr %.anon24, align 8
%gt26 = icmp ugt i64 4, %38
br i1 %gt26, label %loop.body27, label %loop.exit42
loop.body27: ; preds = %loop.cond25
%39 = load i64, ptr %.anon24, align 8
store i64 %39, ptr %i28, align 8
%40 = load i64, ptr %.anon24, align 8
%41 = getelementptr inbounds [4 x i32], ptr %a23, i64 0, i64 %40
%42 = load i32, ptr %41, align 4
store i32 %42, ptr %x29, align 4
store %"char[]" { ptr @.str.4, i64 6 }, ptr %taddr31, align 8
%43 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 0
%lo32 = load ptr, ptr %43, align 8
%44 = getelementptr inbounds { ptr, i64 }, ptr %taddr31, i32 0, i32 1
%hi33 = load i64, ptr %44, align 8
%45 = insertvalue %variant undef, ptr %i28, 0
%46 = insertvalue %variant %45, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%47 = getelementptr inbounds [2 x %variant], ptr %varargslots35, i64 0, i64 0
store %variant %46, ptr %47, align 16
%48 = insertvalue %variant undef, ptr %x29, 0
%49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$int" to i64), 1
%50 = getelementptr inbounds [2 x %variant], ptr %varargslots35, i64 0, i64 1
store %variant %49, ptr %50, align 16
%51 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 1
store i64 2, ptr %51, align 8
%52 = getelementptr inbounds %"variant[]", ptr %vararg34, i32 0, i32 0
store ptr %varargslots35, ptr %52, align 8
%53 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 0
%lo36 = load ptr, ptr %53, align 8
%54 = getelementptr inbounds { ptr, i64 }, ptr %vararg34, i32 0, i32 1
%hi37 = load i64, ptr %54, align 8
%55 = call i64 @std_io_printfln(ptr %retparam30, ptr %lo32, i64 %hi33, ptr %lo36, i64 %hi37)
%not_err38 = icmp eq i64 %55, 0
br i1 %not_err38, label %after_check39, label %voiderr40
after_check39: ; preds = %loop.body27
br label %voiderr40
voiderr40: ; preds = %after_check39, %loop.body27
%56 = load i64, ptr %.anon24, align 8
%add41 = add i64 %56, 1
store i64 %add41, ptr %.anon24, align 8
br label %loop.cond25
loop.exit42: ; preds = %loop.cond25
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a43, ptr align 4 @.__const.5, i32 8, i1 false)
store i64 0, ptr %.anon44, align 8
br label %loop.cond45
loop.cond45: ; preds = %voiderr60, %loop.exit42
%57 = load i64, ptr %.anon44, align 8
%gt46 = icmp ugt i64 2, %57
br i1 %gt46, label %loop.body47, label %loop.exit62
loop.body47: ; preds = %loop.cond45
%58 = load i64, ptr %.anon44, align 8
store i64 %58, ptr %i48, align 8
%59 = load i64, ptr %.anon44, align 8
%60 = getelementptr inbounds [2 x i32], ptr %a43, i64 0, i64 %59
%61 = load i32, ptr %60, align 4
store i32 %61, ptr %x49, align 4
store %"char[]" { ptr @.str.6, i64 6 }, ptr %taddr51, align 8
%62 = getelementptr inbounds { ptr, i64 }, ptr %taddr51, i32 0, i32 0
%lo52 = load ptr, ptr %62, align 8
%63 = getelementptr inbounds { ptr, i64 }, ptr %taddr51, i32 0, i32 1
%hi53 = load i64, ptr %63, align 8
%64 = insertvalue %variant undef, ptr %i48, 0
%65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%66 = getelementptr inbounds [2 x %variant], ptr %varargslots55, i64 0, i64 0
store %variant %65, ptr %66, align 16
%67 = insertvalue %variant undef, ptr %x49, 0
%68 = insertvalue %variant %67, i64 ptrtoint (ptr @"ct$int" to i64), 1
%69 = getelementptr inbounds [2 x %variant], ptr %varargslots55, i64 0, i64 1
store %variant %68, ptr %69, align 16
%70 = getelementptr inbounds %"variant[]", ptr %vararg54, i32 0, i32 1
store i64 2, ptr %70, align 8
%71 = getelementptr inbounds %"variant[]", ptr %vararg54, i32 0, i32 0
store ptr %varargslots55, ptr %71, align 8
%72 = getelementptr inbounds { ptr, i64 }, ptr %vararg54, i32 0, i32 0
%lo56 = load ptr, ptr %72, align 8
%73 = getelementptr inbounds { ptr, i64 }, ptr %vararg54, i32 0, i32 1
%hi57 = load i64, ptr %73, align 8
%74 = call i64 @std_io_printfln(ptr %retparam50, ptr %lo52, i64 %hi53, ptr %lo56, i64 %hi57)
%not_err58 = icmp eq i64 %74, 0
br i1 %not_err58, label %after_check59, label %voiderr60
after_check59: ; preds = %loop.body47
br label %voiderr60
voiderr60: ; preds = %after_check59, %loop.body47
%75 = load i64, ptr %.anon44, align 8
%add61 = add i64 %75, 1
store i64 %add61, ptr %.anon44, align 8
br label %loop.cond45
loop.exit62: ; preds = %loop.cond45
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a63, ptr align 4 @.__const.7, i32 12, i1 false)
store i64 0, ptr %.anon64, align 8
br label %loop.cond65
loop.cond65: ; preds = %voiderr80, %loop.exit62
%76 = load i64, ptr %.anon64, align 8
%gt66 = icmp ugt i64 3, %76
br i1 %gt66, label %loop.body67, label %loop.exit82
loop.body67: ; preds = %loop.cond65
%77 = load i64, ptr %.anon64, align 8
store i64 %77, ptr %i68, align 8
%78 = load i64, ptr %.anon64, align 8
%79 = getelementptr inbounds [3 x i32], ptr %a63, i64 0, i64 %78
%80 = load i32, ptr %79, align 4
store i32 %80, ptr %x69, align 4
store %"char[]" { ptr @.str.8, i64 8 }, ptr %taddr71, align 8
%81 = getelementptr inbounds { ptr, i64 }, ptr %taddr71, i32 0, i32 0
%lo72 = load ptr, ptr %81, align 8
%82 = getelementptr inbounds { ptr, i64 }, ptr %taddr71, i32 0, i32 1
%hi73 = load i64, ptr %82, align 8
%83 = insertvalue %variant undef, ptr %i68, 0
%84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%85 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 0
store %variant %84, ptr %85, align 16
%86 = insertvalue %variant undef, ptr %x69, 0
%87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$int" to i64), 1
%88 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 1
store %variant %87, ptr %88, align 16
%89 = getelementptr inbounds %"variant[]", ptr %vararg74, i32 0, i32 1
store i64 2, ptr %89, align 8
%90 = getelementptr inbounds %"variant[]", ptr %vararg74, i32 0, i32 0
store ptr %varargslots75, ptr %90, align 8
%91 = getelementptr inbounds { ptr, i64 }, ptr %vararg74, i32 0, i32 0
%lo76 = load ptr, ptr %91, align 8
%92 = getelementptr inbounds { ptr, i64 }, ptr %vararg74, i32 0, i32 1
%hi77 = load i64, ptr %92, align 8
%93 = call i64 @std_io_printfln(ptr %retparam70, ptr %lo72, i64 %hi73, ptr %lo76, i64 %hi77)
%not_err78 = icmp eq i64 %93, 0
br i1 %not_err78, label %after_check79, label %voiderr80
after_check79: ; preds = %loop.body67
br label %voiderr80
voiderr80: ; preds = %after_check79, %loop.body67
%94 = load i64, ptr %.anon64, align 8
%add81 = add i64 %94, 1
store i64 %add81, ptr %.anon64, align 8
br label %loop.cond65
loop.exit82: ; preds = %loop.cond65
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a83, ptr align 4 @.__const.9, i32 4, i1 false)
store i64 0, ptr %.anon84, align 8
br label %loop.cond85
loop.cond85: ; preds = %voiderr100, %loop.exit82
%95 = load i64, ptr %.anon84, align 8
%gt86 = icmp ugt i64 1, %95
br i1 %gt86, label %loop.body87, label %loop.exit102
loop.body87: ; preds = %loop.cond85
%96 = load i64, ptr %.anon84, align 8
store i64 %96, ptr %i88, align 8
%97 = load i64, ptr %.anon84, align 8
%98 = getelementptr inbounds [1 x i32], ptr %a83, i64 0, i64 %97
%99 = load i32, ptr %98, align 4
store i32 %99, ptr %x89, align 4
store %"char[]" { ptr @.str.10, i64 8 }, ptr %taddr91, align 8
%100 = getelementptr inbounds { ptr, i64 }, ptr %taddr91, i32 0, i32 0
%lo92 = load ptr, ptr %100, align 8
%101 = getelementptr inbounds { ptr, i64 }, ptr %taddr91, i32 0, i32 1
%hi93 = load i64, ptr %101, align 8
%102 = insertvalue %variant undef, ptr %i88, 0
%103 = insertvalue %variant %102, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%104 = getelementptr inbounds [2 x %variant], ptr %varargslots95, i64 0, i64 0
store %variant %103, ptr %104, align 16
%105 = insertvalue %variant undef, ptr %x89, 0
%106 = insertvalue %variant %105, i64 ptrtoint (ptr @"ct$int" to i64), 1
%107 = getelementptr inbounds [2 x %variant], ptr %varargslots95, i64 0, i64 1
store %variant %106, ptr %107, align 16
%108 = getelementptr inbounds %"variant[]", ptr %vararg94, i32 0, i32 1
store i64 2, ptr %108, align 8
%109 = getelementptr inbounds %"variant[]", ptr %vararg94, i32 0, i32 0
store ptr %varargslots95, ptr %109, align 8
%110 = getelementptr inbounds { ptr, i64 }, ptr %vararg94, i32 0, i32 0
%lo96 = load ptr, ptr %110, align 8
%111 = getelementptr inbounds { ptr, i64 }, ptr %vararg94, i32 0, i32 1
%hi97 = load i64, ptr %111, align 8
%112 = call i64 @std_io_printfln(ptr %retparam90, ptr %lo92, i64 %hi93, ptr %lo96, i64 %hi97)
%not_err98 = icmp eq i64 %112, 0
br i1 %not_err98, label %after_check99, label %voiderr100
after_check99: ; preds = %loop.body87
br label %voiderr100
voiderr100: ; preds = %after_check99, %loop.body87
%113 = load i64, ptr %.anon84, align 8
%add101 = add i64 %113, 1
store i64 %add101, ptr %.anon84, align 8
br label %loop.cond85
loop.exit102: ; preds = %loop.cond85
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a103, ptr align 4 @.__const.11, i32 8, i1 false)
store i64 0, ptr %.anon104, align 8
br label %loop.cond105
loop.cond105: ; preds = %voiderr120, %loop.exit102
%114 = load i64, ptr %.anon104, align 8
%gt106 = icmp ugt i64 2, %114
br i1 %gt106, label %loop.body107, label %loop.exit122
loop.body107: ; preds = %loop.cond105
%115 = load i64, ptr %.anon104, align 8
store i64 %115, ptr %i108, align 8
%116 = load i64, ptr %.anon104, align 8
%117 = getelementptr inbounds [2 x i32], ptr %a103, i64 0, i64 %116
%118 = load i32, ptr %117, align 4
store i32 %118, ptr %x109, align 4
store %"char[]" { ptr @.str.12, i64 8 }, ptr %taddr111, align 8
%119 = getelementptr inbounds { ptr, i64 }, ptr %taddr111, i32 0, i32 0
%lo112 = load ptr, ptr %119, align 8
%120 = getelementptr inbounds { ptr, i64 }, ptr %taddr111, i32 0, i32 1
%hi113 = load i64, ptr %120, align 8
%121 = insertvalue %variant undef, ptr %i108, 0
%122 = insertvalue %variant %121, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%123 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 0
store %variant %122, ptr %123, align 16
%124 = insertvalue %variant undef, ptr %x109, 0
%125 = insertvalue %variant %124, i64 ptrtoint (ptr @"ct$int" to i64), 1
%126 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 1
store %variant %125, ptr %126, align 16
%127 = getelementptr inbounds %"variant[]", ptr %vararg114, i32 0, i32 1
store i64 2, ptr %127, align 8
%128 = getelementptr inbounds %"variant[]", ptr %vararg114, i32 0, i32 0
store ptr %varargslots115, ptr %128, align 8
%129 = getelementptr inbounds { ptr, i64 }, ptr %vararg114, i32 0, i32 0
%lo116 = load ptr, ptr %129, align 8
%130 = getelementptr inbounds { ptr, i64 }, ptr %vararg114, i32 0, i32 1
%hi117 = load i64, ptr %130, align 8
%131 = call i64 @std_io_printfln(ptr %retparam110, ptr %lo112, i64 %hi113, ptr %lo116, i64 %hi117)
%not_err118 = icmp eq i64 %131, 0
br i1 %not_err118, label %after_check119, label %voiderr120
after_check119: ; preds = %loop.body107
br label %voiderr120
voiderr120: ; preds = %after_check119, %loop.body107
%132 = load i64, ptr %.anon104, align 8
%add121 = add i64 %132, 1
store i64 %add121, ptr %.anon104, align 8
br label %loop.cond105
loop.exit122: ; preds = %loop.cond105
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a123, ptr align 16 @.__const.13, i32 20, i1 false)
store i64 0, ptr %.anon124, align 8
br label %loop.cond125
loop.cond125: ; preds = %voiderr140, %loop.exit122
%133 = load i64, ptr %.anon124, align 8
%gt126 = icmp ugt i64 5, %133
br i1 %gt126, label %loop.body127, label %loop.exit142
loop.body127: ; preds = %loop.cond125
%134 = load i64, ptr %.anon124, align 8
store i64 %134, ptr %i128, align 8
%135 = load i64, ptr %.anon124, align 8
%136 = getelementptr inbounds [5 x i32], ptr %a123, i64 0, i64 %135
%137 = load i32, ptr %136, align 4
store i32 %137, ptr %x129, align 4
store %"char[]" { ptr @.str.14, i64 8 }, ptr %taddr131, align 8
%138 = getelementptr inbounds { ptr, i64 }, ptr %taddr131, i32 0, i32 0
%lo132 = load ptr, ptr %138, align 8
%139 = getelementptr inbounds { ptr, i64 }, ptr %taddr131, i32 0, i32 1
%hi133 = load i64, ptr %139, align 8
%140 = insertvalue %variant undef, ptr %i128, 0
%141 = insertvalue %variant %140, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%142 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 0
store %variant %141, ptr %142, align 16
%143 = insertvalue %variant undef, ptr %x129, 0
%144 = insertvalue %variant %143, i64 ptrtoint (ptr @"ct$int" to i64), 1
%145 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 1
store %variant %144, ptr %145, align 16
%146 = getelementptr inbounds %"variant[]", ptr %vararg134, i32 0, i32 1
store i64 2, ptr %146, align 8
%147 = getelementptr inbounds %"variant[]", ptr %vararg134, i32 0, i32 0
store ptr %varargslots135, ptr %147, align 8
%148 = getelementptr inbounds { ptr, i64 }, ptr %vararg134, i32 0, i32 0
%lo136 = load ptr, ptr %148, align 8
%149 = getelementptr inbounds { ptr, i64 }, ptr %vararg134, i32 0, i32 1
%hi137 = load i64, ptr %149, align 8
%150 = call i64 @std_io_printfln(ptr %retparam130, ptr %lo132, i64 %hi133, ptr %lo136, i64 %hi137)
%not_err138 = icmp eq i64 %150, 0
br i1 %not_err138, label %after_check139, label %voiderr140
after_check139: ; preds = %loop.body127
br label %voiderr140
voiderr140: ; preds = %after_check139, %loop.body127
%151 = load i64, ptr %.anon124, align 8
%add141 = add i64 %151, 1
store i64 %add141, ptr %.anon124, align 8
br label %loop.cond125
loop.exit142: ; preds = %loop.cond125
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a143, ptr align 16 @.__const.15, i32 32, i1 false)
store i64 0, ptr %.anon144, align 8
br label %loop.cond145
loop.cond145: ; preds = %voiderr160, %loop.exit142
%152 = load i64, ptr %.anon144, align 8
%gt146 = icmp ugt i64 8, %152
br i1 %gt146, label %loop.body147, label %loop.exit162
loop.body147: ; preds = %loop.cond145
%153 = load i64, ptr %.anon144, align 8
store i64 %153, ptr %i148, align 8
%154 = load i64, ptr %.anon144, align 8
%155 = getelementptr inbounds [8 x i32], ptr %a143, i64 0, i64 %154
%156 = load i32, ptr %155, align 4
store i32 %156, ptr %x149, align 4
store %"char[]" { ptr @.str.16, i64 8 }, ptr %taddr151, align 8
%157 = getelementptr inbounds { ptr, i64 }, ptr %taddr151, i32 0, i32 0
%lo152 = load ptr, ptr %157, align 8
%158 = getelementptr inbounds { ptr, i64 }, ptr %taddr151, i32 0, i32 1
%hi153 = load i64, ptr %158, align 8
%159 = insertvalue %variant undef, ptr %i148, 0
%160 = insertvalue %variant %159, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%161 = getelementptr inbounds [2 x %variant], ptr %varargslots155, i64 0, i64 0
store %variant %160, ptr %161, align 16
%162 = insertvalue %variant undef, ptr %x149, 0
%163 = insertvalue %variant %162, i64 ptrtoint (ptr @"ct$int" to i64), 1
%164 = getelementptr inbounds [2 x %variant], ptr %varargslots155, i64 0, i64 1
store %variant %163, ptr %164, align 16
%165 = getelementptr inbounds %"variant[]", ptr %vararg154, i32 0, i32 1
store i64 2, ptr %165, align 8
%166 = getelementptr inbounds %"variant[]", ptr %vararg154, i32 0, i32 0
store ptr %varargslots155, ptr %166, align 8
%167 = getelementptr inbounds { ptr, i64 }, ptr %vararg154, i32 0, i32 0
%lo156 = load ptr, ptr %167, align 8
%168 = getelementptr inbounds { ptr, i64 }, ptr %vararg154, i32 0, i32 1
%hi157 = load i64, ptr %168, align 8
%169 = call i64 @std_io_printfln(ptr %retparam150, ptr %lo152, i64 %hi153, ptr %lo156, i64 %hi157)
%not_err158 = icmp eq i64 %169, 0
br i1 %not_err158, label %after_check159, label %voiderr160
after_check159: ; preds = %loop.body147
br label %voiderr160
voiderr160: ; preds = %after_check159, %loop.body147
%170 = load i64, ptr %.anon144, align 8
%add161 = add i64 %170, 1
store i64 %add161, ptr %.anon144, align 8
br label %loop.cond145
loop.exit162: ; preds = %loop.cond145
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %b, ptr align 16 @.__const.17, i32 28, i1 false)
store i64 0, ptr %.anon163, align 8
br label %loop.cond164
loop.cond164: ; preds = %voiderr179, %loop.exit162
%171 = load i64, ptr %.anon163, align 8
%gt165 = icmp ugt i64 7, %171
br i1 %gt165, label %loop.body166, label %loop.exit181
loop.body166: ; preds = %loop.cond164
%172 = load i64, ptr %.anon163, align 8
store i64 %172, ptr %i167, align 8
%173 = load i64, ptr %.anon163, align 8
%174 = getelementptr inbounds [7 x i32], ptr %b, i64 0, i64 %173
%175 = load i32, ptr %174, align 4
store i32 %175, ptr %x168, align 4
store %"char[]" { ptr @.str.18, i64 8 }, ptr %taddr170, align 8
%176 = getelementptr inbounds { ptr, i64 }, ptr %taddr170, i32 0, i32 0
%lo171 = load ptr, ptr %176, align 8
%177 = getelementptr inbounds { ptr, i64 }, ptr %taddr170, i32 0, i32 1
%hi172 = load i64, ptr %177, align 8
%178 = insertvalue %variant undef, ptr %i167, 0
%179 = insertvalue %variant %178, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%180 = getelementptr inbounds [2 x %variant], ptr %varargslots174, i64 0, i64 0
store %variant %179, ptr %180, align 16
%181 = insertvalue %variant undef, ptr %x168, 0
%182 = insertvalue %variant %181, i64 ptrtoint (ptr @"ct$int" to i64), 1
%183 = getelementptr inbounds [2 x %variant], ptr %varargslots174, i64 0, i64 1
store %variant %182, ptr %183, align 16
%184 = getelementptr inbounds %"variant[]", ptr %vararg173, i32 0, i32 1
store i64 2, ptr %184, align 8
%185 = getelementptr inbounds %"variant[]", ptr %vararg173, i32 0, i32 0
store ptr %varargslots174, ptr %185, align 8
%186 = getelementptr inbounds { ptr, i64 }, ptr %vararg173, i32 0, i32 0
%lo175 = load ptr, ptr %186, align 8
%187 = getelementptr inbounds { ptr, i64 }, ptr %vararg173, i32 0, i32 1
%hi176 = load i64, ptr %187, align 8
%188 = call i64 @std_io_printfln(ptr %retparam169, ptr %lo171, i64 %hi172, ptr %lo175, i64 %hi176)
%not_err177 = icmp eq i64 %188, 0
br i1 %not_err177, label %after_check178, label %voiderr179
after_check178: ; preds = %loop.body166
br label %voiderr179
voiderr179: ; preds = %after_check178, %loop.body166
%189 = load i64, ptr %.anon163, align 8
%add180 = add i64 %189, 1
store i64 %add180, ptr %.anon163, align 8
br label %loop.cond164
loop.exit181: ; preds = %loop.cond164
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %c, ptr align 16 @.__const.19, i32 32, i1 false)
store i64 0, ptr %.anon182, align 8
br label %loop.cond183
loop.cond183: ; preds = %voiderr198, %loop.exit181
%190 = load i64, ptr %.anon182, align 8
%gt184 = icmp ugt i64 8, %190
br i1 %gt184, label %loop.body185, label %loop.exit200
loop.body185: ; preds = %loop.cond183
%191 = load i64, ptr %.anon182, align 8
store i64 %191, ptr %i186, align 8
%192 = load i64, ptr %.anon182, align 8
%193 = getelementptr inbounds [8 x i32], ptr %c, i64 0, i64 %192
%194 = load i32, ptr %193, align 4
store i32 %194, ptr %x187, align 4
store %"char[]" { ptr @.str.20, i64 9 }, ptr %taddr189, align 8
%195 = getelementptr inbounds { ptr, i64 }, ptr %taddr189, i32 0, i32 0
%lo190 = load ptr, ptr %195, align 8
%196 = getelementptr inbounds { ptr, i64 }, ptr %taddr189, i32 0, i32 1
%hi191 = load i64, ptr %196, align 8
%197 = insertvalue %variant undef, ptr %i186, 0
%198 = insertvalue %variant %197, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%199 = getelementptr inbounds [2 x %variant], ptr %varargslots193, i64 0, i64 0
store %variant %198, ptr %199, align 16
%200 = insertvalue %variant undef, ptr %x187, 0
%201 = insertvalue %variant %200, i64 ptrtoint (ptr @"ct$int" to i64), 1
%202 = getelementptr inbounds [2 x %variant], ptr %varargslots193, i64 0, i64 1
store %variant %201, ptr %202, align 16
%203 = getelementptr inbounds %"variant[]", ptr %vararg192, i32 0, i32 1
store i64 2, ptr %203, align 8
%204 = getelementptr inbounds %"variant[]", ptr %vararg192, i32 0, i32 0
store ptr %varargslots193, ptr %204, align 8
%205 = getelementptr inbounds { ptr, i64 }, ptr %vararg192, i32 0, i32 0
%lo194 = load ptr, ptr %205, align 8
%206 = getelementptr inbounds { ptr, i64 }, ptr %vararg192, i32 0, i32 1
%hi195 = load i64, ptr %206, align 8
%207 = call i64 @std_io_printfln(ptr %retparam188, ptr %lo190, i64 %hi191, ptr %lo194, i64 %hi195)
%not_err196 = icmp eq i64 %207, 0
br i1 %not_err196, label %after_check197, label %voiderr198
after_check197: ; preds = %loop.body185
br label %voiderr198
voiderr198: ; preds = %after_check197, %loop.body185
%208 = load i64, ptr %.anon182, align 8
%add199 = add i64 %208, 1
store i64 %add199, ptr %.anon182, align 8
br label %loop.cond183
loop.exit200: ; preds = %loop.cond183
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %a201, ptr align 16 @.__const.21, i32 24, i1 false)
store i64 0, ptr %.anon202, align 8
br label %loop.cond203
loop.cond203: ; preds = %voiderr218, %loop.exit200
%209 = load i64, ptr %.anon202, align 8
%gt204 = icmp ugt i64 6, %209
br i1 %gt204, label %loop.body205, label %loop.exit220
loop.body205: ; preds = %loop.cond203
%210 = load i64, ptr %.anon202, align 8
store i64 %210, ptr %i206, align 8
%211 = load i64, ptr %.anon202, align 8
%212 = getelementptr inbounds [6 x i32], ptr %a201, i64 0, i64 %211
%213 = load i32, ptr %212, align 4
store i32 %213, ptr %x207, align 4
store %"char[]" { ptr @.str.22, i64 6 }, ptr %taddr209, align 8
%214 = getelementptr inbounds { ptr, i64 }, ptr %taddr209, i32 0, i32 0
%lo210 = load ptr, ptr %214, align 8
%215 = getelementptr inbounds { ptr, i64 }, ptr %taddr209, i32 0, i32 1
%hi211 = load i64, ptr %215, align 8
%216 = insertvalue %variant undef, ptr %i206, 0
%217 = insertvalue %variant %216, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
%218 = getelementptr inbounds [2 x %variant], ptr %varargslots213, i64 0, i64 0
store %variant %217, ptr %218, align 16
%219 = insertvalue %variant undef, ptr %x207, 0
%220 = insertvalue %variant %219, i64 ptrtoint (ptr @"ct$int" to i64), 1
%221 = getelementptr inbounds [2 x %variant], ptr %varargslots213, i64 0, i64 1
store %variant %220, ptr %221, align 16
%222 = getelementptr inbounds %"variant[]", ptr %vararg212, i32 0, i32 1
store i64 2, ptr %222, align 8
%223 = getelementptr inbounds %"variant[]", ptr %vararg212, i32 0, i32 0
store ptr %varargslots213, ptr %223, align 8
%224 = getelementptr inbounds { ptr, i64 }, ptr %vararg212, i32 0, i32 0
%lo214 = load ptr, ptr %224, align 8
%225 = getelementptr inbounds { ptr, i64 }, ptr %vararg212, i32 0, i32 1
%hi215 = load i64, ptr %225, align 8
%226 = call i64 @std_io_printfln(ptr %retparam208, ptr %lo210, i64 %hi211, ptr %lo214, i64 %hi215)
%not_err216 = icmp eq i64 %226, 0
br i1 %not_err216, label %after_check217, label %voiderr218
after_check217: ; preds = %loop.body205
br label %voiderr218
voiderr218: ; preds = %after_check217, %loop.body205
%227 = load i64, ptr %.anon202, align 8
%add219 = add i64 %227, 1
store i64 %add219, ptr %.anon202, align 8
br label %loop.cond203
loop.exit220: ; preds = %loop.cond203
ret void
}