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

Make string literals default to char[]

Browse Source
This commit is contained in:
Christoffer Lerno
2023-03-08 11:24:11 +01:00
parent cfba19ab77
commit 9b81623680
26 changed files with 1015 additions and 780 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/std/core/dstring.c3
View File

@@ -59,7 +59,7 @@ fn DString DString.new_tconcat(DString a, DString b) => a.new_concat(b, mem::tem
fn ZString DString.zstr(DString str)
{
StringData* data = str.data();
if (!data) return (ZString)"";
if (!data) return "";
if (data.capacity == data.len)
{
str.reserve(1);

1
src/compiler/compiler_internal.h
View File

@@ -1851,6 +1851,7 @@ extern Type *type_anyfail;
extern Type *type_cint;
extern Type *type_cuint;
extern Type *type_chars;
extern Type *type_string;
extern const char *attribute_list[NUMBER_OF_ATTRIBUTES];

2
src/compiler/expr.c
View File

@@ -933,7 +933,7 @@ void expr_rewrite_to_string(Expr *expr_to_rewrite, const char *string)
ArraySize len = (ArraySize)strlen(string);
expr_to_rewrite->const_expr.string.len = len;
expr_to_rewrite->resolve_status = RESOLVE_DONE;
expr_to_rewrite->type = type_get_ptr(type_get_array(type_char, len));
expr_to_rewrite->type = type_string;
}
void expr_rewrite_to_binary(Expr *expr_to_rewrite, Expr *left, Expr *right, BinaryOp op)

93
src/compiler/llvm_codegen_expr.c
View File

@@ -4471,59 +4471,68 @@ static void llvm_emit_const_expr(GenContext *c, BEValue *be_value, Expr *expr)
case CONST_STRING:
{
Type *str_type = type_lowering(expr->type);
bool is_array = type_flat_is_char_array(str_type);
if (llvm_is_local_eval(c) || !is_array)
bool is_array = str_type->type_kind == TYPE_ARRAY;
if (is_array && llvm_is_global_eval(c))
{
ArraySize strlen = expr->const_expr.string.len;
// In the global alloc case, create the byte array.
ArraySize array_len = str_type->array.len;
ArraySize size = expr->const_expr.string.len + 1;
if (type_flat_is_char_array(expr->type) && type->array.len > size) size = type->array.len;
LLVMValueRef global_name = llvm_add_global_raw(c,
".str",
LLVMArrayType(llvm_get_type(c, type_char), size),
1);
llvm_set_private_linkage(global_name);
LLVMSetUnnamedAddress(global_name, LLVMGlobalUnnamedAddr);
LLVMSetGlobalConstant(global_name, 1);
LLVMValueRef string = llvm_get_zstring(c, expr->const_expr.string.chars, expr->const_expr.string.len);
if (size > strlen + 1)
LLVMValueRef string;
if (array_len == size)
{
LLVMValueRef trailing_zeros = llvm_get_zero_raw(LLVMArrayType(c->byte_type, size - strlen - 1));
LLVMValueRef values[2] = { string, trailing_zeros };
string = llvm_get_packed_struct(c, values, 2);
string = llvm_get_zstring(c, expr->const_expr.string.chars, expr->const_expr.string.len);
}
LLVMSetInitializer(global_name, string);
if (is_array)
else if (array_len < size)
{
llvm_value_set_address(be_value, global_name, type, 1);
string = llvm_get_bytes(c, expr->const_expr.string.chars, array_len);
}
else
{
char *buffer = ccalloc(1, array_len);
memcpy(buffer, expr->const_expr.string.chars, expr->const_expr.string.len);
string = llvm_get_bytes(c, buffer, array_len);
}
llvm_value_set(be_value, string, type);
return;
}
// local case or creating a pointer / subarray.
// In this case we first create the constant.
ArraySize strlen = expr->const_expr.string.len;
if (strlen == 0 && str_type->type_kind == TYPE_SUBARRAY)
{
llvm_value_set(be_value, llvm_get_zero(c, expr->type), expr->type);
return;
}
ArraySize size = expr->const_expr.string.len + 1;
if (is_array && type->array.len > size) size = type->array.len;
LLVMValueRef global_name = llvm_add_global_raw(c, ".str", LLVMArrayType(llvm_get_type(c, type_char), size), 1);
llvm_set_private_linkage(global_name);
LLVMSetUnnamedAddress(global_name, LLVMGlobalUnnamedAddr);
LLVMSetGlobalConstant(global_name, 1);
LLVMValueRef string = llvm_get_zstring(c, expr->const_expr.string.chars, expr->const_expr.string.len);
if (size > strlen + 1)
{
LLVMValueRef trailing_zeros = llvm_get_zero_raw(LLVMArrayType(c->byte_type, size - strlen - 1));
LLVMValueRef values[2] = { string, trailing_zeros };
string = llvm_get_packed_struct(c, values, 2);
}
LLVMSetInitializer(global_name, string);
if (is_array)
{
llvm_value_set_address(be_value, global_name, type, 1);
}
else
{
if (str_type->type_kind == TYPE_SUBARRAY)
{
LLVMValueRef len = llvm_const_int(c, type_usz, strlen);
llvm_value_aggregate_two(c, be_value, str_type, global_name, len);
}
else
{
llvm_value_set(be_value, global_name, type);
}
return;
}
ArraySize array_len = type->array.len;
ArraySize size = expr->const_expr.string.len + 1;
bool zero_terminate = array_len == size;
LLVMValueRef string;
if (array_len <= size)
{
if (zero_terminate)
{
string = llvm_get_zstring(c, expr->const_expr.string.chars, expr->const_expr.string.len);
}
else
{
string = llvm_get_bytes(c, expr->const_expr.string.chars, array_len);
}
}
else
{
char *buffer = ccalloc(1, array_len);
memcpy(buffer, expr->const_expr.string.chars, expr->const_expr.string.len);
string = llvm_get_bytes(c, buffer, array_len);
}
llvm_value_set(be_value, string, type);
return;
}
case CONST_TYPEID:

4
src/compiler/parse_expr.c
View File

@@ -558,7 +558,7 @@ static Expr *parse_ct_stringify(ParseContext *c, Expr *left)
expr->const_expr.const_kind = CONST_STRING;
expr->const_expr.string.chars = content;
expr->const_expr.string.len = len;
expr->type = type_get_ptr(type_get_array(type_char, len));
expr->type = type_string;
return expr;
}
@@ -1622,7 +1622,7 @@ static Expr *parse_string_literal(ParseContext *c, Expr *left)
assert(str);
expr_string->const_expr.string.chars = str;
expr_string->const_expr.string.len = (uint32_t)len;
expr_string->type = type_get_ptr(type_get_array(type_char, len));
expr_string->type = type_string;
expr_string->const_expr.const_kind = CONST_STRING;
return expr_string;
}

47
src/compiler/sema_casts.c
View File

@@ -594,6 +594,7 @@ static bool vector_to_vector(Expr *expr, Type *to_type)
* Perform vararg promotions typical for C style varargs:
* 1. Widen int and bool to C int size
* 2. Widen float and smaller to double
* 3. Turn subarrays into pointers
*/
bool cast_promote_vararg(Expr *arg)
{
@@ -606,6 +607,9 @@ bool cast_promote_vararg(Expr *arg)
// 2. Promote any float to at least double
if (type_is_promotable_float(arg_type)) return cast(arg, type_double);
// 3. Turn subarrays into pointers
if (arg_type->type_kind == TYPE_SUBARRAY) return cast(arg, type_get_ptr(arg_type->array.base));
return true;
}
/**
@@ -1029,23 +1033,36 @@ static void sema_error_const_int_out_of_range(Expr *expr, Expr *problem, Type *t
}
static inline bool cast_maybe_string_lit_to_char_array(Expr *expr, Type *expr_canonical, Type *to_canonical, Type *to_original)
static inline bool cast_maybe_string_lit(Expr *expr, Type *to_canonical, Type *to_original)
{
if (expr->expr_kind != EXPR_CONST || expr->const_expr.const_kind != CONST_STRING) return false;
if (expr_canonical->type_kind != TYPE_POINTER) return false;
if (to_canonical->type_kind != TYPE_ARRAY && to_canonical->type_kind != TYPE_INFERRED_ARRAY) return false;
if (to_canonical->array.base != type_char) return false;
Type *pointer = expr_canonical->pointer;
if (pointer->type_kind != TYPE_ARRAY) return false;
if (pointer->array.base != type_char) return false;
assert(!type_is_optional(expr->type));
if (to_canonical->type_kind == TYPE_INFERRED_ARRAY)
if (expr->expr_kind != EXPR_CONST || expr->const_expr.const_kind != CONST_STRING || expr->type != type_string) return false;
Type *flat = type_flatten(to_canonical);
Type *indexed_type = type_get_indexed_type(flat);
if (indexed_type) indexed_type = type_flatten(indexed_type);
switch (flat->type_kind)
{
assert(to_original->type_kind == TYPE_INFERRED_ARRAY);
to_original = type_get_array(to_original->array.base, pointer->array.len);
case TYPE_SUBARRAY:
case TYPE_POINTER:
if (indexed_type != type_char && indexed_type != type_ichar) return false;
expr->type = to_original;
case TYPE_INFERRED_ARRAY:
if (indexed_type != type_char && indexed_type != type_ichar) return false;
expr->type = type_infer_len_from_actual_type(to_original, type_get_array(indexed_type, expr->const_expr.string.len));
return true;
break;
case TYPE_ARRAY:
if (indexed_type != type_char && indexed_type != type_ichar) return false;
{
ArraySize len = expr->const_expr.string.len;
ArraySize to_len = flat->array.len;
if (len > to_len) return false;
expr->type = to_original;
return true;
}
break;
default:
return false;
}
expr->type = to_original;
return true;
}
@@ -1568,7 +1585,7 @@ static bool cast_expr_inner(SemaContext *context, Expr *expr, Type *to_type, boo
// Handle strings, these don't actually mess with the underlying data,
// just the type.
if (cast_maybe_string_lit_to_char_array(expr, from, to, to_type)) return true;
if (cast_maybe_string_lit(expr, to, to_type)) return true;
// For constant pointers cast into anything pointer-like:
if (expr_is_const_pointer(expr) && from == type_voidptr && type_flatten(to)->type_kind == TYPE_POINTER)

6
src/compiler/sema_expr.c
View File

@@ -3572,6 +3572,12 @@ CHECK_DEEPER:
{
if (flat_type->type_kind == TYPE_SUBARRAY)
{
// Handle literal "foo".len which is now a subarray.
if (expr_is_const_string(parent))
{
expr_rewrite_const_int(expr, type_isz, parent->const_expr.string.len);
return true;
}
expr_rewrite_to_builtin_access(expr, current_parent, ACCESS_LEN, type_usz);
return true;
}

2
src/compiler/sema_stmts.c
View File

@@ -2198,7 +2198,7 @@ static inline bool sema_analyse_ct_switch_stmt(SemaContext *context, Ast *statem
case ALL_FLOATS:
case TYPE_BOOL:
break;
case TYPE_POINTER:
case TYPE_SUBARRAY:
if (expr_is_const_string(cond)) break;
FALLTHROUGH;
default:

2
src/compiler/types.c
View File

@@ -45,6 +45,7 @@ Type *type_untypedlist = &t.untyped_list;
Type *type_anyfail = &t.anyfail;
Type *type_member = &t.member;
Type *type_chars = NULL;
Type *type_string = NULL;
static unsigned size_subarray;
static AlignSize alignment_subarray;
@@ -1505,6 +1506,7 @@ void type_setup(PlatformTarget *target)
size_subarray = (unsigned)(alignment_subarray * 2);
type_init("anyerr", &t.anyerr, TYPE_ANYERR, target->width_pointer, target->align_pointer);
type_chars = type_get_subarray(type_char);
type_string = type_chars;
}
int type_kind_bitsize(TypeKind kind)

2
src/version.h
View File

@@ -1 +1 @@
#define COMPILER_VERSION "0.4.102"
#define COMPILER_VERSION "0.4.103"

10
test/test_suite/arrays/global_init.c3t
View File

@@ -32,8 +32,8 @@ fn void main() {
@test.bf3 = local_unnamed_addr global ptr getelementptr ([3 x i32], ptr @test.abc, i64 1, i64 1), align 8
@.taddr.9 = private global i32 42, align 4
@.taddr.10 = private global i8 99, align 1
@.taddr.11 = private global ptr @.str, align 8
@"main$x" = internal unnamed_addr global [3 x %variant] [%variant { ptr @.taddr.9, i64 ptrtoint (ptr @"$ct.int" to i64) }, %variant { ptr @.taddr.10, i64 ptrtoint (ptr @"$ct.char" to i64) }, %variant { ptr @.taddr.11, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64) }], align 16
@.taddr.11 = private global %"char[]" { ptr @.str, i64 3 }, align 8
@"main$x" = internal unnamed_addr global [3 x %variant] [%variant { ptr @.taddr.9, i64 ptrtoint (ptr @"$ct.int" to i64) }, %variant { ptr @.taddr.10, i64 ptrtoint (ptr @"$ct.char" to i64) }, %variant { ptr @.taddr.11, i64 ptrtoint (ptr @"$ct.sa$char" to i64) }], align 16
define void @test.main() #0 {
entry:
@@ -41,7 +41,7 @@ entry:
%y = alloca [3 x %variant], align 16
%taddr = alloca i32, align 4
%taddr1 = alloca i8, align 1
%taddr2 = alloca ptr, align 8
%taddr2 = alloca %"char[]", align 8
store ptr getelementptr ([3 x i32], ptr @test.abc, i64 2, i64 1), ptr %bf34, align 8
%0 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 0
store i32 42, ptr %taddr, align 4
@@ -54,9 +54,9 @@ entry:
%5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.char" to i64), 1
store %variant %5, ptr %3, align 16
%6 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 2
store ptr @.str.12, ptr %taddr2, align 8
store %"char[]" { ptr @.str.12, i64 3 }, ptr %taddr2, align 8
%7 = insertvalue %variant undef, ptr %taddr2, 0
%8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
%8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
store %variant %8, ptr %6, align 16
ret void
}

204
test/test_suite/bitstruct/bitstruct_be.c3t
View File

@@ -89,120 +89,132 @@ loop.body: ; preds = %loop.cond
br label %loop.cond
loop.exit: ; preds = %loop.cond
store ptr @.str.2, ptr %x4, align 8
store %"char[]" zeroinitializer, ptr %x4, align 8
%22 = call ptr @std.io.stdout()
store ptr %22, ptr %result, align 8
%23 = load ptr, ptr %result, align 8
%24 = call i64 @std.io.File.printn(ptr %retparam5, ptr %23, ptr null, i64 0)
%25 = load ptr, ptr %z, align 8
store ptr %25, ptr %.anon6, align 8
%24 = getelementptr inbounds %"char[]", ptr %x4, i32 0, i32 0
%lo = load ptr, ptr %24, align 8
%25 = getelementptr inbounds %"char[]", ptr %x4, i32 0, i32 1
%hi = load i64, ptr %25, align 8
%26 = call i64 @std.io.File.printn(ptr %retparam5, ptr %23, ptr %lo, i64 %hi)
%27 = load ptr, ptr %z, align 8
store ptr %27, ptr %.anon6, align 8
store i64 0, ptr %.anon7, align 8
br label %loop.cond8
loop.cond8: ; preds = %loop.body10, %loop.exit
%26 = load i64, ptr %.anon7, align 8
%gt9 = icmp ugt i64 4, %26
%28 = load i64, ptr %.anon7, align 8
%gt9 = icmp ugt i64 4, %28
br i1 %gt9, label %loop.body10, label %loop.exit15
loop.body10: ; preds = %loop.cond8
%27 = load ptr, ptr %.anon6, align 8
%28 = load i64, ptr %.anon7, align 8
%29 = getelementptr inbounds [4 x i8], ptr %27, i64 0, i64 %28
%30 = load i8, ptr %29, align 1
store i8 %30, ptr %d11, align 1
%31 = insertvalue %variant undef, ptr %d11, 0
%32 = insertvalue %variant %31, i64 ptrtoint (ptr @"$ct.char" to i64), 1
%33 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
store %variant %32, ptr %33, align 16
%34 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1)
%35 = load i64, ptr %.anon7, align 8
%add14 = add i64 %35, 1
%29 = load ptr, ptr %.anon6, align 8
%30 = load i64, ptr %.anon7, align 8
%31 = getelementptr inbounds [4 x i8], ptr %29, i64 0, i64 %30
%32 = load i8, ptr %31, align 1
store i8 %32, ptr %d11, align 1
%33 = insertvalue %variant undef, ptr %d11, 0
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.char" to i64), 1
%35 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
store %variant %34, ptr %35, align 16
%36 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.2, i64 3, ptr %varargslots13, i64 1)
%37 = load i64, ptr %.anon7, align 8
%add14 = add i64 %37, 1
store i64 %add14, ptr %.anon7, align 8
br label %loop.cond8
loop.exit15: ; preds = %loop.cond8
store ptr @.str.4, ptr %x16, align 8
%36 = call ptr @std.io.stdout()
store ptr %36, ptr %result18, align 8
%37 = load ptr, ptr %result18, align 8
%38 = call i64 @std.io.File.printn(ptr %retparam17, ptr %37, ptr null, i64 0)
%39 = load i32, ptr %abc, align 4
%40 = call i32 @llvm.bswap.i32(i32 %39)
%41 = and i32 65535, %40
%trunc = trunc i32 %41 to i16
store i16 %trunc, ptr %taddr21, align 2
%42 = insertvalue %variant undef, ptr %taddr21, 0
%43 = insertvalue %variant %42, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
%44 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
store %variant %43, ptr %44, align 16
%45 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1)
%46 = load i32, ptr %abc, align 4
%47 = call i32 @llvm.bswap.i32(i32 %46)
%48 = and i32 %47, -65536
%49 = or i32 %48, 4660
%50 = call i32 @llvm.bswap.i32(i32 %49)
store i32 %50, ptr %abc, align 4
%51 = load i32, ptr %abc, align 4
%52 = call i32 @llvm.bswap.i32(i32 %51)
%53 = and i32 %52, 65535
%54 = or i32 %53, 1450704896
%55 = call i32 @llvm.bswap.i32(i32 %54)
store i32 %55, ptr %abc, align 4
%56 = load i32, ptr %abc, align 4
%57 = call i32 @llvm.bswap.i32(i32 %56)
%58 = and i32 65535, %57
%trunc24 = trunc i32 %58 to i16
store i16 %trunc24, ptr %taddr25, align 2
%59 = insertvalue %variant undef, ptr %taddr25, 0
%60 = insertvalue %variant %59, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
%61 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
store %variant %60, ptr %61, align 16
%62 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1)
%63 = load ptr, ptr %z, align 8
store ptr %63, ptr %.anon26, align 8
store i64 0, ptr %.anon27, align 8
br label %loop.cond28
store %"char[]" zeroinitializer, ptr %x16, align 8
%38 = call ptr @std.io.stdout()
store ptr %38, ptr %result18, align 8
%39 = load ptr, ptr %result18, align 8
%40 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0
%lo19 = load ptr, ptr %40, align 8
%41 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1
%hi20 = load i64, ptr %41, align 8
%42 = call i64 @std.io.File.printn(ptr %retparam17, ptr %39, ptr %lo19, i64 %hi20)
%43 = load i32, ptr %abc, align 4
%44 = call i32 @llvm.bswap.i32(i32 %43)
%45 = and i32 65535, %44
%trunc = trunc i32 %45 to i16
store i16 %trunc, ptr %taddr23, align 2
%46 = insertvalue %variant undef, ptr %taddr23, 0
%47 = insertvalue %variant %46, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
%48 = getelementptr inbounds [1 x %variant], ptr %varargslots22, i64 0, i64 0
store %variant %47, ptr %48, align 16
%49 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.3, i64 10, ptr %varargslots22, i64 1)
%50 = load i32, ptr %abc, align 4
%51 = call i32 @llvm.bswap.i32(i32 %50)
%52 = and i32 %51, -65536
%53 = or i32 %52, 4660
%54 = call i32 @llvm.bswap.i32(i32 %53)
store i32 %54, ptr %abc, align 4
%55 = load i32, ptr %abc, align 4
%56 = call i32 @llvm.bswap.i32(i32 %55)
%57 = and i32 %56, 65535
%58 = or i32 %57, 1450704896
%59 = call i32 @llvm.bswap.i32(i32 %58)
store i32 %59, ptr %abc, align 4
%60 = load i32, ptr %abc, align 4
%61 = call i32 @llvm.bswap.i32(i32 %60)
%62 = and i32 65535, %61
%trunc26 = trunc i32 %62 to i16
store i16 %trunc26, ptr %taddr27, align 2
%63 = insertvalue %variant undef, ptr %taddr27, 0
%64 = insertvalue %variant %63, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
%65 = getelementptr inbounds [1 x %variant], ptr %varargslots25, i64 0, i64 0
store %variant %64, ptr %65, align 16
%66 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.4, i64 12, ptr %varargslots25, i64 1)
%67 = load ptr, ptr %z, align 8
store ptr %67, ptr %.anon28, align 8
store i64 0, ptr %.anon29, align 8
br label %loop.cond30
loop.cond28: ; preds = %loop.body30, %loop.exit15
%64 = load i64, ptr %.anon27, align 8
%gt29 = icmp ugt i64 4, %64
br i1 %gt29, label %loop.body30, label %loop.exit35
loop.cond30: ; preds = %loop.body32, %loop.exit15
%68 = load i64, ptr %.anon29, align 8
%gt31 = icmp ugt i64 4, %68
br i1 %gt31, label %loop.body32, label %loop.exit37
loop.body30: ; preds = %loop.cond28
%65 = load ptr, ptr %.anon26, align 8
%66 = load i64, ptr %.anon27, align 8
%67 = getelementptr inbounds [4 x i8], ptr %65, i64 0, i64 %66
%68 = load i8, ptr %67, align 1
store i8 %68, ptr %d31, align 1
%69 = insertvalue %variant undef, ptr %d31, 0
%70 = insertvalue %variant %69, i64 ptrtoint (ptr @"$ct.char" to i64), 1
%71 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
store %variant %70, ptr %71, align 16
%72 = call i64 @std.io.printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1)
%73 = load i64, ptr %.anon27, align 8
%add34 = add i64 %73, 1
store i64 %add34, ptr %.anon27, align 8
br label %loop.cond28
loop.body32: ; preds = %loop.cond30
%69 = load ptr, ptr %.anon28, align 8
%70 = load i64, ptr %.anon29, align 8
%71 = getelementptr inbounds [4 x i8], ptr %69, i64 0, i64 %70
%72 = load i8, ptr %71, align 1
store i8 %72, ptr %d33, align 1
%73 = insertvalue %variant undef, ptr %d33, 0
%74 = insertvalue %variant %73, i64 ptrtoint (ptr @"$ct.char" to i64), 1
%75 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0
store %variant %74, ptr %75, align 16
%76 = call i64 @std.io.printf(ptr %retparam34, ptr @.str.5, i64 3, ptr %varargslots35, i64 1)
%77 = load i64, ptr %.anon29, align 8
%add36 = add i64 %77, 1
store i64 %add36, ptr %.anon29, align 8
br label %loop.cond30
loop.exit35: ; preds = %loop.cond28
store ptr @.str.8, ptr %x36, align 8
%74 = call ptr @std.io.stdout()
store ptr %74, ptr %result38, align 8
%75 = load ptr, ptr %result38, align 8
%76 = call i64 @std.io.File.printn(ptr %retparam37, ptr %75, ptr null, i64 0)
loop.exit37: ; preds = %loop.cond30
store %"char[]" zeroinitializer, ptr %x38, align 8
%78 = call ptr @std.io.stdout()
store ptr %78, ptr %result40, align 8
%79 = load ptr, ptr %result40, align 8
%80 = getelementptr inbounds %"char[]", ptr %x38, i32 0, i32 0
%lo41 = load ptr, ptr %80, align 8
%81 = getelementptr inbounds %"char[]", ptr %x38, i32 0, i32 1
%hi42 = load i64, ptr %81, align 8
%82 = call i64 @std.io.File.printn(ptr %retparam39, ptr %79, ptr %lo41, i64 %hi42)
store i32 0, ptr %y, align 4
%77 = load i32, ptr %y, align 4
%83 = load i32, ptr %y, align 4
store i32 123, ptr %y, align 4
%78 = insertvalue %variant undef, ptr %y, 0
%79 = insertvalue %variant %78, i64 ptrtoint (ptr @"$ct.int" to i64), 1
%80 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
store %variant %79, ptr %80, align 16
%81 = load i32, ptr %y, align 4
store i32 %81, ptr %taddr41, align 4
%82 = insertvalue %variant undef, ptr %taddr41, 0
%83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.int" to i64), 1
%84 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
store %variant %83, ptr %84, align 16
%85 = call i64 @std.io.printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2)
%84 = insertvalue %variant undef, ptr %y, 0
%85 = insertvalue %variant %84, i64 ptrtoint (ptr @"$ct.int" to i64), 1
%86 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0
store %variant %85, ptr %86, align 16
%87 = load i32, ptr %y, align 4
store i32 %87, ptr %taddr45, align 4
%88 = insertvalue %variant undef, ptr %taddr45, 0
%89 = insertvalue %variant %88, i64 ptrtoint (ptr @"$ct.int" to i64), 1
%90 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1
store %variant %89, ptr %90, align 16
%91 = call i64 @std.io.printf(ptr %retparam43, ptr @.str.6, i64 18, ptr %varargslots44, i64 2)
ret void
}

115
test/test_suite/compile_time/ct_builtin_time_date.c3t
View File

@@ -26,30 +26,29 @@ fn void main()
/* #expect: test.ll
define void @test.test(i32 %0) #0 {
entry:
%retparam = alloca i64, align 8
%varargslots = alloca [1 x %variant], align 16
%taddr = alloca i32, align 4
%x = alloca ptr, align 8
%x = alloca %"char[]", align 8
%retparam1 = alloca i64, align 8
%result = alloca %File, align 8
%x2 = alloca ptr, align 8
%x2 = alloca %"char[]", align 8
%retparam3 = alloca i64, align 8
%result4 = alloca %File, align 8
%retparam5 = alloca i64, align 8
%varargslots6 = alloca [1 x %variant], align 16
%taddr7 = alloca i64, align 8
%retparam8 = alloca i64, align 8
%varargslots9 = alloca [1 x %variant], align 16
%taddr10 = alloca i64, align 8
%x11 = alloca ptr, align 8
%retparam12 = alloca i64, align 8
%result13 = alloca %File, align 8
%x14 = alloca ptr, align 8
%retparam15 = alloca i64, align 8
%result16 = alloca %File, align 8
%retparam7 = alloca i64, align 8
%varargslots8 = alloca [1 x %variant], align 16
%taddr9 = alloca i64, align 8
%retparam10 = alloca i64, align 8
%varargslots11 = alloca [1 x %variant], align 16
%taddr12 = alloca i64, align 8
%x13 = alloca %"char[]", align 8
%retparam14 = alloca i64, align 8
%result15 = alloca %File, align 8
%x18 = alloca %"char[]", align 8
%retparam19 = alloca i64, align 8
%result20 = alloca %File, align 8
store i32 %0, ptr %taddr, align 4
%1 = insertvalue %variant undef, ptr %taddr, 0
%2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
@@ -63,41 +62,61 @@ if.then: ; preds = %entry
call void @test.test(i32 %sub)
br label %if.exit
if.exit: ; preds = %if.then, %entry
store ptr @.str.1, ptr %x, align 8
store %"char[]" { ptr @.str.1, i64 8 }, ptr %x, align 8
%5 = call ptr @std.io.stdout()
store ptr %5, ptr %result, align 8
%6 = load ptr, ptr %result, align 8
%7 = load ptr, ptr %x, align 8
%8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr %7, i64 8)
store ptr @.str.2, ptr %x2, align 8
%9 = call ptr @std.io.stdout()
store ptr %9, ptr %result4, align 8
%10 = load ptr, ptr %result4, align 8
%11 = load ptr, ptr %x2, align 8
%12 = call i64 @std.io.File.printn(ptr %retparam3, ptr %10, ptr %11, i64 10)
store i64 14, ptr %taddr7, align 8
%13 = insertvalue %variant undef, ptr %taddr7, 0
%14 = insertvalue %variant %13, i64 ptrtoint (ptr @"$ct.long" to i64), 1
%15 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0
store %variant %14, ptr %15, align 16
%16 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1)
store i64 6, ptr %taddr10, align 8
%17 = insertvalue %variant undef, ptr %taddr10, 0
%18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.long" to i64), 1
%19 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
store %variant %18, ptr %19, align 16
%20 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1)
store ptr @.str.5, ptr %x11, align 8
%21 = call ptr @std.io.stdout()
store ptr %21, ptr %result13, align 8
%22 = load ptr, ptr %result13, align 8
%23 = load ptr, ptr %x11, align 8
%24 = call i64 @std.io.File.printn(ptr %retparam12, ptr %22, ptr %23, i64 23)
store ptr @.str.6, ptr %x14, align 8
%25 = call ptr @std.io.stdout()
store ptr %25, ptr %result16, align 8
%26 = load ptr, ptr %result16, align 8
%27 = load ptr, ptr %x14, align 8
%28 = call i64 @std.io.File.printn(ptr %retparam15, ptr %26, ptr %27, i64 4)
%7 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %7, align 8
%8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %8, align 8
%9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr %lo, i64 %hi)
store %"char[]" { ptr @.str.2, i64 10 }, ptr %x2, align 8
%10 = call ptr @std.io.stdout()
store ptr %10, ptr %result4, align 8
%11 = load ptr, ptr %result4, align 8
%12 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0
%lo5 = load ptr, ptr %12, align 8
%13 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1
%hi6 = load i64, ptr %13, align 8
%14 = call i64 @std.io.File.printn(ptr %retparam3, ptr %11, ptr %lo5, i64 %hi6)
store i64 14, ptr %taddr9, align 8
%15 = insertvalue %variant undef, ptr %taddr9, 0
%16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.long" to i64), 1
%17 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
store %variant %16, ptr %17, align 16
%18 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
store i64 6, ptr %taddr12, align 8
%19 = insertvalue %variant undef, ptr %taddr12, 0
%20 = insertvalue %variant %19, i64 ptrtoint (ptr @"$ct.long" to i64), 1
%21 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
store %variant %20, ptr %21, align 16
%22 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.4, i64 2, ptr %varargslots11, i64 1)
store %"char[]" { ptr @.str.5, i64 23 }, ptr %x13, align 8
%23 = call ptr @std.io.stdout()
store ptr %23, ptr %result15, align 8
%24 = load ptr, ptr %result15, align 8
%25 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 0
%lo16 = load ptr, ptr %25, align 8
%26 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 1
%hi17 = load i64, ptr %26, align 8
%27 = call i64 @std.io.File.printn(ptr %retparam14, ptr %24, ptr %lo16, i64 %hi17)
store %"char[]" { ptr @.str.6, i64 4 }, ptr %x18, align 8
%28 = call ptr @std.io.stdout()
store ptr %28, ptr %result20, align 8
%29 = load ptr, ptr %result20, align 8
%30 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0
%lo21 = load ptr, ptr %30, align 8
%31 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1
%hi22 = load i64, ptr %31, align 8
%32 = call i64 @std.io.File.printn(ptr %retparam19, ptr %29, ptr %lo21, i64 %hi22)
ret void
}
; Function Attrs: nounwind
define void @test.main() #0 {
entry:
%is_def2 = alloca i8, align 1
store i8 1, ptr %is_def2, align 1
call void @test.test(i32 10)
ret void
}

11
test/test_suite/compile_time/ct_foreach.c3t
View File

@@ -28,12 +28,13 @@ fn void main()
}
/* #expect: test.ll
define void @test.main() #0 {
entry:
%z = alloca i32, align 4
%z1 = alloca ptr, align 8
%z1 = alloca %"char[]", align 8
%z2 = alloca i32, align 4
%z3 = alloca ptr, align 8
%z3 = alloca %"char[]", align 8
call void (ptr, ...) @printf(ptr @.str, i32 1)
call void (ptr, ...) @printf(ptr @.str.1, i32 10)
call void (ptr, ...) @printf(ptr @.str.2, i32 34)
@@ -42,11 +43,11 @@ entry:
call void (ptr, ...) @printf(ptr @.str.5, i32 2, i32 34)
store i32 123, ptr %z, align 4
call void (ptr, ...) @printf(ptr @.str.6, i32 123)
store ptr @.str.7, ptr %z1, align 8
store %"char[]" { ptr @.str.7, i64 3 }, ptr %z1, align 8
call void (ptr, ...) @printf(ptr @.str.8, ptr @.str.9)
store i32 1177, ptr %z2, align 4
call void (ptr, ...) @printf(ptr @.str.10, i32 1177)
store ptr @.str.11, ptr %z3, align 8
store %"char[]" { ptr @.str.11, i64 5 }, ptr %z3, align 8
call void (ptr, ...) @printf(ptr @.str.12, ptr @.str.13)
ret void
}
}

452
test/test_suite/compile_time/ct_memberof.c3t
View File

@@ -117,249 +117,269 @@ entry:
; Function Attrs: nounwind
define void @test.test(i32 %0) #0 {
entry:
%x = alloca ptr, align 8
%x = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
%x1 = alloca ptr, align 8
%x1 = alloca %"char[]", align 8
%retparam2 = alloca i64, align 8
%result3 = alloca %File, align 8
%x4 = alloca ptr, align 8
%retparam5 = alloca i64, align 8
%result6 = alloca %File, align 8
%x7 = alloca ptr, align 8
%retparam8 = alloca i64, align 8
%result9 = alloca %File, align 8
%x10 = alloca ptr, align 8
%retparam11 = alloca i64, align 8
%result12 = alloca %File, align 8
%x13 = alloca ptr, align 8
%retparam14 = alloca i64, align 8
%result15 = alloca %File, align 8
%x16 = alloca ptr, align 8
%x6 = alloca %"char[]", align 8
%retparam7 = alloca i64, align 8
%result8 = alloca %File, align 8
%x11 = alloca %"char[]", align 8
%retparam12 = alloca i64, align 8
%result13 = alloca %File, align 8
%x16 = alloca %"char[]", align 8
%retparam17 = alloca i64, align 8
%result18 = alloca %File, align 8
%retparam19 = alloca i64, align 8
%x21 = alloca %"char[]", align 8
%retparam22 = alloca i64, align 8
%result23 = alloca %File, align 8
%x26 = alloca %"char[]", align 8
%retparam27 = alloca i64, align 8
%result28 = alloca %File, align 8
%retparam31 = alloca i64, align 8
%varargslots = alloca [1 x %variant], align 16
%taddr = alloca ptr, align 8
%retparam20 = alloca i64, align 8
%varargslots21 = alloca [2 x %variant], align 16
%taddr22 = alloca ptr, align 8
%taddr23 = alloca ptr, align 8
%retparam24 = alloca i64, align 8
%varargslots25 = alloca [2 x %variant], align 16
%taddr26 = alloca ptr, align 8
%taddr27 = alloca ptr, align 8
%retparam28 = alloca i64, align 8
%varargslots29 = alloca [2 x %variant], align 16
%taddr30 = alloca ptr, align 8
%taddr31 = alloca ptr, align 8
%taddr = alloca %"char[]", align 8
%retparam32 = alloca i64, align 8
%varargslots33 = alloca [2 x %variant], align 16
%taddr34 = alloca ptr, align 8
%taddr35 = alloca ptr, align 8
%taddr34 = alloca %"char[]", align 8
%taddr35 = alloca %"char[]", align 8
%retparam36 = alloca i64, align 8
%varargslots37 = alloca [1 x %variant], align 16
%taddr38 = alloca ptr, align 8
%retparam39 = alloca i64, align 8
%varargslots40 = alloca [2 x %variant], align 16
%taddr41 = alloca ptr, align 8
%taddr42 = alloca ptr, align 8
%retparam43 = alloca i64, align 8
%varargslots44 = alloca [2 x %variant], align 16
%taddr45 = alloca ptr, align 8
%taddr46 = alloca ptr, align 8
%retparam47 = alloca i64, align 8
%varargslots48 = alloca [2 x %variant], align 16
%taddr49 = alloca ptr, align 8
%taddr50 = alloca ptr, align 8
%varargslots37 = alloca [2 x %variant], align 16
%taddr38 = alloca %"char[]", align 8
%taddr39 = alloca %"char[]", align 8
%retparam40 = alloca i64, align 8
%varargslots41 = alloca [2 x %variant], align 16
%taddr42 = alloca %"char[]", align 8
%taddr43 = alloca %"char[]", align 8
%retparam44 = alloca i64, align 8
%varargslots45 = alloca [2 x %variant], align 16
%taddr46 = alloca %"char[]", align 8
%taddr47 = alloca %"char[]", align 8
%retparam48 = alloca i64, align 8
%varargslots49 = alloca [1 x %variant], align 16
%taddr50 = alloca %"char[]", align 8
%retparam51 = alloca i64, align 8
%varargslots52 = alloca [2 x %variant], align 16
%taddr53 = alloca ptr, align 8
%taddr54 = alloca ptr, align 8
%taddr53 = alloca %"char[]", align 8
%taddr54 = alloca %"char[]", align 8
%retparam55 = alloca i64, align 8
%varargslots56 = alloca [1 x %variant], align 16
%taddr57 = alloca ptr, align 8
%retparam58 = alloca i64, align 8
%varargslots59 = alloca [2 x %variant], align 16
%taddr60 = alloca ptr, align 8
%taddr61 = alloca ptr, align 8
%retparam62 = alloca i64, align 8
%varargslots63 = alloca [2 x %variant], align 16
%taddr64 = alloca ptr, align 8
%taddr65 = alloca ptr, align 8
store ptr @.str, ptr %x, align 8
%varargslots56 = alloca [2 x %variant], align 16
%taddr57 = alloca %"char[]", align 8
%taddr58 = alloca %"char[]", align 8
%retparam59 = alloca i64, align 8
%varargslots60 = alloca [2 x %variant], align 16
%taddr61 = alloca %"char[]", align 8
%taddr62 = alloca %"char[]", align 8
%retparam63 = alloca i64, align 8
%varargslots64 = alloca [2 x %variant], align 16
%taddr65 = alloca %"char[]", align 8
%taddr66 = alloca %"char[]", align 8
%retparam67 = alloca i64, align 8
%varargslots68 = alloca [1 x %variant], align 16
%taddr69 = alloca %"char[]", align 8
%retparam70 = alloca i64, align 8
%varargslots71 = alloca [2 x %variant], align 16
%taddr72 = alloca %"char[]", align 8
%taddr73 = alloca %"char[]", align 8
%retparam74 = alloca i64, align 8
%varargslots75 = alloca [2 x %variant], align 16
%taddr76 = alloca %"char[]", align 8
%taddr77 = alloca %"char[]", align 8
store %"char[]" { ptr @.str, i64 3 }, ptr %x, align 8
%1 = call ptr @std.io.stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = load ptr, ptr %x, align 8
%4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 3)
store ptr @.str.10, ptr %x1, align 8
%5 = call ptr @std.io.stdout()
store ptr %5, ptr %result3, align 8
%6 = load ptr, ptr %result3, align 8
%7 = load ptr, ptr %x1, align 8
%8 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr %7, i64 3)
store ptr @.str.11, ptr %x4, align 8
%9 = call ptr @std.io.stdout()
store ptr %9, ptr %result6, align 8
%10 = load ptr, ptr %result6, align 8
%11 = load ptr, ptr %x4, align 8
%12 = call i64 @std.io.File.printn(ptr %retparam5, ptr %10, ptr %11, i64 6)
store ptr @.str.12, ptr %x7, align 8
%13 = call ptr @std.io.stdout()
store ptr %13, ptr %result9, align 8
%14 = load ptr, ptr %result9, align 8
%15 = load ptr, ptr %x7, align 8
%16 = call i64 @std.io.File.printn(ptr %retparam8, ptr %14, ptr %15, i64 6)
store ptr @.str.13, ptr %x10, align 8
%17 = call ptr @std.io.stdout()
store ptr %17, ptr %result12, align 8
%18 = load ptr, ptr %result12, align 8
%19 = load ptr, ptr %x10, align 8
%20 = call i64 @std.io.File.printn(ptr %retparam11, ptr %18, ptr %19, i64 9)
store ptr @.str.14, ptr %x13, align 8
%3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %3, align 8
%4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %4, align 8
%5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
store %"char[]" { ptr @.str.10, i64 3 }, ptr %x1, align 8
%6 = call ptr @std.io.stdout()
store ptr %6, ptr %result3, align 8
%7 = load ptr, ptr %result3, align 8
%8 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
%lo4 = load ptr, ptr %8, align 8
%9 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
%hi5 = load i64, ptr %9, align 8
%10 = call i64 @std.io.File.printn(ptr %retparam2, ptr %7, ptr %lo4, i64 %hi5)
store %"char[]" { ptr @.str.11, i64 6 }, ptr %x6, align 8
%11 = call ptr @std.io.stdout()
store ptr %11, ptr %result8, align 8
%12 = load ptr, ptr %result8, align 8
%13 = getelementptr inbounds %"char[]", ptr %x6, i32 0, i32 0
%lo9 = load ptr, ptr %13, align 8
%14 = getelementptr inbounds %"char[]", ptr %x6, i32 0, i32 1
%hi10 = load i64, ptr %14, align 8
%15 = call i64 @std.io.File.printn(ptr %retparam7, ptr %12, ptr %lo9, i64 %hi10)
store %"char[]" { ptr @.str.12, i64 6 }, ptr %x11, align 8
%16 = call ptr @std.io.stdout()
store ptr %16, ptr %result13, align 8
%17 = load ptr, ptr %result13, align 8
%18 = getelementptr inbounds %"char[]", ptr %x11, i32 0, i32 0
%lo14 = load ptr, ptr %18, align 8
%19 = getelementptr inbounds %"char[]", ptr %x11, i32 0, i32 1
%hi15 = load i64, ptr %19, align 8
%20 = call i64 @std.io.File.printn(ptr %retparam12, ptr %17, ptr %lo14, i64 %hi15)
store %"char[]" { ptr @.str.13, i64 9 }, ptr %x16, align 8
%21 = call ptr @std.io.stdout()
store ptr %21, ptr %result15, align 8
%22 = load ptr, ptr %result15, align 8
%23 = load ptr, ptr %x13, align 8
%24 = call i64 @std.io.File.printn(ptr %retparam14, ptr %22, ptr %23, i64 4)
store ptr @.str.15, ptr %x16, align 8
%25 = call ptr @std.io.stdout()
store ptr %25, ptr %result18, align 8
%26 = load ptr, ptr %result18, align 8
%27 = load ptr, ptr %x16, align 8
%28 = call i64 @std.io.File.printn(ptr %retparam17, ptr %26, ptr %27, i64 3)
store ptr @.str.17, ptr %taddr, align 8
%29 = insertvalue %variant undef, ptr %taddr, 0
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
%31 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %30, ptr %31, align 16
%32 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
store ptr @.str.19, ptr %taddr22, align 8
%33 = insertvalue %variant undef, ptr %taddr22, 0
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
%35 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0
store %variant %34, ptr %35, align 16
store ptr @.str.20, ptr %taddr23, align 8
%36 = insertvalue %variant undef, ptr %taddr23, 0
%37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
%38 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
store ptr %21, ptr %result18, align 8
%22 = load ptr, ptr %result18, align 8
%23 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0
%lo19 = load ptr, ptr %23, align 8
%24 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1
%hi20 = load i64, ptr %24, align 8
%25 = call i64 @std.io.File.printn(ptr %retparam17, ptr %22, ptr %lo19, i64 %hi20)
store %"char[]" { ptr @.str.14, i64 4 }, ptr %x21, align 8
%26 = call ptr @std.io.stdout()
store ptr %26, ptr %result23, align 8
%27 = load ptr, ptr %result23, align 8
%28 = getelementptr inbounds %"char[]", ptr %x21, i32 0, i32 0
%lo24 = load ptr, ptr %28, align 8
%29 = getelementptr inbounds %"char[]", ptr %x21, i32 0, i32 1
%hi25 = load i64, ptr %29, align 8
%30 = call i64 @std.io.File.printn(ptr %retparam22, ptr %27, ptr %lo24, i64 %hi25)
store %"char[]" { ptr @.str.15, i64 3 }, ptr %x26, align 8
%31 = call ptr @std.io.stdout()
store ptr %31, ptr %result28, align 8
%32 = load ptr, ptr %result28, align 8
%33 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 0
%lo29 = load ptr, ptr %33, align 8
%34 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 1
%hi30 = load i64, ptr %34, align 8
%35 = call i64 @std.io.File.printn(ptr %retparam27, ptr %32, ptr %lo29, i64 %hi30)
store %"char[]" { ptr @.str.17, i64 3 }, ptr %taddr, align 8
%36 = insertvalue %variant undef, ptr %taddr, 0
%37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%38 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %37, ptr %38, align 16
%39 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2)
store ptr @.str.22, ptr %taddr26, align 8
%40 = insertvalue %variant undef, ptr %taddr26, 0
%41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
%42 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
%39 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr34, align 8
%40 = insertvalue %variant undef, ptr %taddr34, 0
%41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%42 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
store %variant %41, ptr %42, align 16
store ptr @.str.23, ptr %taddr27, align 8
%43 = insertvalue %variant undef, ptr %taddr27, 0
%44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
%45 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr35, align 8
%43 = insertvalue %variant undef, ptr %taddr35, 0
%44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%45 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
store %variant %44, ptr %45, align 16
%46 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2)
store ptr @.str.25, ptr %taddr30, align 8
%47 = insertvalue %variant undef, ptr %taddr30, 0
%48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
%49 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
%46 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.18, i64 6, ptr %varargslots33, i64 2)
store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr38, align 8
%47 = insertvalue %variant undef, ptr %taddr38, 0
%48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%49 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 0
store %variant %48, ptr %49, align 16
store ptr @.str.26, ptr %taddr31, align 8
%50 = insertvalue %variant undef, ptr %taddr31, 0
%51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
%52 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr39, align 8
%50 = insertvalue %variant undef, ptr %taddr39, 0
%51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%52 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 1
store %variant %51, ptr %52, align 16
%53 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2)
store ptr @.str.28, ptr %taddr34, align 8
%54 = insertvalue %variant undef, ptr %taddr34, 0
%55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
%56 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
%53 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.21, i64 6, ptr %varargslots37, i64 2)
store %"char[]" zeroinitializer, ptr %taddr42, align 8
%54 = insertvalue %variant undef, ptr %taddr42, 0
%55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%56 = getelementptr inbounds [2 x %variant], ptr %varargslots41, i64 0, i64 0
store %variant %55, ptr %56, align 16
store ptr @.str.29, ptr %taddr35, align 8
%57 = insertvalue %variant undef, ptr %taddr35, 0
%58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
%59 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr43, align 8
%57 = insertvalue %variant undef, ptr %taddr43, 0
%58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%59 = getelementptr inbounds [2 x %variant], ptr %varargslots41, i64 0, i64 1
store %variant %58, ptr %59, align 16
%60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2)
store ptr @.str.31, ptr %taddr38, align 8
%61 = insertvalue %variant undef, ptr %taddr38, 0
%62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
%63 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
%60 = call i64 @std.io.printfn(ptr %retparam40, ptr @.str.24, i64 6, ptr %varargslots41, i64 2)
store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr46, align 8
%61 = insertvalue %variant undef, ptr %taddr46, 0
%62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%63 = getelementptr inbounds [2 x %variant], ptr %varargslots45, i64 0, i64 0
store %variant %62, ptr %63, align 16
%64 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1)
store ptr @.str.33, ptr %taddr41, align 8
%65 = insertvalue %variant undef, ptr %taddr41, 0
%66 = insertvalue %variant %65, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
%67 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
store %variant %66, ptr %67, align 16
store ptr @.str.34, ptr %taddr42, align 8
%68 = insertvalue %variant undef, ptr %taddr42, 0
%69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
%70 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr47, align 8
%64 = insertvalue %variant undef, ptr %taddr47, 0
%65 = insertvalue %variant %64, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%66 = getelementptr inbounds [2 x %variant], ptr %varargslots45, i64 0, i64 1
store %variant %65, ptr %66, align 16
%67 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.26, i64 6, ptr %varargslots45, i64 2)
store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr50, align 8
%68 = insertvalue %variant undef, ptr %taddr50, 0
%69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%70 = getelementptr inbounds [1 x %variant], ptr %varargslots49, i64 0, i64 0
store %variant %69, ptr %70, align 16
%71 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2)
store ptr @.str.36, ptr %taddr45, align 8
%72 = insertvalue %variant undef, ptr %taddr45, 0
%73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
%74 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0
%71 = call i64 @std.io.printfn(ptr %retparam48, ptr @.str.29, i64 8, ptr %varargslots49, i64 1)
store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr53, align 8
%72 = insertvalue %variant undef, ptr %taddr53, 0
%73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%74 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
store %variant %73, ptr %74, align 16
store ptr @.str.37, ptr %taddr46, align 8
%75 = insertvalue %variant undef, ptr %taddr46, 0
%76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
%77 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1
store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr54, align 8
%75 = insertvalue %variant undef, ptr %taddr54, 0
%76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%77 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
store %variant %76, ptr %77, align 16
%78 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2)
store ptr @.str.39, ptr %taddr49, align 8
%79 = insertvalue %variant undef, ptr %taddr49, 0
%80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
%81 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0
%78 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.31, i64 6, ptr %varargslots52, i64 2)
store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr57, align 8
%79 = insertvalue %variant undef, ptr %taddr57, 0
%80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%81 = getelementptr inbounds [2 x %variant], ptr %varargslots56, i64 0, i64 0
store %variant %80, ptr %81, align 16
store ptr @.str.40, ptr %taddr50, align 8
%82 = insertvalue %variant undef, ptr %taddr50, 0
%83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
%84 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1
store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr58, align 8
%82 = insertvalue %variant undef, ptr %taddr58, 0
%83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%84 = getelementptr inbounds [2 x %variant], ptr %varargslots56, i64 0, i64 1
store %variant %83, ptr %84, align 16
%85 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2)
store ptr @.str.42, ptr %taddr53, align 8
%86 = insertvalue %variant undef, ptr %taddr53, 0
%87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
%88 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
%85 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.34, i64 6, ptr %varargslots56, i64 2)
store %"char[]" zeroinitializer, ptr %taddr61, align 8
%86 = insertvalue %variant undef, ptr %taddr61, 0
%87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%88 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 0
store %variant %87, ptr %88, align 16
store ptr @.str.43, ptr %taddr54, align 8
%89 = insertvalue %variant undef, ptr %taddr54, 0
%90 = insertvalue %variant %89, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
%91 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr62, align 8
%89 = insertvalue %variant undef, ptr %taddr62, 0
%90 = insertvalue %variant %89, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%91 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 1
store %variant %90, ptr %91, align 16
%92 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2)
store ptr @.str.45, ptr %taddr57, align 8
%93 = insertvalue %variant undef, ptr %taddr57, 0
%94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
%95 = getelementptr inbounds [1 x %variant], ptr %varargslots56, i64 0, i64 0
%92 = call i64 @std.io.printfn(ptr %retparam59, ptr @.str.37, i64 6, ptr %varargslots60, i64 2)
store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr65, align 8
%93 = insertvalue %variant undef, ptr %taddr65, 0
%94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%95 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 0
store %variant %94, ptr %95, align 16
%96 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1)
store ptr @.str.47, ptr %taddr60, align 8
%97 = insertvalue %variant undef, ptr %taddr60, 0
%98 = insertvalue %variant %97, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
%99 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 0
store %variant %98, ptr %99, align 16
store ptr @.str.48, ptr %taddr61, align 8
%100 = insertvalue %variant undef, ptr %taddr61, 0
%101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
%102 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 1
store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr66, align 8
%96 = insertvalue %variant undef, ptr %taddr66, 0
%97 = insertvalue %variant %96, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%98 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 1
store %variant %97, ptr %98, align 16
%99 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.39, i64 6, ptr %varargslots64, i64 2)
store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr69, align 8
%100 = insertvalue %variant undef, ptr %taddr69, 0
%101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%102 = getelementptr inbounds [1 x %variant], ptr %varargslots68, i64 0, i64 0
store %variant %101, ptr %102, align 16
%103 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2)
store ptr @.str.50, ptr %taddr64, align 8
%104 = insertvalue %variant undef, ptr %taddr64, 0
%105 = insertvalue %variant %104, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
%106 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0
%103 = call i64 @std.io.printfn(ptr %retparam67, ptr @.str.42, i64 8, ptr %varargslots68, i64 1)
store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr72, align 8
%104 = insertvalue %variant undef, ptr %taddr72, 0
%105 = insertvalue %variant %104, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%106 = getelementptr inbounds [2 x %variant], ptr %varargslots71, i64 0, i64 0
store %variant %105, ptr %106, align 16
store ptr @.str.51, ptr %taddr65, align 8
%107 = insertvalue %variant undef, ptr %taddr65, 0
%108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
%109 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1
store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr73, align 8
%107 = insertvalue %variant undef, ptr %taddr73, 0
%108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%109 = getelementptr inbounds [2 x %variant], ptr %varargslots71, i64 0, i64 1
store %variant %108, ptr %109, align 16
%110 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2)
%110 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.44, i64 6, ptr %varargslots71, i64 2)
store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr76, align 8
%111 = insertvalue %variant undef, ptr %taddr76, 0
%112 = insertvalue %variant %111, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%113 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 0
store %variant %112, ptr %113, align 16
store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr77, align 8
%114 = insertvalue %variant undef, ptr %taddr77, 0
%115 = insertvalue %variant %114, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%116 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 1
store %variant %115, ptr %116, align 16
%117 = call i64 @std.io.printfn(ptr %retparam74, ptr @.str.47, i64 6, ptr %varargslots75, i64 2)
ret void
}
; Function Attrs: nounwind
define void @test.main() #0 {
entry:
@@ -409,13 +429,13 @@ entry:
%1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.long" to i64), 1
%2 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %1, ptr %2, align 16
%3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.52, i64 7, ptr %varargslots, i64 1)
%3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.50, i64 7, ptr %varargslots, i64 1)
store i64 1, ptr %taddr3, align 8
%4 = insertvalue %variant undef, ptr %taddr3, 0
%5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.long" to i64), 1
%6 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
store %variant %5, ptr %6, align 16
%7 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.53, i64 7, ptr %varargslots2, i64 1)
%7 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.51, i64 7, ptr %varargslots2, i64 1)
store i64 0, ptr %taddr6, align 8
%8 = insertvalue %variant undef, ptr %taddr6, 0
%9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -426,7 +446,7 @@ entry:
%12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%13 = getelementptr inbounds [2 x %variant], ptr %varargslots5, i64 0, i64 1
store %variant %12, ptr %13, align 16
%14 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.54, i64 8, ptr %varargslots5, i64 2)
%14 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.52, i64 8, ptr %varargslots5, i64 2)
store i64 2, ptr %taddr10, align 8
%15 = insertvalue %variant undef, ptr %taddr10, 0
%16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -437,7 +457,7 @@ entry:
%19 = insertvalue %variant %18, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%20 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1
store %variant %19, ptr %20, align 16
%21 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.55, i64 8, ptr %varargslots9, i64 2)
%21 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.53, i64 8, ptr %varargslots9, i64 2)
store i64 4, ptr %taddr14, align 8
%22 = insertvalue %variant undef, ptr %taddr14, 0
%23 = insertvalue %variant %22, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -448,7 +468,7 @@ entry:
%26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%27 = getelementptr inbounds [2 x %variant], ptr %varargslots13, i64 0, i64 1
store %variant %26, ptr %27, align 16
%28 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.56, i64 8, ptr %varargslots13, i64 2)
%28 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.54, i64 8, ptr %varargslots13, i64 2)
store i64 4, ptr %taddr18, align 8
%29 = insertvalue %variant undef, ptr %taddr18, 0
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -459,7 +479,7 @@ entry:
%33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%34 = getelementptr inbounds [2 x %variant], ptr %varargslots17, i64 0, i64 1
store %variant %33, ptr %34, align 16
%35 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.57, i64 8, ptr %varargslots17, i64 2)
%35 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.55, i64 8, ptr %varargslots17, i64 2)
store i64 4, ptr %taddr22, align 8
%36 = insertvalue %variant undef, ptr %taddr22, 0
%37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -470,7 +490,7 @@ entry:
%40 = insertvalue %variant %39, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%41 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
store %variant %40, ptr %41, align 16
%42 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.58, i64 9, ptr %varargslots21, i64 2)
%42 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.56, i64 9, ptr %varargslots21, i64 2)
store i64 5, ptr %taddr26, align 8
%43 = insertvalue %variant undef, ptr %taddr26, 0
%44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -481,7 +501,7 @@ entry:
%47 = insertvalue %variant %46, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%48 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
store %variant %47, ptr %48, align 16
%49 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.59, i64 9, ptr %varargslots25, i64 2)
%49 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.57, i64 9, ptr %varargslots25, i64 2)
store i64 8, ptr %taddr30, align 8
%50 = insertvalue %variant undef, ptr %taddr30, 0
%51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -492,13 +512,13 @@ entry:
%54 = insertvalue %variant %53, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%55 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
store %variant %54, ptr %55, align 16
%56 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.60, i64 10, ptr %varargslots29, i64 2)
%56 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.58, i64 10, ptr %varargslots29, i64 2)
store i64 4, ptr %taddr34, align 8
%57 = insertvalue %variant undef, ptr %taddr34, 0
%58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%59 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
store %variant %58, ptr %59, align 16
%60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.61, i64 7, ptr %varargslots33, i64 1)
%60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.59, i64 7, ptr %varargslots33, i64 1)
store i64 8, ptr %taddr37, align 8
%61 = insertvalue %variant undef, ptr %taddr37, 0
%62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
@@ -509,7 +529,7 @@ entry:
%65 = insertvalue %variant %64, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
%66 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1
store %variant %65, ptr %66, align 16
%67 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.62, i64 10, ptr %varargslots36, i64 2)
%67 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.60, i64 10, ptr %varargslots36, i64 2)
call void @test.test(i32 10)
ret void
}

52
test/test_suite/errors/error_regression_2.c3t
View File

@@ -168,7 +168,7 @@ cond.rhs: ; preds = %entry
br label %cond.phi
cond.phi: ; preds = %cond.rhs, %cond.lhs
%val = phi %"char[]" [ %6, %cond.lhs ], [ { ptr @.str.43, i64 7 }, %cond.rhs ]
%val = phi %"char[]" [ %6, %cond.lhs ], [ { ptr @.str.41, i64 7 }, %cond.rhs ]
store %"char[]" %val, ptr %title, align 8
%7 = getelementptr inbounds %"char[]", ptr %title, i32 0, i32 1
%8 = load i64, ptr %7, align 8
@@ -178,8 +178,8 @@ cond.phi: ; preds = %cond.rhs, %cond.lhs
%11 = getelementptr inbounds %Summary, ptr %0, i32 0, i32 1
%12 = load i8, ptr %11, align 8
%13 = trunc i8 %12 to i1
%ternary = select i1 %13, ptr @.str.45, ptr @.str.46
%14 = call i32 (ptr, ptr, ...) @fprintf(ptr %1, ptr @.str.44, i32 %trunc, ptr %10, ptr %ternary)
%ternary = select i1 %13, ptr @.str.43, ptr @.str.44
%14 = call i32 (ptr, ptr, ...) @fprintf(ptr %1, ptr @.str.42, i32 %trunc, ptr %10, ptr %ternary)
ret void
}
@@ -488,7 +488,7 @@ expr_block.exit46: ; preds = %after_check45
panic_block47: ; preds = %assign_optional44
%49 = load ptr, ptr @std.core.builtin.panic, align 8
call void %49(ptr @.panic_msg.7, i64 27, ptr @.file.8, i64 6, ptr @.func.9, i64 7
call void %49(ptr @.panic_msg.6, i64 27, ptr @.file.7, i64 6, ptr @.func.8, i64 7
unreachable
noerr_block48: ; preds = %expr_block.exit46
@@ -546,7 +546,7 @@ expr_block.exit69: ; preds = %after_check68
panic_block70: ; preds = %assign_optional67
%64 = load ptr, ptr @std.core.builtin.panic, align 8
call void %64(ptr @.panic_msg.10, i64 27, ptr @.file.11, i64 6, ptr @.func.12, i64 7
call void %64(ptr @.panic_msg.9, i64 27, ptr @.file.10, i64 6, ptr @.func.11, i64 7
unreachable
noerr_block71: ; preds = %expr_block.exit69
@@ -580,7 +580,7 @@ if.exit77: ; preds = %if.exit20
%trunc = trunc i64 %70 to i32
%71 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
%72 = load ptr, ptr %71, align 8
%73 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.13, i32 %trunc, ptr %72)
%73 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.12, i32 %trunc, ptr %72)
store i32 %73, ptr %len, align 4
%74 = load ptr, ptr @std.core.mem.thread_allocator, align 8
store ptr %74, ptr %using78, align 8
@@ -617,7 +617,7 @@ expr_block.exit91: ; preds = %after_check90
panic_block92: ; preds = %assign_optional89
%85 = load ptr, ptr @std.core.builtin.panic, align 8
call void %85(ptr @.panic_msg.14, i64 27, ptr @.file.15, i64 6, ptr @.func.16
call void %85(ptr @.panic_msg.13, i64 27, ptr @.file.14, i64 6, ptr @.func.15
unreachable
noerr_block93: ; preds = %expr_block.exit91
@@ -639,7 +639,7 @@ if.exit96: ; preds = %noerr_block93
%trunc99 = trunc i64 %90 to i32
%91 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
%92 = load ptr, ptr %91, align 8
%93 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %87, i64 %add98, ptr @.str.17, i32 %trunc99, ptr %92)
%93 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %87, i64 %add98, ptr @.str.16, i32 %trunc99, ptr %92)
%94 = getelementptr inbounds %Doc, ptr %literal101, i32 0, i32 0
store ptr null, ptr %literal104, align 8
%95 = getelementptr inbounds %Head, ptr %literal104, i32 0, i32 0
@@ -685,7 +685,7 @@ expr_block.exit124: ; preds = %after_check123
panic_block125: ; preds = %assign_optional122
%111 = load ptr, ptr @std.core.builtin.panic, align 8
call void %111(ptr @.panic_msg.18, i64 27, ptr @.file.19, i64 6, ptr @.func.20
call void %111(ptr @.panic_msg.17, i64 27, ptr @.file.18, i64 6, ptr @.func.19
unreachable
noerr_block126: ; preds = %expr_block.exit124
@@ -743,7 +743,7 @@ expr_block.exit147: ; preds = %after_check146
panic_block148: ; preds = %assign_optional145
%126 = load ptr, ptr @std.core.builtin.panic, align 8
call void %126(ptr @.panic_msg.21, i64 27, ptr @.file.22, i64 6, ptr @.func.23
call void %126(ptr @.panic_msg.20, i64 27, ptr @.file.21, i64 6, ptr @.func.22
unreachable
noerr_block149: ; preds = %expr_block.exit147
@@ -935,7 +935,7 @@ err_retblock: ; preds = %assign_optional3, %
define ptr @test.bool_to_string(i8 zeroext %0) #0 {
entry:
%1 = trunc i8 %0 to i1
%ternary = select i1 %1, %"char[]" { ptr @.str.24, i64 4 }, %"char[]" { ptr @.str.25, i64 5 }
%ternary = select i1 %1, %"char[]" { ptr @.str.23, i64 4 }, %"char[]" { ptr @.str.24, i64 5 }
%2 = extractvalue %"char[]" %ternary, 0
ret ptr %2
}
@@ -953,27 +953,27 @@ switch.entry: ; preds = %entry
br i1 %eq, label %switch.case, label %next_if
switch.case: ; preds = %switch.entry
ret ptr @.str.26
ret ptr @.str.25
next_if: ; preds = %switch.entry
%eq1 = icmp eq i64 ptrtoint (ptr @"test.ReadError$BAD_READ" to i64), %1
br i1 %eq1, label %switch.case2, label %next_if3
switch.case2: ; preds = %next_if
ret ptr @.str.27
ret ptr @.str.26
next_if3: ; preds = %next_if
%eq4 = icmp eq i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), %1
br i1 %eq4, label %switch.case5, label %next_if6
switch.case5: ; preds = %next_if3
ret ptr @.str.28
ret ptr @.str.27
next_if6: ; preds = %next_if3
br label %switch.default
switch.default: ; preds = %next_if6
ret ptr @.str.29
ret ptr @.str.28
}
; Function Attrs: nounwind
@@ -991,15 +991,15 @@ entry:
%has_title.f = alloca i64, align 8
%retparam = alloca i8, align 1
%0 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 0
store %"char[]" { ptr @.str.30, i64 4 }, ptr %0, align 8
store %"char[]" { ptr @.str.29, i64 4 }, ptr %0, align 8
%1 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 1
store %"char[]" { ptr @.str.31, i64 11 }, ptr %1, align 8
store %"char[]" { ptr @.str.30, i64 11 }, ptr %1, align 8
%2 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 2
store %"char[]" { ptr @.str.32, i64 13 }, ptr %2, align 8
store %"char[]" { ptr @.str.31, i64 13 }, ptr %2, align 8
%3 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 3
store %"char[]" { ptr @.str.33, i64 12 }, ptr %3, align 8
store %"char[]" { ptr @.str.32, i64 12 }, ptr %3, align 8
%4 = getelementptr inbounds [5 x %"char[]"], ptr %literal, i64 0, i64 4
store %"char[]" { ptr @.str.34, i64 4 }, ptr %4, align 8
store %"char[]" { ptr @.str.33, i64 4 }, ptr %4, align 8
%5 = insertvalue %"char[][]" undef, ptr %literal, 0
%6 = insertvalue %"char[][]" %5, i64 5, 1
store %"char[][]" %6, ptr %URLS, align 8
@@ -1026,7 +1026,7 @@ loop.body: ; preds = %loop.cond
%trunc = trunc i64 %15 to i32
%16 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
%17 = load ptr, ptr %16, align 8
%18 = call i32 (ptr, ...) @printf(ptr @.str.35, i32 %trunc, ptr %17)
%18 = call i32 (ptr, ...) @printf(ptr @.str.34, i32 %trunc, ptr %17)
%19 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
%lo = load ptr, ptr %19, align 8
%20 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
@@ -1034,10 +1034,10 @@ loop.body: ; preds = %loop.cond
%21 = call { ptr, i8 } @test.readAndBuildSummary(ptr %lo, i64 %hi)
store { ptr, i8 } %21, ptr %result, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %summary, ptr align 8 %result, i32 16, i1 false)
%22 = call i32 (ptr, ...) @printf(ptr @.str.36)
%22 = call i32 (ptr, ...) @printf(ptr @.str.35)
%23 = load ptr, ptr @__stdoutp, align 8
call void @test.Summary.print(ptr %summary, ptr %23)
%24 = call i32 (ptr, ...) @printf(ptr @.str.37)
%24 = call i32 (ptr, ...) @printf(ptr @.str.36)
%25 = getelementptr inbounds %Summary, ptr %summary, i32 0, i32 0
%26 = load ptr, ptr %25, align 8
%ptrbool = icmp ne ptr %26, null
@@ -1060,7 +1060,7 @@ cond.phi: ; preds = %cond.rhs, %cond.lhs
%trunc2 = trunc i64 %31 to i32
%32 = getelementptr inbounds %"char[]", ptr %title_sure, i32 0, i32 0
%33 = load ptr, ptr %32, align 8
%34 = call i32 (ptr, ...) @printf(ptr @.str.39, i32 %trunc2, ptr %33)
%34 = call i32 (ptr, ...) @printf(ptr @.str.37, i32 %trunc2, ptr %33)
%35 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
%lo3 = load ptr, ptr %35, align 8
%36 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
@@ -1113,8 +1113,8 @@ else_block11: ; preds = %phi_block
phi_block12: ; preds = %else_block11, %after_check10
%val13 = phi i1 [ %47, %after_check10 ], [ false, %else_block11 ]
%ternary = select i1 %val13, ptr @.str.41, ptr @.str.42
%48 = call i32 (ptr, ...) @printf(ptr @.str.40, ptr %val7, ptr %ternary)
%ternary = select i1 %val13, ptr @.str.39, ptr @.str.40
%48 = call i32 (ptr, ...) @printf(ptr @.str.38, ptr %val7, ptr %ternary)
%49 = load i64, ptr %.anon1, align 8
%add = add i64 %49, 1
store i64 %add, ptr %.anon1, align 8

33
test/test_suite/errors/general_error_regression.c3t
View File

@@ -74,45 +74,54 @@ fn void main()
define void @foo.Foo.hello(ptr %0) #0 {
entry:
%x = alloca ptr, align 8
%x = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store ptr @.str.12, ptr %x, align 8
store %"char[]" { ptr @.str.12, i64 14 }, ptr %x, align 8
%1 = call ptr @std.io.stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = load ptr, ptr %x, align 8
%4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 14)
%3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %3, align 8
%4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %4, align 8
%5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
ret void
}
; Function Attrs: nounwind
define void @foo.Bar.hello(ptr %0) #0 {
entry:
%x = alloca ptr, align 8
%x = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store ptr @.str.13, ptr %x, align 8
store %"char[]" { ptr @.str.13, i64 14 }, ptr %x, align 8
%1 = call ptr @std.io.stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = load ptr, ptr %x, align 8
%4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 14)
%3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %3, align 8
%4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %4, align 8
%5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
ret void
}
; Function Attrs: nounwind
define void @foo.MyEnum.hello(ptr %0) #0 {
entry:
%x = alloca ptr, align 8
%x = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store ptr @.str.14, ptr %x, align 8
store %"char[]" { ptr @.str.14, i64 17 }, ptr %x, align 8
%1 = call ptr @std.io.stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = load ptr, ptr %x, align 8
%4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 17)
%3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %3, align 8
%4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %4, align 8
%5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
ret void
}

107
test/test_suite/errors/or_and_rethrow.c3t
View File

@@ -46,20 +46,20 @@ entry:
%taddr = alloca i32, align 4
%error_var = alloca i64, align 8
%blockret = alloca i32, align 4
%x = alloca ptr, align 8
%x = alloca %"char[]", align 8
%retparam1 = alloca i64, align 8
%result = alloca %File, align 8
%x2 = alloca ptr, align 8
%x2 = alloca %"char[]", align 8
%retparam3 = alloca i64, align 8
%result4 = alloca %File, align 8
%error_var5 = alloca i64, align 8
%blockret6 = alloca i32, align 4
%x10 = alloca ptr, align 8
%retparam11 = alloca i64, align 8
%result12 = alloca %File, align 8
%x14 = alloca ptr, align 8
%retparam15 = alloca i64, align 8
%result16 = alloca %File, align 8
%error_var7 = alloca i64, align 8
%blockret8 = alloca i32, align 4
%x12 = alloca %"char[]", align 8
%retparam13 = alloca i64, align 8
%result14 = alloca %File, align 8
%x18 = alloca %"char[]", align 8
%retparam19 = alloca i64, align 8
%result20 = alloca %File, align 8
%reterr = alloca i64, align 8
store i32 %0, ptr %taddr, align 4
%1 = insertvalue %variant undef, ptr %taddr, 0
@@ -86,39 +86,48 @@ or.phi: ; preds = %entry
br label %if.then
if.then: ; preds = %or.phi
store ptr @.str.2, ptr %x, align 8
store %"char[]" { ptr @.str.2, i64 3 }, ptr %x, align 8
%6 = call ptr @std.io.stdout()
store ptr %6, ptr %result, align 8
%7 = load ptr, ptr %result, align 8
%8 = load ptr, ptr %x, align 8
%9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %8, i64 3)
%8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %8, align 8
%9 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %9, align 8
%10 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %lo, i64 %hi)
br label %if.exit
if.exit: ; preds = %if.then
store ptr @.str.3, ptr %x2, align 8
%10 = call ptr @std.io.stdout()
store ptr %10, ptr %result4, align 8
%11 = load ptr, ptr %result4, align 8
%12 = load ptr, ptr %x2, align 8
%13 = call i64 @std.io.File.printn(ptr %retparam3, ptr %11, ptr %12, i64 9)
store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var5, align 8
br label %opt_block_cleanup7
store %"char[]" { ptr @.str.3, i64 9 }, ptr %x2, align 8
%11 = call ptr @std.io.stdout()
store ptr %11, ptr %result4, align 8
%12 = load ptr, ptr %result4, align 8
%13 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0
%lo5 = load ptr, ptr %13, align 8
%14 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1
%hi6 = load i64, ptr %14, align 8
%15 = call i64 @std.io.File.printn(ptr %retparam3, ptr %12, ptr %lo5, i64 %hi6)
store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var7, align 8
br label %opt_block_cleanup9
opt_block_cleanup7: ; preds = %if.exit
opt_block_cleanup9: ; preds = %if.exit
call void @foo.blurb()
br label %guard_block8
br label %guard_block10
guard_block8: ; preds = %opt_block_cleanup7
%14 = load i64, ptr %error_var5, align 8
ret i64 %14
guard_block10: ; preds = %opt_block_cleanup9
%16 = load i64, ptr %error_var7, align 8
ret i64 %16
if.exit13: ; No predecessors!
store ptr @.str.5, ptr %x14, align 8
%15 = call ptr @std.io.stdout()
store ptr %15, ptr %result16, align 8
%16 = load ptr, ptr %result16, align 8
%17 = load ptr, ptr %x14, align 8
%18 = call i64 @std.io.File.printn(ptr %retparam15, ptr %16, ptr %17, i64 7)
if.exit17: ; No predecessors!
store %"char[]" { ptr @.str.5, i64 7 }, ptr %x18, align 8
%17 = call ptr @std.io.stdout()
store ptr %17, ptr %result20, align 8
%18 = load ptr, ptr %result20, align 8
%19 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0
%lo21 = load ptr, ptr %19, align 8
%20 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1
%hi22 = load i64, ptr %20, align 8
%21 = call i64 @std.io.File.printn(ptr %retparam19, ptr %18, ptr %lo21, i64 %hi22)
ret i64 0
}
@@ -130,12 +139,12 @@ entry:
%taddr = alloca i32, align 4
%error_var = alloca i64, align 8
%blockret = alloca i32, align 4
%x = alloca ptr, align 8
%x = alloca %"char[]", align 8
%retparam1 = alloca i64, align 8
%result = alloca %File, align 8
%error_var2 = alloca i64, align 8
%blockret3 = alloca i32, align 4
%x7 = alloca ptr, align 8
%x7 = alloca %"char[]", align 8
%retparam8 = alloca i64, align 8
%result9 = alloca %File, align 8
%reterr = alloca i64, align 8
@@ -164,12 +173,15 @@ and.phi: ; preds = %entry
br label %if.exit
if.exit: ; preds = %and.phi
store ptr @.str.7, ptr %x, align 8
store %"char[]" { ptr @.str.7, i64 9 }, ptr %x, align 8
%6 = call ptr @std.io.stdout()
store ptr %6, ptr %result, align 8
%7 = load ptr, ptr %result, align 8
%8 = load ptr, ptr %x, align 8
%9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %8, i64 9)
%8 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %8, align 8
%9 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %9, align 8
%10 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %lo, i64 %hi)
store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var2, align 8
br label %opt_block_cleanup4
@@ -178,16 +190,19 @@ opt_block_cleanup4: ; preds = %if.exit
br label %guard_block5
guard_block5: ; preds = %opt_block_cleanup4
%10 = load i64, ptr %error_var2, align 8
ret i64 %10
%11 = load i64, ptr %error_var2, align 8
ret i64 %11
if.exit6: ; No predecessors!
store ptr @.str.8, ptr %x7, align 8
%11 = call ptr @std.io.stdout()
store ptr %11, ptr %result9, align 8
%12 = load ptr, ptr %result9, align 8
%13 = load ptr, ptr %x7, align 8
%14 = call i64 @std.io.File.printn(ptr %retparam8, ptr %12, ptr %13, i64 7)
store %"char[]" { ptr @.str.8, i64 7 }, ptr %x7, align 8
%12 = call ptr @std.io.stdout()
store ptr %12, ptr %result9, align 8
%13 = load ptr, ptr %result9, align 8
%14 = getelementptr inbounds %"char[]", ptr %x7, i32 0, i32 0
%lo10 = load ptr, ptr %14, align 8
%15 = getelementptr inbounds %"char[]", ptr %x7, i32 0, i32 1
%hi11 = load i64, ptr %15, align 8
%16 = call i64 @std.io.File.printn(ptr %retparam8, ptr %13, ptr %lo10, i64 %hi11)
ret i64 0
}

30
test/test_suite/errors/printing_errors.c3t
View File

@@ -20,12 +20,12 @@ entry:
%x = alloca i64, align 8
%retparam = alloca i64, align 8
%varargslots = alloca [2 x %variant], align 16
%taddr = alloca ptr, align 8
%taddr = alloca %"char[]", align 8
%faultname_zero = alloca %"char[]", align 8
store i64 ptrtoint (ptr @"test.Cde$WORLD" to i64), ptr %x, align 8
store ptr @.str.2, ptr %taddr, align 8
store %"char[]" { ptr @.str.2, i64 5 }, ptr %taddr, align 8
%0 = insertvalue %variant undef, ptr %taddr, 0
%1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
%1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%2 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %1, ptr %2, align 16
%3 = load i64, ptr %x, align 8
@@ -50,3 +50,27 @@ faultname_exit: ; preds = %faultname_ok, %faul
%9 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 6, ptr %varargslots, i64 2)
ret void
}
; Function Attrs: nounwind
define i32 @main(i32 %0, ptr %1) #0 {
entry:
%.anon = alloca i32, align 4
%.anon1 = alloca ptr, align 8
store i32 %0, ptr %.anon, align 4
store ptr %1, ptr %.anon1, align 8
call void @test.main()
ret i32 0
}
; Function Attrs: nounwind
declare i64 @std.io.printf(ptr, ptr, i64, ptr, i64) #0
; Function Attrs: argmemonly nocallback nofree nounwind willreturn writeonly
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #1
; Function Attrs: nocallback nofree nosync nounwind readnone willreturn
declare i1 @llvm.expect.i1(i1, i1) #2
attributes #0 = { nounwind }
attributes #1 = { argmemonly nocallback nofree nounwind willreturn writeonly }
attributes #2 = { nocallback nofree nosync nounwind readnone willreturn }

130
test/test_suite/from_docs/examples_defer.c3t
View File

@@ -29,67 +29,97 @@ entry:
br i1 %eq, label %if.then, label %if.exit
if.then: ; preds = %entry
store ptr @.str, ptr %x, align 8
store %"char[]" { ptr @.str, i64 1 }, ptr %x, align 8
%1 = call ptr @std.io.stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = load ptr, ptr %x, align 8
%4 = call i64 @std.io.File.print(ptr %retparam, ptr %2, ptr %3, i64 1)
store ptr @.str.1, ptr %x1, align 8
%5 = call ptr @std.io.stdout()
store ptr %5, ptr %result3, align 8
%6 = load ptr, ptr %result3, align 8
%7 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr null, i64 0)
%3 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %3, align 8
%4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %4, align 8
%5 = call i64 @std.io.File.print(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
store %"char[]" zeroinitializer, ptr %x1, align 8
%6 = call ptr @std.io.stdout()
store ptr %6, ptr %result3, align 8
%7 = load ptr, ptr %result3, align 8
%8 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
%lo4 = load ptr, ptr %8, align 8
%9 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
%hi5 = load i64, ptr %9, align 8
%10 = call i64 @std.io.File.printn(ptr %retparam2, ptr %7, ptr %lo4, i64 %hi5)
ret void
if.exit: ; preds = %entry
%eq4 = icmp eq i32 %0, 0
br i1 %eq4, label %if.then5, label %if.exit15
%eq6 = icmp eq i32 %0, 0
br i1 %eq6, label %if.then7, label %if.exit23
if.then5: ; preds = %if.exit
store ptr @.str.2, ptr %x6, align 8
%8 = call ptr @std.io.stdout()
store ptr %8, ptr %result8, align 8
%9 = load ptr, ptr %result8, align 8
%10 = load ptr, ptr %x6, align 8
%11 = call i64 @std.io.File.print(ptr %retparam7, ptr %9, ptr %10, i64 1)
store ptr @.str.3, ptr %x9, align 8
%12 = call ptr @std.io.stdout()
store ptr %12, ptr %result11, align 8
%13 = load ptr, ptr %result11, align 8
%14 = load ptr, ptr %x9, align 8
%15 = call i64 @std.io.File.print(ptr %retparam10, ptr %13, ptr %14, i64 1)
store ptr @.str.4, ptr %x12, align 8
if.then7: ; preds = %if.exit
store %"char[]" { ptr @.str.1, i64 1 }, ptr %x8, align 8
%11 = call ptr @std.io.stdout()
store ptr %11, ptr %result10, align 8
%12 = load ptr, ptr %result10, align 8
%13 = getelementptr inbounds %"char[]", ptr %x8, i32 0, i32 0
%lo11 = load ptr, ptr %13, align 8
%14 = getelementptr inbounds %"char[]", ptr %x8, i32 0, i32 1
%hi12 = load i64, ptr %14, align 8
%15 = call i64 @std.io.File.print(ptr %retparam9, ptr %12, ptr %lo11, i64 %hi12)
store %"char[]" { ptr @.str.2, i64 1 }, ptr %x13, align 8
%16 = call ptr @std.io.stdout()
store ptr %16, ptr %result14, align 8
%17 = load ptr, ptr %result14, align 8
%18 = call i64 @std.io.File.printn(ptr %retparam13, ptr %17, ptr null, i64 0)
store ptr %16, ptr %result15, align 8
%17 = load ptr, ptr %result15, align 8
%18 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 0
%lo16 = load ptr, ptr %18, align 8
%19 = getelementptr inbounds %"char[]", ptr %x13, i32 0, i32 1
%hi17 = load i64, ptr %19, align 8
%20 = call i64 @std.io.File.print(ptr %retparam14, ptr %17, ptr %lo16, i64 %hi17)
store %"char[]" zeroinitializer, ptr %x18, align 8
%21 = call ptr @std.io.stdout()
store ptr %21, ptr %result20, align 8
%22 = load ptr, ptr %result20, align 8
%23 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 0
%lo21 = load ptr, ptr %23, align 8
%24 = getelementptr inbounds %"char[]", ptr %x18, i32 0, i32 1
%hi22 = load i64, ptr %24, align 8
%25 = call i64 @std.io.File.printn(ptr %retparam19, ptr %22, ptr %lo21, i64 %hi22)
ret void
if.exit15: ; preds = %if.exit
store ptr @.str.5, ptr %x16, align 8
%19 = call ptr @std.io.stdout()
store ptr %19, ptr %result18, align 8
%20 = load ptr, ptr %result18, align 8
%21 = load ptr, ptr %x16, align 8
%22 = call i64 @std.io.File.print(ptr %retparam17, ptr %20, ptr %21, i64 1)
store ptr @.str.6, ptr %x19, align 8
%23 = call ptr @std.io.stdout()
store ptr %23, ptr %result21, align 8
%24 = load ptr, ptr %result21, align 8
%25 = load ptr, ptr %x19, align 8
%26 = call i64 @std.io.File.print(ptr %retparam20, ptr %24, ptr %25, i64 1)
store ptr @.str.7, ptr %x22, align 8
%27 = call ptr @std.io.stdout()
store ptr %27, ptr %result24, align 8
%28 = load ptr, ptr %result24, align 8
%29 = load ptr, ptr %x22, align 8
%30 = call i64 @std.io.File.print(ptr %retparam23, ptr %28, ptr %29, i64 1)
store ptr @.str.8, ptr %x25, align 8
if.exit23: ; preds = %if.exit
store %"char[]" { ptr @.str.3, i64 1 }, ptr %x24, align 8
%26 = call ptr @std.io.stdout()
store ptr %26, ptr %result26, align 8
%27 = load ptr, ptr %result26, align 8
%28 = getelementptr inbounds %"char[]", ptr %x24, i32 0, i32 0
%lo27 = load ptr, ptr %28, align 8
%29 = getelementptr inbounds %"char[]", ptr %x24, i32 0, i32 1
%hi28 = load i64, ptr %29, align 8
%30 = call i64 @std.io.File.print(ptr %retparam25, ptr %27, ptr %lo27, i64 %hi28)
store %"char[]" { ptr @.str.4, i64 1 }, ptr %x29, align 8
%31 = call ptr @std.io.stdout()
store ptr %31, ptr %result27, align 8
%32 = load ptr, ptr %result27, align 8
%33 = call i64 @std.io.File.printn(ptr %retparam26, ptr %32, ptr null, i64 0)
store ptr %31, ptr %result31, align 8
%32 = load ptr, ptr %result31, align 8
%33 = getelementptr inbounds %"char[]", ptr %x29, i32 0, i32 0
%lo32 = load ptr, ptr %33, align 8
%34 = getelementptr inbounds %"char[]", ptr %x29, i32 0, i32 1
%hi33 = load i64, ptr %34, align 8
%35 = call i64 @std.io.File.print(ptr %retparam30, ptr %32, ptr %lo32, i64 %hi33)
store %"char[]" { ptr @.str.5, i64 1 }, ptr %x34, align 8
%36 = call ptr @std.io.stdout()
store ptr %36, ptr %result36, align 8
%37 = load ptr, ptr %result36, align 8
%38 = getelementptr inbounds %"char[]", ptr %x34, i32 0, i32 0
%lo37 = load ptr, ptr %38, align 8
%39 = getelementptr inbounds %"char[]", ptr %x34, i32 0, i32 1
%hi38 = load i64, ptr %39, align 8
%40 = call i64 @std.io.File.print(ptr %retparam35, ptr %37, ptr %lo37, i64 %hi38)
store %"char[]" zeroinitializer, ptr %x39, align 8
%41 = call ptr @std.io.stdout()
store ptr %41, ptr %result41, align 8
%42 = load ptr, ptr %result41, align 8
%43 = getelementptr inbounds %"char[]", ptr %x39, i32 0, i32 0
%lo42 = load ptr, ptr %43, align 8
%44 = getelementptr inbounds %"char[]", ptr %x39, i32 0, i32 1
%hi43 = load i64, ptr %44, align 8
%45 = call i64 @std.io.File.printn(ptr %retparam40, ptr %42, ptr %lo42, i64 %hi43)
ret void
}

286
test/test_suite/from_docs/examples_forswitch.c3t
View File

@@ -121,36 +121,36 @@ unreachable_block: ; No predecessors!
define void @examples.demo_enum(i32 %0) #0 {
entry:
%switch = alloca i32, align 4
%x = alloca ptr, align 8
%x = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
%x2 = alloca ptr, align 8
%x2 = alloca %"char[]", align 8
%retparam3 = alloca i64, align 8
%result4 = alloca %File, align 8
%switch5 = alloca i32, align 4
%x8 = alloca ptr, align 8
%retparam9 = alloca i64, align 8
%result10 = alloca %File, align 8
%x12 = alloca ptr, align 8
%retparam13 = alloca i64, align 8
%result14 = alloca %File, align 8
%switch16 = alloca i32, align 4
%x20 = alloca ptr, align 8
%retparam21 = alloca i64, align 8
%result22 = alloca %File, align 8
%switch25 = alloca i32, align 4
%switch29 = alloca i32, align 4
%switch7 = alloca i32, align 4
%x10 = alloca %"char[]", align 8
%retparam11 = alloca i64, align 8
%result12 = alloca %File, align 8
%x16 = alloca %"char[]", align 8
%retparam17 = alloca i64, align 8
%result18 = alloca %File, align 8
%switch22 = alloca i32, align 4
%x26 = alloca %"char[]", align 8
%retparam27 = alloca i64, align 8
%result28 = alloca %File, align 8
%switch33 = alloca i32, align 4
%switch37 = alloca i32, align 4
%a = alloca i32, align 4
%x32 = alloca ptr, align 8
%retparam33 = alloca i64, align 8
%result34 = alloca %File, align 8
%a36 = alloca i32, align 4
%x37 = alloca ptr, align 8
%retparam38 = alloca i64, align 8
%result39 = alloca %File, align 8
%x41 = alloca ptr, align 8
%retparam42 = alloca i64, align 8
%result43 = alloca %File, align 8
%x40 = alloca %"char[]", align 8
%retparam41 = alloca i64, align 8
%result42 = alloca %File, align 8
%a46 = alloca i32, align 4
%x47 = alloca %"char[]", align 8
%retparam48 = alloca i64, align 8
%result49 = alloca %File, align 8
%x53 = alloca %"char[]", align 8
%retparam54 = alloca i64, align 8
%result55 = alloca %File, align 8
store i32 %0, ptr %switch, align 4
br label %switch.entry
@@ -163,139 +163,163 @@ switch.entry: ; preds = %entry
]
switch.case: ; preds = %switch.entry, %switch.entry
store ptr @.str.1, ptr %x, align 8
store %"char[]" { ptr @.str.1, i64 8 }, ptr %x, align 8
%2 = call ptr @std.io.stdout()
store ptr %2, ptr %result, align 8
%3 = load ptr, ptr %result, align 8
%4 = load ptr, ptr %x, align 8
%5 = call i64 @std.io.File.printn(ptr %retparam, ptr %3, ptr %4, i64 8)
%4 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 0
%lo = load ptr, ptr %4, align 8
%5 = getelementptr inbounds %"char[]", ptr %x, i32 0, i32 1
%hi = load i64, ptr %5, align 8
%6 = call i64 @std.io.File.printn(ptr %retparam, ptr %3, ptr %lo, i64 %hi)
br label %switch.exit
switch.case1: ; preds = %switch.entry
store ptr @.str.2, ptr %x2, align 8
%6 = call ptr @std.io.stdout()
store ptr %6, ptr %result4, align 8
%7 = load ptr, ptr %result4, align 8
%8 = load ptr, ptr %x2, align 8
%9 = call i64 @std.io.File.printn(ptr %retparam3, ptr %7, ptr %8, i64 4)
store %"char[]" { ptr @.str.2, i64 4 }, ptr %x2, align 8
%7 = call ptr @std.io.stdout()
store ptr %7, ptr %result4, align 8
%8 = load ptr, ptr %result4, align 8
%9 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 0
%lo5 = load ptr, ptr %9, align 8
%10 = getelementptr inbounds %"char[]", ptr %x2, i32 0, i32 1
%hi6 = load i64, ptr %10, align 8
%11 = call i64 @std.io.File.printn(ptr %retparam3, ptr %8, ptr %lo5, i64 %hi6)
br label %switch.exit
switch.exit: ; preds = %switch.case1, %switch.case, %switch.entry
store i32 %0, ptr %switch5, align 4
br label %switch.entry6
store i32 %0, ptr %switch7, align 4
br label %switch.entry8
switch.entry6: ; preds = %switch.exit
%10 = load i32, ptr %switch5, align 4
switch i32 %10, label %switch.exit15 [
i32 0, label %switch.case7
i32 1, label %switch.case7
i32 2, label %switch.case11
switch.entry8: ; preds = %switch.exit
%12 = load i32, ptr %switch7, align 4
switch i32 %12, label %switch.exit21 [
i32 0, label %switch.case9
i32 1, label %switch.case9
i32 2, label %switch.case15
]
switch.case7: ; preds = %switch.entry6, %switch.entry6
store ptr @.str.3, ptr %x8, align 8
%11 = call ptr @std.io.stdout()
store ptr %11, ptr %result10, align 8
%12 = load ptr, ptr %result10, align 8
%13 = load ptr, ptr %x8, align 8
%14 = call i64 @std.io.File.printn(ptr %retparam9, ptr %12, ptr %13, i64 8)
br label %switch.exit15
switch.case9: ; preds = %switch.entry8, %switch.entry8
store %"char[]" { ptr @.str.3, i64 8 }, ptr %x10, align 8
%13 = call ptr @std.io.stdout()
store ptr %13, ptr %result12, align 8
%14 = load ptr, ptr %result12, align 8
%15 = getelementptr inbounds %"char[]", ptr %x10, i32 0, i32 0
%lo13 = load ptr, ptr %15, align 8
%16 = getelementptr inbounds %"char[]", ptr %x10, i32 0, i32 1
%hi14 = load i64, ptr %16, align 8
%17 = call i64 @std.io.File.printn(ptr %retparam11, ptr %14, ptr %lo13, i64 %hi14)
br label %switch.exit21
switch.case11: ; preds = %switch.entry6
store ptr @.str.4, ptr %x12, align 8
%15 = call ptr @std.io.stdout()
store ptr %15, ptr %result14, align 8
%16 = load ptr, ptr %result14, align 8
%17 = load ptr, ptr %x12, align 8
%18 = call i64 @std.io.File.printn(ptr %retparam13, ptr %16, ptr %17, i64 4)
br label %switch.exit15
switch.case15: ; preds = %switch.entry8
store %"char[]" { ptr @.str.4, i64 4 }, ptr %x16, align 8
%18 = call ptr @std.io.stdout()
store ptr %18, ptr %result18, align 8
%19 = load ptr, ptr %result18, align 8
%20 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0
%lo19 = load ptr, ptr %20, align 8
%21 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1
%hi20 = load i64, ptr %21, align 8
%22 = call i64 @std.io.File.printn(ptr %retparam17, ptr %19, ptr %lo19, i64 %hi20)
br label %switch.exit21
switch.exit15: ; preds = %switch.case11, %switch.case7, %switch.entry6
store i32 %0, ptr %switch16, align 4
br label %switch.entry17
switch.exit21: ; preds = %switch.case15, %switch.case9, %switch.entry8
store i32 %0, ptr %switch22, align 4
br label %switch.entry23
switch.entry17: ; preds = %switch.exit15
%19 = load i32, ptr %switch16, align 4
switch i32 %19, label %switch.exit24 [
i32 0, label %switch.case18
i32 1, label %switch.case19
i32 2, label %switch.case23
switch.entry23: ; preds = %switch.exit21
%23 = load i32, ptr %switch22, align 4
switch i32 %23, label %switch.exit32 [
i32 0, label %switch.case24
i32 1, label %switch.case25
i32 2, label %switch.case31
]
switch.case18: ; preds = %switch.entry17
br label %switch.exit24
switch.case24: ; preds = %switch.entry23
br label %switch.exit32
switch.case19: ; preds = %switch.entry17
store ptr @.str.5, ptr %x20, align 8
%20 = call ptr @std.io.stdout()
store ptr %20, ptr %result22, align 8
%21 = load ptr, ptr %result22, align 8
%22 = load ptr, ptr %x20, align 8
%23 = call i64 @std.io.File.printn(ptr %retparam21, ptr %21, ptr %22, i64 6)
br label %switch.exit24
switch.case25: ; preds = %switch.entry23
store %"char[]" { ptr @.str.5, i64 6 }, ptr %x26, align 8
%24 = call ptr @std.io.stdout()
store ptr %24, ptr %result28, align 8
%25 = load ptr, ptr %result28, align 8
%26 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 0
%lo29 = load ptr, ptr %26, align 8
%27 = getelementptr inbounds %"char[]", ptr %x26, i32 0, i32 1
%hi30 = load i64, ptr %27, align 8
%28 = call i64 @std.io.File.printn(ptr %retparam27, ptr %25, ptr %lo29, i64 %hi30)
br label %switch.exit32
switch.case23: ; preds = %switch.entry17
br label %switch.exit24
switch.case31: ; preds = %switch.entry23
br label %switch.exit32
switch.exit24: ; preds = %switch.case23, %switch.case19, %switch.case18, %switch.entry17
store i32 %0, ptr %switch25, align 4
br label %switch.entry26
switch.exit32: ; preds = %switch.case31, %switch.case25, %switch.case24, %switch.entry23
store i32 %0, ptr %switch33, align 4
br label %switch.entry34
switch.entry26: ; preds = %switch.exit24
%24 = load i32, ptr %switch25, align 4
switch i32 %24, label %switch.default [
i32 0, label %switch.case27
i32 1, label %switch.case27
i32 2, label %switch.case27
]
switch.case27: ; preds = %switch.entry26, %switch.entry26, %switch.entry26
br label %switch.exit28
switch.default: ; preds = %switch.entry26
br label %switch.exit28
switch.exit28: ; preds = %switch.default, %switch.case27
store i32 %0, ptr %switch29, align 4
br label %switch.entry30
switch.entry30: ; preds = %switch.exit28
%25 = load i32, ptr %switch29, align 4
switch i32 %25, label %switch.exit44 [
i32 0, label %switch.case31
switch.entry34: ; preds = %switch.exit32
%29 = load i32, ptr %switch33, align 4
switch i32 %29, label %switch.default [
i32 0, label %switch.case35
i32 1, label %switch.case35
i32 2, label %switch.case40
i32 2, label %switch.case35
]
switch.case31: ; preds = %switch.entry30
switch.case35: ; preds = %switch.entry34, %switch.entry34, %switch.entry34
br label %switch.exit36
switch.default: ; preds = %switch.entry34
br label %switch.exit36
switch.exit36: ; preds = %switch.default, %switch.case35
store i32 %0, ptr %switch37, align 4
br label %switch.entry38
switch.entry38: ; preds = %switch.exit36
%30 = load i32, ptr %switch37, align 4
switch i32 %30, label %switch.exit58 [
i32 0, label %switch.case39
i32 1, label %switch.case45
i32 2, label %switch.case52
]
switch.case39: ; preds = %switch.entry38
store i32 1, ptr %a, align 4
store ptr @.str.6, ptr %x32, align 8
%26 = call ptr @std.io.stdout()
store ptr %26, ptr %result34, align 8
%27 = load ptr, ptr %result34, align 8
%28 = load ptr, ptr %x32, align 8
%29 = call i64 @std.io.File.printn(ptr %retparam33, ptr %27, ptr %28, i64 1)
br label %switch.case35
store %"char[]" { ptr @.str.6, i64 1 }, ptr %x40, align 8
%31 = call ptr @std.io.stdout()
store ptr %31, ptr %result42, align 8
%32 = load ptr, ptr %result42, align 8
%33 = getelementptr inbounds %"char[]", ptr %x40, i32 0, i32 0
%lo43 = load ptr, ptr %33, align 8
%34 = getelementptr inbounds %"char[]", ptr %x40, i32 0, i32 1
%hi44 = load i64, ptr %34, align 8
%35 = call i64 @std.io.File.printn(ptr %retparam41, ptr %32, ptr %lo43, i64 %hi44)
br label %switch.case45
switch.case35: ; preds = %switch.entry30, %switch.case31
store i32 2, ptr %a36, align 4
store ptr @.str.7, ptr %x37, align 8
%30 = call ptr @std.io.stdout()
store ptr %30, ptr %result39, align 8
%31 = load ptr, ptr %result39, align 8
%32 = load ptr, ptr %x37, align 8
%33 = call i64 @std.io.File.printn(ptr %retparam38, ptr %31, ptr %32, i64 1)
br label %switch.case40
switch.case45: ; preds = %switch.entry38, %switch.case39
store i32 2, ptr %a46, align 4
store %"char[]" { ptr @.str.7, i64 1 }, ptr %x47, align 8
%36 = call ptr @std.io.stdout()
store ptr %36, ptr %result49, align 8
%37 = load ptr, ptr %result49, align 8
%38 = getelementptr inbounds %"char[]", ptr %x47, i32 0, i32 0
%lo50 = load ptr, ptr %38, align 8
%39 = getelementptr inbounds %"char[]", ptr %x47, i32 0, i32 1
%hi51 = load i64, ptr %39, align 8
%40 = call i64 @std.io.File.printn(ptr %retparam48, ptr %37, ptr %lo50, i64 %hi51)
br label %switch.case52
switch.case40: ; preds = %switch.entry30, %switch.case35
store ptr @.str.8, ptr %x41, align 8
%34 = call ptr @std.io.stdout()
store ptr %34, ptr %result43, align 8
%35 = load ptr, ptr %result43, align 8
%36 = load ptr, ptr %x41, align 8
%37 = call i64 @std.io.File.printn(ptr %retparam42, ptr %35, ptr %36, i64 1)
br label %switch.exit44
switch.case52: ; preds = %switch.entry38, %switch.case45
store %"char[]" { ptr @.str.8, i64 1 }, ptr %x53, align 8
%41 = call ptr @std.io.stdout()
store ptr %41, ptr %result55, align 8
%42 = load ptr, ptr %result55, align 8
%43 = getelementptr inbounds %"char[]", ptr %x53, i32 0, i32 0
%lo56 = load ptr, ptr %43, align 8
%44 = getelementptr inbounds %"char[]", ptr %x53, i32 0, i32 1
%hi57 = load i64, ptr %44, align 8
%45 = call i64 @std.io.File.printn(ptr %retparam54, ptr %42, ptr %lo56, i64 %hi57)
br label %switch.exit58
switch.exit44: ; preds = %switch.case40, %switch.entry30
switch.exit58: ; preds = %switch.case52, %switch.entry38
ret void
}

37
test/test_suite/functions/func_ptr_conversions_and_names.c3t
View File

@@ -38,20 +38,15 @@ fn void main()
@.str.3 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
@.str.4 = private unnamed_addr constant [13 x i8] c"fn int(int)*\00", align 1
@"$ct.char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
@"$ct.a12$char" = linkonce constant %.introspect { i8 15, i64 12, i64 ptrtoint (ptr @"$ct.char" to i64), i64 12, [0 x i64] zeroinitializer }, align 8
@"$ct.p$a12$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a12$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
@"$ct.sa$char" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"$ct.char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
@.str.5 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
@.str.6 = private unnamed_addr constant [13 x i8] c"fn int(int)*\00", align 1
@.str.7 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
@.str.8 = private unnamed_addr constant [13 x i8] c"test::test2*\00", align 1
@.str.9 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
@.str.10 = private unnamed_addr constant [7 x i8] c"test2*\00", align 1
@"$ct.a6$char" = linkonce constant %.introspect { i8 15, i64 6, i64 ptrtoint (ptr @"$ct.char" to i64), i64 6, [0 x i64] zeroinitializer }, align 8
@"$ct.p$a6$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a6$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
@.str.11 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
@.str.12 = private unnamed_addr constant [14 x i8] c"fn int!(int)*\00", align 1
@"$ct.a13$char" = linkonce constant %.introspect { i8 15, i64 13, i64 ptrtoint (ptr @"$ct.char" to i64), i64 13, [0 x i64] zeroinitializer }, align 8
@"$ct.p$a13$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a13$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
@"$ct.fn$int$int$" = linkonce constant %.introspect { i8 13, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
@"$ct.p$fn$int$int$" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.fn$int$int$" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
@@ -71,19 +66,19 @@ entry:
%taddr6 = alloca i32, align 4
%retparam7 = alloca i64, align 8
%varargslots8 = alloca [1 x %variant], align 16
%taddr9 = alloca ptr, align 8
%taddr9 = alloca %"char[]", align 8
%retparam10 = alloca i64, align 8
%varargslots11 = alloca [1 x %variant], align 16
%taddr12 = alloca ptr, align 8
%taddr12 = alloca %"char[]", align 8
%retparam13 = alloca i64, align 8
%varargslots14 = alloca [1 x %variant], align 16
%taddr15 = alloca ptr, align 8
%taddr15 = alloca %"char[]", align 8
%retparam16 = alloca i64, align 8
%varargslots17 = alloca [1 x %variant], align 16
%taddr18 = alloca ptr, align 8
%taddr18 = alloca %"char[]", align 8
%retparam19 = alloca i64, align 8
%varargslots20 = alloca [1 x %variant], align 16
%taddr21 = alloca ptr, align 8
%taddr21 = alloca %"char[]", align 8
%y = alloca ptr, align 8
%zfoke = alloca i64, align 8
store ptr @test.test, ptr %a, align 8
@@ -112,33 +107,33 @@ entry:
%15 = getelementptr inbounds [1 x %variant], ptr %varargslots5, i64 0, i64 0
store %variant %14, ptr %15, align 16
%16 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.2, i64 2, ptr %varargslots5, i64 1)
store ptr @.str.4, ptr %taddr9, align 8
store %"char[]" { ptr @.str.4, i64 12 }, ptr %taddr9, align 8
%17 = insertvalue %variant undef, ptr %taddr9, 0
%18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
%18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%19 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
store %variant %18, ptr %19, align 16
%20 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
store ptr @.str.6, ptr %taddr12, align 8
store %"char[]" { ptr @.str.6, i64 12 }, ptr %taddr12, align 8
%21 = insertvalue %variant undef, ptr %taddr12, 0
%22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
%22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%23 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
store %variant %22, ptr %23, align 16
%24 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.5, i64 2, ptr %varargslots11, i64 1)
store ptr @.str.8, ptr %taddr15, align 8
store %"char[]" { ptr @.str.8, i64 12 }, ptr %taddr15, align 8
%25 = insertvalue %variant undef, ptr %taddr15, 0
%26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
%26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%27 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
store %variant %26, ptr %27, align 16
%28 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.7, i64 2, ptr %varargslots14, i64 1)
store ptr @.str.10, ptr %taddr18, align 8
store %"char[]" { ptr @.str.10, i64 6 }, ptr %taddr18, align 8
%29 = insertvalue %variant undef, ptr %taddr18, 0
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%31 = getelementptr inbounds [1 x %variant], ptr %varargslots17, i64 0, i64 0
store %variant %30, ptr %31, align 16
%32 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.9, i64 2, ptr %varargslots17, i64 1)
store ptr @.str.12, ptr %taddr21, align 8
store %"char[]" { ptr @.str.12, i64 13 }, ptr %taddr21, align 8
%33 = insertvalue %variant undef, ptr %taddr21, 0
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a13$char" to i64), 1
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%35 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
store %variant %34, ptr %35, align 16
%36 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.11, i64 2, ptr %varargslots20, i64 1)

105
test/test_suite/initializer_lists/subarrays.c3t
View File

@@ -48,7 +48,10 @@ fn int main()
%Bar = type { i32, i32 }
%"Bar[]" = type { ptr, i64 }
%"int[]" = type { ptr, i64 }
%"char[]" = type { ptr, i64 }
%File = type { ptr }
%Baz = type { double }
@"$ct.subarrays.Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
@"$ct.subarrays.Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
@.taddr = private global [2 x %Bar] [%Bar { i32 3, i32 4 }, %Bar { i32 8, i32 9 }], align 8
@@ -72,14 +75,14 @@ entry:
%literal = alloca [3 x i32], align 4
%y = alloca ptr, align 8
%literal2 = alloca [3 x i32], align 4
%x3 = alloca ptr, align 8
%x3 = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
%ffe = alloca %Baz, align 8
%azz = alloca [1 x i32], align 4
%xy = alloca i8, align 1
%literal7 = alloca [3 x i32], align 4
%x9 = alloca ptr, align 8
%x9 = alloca %"char[]", align 8
%retparam10 = alloca i64, align 8
%result11 = alloca %File, align 8
%b = alloca %Bar, align 4
@@ -111,62 +114,68 @@ entry:
%12 = getelementptr inbounds [3 x i32], ptr %literal2, i64 0, i64 2
store i32 567, ptr %12, align 4
store ptr %literal2, ptr %y, align 8
store ptr @.str.5, ptr %x3, align 8
store %"char[]" { ptr @.str.5, i64 6 }, ptr %x3, align 8
%13 = call ptr @std.io.stdout()
store ptr %13, ptr %result, align 8
%14 = load ptr, ptr %result, align 8
%15 = load ptr, ptr %x3, align 8
%16 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr %15, i64 6)
%17 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
%18 = load i64, ptr %17, align 8
%trunc = trunc i64 %18 to i32
%19 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
%20 = load ptr, ptr %19, align 8
%ptroffset4 = getelementptr inbounds i32, ptr %20, i64 1
%21 = load i32, ptr %ptroffset4, align 4
%22 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %trunc, i32 %21)
%23 = load ptr, ptr %y, align 8
%ptroffset5 = getelementptr inbounds i32, ptr %23, i64 1
%24 = load i32, ptr %ptroffset5, align 4
%25 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %24)
%26 = load ptr, ptr @subarrays.fofeo, align 8
%ptroffset6 = getelementptr inbounds i32, ptr %26, i64 1
%27 = load i32, ptr %ptroffset6, align 4
%28 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %27)
%15 = getelementptr inbounds %"char[]", ptr %x3, i32 0, i32 0
%lo = load ptr, ptr %15, align 8
%16 = getelementptr inbounds %"char[]", ptr %x3, i32 0, i32 1
%hi = load i64, ptr %16, align 8
%17 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr %lo, i64 %hi)
%18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
%19 = load i64, ptr %18, align 8
%trunc = trunc i64 %19 to i32
%20 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
%21 = load ptr, ptr %20, align 8
%ptroffset4 = getelementptr inbounds i32, ptr %21, i64 1
%22 = load i32, ptr %ptroffset4, align 4
%23 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %trunc, i32 %22)
%24 = load ptr, ptr %y, align 8
%ptroffset5 = getelementptr inbounds i32, ptr %24, i64 1
%25 = load i32, ptr %ptroffset5, align 4
%26 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %25)
%27 = load ptr, ptr @subarrays.fofeo, align 8
%ptroffset6 = getelementptr inbounds i32, ptr %27, i64 1
%28 = load i32, ptr %ptroffset6, align 4
%29 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %28)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const, i32 8, i1 false)
%29 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
store i32 0, ptr %29, align 4
%30 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0
store i32 1, ptr %30, align 4
%31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1
store i32 2, ptr %31, align 4
%32 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2
store i32 3, ptr %32, align 4
%33 = insertvalue %"int[]" undef, ptr %literal7, 0
%34 = insertvalue %"int[]" %33, i64 3, 1
%35 = extractvalue %"int[]" %34, 1
%not = icmp eq i64 %35, 0
%36 = zext i1 %not to i8
store i8 %36, ptr %xy, align 1
%37 = load i8, ptr %xy, align 1
%38 = trunc i8 %37 to i1
%not8 = xor i1 %38, true
%30 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
store i32 0, ptr %30, align 4
%31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0
store i32 1, ptr %31, align 4
%32 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1
store i32 2, ptr %32, align 4
%33 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2
store i32 3, ptr %33, align 4
%34 = insertvalue %"int[]" undef, ptr %literal7, 0
%35 = insertvalue %"int[]" %34, i64 3, 1
%36 = extractvalue %"int[]" %35, 1
%not = icmp eq i64 %36, 0
%37 = zext i1 %not to i8
store i8 %37, ptr %xy, align 1
%38 = load i8, ptr %xy, align 1
%39 = trunc i8 %38 to i1
%not8 = xor i1 %39, true
br i1 %not8, label %if.then, label %if.exit
if.then: ; preds = %entry
store ptr @.str.9, ptr %x9, align 8
%39 = call ptr @std.io.stdout()
store ptr %39, ptr %result11, align 8
%40 = load ptr, ptr %result11, align 8
%41 = load ptr, ptr %x9, align 8
%42 = call i64 @std.io.File.printn(ptr %retparam10, ptr %40, ptr %41, i64 2)
store %"char[]" { ptr @.str.9, i64 2 }, ptr %x9, align 8
%40 = call ptr @std.io.stdout()
store ptr %40, ptr %result11, align 8
%41 = load ptr, ptr %result11, align 8
%42 = getelementptr inbounds %"char[]", ptr %x9, i32 0, i32 0
%lo12 = load ptr, ptr %42, align 8
%43 = getelementptr inbounds %"char[]", ptr %x9, i32 0, i32 1
%hi13 = load i64, ptr %43, align 8
%44 = call i64 @std.io.File.printn(ptr %retparam10, ptr %41, ptr %lo12, i64 %hi13)
br label %if.exit
if.exit: ; preds = %if.then, %entry
%43 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
store i32 0, ptr %43, align 4
%44 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
store i32 0, ptr %44, align 4
%45 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
store i32 0, ptr %45, align 4
%46 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
store i32 0, ptr %46, align 4
call void @llvm.memset.p0.i64(ptr align 8 %z, i8 0, i64 8, i1 false)
store %"int[]" zeroinitializer, ptr %sub, align 8
store %"Bar[]" zeroinitializer, ptr %foo, align 8

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

@@ -93,11 +93,11 @@ entry:
%x = alloca i32, align 4
%retparam11 = alloca i64, align 8
%varargslots12 = alloca [1 x %variant], align 16
%taddr = alloca ptr, align 8
%taddr = alloca %"char[]", align 8
%x13 = alloca double, align 8
%retparam14 = alloca i64, align 8
%varargslots15 = alloca [1 x %variant], align 16
%taddr16 = alloca ptr, align 8
%taddr16 = alloca %"char[]", align 8
%retparam17 = alloca i64, align 8
%varargslots18 = alloca [1 x %variant], align 16
%taddr19 = alloca i32, align 4
@@ -146,16 +146,16 @@ entry:
store %variant %21, ptr %22, align 16
%23 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.4, i64 2, ptr %varargslots10, i64 1)
store i32 0, ptr %x, align 4
store ptr @.str.6, ptr %taddr, align 8
store %"char[]" { ptr @.str.6, i64 3 }, ptr %taddr, align 8
%24 = insertvalue %variant undef, ptr %taddr, 0
%25 = insertvalue %variant %24, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
%25 = insertvalue %variant %24, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%26 = getelementptr inbounds [1 x %variant], ptr %varargslots12, i64 0, i64 0
store %variant %25, ptr %26, align 16
%27 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.5, i64 2, ptr %varargslots12, i64 1)
store double 0.000000e+00, ptr %x13, align 8
store ptr @.str.8, ptr %taddr16, align 8
store %"char[]" { ptr @.str.8, i64 6 }, ptr %taddr16, align 8
%28 = insertvalue %variant undef, ptr %taddr16, 0
%29 = insertvalue %variant %28, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
%29 = insertvalue %variant %28, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
%30 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
store %variant %29, ptr %30, align 16
%31 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.7, i64 2, ptr %varargslots15, i64 1)

48
test/test_suite/methods/enum_distinct_err_methods.c3t
View File

@@ -43,20 +43,62 @@ fn int main()
/* #expect: foo.ll
define void @foo.Foo.hello(ptr %0) #0 {
entry:
store ptr @.str, ptr %x, align 8
%x = alloca %"char[]", align 8
%x1 = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store %"char[]" { ptr @.str, i64 14 }, ptr %x, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %x1, ptr align 8 %x, i32 16, i1 false)
%1 = call ptr @std.io.stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
%lo = load ptr, ptr %3, align 8
%4 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
%hi = load i64, ptr %4, align 8
%5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
ret void
}
define void @foo.Bar.hello(ptr %0) #0 {
entry:
store ptr @.str.1, ptr %x, align 8
%x = alloca %"char[]", align 8
%x1 = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store %"char[]" { ptr @.str.1, i64 14 }, ptr %x, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %x1, ptr align 8 %x, i32 16, i1 false)
%1 = call ptr @std.io.stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
%lo = load ptr, ptr %3, align 8
%4 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
%hi = load i64, ptr %4, align 8
%5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
ret void
}
define void @foo.MyEnum.hello(ptr %0) #0 {
entry:
store ptr @.str.2, ptr %x, align 8
%x = alloca %"char[]", align 8
%x1 = alloca %"char[]", align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store %"char[]" { ptr @.str.2, i64 17 }, ptr %x, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %x1, ptr align 8 %x, i32 16, i1 false)
%1 = call ptr @std.io.stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 0
%lo = load ptr, ptr %3, align 8
%4 = getelementptr inbounds %"char[]", ptr %x1, i32 0, i32 1
%hi = load i64, ptr %4, align 8
%5 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %lo, i64 %hi)
ret void
}
define i32 @main() #0 {

2
test/test_suite/symbols/various.c3
View File

@@ -125,7 +125,7 @@ fn void test16()
fn void test17()
{
int a = "test"; // #error: 'char[4]*' to 'int'
int a = "test"; // #error: 'char[]' to 'int'
}
fn void test18()