mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
407 lines
18 KiB
C
407 lines
18 KiB
C
// #target: macos-x64
|
|
|
|
module test;
|
|
import std::io;
|
|
import std::map;
|
|
|
|
struct Foo { int x; void* bar; }
|
|
|
|
define IntFooMap = std::map::HashMap<int, Foo>;
|
|
define IntDoubleMap = std::map::HashMap<int, double>;
|
|
|
|
fn char[] Foo.to_string(Foo* foo, Allocator* allocator = mem::current_allocator())
|
|
{
|
|
VarString s = string::new_with_capacity(128, allocator);
|
|
s.printf("{%s, %p}", foo.x, foo.bar);
|
|
return s.str();
|
|
}
|
|
|
|
static initialize
|
|
{
|
|
io::formatter_register_type(Foo);
|
|
}
|
|
|
|
fn void main()
|
|
{
|
|
IntFooMap map;
|
|
map.init();
|
|
io::printfln("Map size: %d", map.count);
|
|
map.set(1, Foo { 1, null });
|
|
io::printfln("Map size: %d", map.count);
|
|
map.set(1, Foo { 2, null });
|
|
io::printfln("Map size: %d", map.count);
|
|
io::printfln("Val: %d", map.get(1).x);
|
|
io::printfln("Has 1: %s", map.has_key(1));
|
|
io::printfln("Has 2: %s", map.has_key(2));
|
|
map.set(7, Foo { 4, null });
|
|
io::printfln("Values: %s", map.value_list());
|
|
IntDoubleMap map2;
|
|
map2.init();
|
|
map2.set(4, 1.3);
|
|
io::printfln("Map find: %s", map2.has_value(1.3));
|
|
io::printfln("Map find: %s", map2.has_value(1.2));
|
|
map2.set(100, 3.4);
|
|
io::printfln("%s", map2.key_list());
|
|
io::printfln("%s", map2.value_list());
|
|
@pool()
|
|
{
|
|
IntDoubleMap map3;
|
|
map3.init();
|
|
map3.set(5, 3.2);
|
|
map3.set(7, 5.2);
|
|
io::printfln("%s", map3.key_list());
|
|
};
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @.static_initialize.0, ptr null }]
|
|
|
|
define internal void @.static_initialize.0() {
|
|
entry:
|
|
%0 = load i64, ptr getelementptr inbounds (%"Entry*[]", ptr @std_io_tostring_functions, i32 0, i32 1), align 8
|
|
%not = icmp eq i64 %0, 0
|
|
br i1 %not, label %if.then, label %if.exit
|
|
|
|
if.then: ; preds = %entry
|
|
%1 = load ptr, ptr @std_core_mem_thread_allocator, align 8
|
|
call void @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_init"(ptr @std_io_tostring_functions, i32 512, float 7.500000e-01, ptr %1)
|
|
br label %if.exit
|
|
|
|
if.exit: ; preds = %if.then, %entry
|
|
%2 = call i8 @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_set"(ptr @std_io_tostring_functions, i64 ptrtoint (ptr @"ct$test_Foo" to i64), ptr @test_Foo_to_string)
|
|
ret void
|
|
}
|
|
|
|
define { ptr, i64 } @test_Foo_to_string(ptr %0, ptr %1) #0 {
|
|
entry:
|
|
%s = alloca ptr, align 8
|
|
%retparam = alloca i64, align 8
|
|
%varargslots = alloca [2 x %variant], align 16
|
|
%result = alloca %"char[]", align 8
|
|
%2 = call ptr @std_core_string_new_with_capacity(i64 128, ptr %1)
|
|
store ptr %2, ptr %s, align 8
|
|
%3 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 0
|
|
%4 = insertvalue %variant undef, ptr %3, 0
|
|
%5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1
|
|
%6 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
|
|
store %variant %5, ptr %6, align 16
|
|
%7 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 1
|
|
%8 = insertvalue %variant undef, ptr %7, 0
|
|
%9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$p$void" to i64), 1
|
|
%10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
|
|
store %variant %9, ptr %10, align 16
|
|
%11 = call i64 @std_core_string_VarString_printf(ptr %retparam, ptr %s, ptr @.str.12, i64 8, ptr %varargslots, i64 2)
|
|
%not_err = icmp eq i64 %11, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
%12 = load ptr, ptr %s, align 8
|
|
%13 = call { ptr, i64 } @std_core_string_VarString_str(ptr %12)
|
|
store { ptr, i64 } %13, ptr %result, align 8
|
|
%14 = load { ptr, i64 }, ptr %result, align 8
|
|
ret { ptr, i64 } %14
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define void @test_main() #0 {
|
|
entry:
|
|
%map = alloca %HashMap.0, align 8
|
|
%retparam = alloca i64, align 8
|
|
%varargslots = alloca [1 x %variant], align 16
|
|
%literal = alloca %Foo, align 8
|
|
%retparam1 = alloca i64, align 8
|
|
%varargslots2 = alloca [1 x %variant], align 16
|
|
%literal6 = alloca %Foo, align 8
|
|
%retparam9 = alloca i64, align 8
|
|
%varargslots10 = alloca [1 x %variant], align 16
|
|
%retparam14 = alloca i64, align 8
|
|
%varargslots15 = alloca [1 x %variant], align 16
|
|
%retparam16 = alloca %Foo, align 8
|
|
%retparam22 = alloca i64, align 8
|
|
%varargslots23 = alloca [1 x %variant], align 16
|
|
%taddr = alloca i8, align 1
|
|
%retparam27 = alloca i64, align 8
|
|
%varargslots28 = alloca [1 x %variant], align 16
|
|
%taddr29 = alloca i8, align 1
|
|
%literal33 = alloca %Foo, align 8
|
|
%retparam36 = alloca i64, align 8
|
|
%varargslots37 = alloca [1 x %variant], align 16
|
|
%result = alloca %"Foo[]", align 8
|
|
%map2 = alloca %HashMap.3, align 8
|
|
%retparam41 = alloca i64, align 8
|
|
%varargslots42 = alloca [1 x %variant], align 16
|
|
%taddr43 = alloca i8, align 1
|
|
%retparam47 = alloca i64, align 8
|
|
%varargslots48 = alloca [1 x %variant], align 16
|
|
%taddr49 = alloca i8, align 1
|
|
%retparam53 = alloca i64, align 8
|
|
%varargslots54 = alloca [1 x %variant], align 16
|
|
%result55 = alloca %"int[]", align 8
|
|
%retparam59 = alloca i64, align 8
|
|
%varargslots60 = alloca [1 x %variant], align 16
|
|
%result61 = alloca %"double[]", align 8
|
|
%temp = alloca ptr, align 8
|
|
%error_var = alloca i64, align 8
|
|
%retparam65 = alloca ptr, align 8
|
|
%mark = alloca i64, align 8
|
|
%map3 = alloca %HashMap.3, align 8
|
|
%retparam68 = alloca i64, align 8
|
|
%varargslots69 = alloca [1 x %variant], align 16
|
|
%result70 = alloca %"int[]", align 8
|
|
call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false)
|
|
%0 = load ptr, ptr @std_core_mem_thread_allocator, align 8
|
|
call void @"std_map$$int.test_Foo_HashMap_init"(ptr %map, i32 16, float 7.500000e-01, ptr %0)
|
|
%1 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
|
|
%2 = insertvalue %variant undef, ptr %1, 0
|
|
%3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$uint" to i64), 1
|
|
%4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
|
|
store %variant %3, ptr %4, align 16
|
|
%5 = call i64 @std_io_printfln(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
|
|
%not_err = icmp eq i64 %5, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
%6 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
|
|
store i32 1, ptr %6, align 8
|
|
%7 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
|
|
store ptr null, ptr %7, align 8
|
|
%8 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 0
|
|
%lo = load i64, ptr %8, align 8
|
|
%9 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 1
|
|
%hi = load ptr, ptr %9, align 8
|
|
%10 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo, ptr %hi)
|
|
%11 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
|
|
%12 = insertvalue %variant undef, ptr %11, 0
|
|
%13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$uint" to i64), 1
|
|
%14 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
|
|
store %variant %13, ptr %14, align 16
|
|
%15 = call i64 @std_io_printfln(ptr %retparam1, ptr @.str.1, i64 12, ptr %varargslots2, i64 1)
|
|
%not_err3 = icmp eq i64 %15, 0
|
|
br i1 %not_err3, label %after_check4, label %voiderr5
|
|
|
|
after_check4: ; preds = %voiderr
|
|
br label %voiderr5
|
|
|
|
voiderr5: ; preds = %after_check4, %voiderr
|
|
%16 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 0
|
|
store i32 2, ptr %16, align 8
|
|
%17 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 1
|
|
store ptr null, ptr %17, align 8
|
|
%18 = getelementptr inbounds { i64, ptr }, ptr %literal6, i32 0, i32 0
|
|
%lo7 = load i64, ptr %18, align 8
|
|
%19 = getelementptr inbounds { i64, ptr }, ptr %literal6, i32 0, i32 1
|
|
%hi8 = load ptr, ptr %19, align 8
|
|
%20 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 1, i64 %lo7, ptr %hi8)
|
|
%21 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
|
|
%22 = insertvalue %variant undef, ptr %21, 0
|
|
%23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$uint" to i64), 1
|
|
%24 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0
|
|
store %variant %23, ptr %24, align 16
|
|
%25 = call i64 @std_io_printfln(ptr %retparam9, ptr @.str.2, i64 12, ptr %varargslots10, i64 1)
|
|
%not_err11 = icmp eq i64 %25, 0
|
|
br i1 %not_err11, label %after_check12, label %voiderr13
|
|
|
|
after_check12: ; preds = %voiderr5
|
|
br label %voiderr13
|
|
|
|
voiderr13: ; preds = %after_check12, %voiderr5
|
|
%26 = call i64 @"std_map$$int.test_Foo_HashMap_get"(ptr %retparam16, ptr %map, i32 1)
|
|
%not_err17 = icmp eq i64 %26, 0
|
|
br i1 %not_err17, label %after_check18, label %voiderr21
|
|
|
|
after_check18: ; preds = %voiderr13
|
|
%27 = getelementptr inbounds %Foo, ptr %retparam16, i32 0, i32 0
|
|
%28 = insertvalue %variant undef, ptr %27, 0
|
|
%29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$int" to i64), 1
|
|
%30 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
|
|
store %variant %29, ptr %30, align 16
|
|
%31 = call i64 @std_io_printfln(ptr %retparam14, ptr @.str.3, i64 7, ptr %varargslots15, i64 1)
|
|
%not_err19 = icmp eq i64 %31, 0
|
|
br i1 %not_err19, label %after_check20, label %voiderr21
|
|
|
|
after_check20: ; preds = %after_check18
|
|
br label %voiderr21
|
|
|
|
voiderr21: ; preds = %after_check20, %after_check18, %voiderr13
|
|
%32 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 1)
|
|
store i8 %32, ptr %taddr, align 1
|
|
%33 = insertvalue %variant undef, ptr %taddr, 0
|
|
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$bool" to i64), 1
|
|
%35 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
|
|
store %variant %34, ptr %35, align 16
|
|
%36 = call i64 @std_io_printfln(ptr %retparam22, ptr @.str.4, i64 9, ptr %varargslots23, i64 1)
|
|
%not_err24 = icmp eq i64 %36, 0
|
|
br i1 %not_err24, label %after_check25, label %voiderr26
|
|
|
|
after_check25: ; preds = %voiderr21
|
|
br label %voiderr26
|
|
|
|
voiderr26: ; preds = %after_check25, %voiderr21
|
|
%37 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(ptr %map, i32 2)
|
|
store i8 %37, ptr %taddr29, align 1
|
|
%38 = insertvalue %variant undef, ptr %taddr29, 0
|
|
%39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$bool" to i64), 1
|
|
%40 = getelementptr inbounds [1 x %variant], ptr %varargslots28, i64 0, i64 0
|
|
store %variant %39, ptr %40, align 16
|
|
%41 = call i64 @std_io_printfln(ptr %retparam27, ptr @.str.5, i64 9, ptr %varargslots28, i64 1)
|
|
%not_err30 = icmp eq i64 %41, 0
|
|
br i1 %not_err30, label %after_check31, label %voiderr32
|
|
|
|
after_check31: ; preds = %voiderr26
|
|
br label %voiderr32
|
|
|
|
voiderr32: ; preds = %after_check31, %voiderr26
|
|
%42 = getelementptr inbounds %Foo, ptr %literal33, i32 0, i32 0
|
|
store i32 4, ptr %42, align 8
|
|
%43 = getelementptr inbounds %Foo, ptr %literal33, i32 0, i32 1
|
|
store ptr null, ptr %43, align 8
|
|
%44 = getelementptr inbounds { i64, ptr }, ptr %literal33, i32 0, i32 0
|
|
%lo34 = load i64, ptr %44, align 8
|
|
%45 = getelementptr inbounds { i64, ptr }, ptr %literal33, i32 0, i32 1
|
|
%hi35 = load ptr, ptr %45, align 8
|
|
%46 = call i8 @"std_map$$int.test_Foo_HashMap_set"(ptr %map, i32 7, i64 %lo34, ptr %hi35)
|
|
%47 = load ptr, ptr @std_core_mem_thread_allocator, align 8
|
|
%48 = call { ptr, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(ptr %map, ptr %47)
|
|
store { ptr, i64 } %48, ptr %result, align 8
|
|
%49 = insertvalue %variant undef, ptr %result, 0
|
|
%50 = insertvalue %variant %49, i64 ptrtoint (ptr @"ct$sa$test_Foo" to i64), 1
|
|
%51 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
|
|
store %variant %50, ptr %51, align 16
|
|
%52 = call i64 @std_io_printfln(ptr %retparam36, ptr @.str.6, i64 10, ptr %varargslots37, i64 1)
|
|
%not_err38 = icmp eq i64 %52, 0
|
|
br i1 %not_err38, label %after_check39, label %voiderr40
|
|
|
|
after_check39: ; preds = %voiderr32
|
|
br label %voiderr40
|
|
|
|
voiderr40: ; preds = %after_check39, %voiderr32
|
|
call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 40, i1 false)
|
|
%53 = load ptr, ptr @std_core_mem_thread_allocator, align 8
|
|
call void @"std_map$$int.double_HashMap_init"(ptr %map2, i32 16, float 7.500000e-01, ptr %53)
|
|
%54 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 4, double 1.300000e+00)
|
|
%55 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.300000e+00)
|
|
store i8 %55, ptr %taddr43, align 1
|
|
%56 = insertvalue %variant undef, ptr %taddr43, 0
|
|
%57 = insertvalue %variant %56, i64 ptrtoint (ptr @"ct$bool" to i64), 1
|
|
%58 = getelementptr inbounds [1 x %variant], ptr %varargslots42, i64 0, i64 0
|
|
store %variant %57, ptr %58, align 16
|
|
%59 = call i64 @std_io_printfln(ptr %retparam41, ptr @.str.7, i64 12, ptr %varargslots42, i64 1)
|
|
%not_err44 = icmp eq i64 %59, 0
|
|
br i1 %not_err44, label %after_check45, label %voiderr46
|
|
|
|
after_check45: ; preds = %voiderr40
|
|
br label %voiderr46
|
|
|
|
voiderr46: ; preds = %after_check45, %voiderr40
|
|
%60 = call i8 @"std_map$$int.double_HashMap_has_value"(ptr %map2, double 1.200000e+00)
|
|
store i8 %60, ptr %taddr49, align 1
|
|
%61 = insertvalue %variant undef, ptr %taddr49, 0
|
|
%62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$bool" to i64), 1
|
|
%63 = getelementptr inbounds [1 x %variant], ptr %varargslots48, i64 0, i64 0
|
|
store %variant %62, ptr %63, align 16
|
|
%64 = call i64 @std_io_printfln(ptr %retparam47, ptr @.str.8, i64 12, ptr %varargslots48, i64 1)
|
|
%not_err50 = icmp eq i64 %64, 0
|
|
br i1 %not_err50, label %after_check51, label %voiderr52
|
|
|
|
after_check51: ; preds = %voiderr46
|
|
br label %voiderr52
|
|
|
|
voiderr52: ; preds = %after_check51, %voiderr46
|
|
%65 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map2, i32 100, double 3.400000e+00)
|
|
%66 = load ptr, ptr @std_core_mem_thread_allocator, align 8
|
|
%67 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map2, ptr %66)
|
|
store { ptr, i64 } %67, ptr %result55, align 8
|
|
%68 = insertvalue %variant undef, ptr %result55, 0
|
|
%69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
|
|
%70 = getelementptr inbounds [1 x %variant], ptr %varargslots54, i64 0, i64 0
|
|
store %variant %69, ptr %70, align 16
|
|
%71 = call i64 @std_io_printfln(ptr %retparam53, ptr @.str.9, i64 2, ptr %varargslots54, i64 1)
|
|
%not_err56 = icmp eq i64 %71, 0
|
|
br i1 %not_err56, label %after_check57, label %voiderr58
|
|
|
|
after_check57: ; preds = %voiderr52
|
|
br label %voiderr58
|
|
|
|
voiderr58: ; preds = %after_check57, %voiderr52
|
|
%72 = load ptr, ptr @std_core_mem_thread_allocator, align 8
|
|
%73 = call { ptr, i64 } @"std_map$$int.double_HashMap_value_list"(ptr %map2, ptr %72)
|
|
store { ptr, i64 } %73, ptr %result61, align 8
|
|
%74 = insertvalue %variant undef, ptr %result61, 0
|
|
%75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$double" to i64), 1
|
|
%76 = getelementptr inbounds [1 x %variant], ptr %varargslots60, i64 0, i64 0
|
|
store %variant %75, ptr %76, align 16
|
|
%77 = call i64 @std_io_printfln(ptr %retparam59, ptr @.str.10, i64 2, ptr %varargslots60, i64 1)
|
|
%not_err62 = icmp eq i64 %77, 0
|
|
br i1 %not_err62, label %after_check63, label %voiderr64
|
|
|
|
after_check63: ; preds = %voiderr58
|
|
br label %voiderr64
|
|
|
|
voiderr64: ; preds = %after_check63, %voiderr58
|
|
%78 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
|
|
%not = icmp eq ptr %78, null
|
|
br i1 %not, label %if.then, label %if.exit
|
|
|
|
if.then: ; preds = %voiderr64
|
|
%79 = call i64 @std_core_mem_allocator_new_temp(ptr %retparam65, i64 131072, ptr @std_core_mem_allocator__SYSTEM_ALLOCATOR)
|
|
%not_err66 = icmp eq i64 %79, 0
|
|
br i1 %not_err66, label %after_check67, label %assign_optional
|
|
|
|
assign_optional: ; preds = %if.then
|
|
store i64 %79, ptr %error_var, align 8
|
|
br label %panic_block
|
|
|
|
after_check67: ; preds = %if.then
|
|
%80 = load ptr, ptr %retparam65, align 8
|
|
br label %noerr_block
|
|
|
|
panic_block: ; preds = %assign_optional
|
|
%81 = load ptr, ptr @std_core_builtin_panic, align 8
|
|
call void %81(ptr @.panic_msg, i64 27, ptr @.file, i64 6, ptr @.func, i64 4,
|
|
unreachable
|
|
|
|
noerr_block: ; preds = %after_check67
|
|
store ptr %80, ptr @std_core_mem_thread_temp_allocator, align 8
|
|
br label %if.exit
|
|
|
|
if.exit: ; preds = %noerr_block, %voiderr64
|
|
%82 = load ptr, ptr @std_core_mem_thread_temp_allocator, align 8
|
|
store ptr %82, ptr %temp, align 8
|
|
%83 = load ptr, ptr %temp, align 8
|
|
%84 = getelementptr inbounds %TempAllocator, ptr %83, i32 0, i32 3
|
|
%85 = load i64, ptr %84, align 8
|
|
store i64 %85, ptr %mark, align 8
|
|
call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 40, i1 false)
|
|
%86 = load ptr, ptr @std_core_mem_thread_allocator, align 8
|
|
call void @"std_map$$int.double_HashMap_init"(ptr %map3, i32 16, float 7.500000e-01, ptr %86)
|
|
%87 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 5, double 3.200000e+00)
|
|
%88 = call i8 @"std_map$$int.double_HashMap_set"(ptr %map3, i32 7, double 5.200000e+00)
|
|
%89 = load ptr, ptr @std_core_mem_thread_allocator, align 8
|
|
%90 = call { ptr, i64 } @"std_map$$int.double_HashMap_key_list"(ptr %map3, ptr %89)
|
|
store { ptr, i64 } %90, ptr %result70, align 8
|
|
%91 = insertvalue %variant undef, ptr %result70, 0
|
|
%92 = insertvalue %variant %91, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
|
|
%93 = getelementptr inbounds [1 x %variant], ptr %varargslots69, i64 0, i64 0
|
|
store %variant %92, ptr %93, align 16
|
|
%94 = call i64 @std_io_printfln(ptr %retparam68, ptr @.str.11, i64 2, ptr %varargslots69, i64 1)
|
|
%not_err71 = icmp eq i64 %94, 0
|
|
br i1 %not_err71, label %after_check72, label %voiderr73
|
|
|
|
after_check72: ; preds = %if.exit
|
|
br label %voiderr73
|
|
|
|
voiderr73: ; preds = %after_check72, %if.exit
|
|
%95 = load ptr, ptr %temp, align 8
|
|
%96 = getelementptr inbounds %TempAllocator, ptr %95, i32 0, i32 0
|
|
%97 = load i64, ptr %mark, align 8
|
|
call void @std_core_mem_allocator_Allocator_reset(ptr %96, i64 %97)
|
|
ret void
|
|
}
|