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

Support for memberof/returns/params.

Browse Source
This commit is contained in:
Christoffer Lerno
2022-10-06 17:18:16 +02:00
parent 870e716f59
commit ec1a5d97c9
8 changed files with 790 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/compiler/compiler_internal.h
View File

@@ -2072,6 +2072,7 @@ Decl *decl_find_enum_constant(Decl *decl, const char *name);
Expr *expr_new(ExprKind kind, SourceSpan start);
Expr *expr_new_const_int(SourceSpan span, Type *type, uint64_t v, bool narrowable);
Expr *expr_new_const_bool(SourceSpan span, Type *type, bool value);
Expr *expr_new_const_typeid(SourceSpan span, Type *type);
bool expr_is_simple(Expr *expr);
bool expr_is_pure(Expr *expr);
bool expr_is_constant_eval(Expr *expr, ConstantEvalKind eval_kind);
@@ -2105,7 +2106,9 @@ INLINE void expr_rewrite_const_null(Expr *expr, Type *type);
INLINE void expr_rewrite_const_bool(Expr *expr, Type *type, bool b);
INLINE void expr_rewrite_const_float(Expr *expr, Type *type, Real d);
INLINE void expr_rewrite_const_int(Expr *expr, Type *type, uint64_t v, bool narrowable);
INLINE void expr_rewrite_const_typeid(Expr *expr, Type *type);
INLINE void expr_rewrite_const_initializer(Expr *expr, Type *type, ConstInitializer *initializer);
INLINE void expr_rewrite_const_untyped_list(Expr *expr, Expr **elements);
void expr_rewrite_to_builtin_access(Expr *expr, Expr *parent, BuiltinAccessKind kind, Type *type);
void expr_rewrite_to_string(Expr *expr_to_rewrite, const char *string);
@@ -2896,6 +2899,14 @@ INLINE void expr_rewrite_const_null(Expr *expr, Type *type)
expr->resolve_status = RESOLVE_DONE;
}
INLINE void expr_rewrite_const_untyped_list(Expr *expr, Expr **elements)
{
expr->expr_kind = EXPR_CONST;
expr->type = type_untypedlist;
expr->const_expr = (ExprConst) { .untyped_list = elements, .const_kind = CONST_UNTYPED_LIST };
expr->resolve_status = RESOLVE_DONE;
}
INLINE void expr_rewrite_const_initializer(Expr *expr, Type *type, ConstInitializer *initializer)
{
expr->expr_kind = EXPR_CONST;
@@ -2904,6 +2915,16 @@ INLINE void expr_rewrite_const_initializer(Expr *expr, Type *type, ConstInitiali
expr->resolve_status = RESOLVE_DONE;
}
INLINE void expr_rewrite_const_typeid(Expr *expr, Type *type)
{
expr->expr_kind = EXPR_CONST;
expr->const_expr.const_kind = CONST_TYPEID;
expr->const_expr.typeid = type->canonical;
expr->type = type_typeid;
expr->resolve_status = RESOLVE_DONE;
}
INLINE void expr_rewrite_const_int(Expr *expr, Type *type, uint64_t v, bool narrowable)
{
expr->expr_kind = EXPR_CONST;

5
src/compiler/enums.h
View File

@@ -883,12 +883,15 @@ typedef enum
TYPE_PROPERTY_ELEMENTS,
TYPE_PROPERTY_INF,
TYPE_PROPERTY_LEN,
TYPE_PROPERTY_MIN,
TYPE_PROPERTY_MAX,
TYPE_PROPERTY_MEMBERSOF,
TYPE_PROPERTY_MIN,
TYPE_PROPERTY_NAN,
TYPE_PROPERTY_INNER,
TYPE_PROPERTY_KIND,
TYPE_PROPERTY_NAMES,
TYPE_PROPERTY_PARAMS,
TYPE_PROPERTY_RETURNS,
TYPE_PROPERTY_SIZEOF,
TYPE_PROPERTY_VALUES,
TYPE_PROPERTY_NONE,

12
src/compiler/expr.c
View File

@@ -825,6 +825,18 @@ Expr *expr_new_const_int(SourceSpan span, Type *type, uint64_t v, bool narrowabl
return expr;
}
Expr *expr_new_const_typeid(SourceSpan span, Type *type)
{
Expr *expr = expr_calloc();
expr->expr_kind = EXPR_CONST;
expr->span = span;
expr->type = type_typeid;
expr->const_expr.const_kind = CONST_TYPEID;
expr->const_expr.typeid = type;
expr->resolve_status = RESOLVE_DONE;
return expr;
}
Expr *expr_new_const_bool(SourceSpan span, Type *type, bool value)
{
Expr *expr = expr_calloc();

63
src/compiler/sema_expr.c
View File

@@ -171,6 +171,8 @@ static inline bool sema_create_const_len(SemaContext *context, Expr *expr, Type
static inline bool sema_create_const_inner(SemaContext *context, Expr *expr, Type *type);
static inline bool sema_create_const_min(SemaContext *context, Expr *expr, Type *type, Type *flat);
static inline bool sema_create_const_max(SemaContext *context, Expr *expr, Type *type, Type *flat);
static inline bool sema_create_const_params(SemaContext *context, Expr *expr, Type *type);
static inline bool sema_create_const_membersof(SemaContext *context, Expr *expr, Type *type);
void expr_insert_widening_type(Expr *expr, Type *infer_type);
static Expr *expr_access_inline_member(Expr *parent, Decl *parent_decl);
@@ -2853,10 +2855,7 @@ static inline bool sema_create_const_inner(SemaContext *context, Expr *expr, Typ
default:
return false;
}
expr->expr_kind = EXPR_CONST;
expr->const_expr.const_kind = CONST_TYPEID;
expr->const_expr.typeid = inner->canonical;
expr->type = type_typeid;
expr_rewrite_const_typeid(expr, inner);
return true;
}
@@ -2922,6 +2921,50 @@ static inline bool sema_create_const_min(SemaContext *context, Expr *expr, Type
return false;
}
static inline bool sema_create_const_params(SemaContext *context, Expr *expr, Type *type)
{
if (type->type_kind != TYPE_POINTER || type->pointer->type_kind != TYPE_FUNC) return false;
type = type->pointer;
Signature *sig = type->function.signature;
unsigned params = vec_size(sig->params);
Expr **param_exprs = params ? VECNEW(Expr*, params) : NULL;
for (unsigned i = 0; i < params; i++)
{
Decl *decl = sig->params[i];
Expr *expr_element = expr_new_const_typeid(expr->span, decl->type->canonical);
vec_add(param_exprs, expr_element);
}
expr_rewrite_const_untyped_list(expr, param_exprs);
return true;
}
static inline bool sema_create_const_membersof(SemaContext *context, Expr *expr, Type *type)
{
Decl **members = NULL;
if (type_is_union_or_strukt(type))
{
members = type->decl->strukt.members;
}
else if (type->type_kind == TYPE_BITSTRUCT)
{
members = type->decl->bitstruct.members;
}
else
{
return false;
}
unsigned count = vec_size(members);
Expr **member_exprs = count ? VECNEW(Expr*, count) : NULL;
for (unsigned i = 0; i < count; i++)
{
Decl *decl = members[i];
Expr *expr_element = expr_new_const_typeid(expr->span, decl->type->canonical);
vec_add(member_exprs, expr_element);
}
expr_rewrite_const_untyped_list(expr, member_exprs);
return true;
}
static inline bool sema_create_const_max(SemaContext *context, Expr *expr, Type *type, Type *flat)
{
if (type_is_integer(flat))
@@ -3032,6 +3075,9 @@ static bool sema_expr_rewrite_to_typeid_property(SemaContext *context, Expr *exp
case TYPE_PROPERTY_NAN:
case TYPE_PROPERTY_ELEMENTS:
case TYPE_PROPERTY_VALUES:
case TYPE_PROPERTY_RETURNS:
case TYPE_PROPERTY_PARAMS:
case TYPE_PROPERTY_MEMBERSOF:
// Not supported by dynamic typeid
case TYPE_PROPERTY_NONE:
return false;
@@ -3142,6 +3188,15 @@ static bool sema_expr_rewrite_to_type_property(SemaContext *context, Expr *expr,
expr->type = type;
expr->resolve_status = RESOLVE_DONE;
return true;
case TYPE_PROPERTY_MEMBERSOF:
return sema_create_const_membersof(context, expr, flat);
case TYPE_PROPERTY_PARAMS:
return sema_create_const_params(context, expr, flat);
case TYPE_PROPERTY_RETURNS:
if (flat->type_kind != TYPE_POINTER || flat->pointer->type_kind != TYPE_FUNC) return false;
flat = flat->pointer;
expr_rewrite_const_typeid(expr, type_infoptr(flat->function.signature->rtype)->type);
return true;
case TYPE_PROPERTY_SIZEOF:
expr_rewrite_const_int(expr, type_usize, type_size(type), true);
return true;

3
src/compiler/symtab.c
View File

@@ -167,7 +167,10 @@ void symtab_init(uint32_t capacity)
type_property_list[TYPE_PROPERTY_NAMES] = KW_DEF("names");
type_property_list[TYPE_PROPERTY_INNER] = KW_DEF("inner");
type_property_list[TYPE_PROPERTY_KIND] = KW_DEF("kind");
type_property_list[TYPE_PROPERTY_MEMBERSOF] = KW_DEF("membersof");
type_property_list[TYPE_PROPERTY_INF] = KW_DEF("inf");
type_property_list[TYPE_PROPERTY_PARAMS] = KW_DEF("params");
type_property_list[TYPE_PROPERTY_RETURNS] = KW_DEF("returns");
type_property_list[TYPE_PROPERTY_SIZEOF] = KW_DEF("sizeof");
type_property_list[TYPE_PROPERTY_VALUES] = KW_DEF("values");

2
src/version.h
View File

@@ -1 +1 @@
#define COMPILER_VERSION "0.3.71"
#define COMPILER_VERSION "0.3.72"

371
test/test_suite/compile_time/ct_memberof.c3t Normal file
View File

@@ -0,0 +1,371 @@
// #target: macos-x64
module test;
import std::io;
fn int hell() { return 1; }
macro print_args($Type)
{
var $params = $Type.params;
$foreach ($param : $params):
io::println($nameof($typefrom($param)));
$endforeach
}
bitstruct Bar : ulong
{
int x : 1..4;
short y : 6..10;
}
struct Foo
{
int x;
union test {
int y;
double z;
}
struct {
int abc;
int bcd;
}
double q;
}
macro print_fields($Type)
{
io::printfln("Type: %s", $nameof($Type));
var $params = $Type.membersof;
$foreach ($param : $params):
io::printfln("Member: %s", $nameof($typefrom($param)));
$endforeach
}
fn void hello(int a, double b, int[4] d, args...) {}
fn void test(int x)
{
print_args($typeof(&test));
print_args($typeof(&hell));
print_args($typeof(&hello));
io::println($nameof($typefrom($typeof(&test).returns)));
io::println($nameof($typefrom($typeof(&hell).returns)));
print_fields(Foo);
print_fields(Bar);
}
fn void main()
{
test(10);
}
/* #expect: test.ll
; Function Attrs: nounwind
define void @test_hello(i32 %0, double %1, i64 %2, i64 %3, i8* %4, i64 %5) #0 {
entry:
%d = alloca [4 x i32], align 4
%args = alloca %"variant[]", align 8
%pair = bitcast [4 x i32]* %d to { i64, i64 }*
%6 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %pair, i32 0, i32 0
store i64 %2, i64* %6, align 4
%7 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %pair, i32 0, i32 1
store i64 %3, i64* %7, align 4
%pair1 = bitcast %"variant[]"* %args to { i8*, i64 }*
%8 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair1, i32 0, i32 0
store i8* %4, i8** %8, align 8
%9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair1, i32 0, i32 1
store i64 %5, i64* %9, align 8
ret void
}
; Function Attrs: nounwind
define void @test_test(i32 %0) #0 {
entry:
%retparam = alloca i64, align 8
%taddr = alloca %"char[]", align 8
%vararg = alloca %"variant[]", align 8
%varargslots = alloca [1 x %variant], align 16
%taddr1 = alloca [3 x i8]*, align 8
%retparam4 = alloca i64, align 8
%taddr5 = alloca %"char[]", align 8
%vararg8 = alloca %"variant[]", align 8
%varargslots9 = alloca [1 x %variant], align 16
%taddr10 = alloca [3 x i8]*, align 8
%retparam16 = alloca i64, align 8
%taddr17 = alloca %"char[]", align 8
%vararg20 = alloca %"variant[]", align 8
%varargslots21 = alloca [1 x %variant], align 16
%taddr22 = alloca [4 x i8]*, align 8
%retparam28 = alloca i64, align 8
%taddr29 = alloca %"char[]", align 8
%vararg32 = alloca %"variant[]", align 8
%varargslots33 = alloca [1 x %variant], align 16
%taddr34 = alloca [5 x i8]*, align 8
%retparam40 = alloca i64, align 8
%taddr41 = alloca %"char[]", align 8
%vararg44 = alloca %"variant[]", align 8
%varargslots45 = alloca [1 x %variant], align 16
%taddr46 = alloca [6 x i8]*, align 8
%retparam52 = alloca i64, align 8
%taddr53 = alloca %"char[]", align 8
%vararg56 = alloca %"variant[]", align 8
%varargslots57 = alloca [1 x %variant], align 16
%taddr58 = alloca [3 x i8]*, align 8
%retparam64 = alloca i64, align 8
%taddr65 = alloca %"char[]", align 8
%vararg68 = alloca %"variant[]", align 8
%varargslots69 = alloca [1 x %variant], align 16
%taddr70 = alloca [3 x i8]*, align 8
%retparam76 = alloca i64, align 8
%taddr77 = alloca %"char[]", align 8
%vararg80 = alloca %"variant[]", align 8
%varargslots81 = alloca [1 x %variant], align 16
%taddr82 = alloca [5 x i8]*, align 8
%1 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0)) #1
%2 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0)) #1
%3 = call i32 @std_io_println(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i32 0, i32 0)) #1
%4 = call i32 @std_io_println(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i32 0, i32 0)) #1
%5 = call i32 @std_io_println(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0)) #1
%6 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i32 0, i32 0)) #1
%7 = call i32 @std_io_println(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i32 0, i32 0)) #1
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8
%8 = bitcast %"char[]"* %taddr to { i8*, i64 }*
%9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0
%lo = load i8*, i8** %9, align 8
%10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1
%hi = load i64, i64* %10, align 8
store [3 x i8]* bitcast ([4 x i8]* @.str.10 to [3 x i8]*), [3 x i8]** %taddr1, align 8
%11 = bitcast [3 x i8]** %taddr1 to i8*
%12 = insertvalue %variant undef, i8* %11, 0
%13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1
%14 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
store %variant %13, %variant* %14, align 16
%15 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
store i64 1, i64* %15, align 8
%16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
%17 = bitcast [1 x %variant]* %varargslots to %variant*
store %variant* %17, %variant** %16, align 8
%18 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
%19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0
%lo2 = load i8*, i8** %19, align 8
%20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1
%hi3 = load i64, i64* %20, align 8
%21 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3)
%not_err = icmp eq i64 %21, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
br label %voiderr
voiderr: ; preds = %after_check, %entry
store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.11, i32 0, i32 0), i64 10 }, %"char[]"* %taddr5, align 8
%22 = bitcast %"char[]"* %taddr5 to { i8*, i64 }*
%23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0
%lo6 = load i8*, i8** %23, align 8
%24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1
%hi7 = load i64, i64* %24, align 8
store [3 x i8]* bitcast ([4 x i8]* @.str.12 to [3 x i8]*), [3 x i8]** %taddr10, align 8
%25 = bitcast [3 x i8]** %taddr10 to i8*
%26 = insertvalue %variant undef, i8* %25, 0
%27 = insertvalue %variant %26, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1
%28 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots9, i64 0, i64 0
store %variant %27, %variant* %28, align 16
%29 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 1
store i64 1, i64* %29, align 8
%30 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 0
%31 = bitcast [1 x %variant]* %varargslots9 to %variant*
store %variant* %31, %variant** %30, align 8
%32 = bitcast %"variant[]"* %vararg8 to { i8*, i64 }*
%33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0
%lo11 = load i8*, i8** %33, align 8
%34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1
%hi12 = load i64, i64* %34, align 8
%35 = call i64 @std_io_printfln(i64* %retparam4, i8* %lo6, i64 %hi7, i8* %lo11, i64 %hi12)
%not_err13 = icmp eq i64 %35, 0
br i1 %not_err13, label %after_check14, label %voiderr15
after_check14: ; preds = %voiderr
br label %voiderr15
voiderr15: ; preds = %after_check14, %voiderr
store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i32 0, i32 0), i64 10 }, %"char[]"* %taddr17, align 8
%36 = bitcast %"char[]"* %taddr17 to { i8*, i64 }*
%37 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 0
%lo18 = load i8*, i8** %37, align 8
%38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %36, i32 0, i32 1
%hi19 = load i64, i64* %38, align 8
store [4 x i8]* bitcast ([5 x i8]* @.str.14 to [4 x i8]*), [4 x i8]** %taddr22, align 8
%39 = bitcast [4 x i8]** %taddr22 to i8*
%40 = insertvalue %variant undef, i8* %39, 0
%41 = insertvalue %variant %40, i64 ptrtoint (%.introspect* @"ct$p$a4$char" to i64), 1
%42 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots21, i64 0, i64 0
store %variant %41, %variant* %42, align 16
%43 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 1
store i64 1, i64* %43, align 8
%44 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 0
%45 = bitcast [1 x %variant]* %varargslots21 to %variant*
store %variant* %45, %variant** %44, align 8
%46 = bitcast %"variant[]"* %vararg20 to { i8*, i64 }*
%47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 0
%lo23 = load i8*, i8** %47, align 8
%48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %46, i32 0, i32 1
%hi24 = load i64, i64* %48, align 8
%49 = call i64 @std_io_printfln(i64* %retparam16, i8* %lo18, i64 %hi19, i8* %lo23, i64 %hi24)
%not_err25 = icmp eq i64 %49, 0
br i1 %not_err25, label %after_check26, label %voiderr27
after_check26: ; preds = %voiderr15
br label %voiderr27
voiderr27: ; preds = %after_check26, %voiderr15
store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i32 0, i32 0), i64 10 }, %"char[]"* %taddr29, align 8
%50 = bitcast %"char[]"* %taddr29 to { i8*, i64 }*
%51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %50, i32 0, i32 0
%lo30 = load i8*, i8** %51, align 8
%52 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %50, i32 0, i32 1
%hi31 = load i64, i64* %52, align 8
store [5 x i8]* bitcast ([6 x i8]* @.str.16 to [5 x i8]*), [5 x i8]** %taddr34, align 8
%53 = bitcast [5 x i8]** %taddr34 to i8*
%54 = insertvalue %variant undef, i8* %53, 0
%55 = insertvalue %variant %54, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1
%56 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots33, i64 0, i64 0
store %variant %55, %variant* %56, align 16
%57 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 1
store i64 1, i64* %57, align 8
%58 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 0
%59 = bitcast [1 x %variant]* %varargslots33 to %variant*
store %variant* %59, %variant** %58, align 8
%60 = bitcast %"variant[]"* %vararg32 to { i8*, i64 }*
%61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0
%lo35 = load i8*, i8** %61, align 8
%62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1
%hi36 = load i64, i64* %62, align 8
%63 = call i64 @std_io_printfln(i64* %retparam28, i8* %lo30, i64 %hi31, i8* %lo35, i64 %hi36)
%not_err37 = icmp eq i64 %63, 0
br i1 %not_err37, label %after_check38, label %voiderr39
after_check38: ; preds = %voiderr27
br label %voiderr39
voiderr39: ; preds = %after_check38, %voiderr27
store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.17, i32 0, i32 0), i64 10 }, %"char[]"* %taddr41, align 8
%64 = bitcast %"char[]"* %taddr41 to { i8*, i64 }*
%65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 0
%lo42 = load i8*, i8** %65, align 8
%66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 1
%hi43 = load i64, i64* %66, align 8
store [6 x i8]* bitcast ([7 x i8]* @.str.18 to [6 x i8]*), [6 x i8]** %taddr46, align 8
%67 = bitcast [6 x i8]** %taddr46 to i8*
%68 = insertvalue %variant undef, i8* %67, 0
%69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$p$a6$char" to i64), 1
%70 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots45, i64 0, i64 0
store %variant %69, %variant* %70, align 16
%71 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 1
store i64 1, i64* %71, align 8
%72 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 0
%73 = bitcast [1 x %variant]* %varargslots45 to %variant*
store %variant* %73, %variant** %72, align 8
%74 = bitcast %"variant[]"* %vararg44 to { i8*, i64 }*
%75 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 0
%lo47 = load i8*, i8** %75, align 8
%76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 1
%hi48 = load i64, i64* %76, align 8
%77 = call i64 @std_io_printfln(i64* %retparam40, i8* %lo42, i64 %hi43, i8* %lo47, i64 %hi48)
%not_err49 = icmp eq i64 %77, 0
br i1 %not_err49, label %after_check50, label %voiderr51
after_check50: ; preds = %voiderr39
br label %voiderr51
voiderr51: ; preds = %after_check50, %voiderr39
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.19, i32 0, i32 0), i64 8 }, %"char[]"* %taddr53, align 8
%78 = bitcast %"char[]"* %taddr53 to { i8*, i64 }*
%79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0
%lo54 = load i8*, i8** %79, align 8
%80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1
%hi55 = load i64, i64* %80, align 8
store [3 x i8]* bitcast ([4 x i8]* @.str.20 to [3 x i8]*), [3 x i8]** %taddr58, align 8
%81 = bitcast [3 x i8]** %taddr58 to i8*
%82 = insertvalue %variant undef, i8* %81, 0
%83 = insertvalue %variant %82, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1
%84 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots57, i64 0, i64 0
store %variant %83, %variant* %84, align 16
%85 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg56, i32 0, i32 1
store i64 1, i64* %85, align 8
%86 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg56, i32 0, i32 0
%87 = bitcast [1 x %variant]* %varargslots57 to %variant*
store %variant* %87, %variant** %86, align 8
%88 = bitcast %"variant[]"* %vararg56 to { i8*, i64 }*
%89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 0
%lo59 = load i8*, i8** %89, align 8
%90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 1
%hi60 = load i64, i64* %90, align 8
%91 = call i64 @std_io_printfln(i64* %retparam52, i8* %lo54, i64 %hi55, i8* %lo59, i64 %hi60)
%not_err61 = icmp eq i64 %91, 0
br i1 %not_err61, label %after_check62, label %voiderr63
after_check62: ; preds = %voiderr51
br label %voiderr63
voiderr63: ; preds = %after_check62, %voiderr51
store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.21, i32 0, i32 0), i64 10 }, %"char[]"* %taddr65, align 8
%92 = bitcast %"char[]"* %taddr65 to { i8*, i64 }*
%93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 0
%lo66 = load i8*, i8** %93, align 8
%94 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 1
%hi67 = load i64, i64* %94, align 8
store [3 x i8]* bitcast ([4 x i8]* @.str.22 to [3 x i8]*), [3 x i8]** %taddr70, align 8
%95 = bitcast [3 x i8]** %taddr70 to i8*
%96 = insertvalue %variant undef, i8* %95, 0
%97 = insertvalue %variant %96, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1
%98 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots69, i64 0, i64 0
store %variant %97, %variant* %98, align 16
%99 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg68, i32 0, i32 1
store i64 1, i64* %99, align 8
%100 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg68, i32 0, i32 0
%101 = bitcast [1 x %variant]* %varargslots69 to %variant*
store %variant* %101, %variant** %100, align 8
%102 = bitcast %"variant[]"* %vararg68 to { i8*, i64 }*
%103 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %102, i32 0, i32 0
%lo71 = load i8*, i8** %103, align 8
%104 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %102, i32 0, i32 1
%hi72 = load i64, i64* %104, align 8
%105 = call i64 @std_io_printfln(i64* %retparam64, i8* %lo66, i64 %hi67, i8* %lo71, i64 %hi72)
%not_err73 = icmp eq i64 %105, 0
br i1 %not_err73, label %after_check74, label %voiderr75
after_check74: ; preds = %voiderr63
br label %voiderr75
voiderr75: ; preds = %after_check74, %voiderr63
store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.23, i32 0, i32 0), i64 10 }, %"char[]"* %taddr77, align 8
%106 = bitcast %"char[]"* %taddr77 to { i8*, i64 }*
%107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 0
%lo78 = load i8*, i8** %107, align 8
%108 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %106, i32 0, i32 1
%hi79 = load i64, i64* %108, align 8
store [5 x i8]* bitcast ([6 x i8]* @.str.24 to [5 x i8]*), [5 x i8]** %taddr82, align 8
%109 = bitcast [5 x i8]** %taddr82 to i8*
%110 = insertvalue %variant undef, i8* %109, 0
%111 = insertvalue %variant %110, i64 ptrtoint (%.introspect* @"ct$p$a5$char" to i64), 1
%112 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots81, i64 0, i64 0
store %variant %111, %variant* %112, align 16
%113 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg80, i32 0, i32 1
store i64 1, i64* %113, align 8
%114 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg80, i32 0, i32 0
%115 = bitcast [1 x %variant]* %varargslots81 to %variant*
store %variant* %115, %variant** %114, align 8
%116 = bitcast %"variant[]"* %vararg80 to { i8*, i64 }*
%117 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %116, i32 0, i32 0
%lo83 = load i8*, i8** %117, align 8
%118 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %116, i32 0, i32 1
%hi84 = load i64, i64* %118, align 8
%119 = call i64 @std_io_printfln(i64* %retparam76, i8* %lo78, i64 %hi79, i8* %lo83, i64 %hi84)
%not_err85 = icmp eq i64 %119, 0
br i1 %not_err85, label %after_check86, label %voiderr87
after_check86: ; preds = %voiderr75
br label %voiderr87
voiderr87: ; preds = %after_check86, %voiderr75
ret void
}

319
test/test_suite2/compile_time/ct_memberof.c3t Normal file
View File

@@ -0,0 +1,319 @@
// #target: macos-x64
module test;
import std::io;
fn int hell() { return 1; }
macro print_args($Type)
{
var $params = $Type.params;
$foreach ($param : $params):
io::println($nameof($typefrom($param)));
$endforeach
}
bitstruct Bar : ulong
{
int x : 1..4;
short y : 6..10;
}
struct Foo
{
int x;
union test {
int y;
double z;
}
struct {
int abc;
int bcd;
}
double q;
}
macro print_fields($Type)
{
io::printfln("Type: %s", $nameof($Type));
var $params = $Type.membersof;
$foreach ($param : $params):
io::printfln("Member: %s", $nameof($typefrom($param)));
$endforeach
}
fn void hello(int a, double b, int[4] d, args...) {}
fn void test(int x)
{
print_args($typeof(&test));
print_args($typeof(&hell));
print_args($typeof(&hello));
io::println($nameof($typefrom($typeof(&test).returns)));
io::println($nameof($typefrom($typeof(&hell).returns)));
print_fields(Foo);
print_fields(Bar);
}
fn void main()
{
test(10);
}
/* #expect: test.ll
define void @test_hello(i32 %0, double %1, i64 %2, i64 %3, ptr %4, i64 %5) #0 {
entry:
%d = alloca [4 x i32], align 4
%args = alloca %"variant[]", align 8
%6 = getelementptr inbounds { i64, i64 }, ptr %d, i32 0, i32 0
store i64 %2, ptr %6, align 4
%7 = getelementptr inbounds { i64, i64 }, ptr %d, i32 0, i32 1
store i64 %3, ptr %7, align 4
%8 = getelementptr inbounds { ptr, i64 }, ptr %args, i32 0, i32 0
store ptr %4, ptr %8, align 8
%9 = getelementptr inbounds { ptr, i64 }, ptr %args, i32 0, i32 1
store i64 %5, ptr %9, align 8
ret void
}
; Function Attrs: nounwind
define void @test_test(i32 %0) #0 {
entry:
%retparam = alloca i64, align 8
%taddr = alloca %"char[]", align 8
%vararg = alloca %"variant[]", align 8
%varargslots = alloca [1 x %variant], align 16
%taddr1 = alloca ptr, align 8
%retparam4 = alloca i64, align 8
%taddr5 = alloca %"char[]", align 8
%vararg8 = alloca %"variant[]", align 8
%varargslots9 = alloca [1 x %variant], align 16
%taddr10 = alloca ptr, align 8
%retparam16 = alloca i64, align 8
%taddr17 = alloca %"char[]", align 8
%vararg20 = alloca %"variant[]", align 8
%varargslots21 = alloca [1 x %variant], align 16
%taddr22 = alloca ptr, align 8
%retparam28 = alloca i64, align 8
%taddr29 = alloca %"char[]", align 8
%vararg32 = alloca %"variant[]", align 8
%varargslots33 = alloca [1 x %variant], align 16
%taddr34 = alloca ptr, align 8
%retparam40 = alloca i64, align 8
%taddr41 = alloca %"char[]", align 8
%vararg44 = alloca %"variant[]", align 8
%varargslots45 = alloca [1 x %variant], align 16
%taddr46 = alloca ptr, align 8
%retparam52 = alloca i64, align 8
%taddr53 = alloca %"char[]", align 8
%vararg56 = alloca %"variant[]", align 8
%varargslots57 = alloca [1 x %variant], align 16
%taddr58 = alloca ptr, align 8
%retparam64 = alloca i64, align 8
%taddr65 = alloca %"char[]", align 8
%vararg68 = alloca %"variant[]", align 8
%varargslots69 = alloca [1 x %variant], align 16
%taddr70 = alloca ptr, align 8
%retparam76 = alloca i64, align 8
%taddr77 = alloca %"char[]", align 8
%vararg80 = alloca %"variant[]", align 8
%varargslots81 = alloca [1 x %variant], align 16
%taddr82 = alloca ptr, align 8
%1 = call i32 @std_io_println(ptr @.str) #1
%2 = call i32 @std_io_println(ptr @.str.3) #1
%3 = call i32 @std_io_println(ptr @.str.4) #1
%4 = call i32 @std_io_println(ptr @.str.5) #1
%5 = call i32 @std_io_println(ptr @.str.6) #1
%6 = call i32 @std_io_println(ptr @.str.7) #1
%7 = call i32 @std_io_println(ptr @.str.8) #1
store %"char[]" { ptr @.str.9, i64 8 }, ptr %taddr, align 8
%8 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
%lo = load ptr, ptr %8, align 8
%9 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
%hi = load i64, ptr %9, align 8
store ptr @.str.10, ptr %taddr1, align 8
%10 = insertvalue %variant undef, ptr %taddr1, 0
%11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%12 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %11, ptr %12, align 16
%13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
store i64 1, ptr %13, align 8
%14 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
store ptr %varargslots, ptr %14, align 8
%15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
%lo2 = load ptr, ptr %15, align 8
%16 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
%hi3 = load i64, ptr %16, align 8
%17 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3)
%not_err = icmp eq i64 %17, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
br label %voiderr
voiderr: ; preds = %after_check, %entry
store %"char[]" { ptr @.str.11, i64 10 }, ptr %taddr5, align 8
%18 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 0
%lo6 = load ptr, ptr %18, align 8
%19 = getelementptr inbounds { ptr, i64 }, ptr %taddr5, i32 0, i32 1
%hi7 = load i64, ptr %19, align 8
store ptr @.str.12, ptr %taddr10, align 8
%20 = insertvalue %variant undef, ptr %taddr10, 0
%21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%22 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
store %variant %21, ptr %22, align 16
%23 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 1
store i64 1, ptr %23, align 8
%24 = getelementptr inbounds %"variant[]", ptr %vararg8, i32 0, i32 0
store ptr %varargslots9, ptr %24, align 8
%25 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 0
%lo11 = load ptr, ptr %25, align 8
%26 = getelementptr inbounds { ptr, i64 }, ptr %vararg8, i32 0, i32 1
%hi12 = load i64, ptr %26, align 8
%27 = call i64 @std_io_printfln(ptr %retparam4, ptr %lo6, i64 %hi7, ptr %lo11, i64 %hi12)
%not_err13 = icmp eq i64 %27, 0
br i1 %not_err13, label %after_check14, label %voiderr15
after_check14: ; preds = %voiderr
br label %voiderr15
voiderr15: ; preds = %after_check14, %voiderr
store %"char[]" { ptr @.str.13, i64 10 }, ptr %taddr17, align 8
%28 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 0
%lo18 = load ptr, ptr %28, align 8
%29 = getelementptr inbounds { ptr, i64 }, ptr %taddr17, i32 0, i32 1
%hi19 = load i64, ptr %29, align 8
store ptr @.str.14, ptr %taddr22, align 8
%30 = insertvalue %variant undef, ptr %taddr22, 0
%31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%32 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
store %variant %31, ptr %32, align 16
%33 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 1
store i64 1, ptr %33, align 8
%34 = getelementptr inbounds %"variant[]", ptr %vararg20, i32 0, i32 0
store ptr %varargslots21, ptr %34, align 8
%35 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 0
%lo23 = load ptr, ptr %35, align 8
%36 = getelementptr inbounds { ptr, i64 }, ptr %vararg20, i32 0, i32 1
%hi24 = load i64, ptr %36, align 8
%37 = call i64 @std_io_printfln(ptr %retparam16, ptr %lo18, i64 %hi19, ptr %lo23, i64 %hi24)
%not_err25 = icmp eq i64 %37, 0
br i1 %not_err25, label %after_check26, label %voiderr27
after_check26: ; preds = %voiderr15
br label %voiderr27
voiderr27: ; preds = %after_check26, %voiderr15
store %"char[]" { ptr @.str.15, i64 10 }, ptr %taddr29, align 8
%38 = getelementptr inbounds { ptr, i64 }, ptr %taddr29, i32 0, i32 0
%lo30 = load ptr, ptr %38, align 8
%39 = getelementptr inbounds { ptr, i64 }, ptr %taddr29, i32 0, i32 1
%hi31 = load i64, ptr %39, align 8
store ptr @.str.16, ptr %taddr34, align 8
%40 = insertvalue %variant undef, ptr %taddr34, 0
%41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%42 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
store %variant %41, ptr %42, align 16
%43 = getelementptr inbounds %"variant[]", ptr %vararg32, i32 0, i32 1
store i64 1, ptr %43, align 8
%44 = getelementptr inbounds %"variant[]", ptr %vararg32, i32 0, i32 0
store ptr %varargslots33, ptr %44, align 8
%45 = getelementptr inbounds { ptr, i64 }, ptr %vararg32, i32 0, i32 0
%lo35 = load ptr, ptr %45, align 8
%46 = getelementptr inbounds { ptr, i64 }, ptr %vararg32, i32 0, i32 1
%hi36 = load i64, ptr %46, align 8
%47 = call i64 @std_io_printfln(ptr %retparam28, ptr %lo30, i64 %hi31, ptr %lo35, i64 %hi36)
%not_err37 = icmp eq i64 %47, 0
br i1 %not_err37, label %after_check38, label %voiderr39
after_check38: ; preds = %voiderr27
br label %voiderr39
voiderr39: ; preds = %after_check38, %voiderr27
store %"char[]" { ptr @.str.17, i64 10 }, ptr %taddr41, align 8
%48 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 0
%lo42 = load ptr, ptr %48, align 8
%49 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 1
%hi43 = load i64, ptr %49, align 8
store ptr @.str.18, ptr %taddr46, align 8
%50 = insertvalue %variant undef, ptr %taddr46, 0
%51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
%52 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0
store %variant %51, ptr %52, align 16
%53 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 1
store i64 1, ptr %53, align 8
%54 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 0
store ptr %varargslots45, ptr %54, align 8
%55 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 0
%lo47 = load ptr, ptr %55, align 8
%56 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 1
%hi48 = load i64, ptr %56, align 8
%57 = call i64 @std_io_printfln(ptr %retparam40, ptr %lo42, i64 %hi43, ptr %lo47, i64 %hi48)
%not_err49 = icmp eq i64 %57, 0
br i1 %not_err49, label %after_check50, label %voiderr51
after_check50: ; preds = %voiderr39
br label %voiderr51
voiderr51: ; preds = %after_check50, %voiderr39
store %"char[]" { ptr @.str.19, i64 8 }, ptr %taddr53, align 8
%58 = getelementptr inbounds { ptr, i64 }, ptr %taddr53, i32 0, i32 0
%lo54 = load ptr, ptr %58, align 8
%59 = getelementptr inbounds { ptr, i64 }, ptr %taddr53, i32 0, i32 1
%hi55 = load i64, ptr %59, align 8
store ptr @.str.20, ptr %taddr58, align 8
%60 = insertvalue %variant undef, ptr %taddr58, 0
%61 = insertvalue %variant %60, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%62 = getelementptr inbounds [1 x %variant], ptr %varargslots57, i64 0, i64 0
store %variant %61, ptr %62, align 16
%63 = getelementptr inbounds %"variant[]", ptr %vararg56, i32 0, i32 1
store i64 1, ptr %63, align 8
%64 = getelementptr inbounds %"variant[]", ptr %vararg56, i32 0, i32 0
store ptr %varargslots57, ptr %64, align 8
%65 = getelementptr inbounds { ptr, i64 }, ptr %vararg56, i32 0, i32 0
%lo59 = load ptr, ptr %65, align 8
%66 = getelementptr inbounds { ptr, i64 }, ptr %vararg56, i32 0, i32 1
%hi60 = load i64, ptr %66, align 8
%67 = call i64 @std_io_printfln(ptr %retparam52, ptr %lo54, i64 %hi55, ptr %lo59, i64 %hi60)
%not_err61 = icmp eq i64 %67, 0
br i1 %not_err61, label %after_check62, label %voiderr63
after_check62: ; preds = %voiderr51
br label %voiderr63
voiderr63: ; preds = %after_check62, %voiderr51
store %"char[]" { ptr @.str.21, i64 10 }, ptr %taddr65, align 8
%68 = getelementptr inbounds { ptr, i64 }, ptr %taddr65, i32 0, i32 0
%lo66 = load ptr, ptr %68, align 8
%69 = getelementptr inbounds { ptr, i64 }, ptr %taddr65, i32 0, i32 1
%hi67 = load i64, ptr %69, align 8
store ptr @.str.22, ptr %taddr70, align 8
%70 = insertvalue %variant undef, ptr %taddr70, 0
%71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%72 = getelementptr inbounds [1 x %variant], ptr %varargslots69, i64 0, i64 0
store %variant %71, ptr %72, align 16
%73 = getelementptr inbounds %"variant[]", ptr %vararg68, i32 0, i32 1
store i64 1, ptr %73, align 8
%74 = getelementptr inbounds %"variant[]", ptr %vararg68, i32 0, i32 0
store ptr %varargslots69, ptr %74, align 8
%75 = getelementptr inbounds { ptr, i64 }, ptr %vararg68, i32 0, i32 0
%lo71 = load ptr, ptr %75, align 8
%76 = getelementptr inbounds { ptr, i64 }, ptr %vararg68, i32 0, i32 1
%hi72 = load i64, ptr %76, align 8
%77 = call i64 @std_io_printfln(ptr %retparam64, ptr %lo66, i64 %hi67, ptr %lo71, i64 %hi72)
%not_err73 = icmp eq i64 %77, 0
br i1 %not_err73, label %after_check74, label %voiderr75
after_check74: ; preds = %voiderr63
br label %voiderr75
voiderr75: ; preds = %after_check74, %voiderr63
store %"char[]" { ptr @.str.23, i64 10 }, ptr %taddr77, align 8
%78 = getelementptr inbounds { ptr, i64 }, ptr %taddr77, i32 0, i32 0
%lo78 = load ptr, ptr %78, align 8
%79 = getelementptr inbounds { ptr, i64 }, ptr %taddr77, i32 0, i32 1
%hi79 = load i64, ptr %79, align 8
store ptr @.str.24, ptr %taddr82, align 8
%80 = insertvalue %variant undef, ptr %taddr82, 0
%81 = insertvalue %variant %80, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%82 = getelementptr inbounds [1 x %variant], ptr %varargslots81, i64 0, i64 0
store %variant %81, ptr %82, align 16
%83 = getelementptr inbounds %"variant[]", ptr %vararg80, i32 0, i32 1
store i64 1, ptr %83, align 8
%84 = getelementptr inbounds %"variant[]", ptr %vararg80, i32 0, i32 0
store ptr %varargslots81, ptr %84, align 8
%85 = getelementptr inbounds { ptr, i64 }, ptr %vararg80, i32 0, i32 0
%lo83 = load ptr, ptr %85, align 8
%86 = getelementptr inbounds { ptr, i64 }, ptr %vararg80, i32 0, i32 1
%hi84 = load i64, ptr %86, align 8
%87 = call i64 @std_io_printfln(ptr %retparam76, ptr %lo78, i64 %hi79, ptr %lo83, i64 %hi84)
%not_err85 = icmp eq i64 %87, 0
br i1 %not_err85, label %after_check86, label %voiderr87
after_check86: ; preds = %voiderr75
br label %voiderr87
voiderr87: ; preds = %after_check86, %voiderr75
ret void
}