mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
686 lines
36 KiB
C
686 lines
36 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())
|
|
{
|
|
String 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.tinit();
|
|
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.tinit();
|
|
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.tinit();
|
|
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, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @.static_initialize.0, i8* null }]
|
|
|
|
define internal void @.static_initialize.0() {
|
|
entry:
|
|
%0 = load i64, i64* getelementptr inbounds (%HashMap, %HashMap* @std_io_tostring_functions, i32 0, 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 %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8
|
|
call void @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_init"(%HashMap* @std_io_tostring_functions, i32 512, float 7.500000e-01, %Allocator* %1)
|
|
br label %if.exit
|
|
|
|
if.exit: ; preds = %if.then, %entry
|
|
%2 = call i8 @"std_map$$typeid.p$std_io$ToStringFunction_HashMap_set"(%HashMap* @std_io_tostring_functions, i64 ptrtoint (%.introspect* @"ct$test_Foo" to i64), { i8*, i64 } (i8*, %Allocator*)* bitcast ({ i8*, i64 } (%Foo*, %Allocator*)* @test_Foo_to_string to { i8*, i64 } (i8*, %Allocator*)*))
|
|
ret void
|
|
}
|
|
|
|
define { i8*, i64 } @test_Foo_to_string(%Foo* %0, %Allocator* %1) #0 {
|
|
entry:
|
|
%s = alloca i8*, align 8
|
|
%retparam = alloca i64, align 8
|
|
%taddr = alloca %"char[]", align 8
|
|
%vararg = alloca %"variant[]", align 8
|
|
%varargslots = alloca [2 x %variant], align 16
|
|
%result = alloca %"char[]", align 8
|
|
%2 = call i8* @std_core_string_new_with_capacity(i64 128, %Allocator* %1)
|
|
store i8* %2, i8** %s, align 8
|
|
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8
|
|
%3 = bitcast %"char[]"* %taddr to { i8*, i64 }*
|
|
%4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %3, i32 0, i32 0
|
|
%lo = load i8*, i8** %4, align 8
|
|
%5 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %3, i32 0, i32 1
|
|
%hi = load i64, i64* %5, align 8
|
|
%6 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 0
|
|
%7 = bitcast i32* %6 to i8*
|
|
%8 = insertvalue %variant undef, i8* %7, 0
|
|
%9 = insertvalue %variant %8, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
|
|
%10 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0
|
|
store %variant %9, %variant* %10, align 16
|
|
%11 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 1
|
|
%12 = bitcast i8** %11 to i8*
|
|
%13 = insertvalue %variant undef, i8* %12, 0
|
|
%14 = insertvalue %variant %13, i64 ptrtoint (%.introspect* @"ct$p$void" to i64), 1
|
|
%15 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1
|
|
store %variant %14, %variant* %15, align 16
|
|
%16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
|
|
store i64 2, i64* %16, align 8
|
|
%17 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
|
|
%18 = bitcast [2 x %variant]* %varargslots to %variant*
|
|
store %variant* %18, %variant** %17, align 8
|
|
%19 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
|
|
%20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %19, i32 0, i32 0
|
|
%lo1 = load i8*, i8** %20, align 8
|
|
%21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %19, i32 0, i32 1
|
|
%hi2 = load i64, i64* %21, align 8
|
|
%22 = call i64 @std_core_string_String_printf(i64* %retparam, i8** %s, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2)
|
|
%not_err = icmp eq i64 %22, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
%23 = load i8*, i8** %s, align 8
|
|
%24 = call { i8*, i64 } @std_core_string_String_str(i8* %23)
|
|
%25 = bitcast %"char[]"* %result to { i8*, i64 }*
|
|
store { i8*, i64 } %24, { i8*, i64 }* %25, align 8
|
|
%26 = bitcast %"char[]"* %result to { i8*, i64 }*
|
|
%27 = load { i8*, i64 }, { i8*, i64 }* %26, align 8
|
|
ret { i8*, i64 } %27
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define void @test_main() #0 {
|
|
entry:
|
|
%map = alloca %HashMap.0, align 8
|
|
%retparam = alloca i64, align 8
|
|
%taddr = alloca %"char[]", align 8
|
|
%vararg = alloca %"variant[]", align 8
|
|
%varargslots = alloca [1 x %variant], align 16
|
|
%literal = alloca %Foo, align 8
|
|
%retparam5 = alloca i64, align 8
|
|
%taddr6 = alloca %"char[]", align 8
|
|
%vararg9 = alloca %"variant[]", align 8
|
|
%varargslots10 = alloca [1 x %variant], align 16
|
|
%literal16 = alloca %Foo, align 8
|
|
%retparam19 = alloca i64, align 8
|
|
%taddr20 = alloca %"char[]", align 8
|
|
%vararg23 = alloca %"variant[]", align 8
|
|
%varargslots24 = alloca [1 x %variant], align 16
|
|
%retparam30 = alloca i64, align 8
|
|
%taddr31 = alloca %"char[]", align 8
|
|
%vararg34 = alloca %"variant[]", align 8
|
|
%varargslots35 = alloca [1 x %variant], align 16
|
|
%retparam36 = alloca %Foo, align 8
|
|
%retparam44 = alloca i64, align 8
|
|
%taddr45 = alloca %"char[]", align 8
|
|
%vararg48 = alloca %"variant[]", align 8
|
|
%varargslots49 = alloca [1 x %variant], align 16
|
|
%taddr50 = alloca i8, align 1
|
|
%retparam56 = alloca i64, align 8
|
|
%taddr57 = alloca %"char[]", align 8
|
|
%vararg60 = alloca %"variant[]", align 8
|
|
%varargslots61 = alloca [1 x %variant], align 16
|
|
%taddr62 = alloca i8, align 1
|
|
%literal68 = alloca %Foo, align 8
|
|
%retparam71 = alloca i64, align 8
|
|
%taddr72 = alloca %"char[]", align 8
|
|
%vararg75 = alloca %"variant[]", align 8
|
|
%varargslots76 = alloca [1 x %variant], align 16
|
|
%result = alloca %"Foo[]", align 8
|
|
%map2 = alloca %HashMap.3, align 8
|
|
%retparam82 = alloca i64, align 8
|
|
%taddr83 = alloca %"char[]", align 8
|
|
%vararg86 = alloca %"variant[]", align 8
|
|
%varargslots87 = alloca [1 x %variant], align 16
|
|
%taddr88 = alloca i8, align 1
|
|
%retparam94 = alloca i64, align 8
|
|
%taddr95 = alloca %"char[]", align 8
|
|
%vararg98 = alloca %"variant[]", align 8
|
|
%varargslots99 = alloca [1 x %variant], align 16
|
|
%taddr100 = alloca i8, align 1
|
|
%retparam106 = alloca i64, align 8
|
|
%taddr107 = alloca %"char[]", align 8
|
|
%vararg110 = alloca %"variant[]", align 8
|
|
%varargslots111 = alloca [1 x %variant], align 16
|
|
%result112 = alloca %"int[]", align 8
|
|
%retparam118 = alloca i64, align 8
|
|
%taddr119 = alloca %"char[]", align 8
|
|
%vararg122 = alloca %"variant[]", align 8
|
|
%varargslots123 = alloca [1 x %variant], align 16
|
|
%result124 = alloca %"double[]", align 8
|
|
%temp = alloca %TempAllocator*, align 8
|
|
%error_var = alloca i64, align 8
|
|
%retparam130 = alloca %TempAllocator*, align 8
|
|
%mark = alloca i64, align 8
|
|
%map3 = alloca %HashMap.3, align 8
|
|
%retparam133 = alloca i64, align 8
|
|
%taddr134 = alloca %"char[]", align 8
|
|
%vararg137 = alloca %"variant[]", align 8
|
|
%varargslots138 = alloca [1 x %variant], align 16
|
|
%result139 = alloca %"int[]", align 8
|
|
%0 = bitcast %HashMap.0* %map to i8*
|
|
call void @llvm.memset.p0i8.i64(i8* align 8 %0, i8 0, i64 40, i1 false)
|
|
call void @"std_map$$int.test_Foo_HashMap_tinit"(%HashMap.0* %map, i32 16, float 7.500000e-01)
|
|
store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0), i64 12 }, %"char[]"* %taddr, align 8
|
|
%1 = bitcast %"char[]"* %taddr to { i8*, i64 }*
|
|
%2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0
|
|
%lo = load i8*, i8** %2, align 8
|
|
%3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1
|
|
%hi = load i64, i64* %3, align 8
|
|
%4 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
|
|
%5 = bitcast i32* %4 to i8*
|
|
%6 = insertvalue %variant undef, i8* %5, 0
|
|
%7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%8 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
|
|
store %variant %7, %variant* %8, align 16
|
|
%9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
|
|
store i64 1, i64* %9, align 8
|
|
%10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
|
|
%11 = bitcast [1 x %variant]* %varargslots to %variant*
|
|
store %variant* %11, %variant** %10, align 8
|
|
%12 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
|
|
%13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 0
|
|
%lo1 = load i8*, i8** %13, align 8
|
|
%14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 1
|
|
%hi2 = load i64, i64* %14, align 8
|
|
%15 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2)
|
|
%not_err = icmp eq i64 %15, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
%16 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
|
|
store i32 1, i32* %16, align 8
|
|
%17 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1
|
|
store i8* null, i8** %17, align 8
|
|
%18 = bitcast %Foo* %literal to { i64, i8* }*
|
|
%19 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %18, i32 0, i32 0
|
|
%lo3 = load i64, i64* %19, align 8
|
|
%20 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %18, i32 0, i32 1
|
|
%hi4 = load i8*, i8** %20, align 8
|
|
%21 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo3, i8* %hi4)
|
|
store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i32 0, i32 0), i64 12 }, %"char[]"* %taddr6, align 8
|
|
%22 = bitcast %"char[]"* %taddr6 to { i8*, i64 }*
|
|
%23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0
|
|
%lo7 = load i8*, i8** %23, align 8
|
|
%24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1
|
|
%hi8 = load i64, i64* %24, align 8
|
|
%25 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
|
|
%26 = bitcast i32* %25 to i8*
|
|
%27 = insertvalue %variant undef, i8* %26, 0
|
|
%28 = insertvalue %variant %27, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%29 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots10, i64 0, i64 0
|
|
store %variant %28, %variant* %29, align 16
|
|
%30 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 1
|
|
store i64 1, i64* %30, align 8
|
|
%31 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 0
|
|
%32 = bitcast [1 x %variant]* %varargslots10 to %variant*
|
|
store %variant* %32, %variant** %31, align 8
|
|
%33 = bitcast %"variant[]"* %vararg9 to { i8*, i64 }*
|
|
%34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 0
|
|
%lo11 = load i8*, i8** %34, align 8
|
|
%35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 1
|
|
%hi12 = load i64, i64* %35, align 8
|
|
%36 = call i64 @std_io_printfln(i64* %retparam5, i8* %lo7, i64 %hi8, i8* %lo11, i64 %hi12)
|
|
%not_err13 = icmp eq i64 %36, 0
|
|
br i1 %not_err13, label %after_check14, label %voiderr15
|
|
|
|
after_check14: ; preds = %voiderr
|
|
br label %voiderr15
|
|
|
|
voiderr15: ; preds = %after_check14, %voiderr
|
|
%37 = getelementptr inbounds %Foo, %Foo* %literal16, i32 0, i32 0
|
|
store i32 2, i32* %37, align 8
|
|
%38 = getelementptr inbounds %Foo, %Foo* %literal16, i32 0, i32 1
|
|
store i8* null, i8** %38, align 8
|
|
%39 = bitcast %Foo* %literal16 to { i64, i8* }*
|
|
%40 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %39, i32 0, i32 0
|
|
%lo17 = load i64, i64* %40, align 8
|
|
%41 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %39, i32 0, i32 1
|
|
%hi18 = load i8*, i8** %41, align 8
|
|
%42 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 1, i64 %lo17, i8* %hi18)
|
|
store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i32 0, i32 0), i64 12 }, %"char[]"* %taddr20, align 8
|
|
%43 = bitcast %"char[]"* %taddr20 to { i8*, i64 }*
|
|
%44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0
|
|
%lo21 = load i8*, i8** %44, align 8
|
|
%45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1
|
|
%hi22 = load i64, i64* %45, align 8
|
|
%46 = getelementptr inbounds %HashMap.0, %HashMap.0* %map, i32 0, i32 2
|
|
%47 = bitcast i32* %46 to i8*
|
|
%48 = insertvalue %variant undef, i8* %47, 0
|
|
%49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%50 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0
|
|
store %variant %49, %variant* %50, align 16
|
|
%51 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1
|
|
store i64 1, i64* %51, align 8
|
|
%52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0
|
|
%53 = bitcast [1 x %variant]* %varargslots24 to %variant*
|
|
store %variant* %53, %variant** %52, align 8
|
|
%54 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }*
|
|
%55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 0
|
|
%lo25 = load i8*, i8** %55, align 8
|
|
%56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 1
|
|
%hi26 = load i64, i64* %56, align 8
|
|
%57 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26)
|
|
%not_err27 = icmp eq i64 %57, 0
|
|
br i1 %not_err27, label %after_check28, label %voiderr29
|
|
|
|
after_check28: ; preds = %voiderr15
|
|
br label %voiderr29
|
|
|
|
voiderr29: ; preds = %after_check28, %voiderr15
|
|
store %"char[]" { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i32 0, i32 0), i64 7 }, %"char[]"* %taddr31, align 8
|
|
%58 = bitcast %"char[]"* %taddr31 to { i8*, i64 }*
|
|
%59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0
|
|
%lo32 = load i8*, i8** %59, align 8
|
|
%60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1
|
|
%hi33 = load i64, i64* %60, align 8
|
|
%61 = call i64 @"std_map$$int.test_Foo_HashMap_get"(%Foo* %retparam36, %HashMap.0* %map, i32 1)
|
|
%not_err37 = icmp eq i64 %61, 0
|
|
br i1 %not_err37, label %after_check38, label %voiderr43
|
|
|
|
after_check38: ; preds = %voiderr29
|
|
%62 = getelementptr inbounds %Foo, %Foo* %retparam36, i32 0, i32 0
|
|
%63 = bitcast i32* %62 to i8*
|
|
%64 = insertvalue %variant undef, i8* %63, 0
|
|
%65 = insertvalue %variant %64, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
|
|
%66 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots35, i64 0, i64 0
|
|
store %variant %65, %variant* %66, align 16
|
|
%67 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 1
|
|
store i64 1, i64* %67, align 8
|
|
%68 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg34, i32 0, i32 0
|
|
%69 = bitcast [1 x %variant]* %varargslots35 to %variant*
|
|
store %variant* %69, %variant** %68, align 8
|
|
%70 = bitcast %"variant[]"* %vararg34 to { i8*, i64 }*
|
|
%71 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 0
|
|
%lo39 = load i8*, i8** %71, align 8
|
|
%72 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %70, i32 0, i32 1
|
|
%hi40 = load i64, i64* %72, align 8
|
|
%73 = call i64 @std_io_printfln(i64* %retparam30, i8* %lo32, i64 %hi33, i8* %lo39, i64 %hi40)
|
|
%not_err41 = icmp eq i64 %73, 0
|
|
br i1 %not_err41, label %after_check42, label %voiderr43
|
|
|
|
after_check42: ; preds = %after_check38
|
|
br label %voiderr43
|
|
|
|
voiderr43: ; preds = %after_check42, %after_check38, %voiderr29
|
|
store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i32 0, i32 0), i64 9 }, %"char[]"* %taddr45, align 8
|
|
%74 = bitcast %"char[]"* %taddr45 to { i8*, i64 }*
|
|
%75 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 0
|
|
%lo46 = load i8*, i8** %75, align 8
|
|
%76 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %74, i32 0, i32 1
|
|
%hi47 = load i64, i64* %76, align 8
|
|
%77 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 1)
|
|
store i8 %77, i8* %taddr50, align 1
|
|
%78 = insertvalue %variant undef, i8* %taddr50, 0
|
|
%79 = insertvalue %variant %78, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%80 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots49, i64 0, i64 0
|
|
store %variant %79, %variant* %80, align 16
|
|
%81 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 1
|
|
store i64 1, i64* %81, align 8
|
|
%82 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 0
|
|
%83 = bitcast [1 x %variant]* %varargslots49 to %variant*
|
|
store %variant* %83, %variant** %82, align 8
|
|
%84 = bitcast %"variant[]"* %vararg48 to { i8*, i64 }*
|
|
%85 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %84, i32 0, i32 0
|
|
%lo51 = load i8*, i8** %85, align 8
|
|
%86 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %84, i32 0, i32 1
|
|
%hi52 = load i64, i64* %86, align 8
|
|
%87 = call i64 @std_io_printfln(i64* %retparam44, i8* %lo46, i64 %hi47, i8* %lo51, i64 %hi52)
|
|
%not_err53 = icmp eq i64 %87, 0
|
|
br i1 %not_err53, label %after_check54, label %voiderr55
|
|
|
|
after_check54: ; preds = %voiderr43
|
|
br label %voiderr55
|
|
|
|
voiderr55: ; preds = %after_check54, %voiderr43
|
|
store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i32 0, i32 0), i64 9 }, %"char[]"* %taddr57, align 8
|
|
%88 = bitcast %"char[]"* %taddr57 to { i8*, i64 }*
|
|
%89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 0
|
|
%lo58 = load i8*, i8** %89, align 8
|
|
%90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 1
|
|
%hi59 = load i64, i64* %90, align 8
|
|
%91 = call i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0* %map, i32 2)
|
|
store i8 %91, i8* %taddr62, align 1
|
|
%92 = insertvalue %variant undef, i8* %taddr62, 0
|
|
%93 = insertvalue %variant %92, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%94 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots61, i64 0, i64 0
|
|
store %variant %93, %variant* %94, align 16
|
|
%95 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg60, i32 0, i32 1
|
|
store i64 1, i64* %95, align 8
|
|
%96 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg60, i32 0, i32 0
|
|
%97 = bitcast [1 x %variant]* %varargslots61 to %variant*
|
|
store %variant* %97, %variant** %96, align 8
|
|
%98 = bitcast %"variant[]"* %vararg60 to { i8*, i64 }*
|
|
%99 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %98, i32 0, i32 0
|
|
%lo63 = load i8*, i8** %99, align 8
|
|
%100 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %98, i32 0, i32 1
|
|
%hi64 = load i64, i64* %100, align 8
|
|
%101 = call i64 @std_io_printfln(i64* %retparam56, i8* %lo58, i64 %hi59, i8* %lo63, i64 %hi64)
|
|
%not_err65 = icmp eq i64 %101, 0
|
|
br i1 %not_err65, label %after_check66, label %voiderr67
|
|
|
|
after_check66: ; preds = %voiderr55
|
|
br label %voiderr67
|
|
|
|
voiderr67: ; preds = %after_check66, %voiderr55
|
|
%102 = getelementptr inbounds %Foo, %Foo* %literal68, i32 0, i32 0
|
|
store i32 4, i32* %102, align 8
|
|
%103 = getelementptr inbounds %Foo, %Foo* %literal68, i32 0, i32 1
|
|
store i8* null, i8** %103, align 8
|
|
%104 = bitcast %Foo* %literal68 to { i64, i8* }*
|
|
%105 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %104, i32 0, i32 0
|
|
%lo69 = load i64, i64* %105, align 8
|
|
%106 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %104, i32 0, i32 1
|
|
%hi70 = load i8*, i8** %106, align 8
|
|
%107 = call i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0* %map, i32 7, i64 %lo69, i8* %hi70)
|
|
store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), i64 10 }, %"char[]"* %taddr72, align 8
|
|
%108 = bitcast %"char[]"* %taddr72 to { i8*, i64 }*
|
|
%109 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %108, i32 0, i32 0
|
|
%lo73 = load i8*, i8** %109, align 8
|
|
%110 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %108, i32 0, i32 1
|
|
%hi74 = load i64, i64* %110, align 8
|
|
%111 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8
|
|
%112 = call { i8*, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(%HashMap.0* %map, %Allocator* %111)
|
|
%113 = bitcast %"Foo[]"* %result to { i8*, i64 }*
|
|
store { i8*, i64 } %112, { i8*, i64 }* %113, align 8
|
|
%114 = bitcast %"Foo[]"* %result to i8*
|
|
%115 = insertvalue %variant undef, i8* %114, 0
|
|
%116 = insertvalue %variant %115, i64 ptrtoint (%.introspect* @"ct$sa$test_Foo" to i64), 1
|
|
%117 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots76, i64 0, i64 0
|
|
store %variant %116, %variant* %117, align 16
|
|
%118 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg75, i32 0, i32 1
|
|
store i64 1, i64* %118, align 8
|
|
%119 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg75, i32 0, i32 0
|
|
%120 = bitcast [1 x %variant]* %varargslots76 to %variant*
|
|
store %variant* %120, %variant** %119, align 8
|
|
%121 = bitcast %"variant[]"* %vararg75 to { i8*, i64 }*
|
|
%122 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %121, i32 0, i32 0
|
|
%lo77 = load i8*, i8** %122, align 8
|
|
%123 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %121, i32 0, i32 1
|
|
%hi78 = load i64, i64* %123, align 8
|
|
%124 = call i64 @std_io_printfln(i64* %retparam71, i8* %lo73, i64 %hi74, i8* %lo77, i64 %hi78)
|
|
%not_err79 = icmp eq i64 %124, 0
|
|
br i1 %not_err79, label %after_check80, label %voiderr81
|
|
|
|
after_check80: ; preds = %voiderr67
|
|
br label %voiderr81
|
|
|
|
voiderr81: ; preds = %after_check80, %voiderr67
|
|
%125 = bitcast %HashMap.3* %map2 to i8*
|
|
call void @llvm.memset.p0i8.i64(i8* align 8 %125, i8 0, i64 40, i1 false)
|
|
call void @"std_map$$int.double_HashMap_tinit"(%HashMap.3* %map2, i32 16, float 7.500000e-01)
|
|
%126 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 4, double 1.300000e+00)
|
|
store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i32 0, i32 0), i64 12 }, %"char[]"* %taddr83, align 8
|
|
%127 = bitcast %"char[]"* %taddr83 to { i8*, i64 }*
|
|
%128 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %127, i32 0, i32 0
|
|
%lo84 = load i8*, i8** %128, align 8
|
|
%129 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %127, i32 0, i32 1
|
|
%hi85 = load i64, i64* %129, align 8
|
|
%130 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.300000e+00)
|
|
store i8 %130, i8* %taddr88, align 1
|
|
%131 = insertvalue %variant undef, i8* %taddr88, 0
|
|
%132 = insertvalue %variant %131, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%133 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots87, i64 0, i64 0
|
|
store %variant %132, %variant* %133, align 16
|
|
%134 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 1
|
|
store i64 1, i64* %134, align 8
|
|
%135 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 0
|
|
%136 = bitcast [1 x %variant]* %varargslots87 to %variant*
|
|
store %variant* %136, %variant** %135, align 8
|
|
%137 = bitcast %"variant[]"* %vararg86 to { i8*, i64 }*
|
|
%138 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %137, i32 0, i32 0
|
|
%lo89 = load i8*, i8** %138, align 8
|
|
%139 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %137, i32 0, i32 1
|
|
%hi90 = load i64, i64* %139, align 8
|
|
%140 = call i64 @std_io_printfln(i64* %retparam82, i8* %lo84, i64 %hi85, i8* %lo89, i64 %hi90)
|
|
%not_err91 = icmp eq i64 %140, 0
|
|
br i1 %not_err91, label %after_check92, label %voiderr93
|
|
|
|
after_check92: ; preds = %voiderr81
|
|
br label %voiderr93
|
|
|
|
voiderr93: ; preds = %after_check92, %voiderr81
|
|
store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i64 12 }, %"char[]"* %taddr95, align 8
|
|
%141 = bitcast %"char[]"* %taddr95 to { i8*, i64 }*
|
|
%142 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %141, i32 0, i32 0
|
|
%lo96 = load i8*, i8** %142, align 8
|
|
%143 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %141, i32 0, i32 1
|
|
%hi97 = load i64, i64* %143, align 8
|
|
%144 = call i8 @"std_map$$int.double_HashMap_has_value"(%HashMap.3* %map2, double 1.200000e+00)
|
|
store i8 %144, i8* %taddr100, align 1
|
|
%145 = insertvalue %variant undef, i8* %taddr100, 0
|
|
%146 = insertvalue %variant %145, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%147 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots99, i64 0, i64 0
|
|
store %variant %146, %variant* %147, align 16
|
|
%148 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 1
|
|
store i64 1, i64* %148, align 8
|
|
%149 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg98, i32 0, i32 0
|
|
%150 = bitcast [1 x %variant]* %varargslots99 to %variant*
|
|
store %variant* %150, %variant** %149, align 8
|
|
%151 = bitcast %"variant[]"* %vararg98 to { i8*, i64 }*
|
|
%152 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %151, i32 0, i32 0
|
|
%lo101 = load i8*, i8** %152, align 8
|
|
%153 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %151, i32 0, i32 1
|
|
%hi102 = load i64, i64* %153, align 8
|
|
%154 = call i64 @std_io_printfln(i64* %retparam94, i8* %lo96, i64 %hi97, i8* %lo101, i64 %hi102)
|
|
%not_err103 = icmp eq i64 %154, 0
|
|
br i1 %not_err103, label %after_check104, label %voiderr105
|
|
|
|
after_check104: ; preds = %voiderr93
|
|
br label %voiderr105
|
|
|
|
voiderr105: ; preds = %after_check104, %voiderr93
|
|
%155 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map2, i32 100, double 3.400000e+00)
|
|
store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i64 2 }, %"char[]"* %taddr107, align 8
|
|
%156 = bitcast %"char[]"* %taddr107 to { i8*, i64 }*
|
|
%157 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %156, i32 0, i32 0
|
|
%lo108 = load i8*, i8** %157, align 8
|
|
%158 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %156, i32 0, i32 1
|
|
%hi109 = load i64, i64* %158, align 8
|
|
%159 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8
|
|
%160 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map2, %Allocator* %159)
|
|
%161 = bitcast %"int[]"* %result112 to { i8*, i64 }*
|
|
store { i8*, i64 } %160, { i8*, i64 }* %161, align 8
|
|
%162 = bitcast %"int[]"* %result112 to i8*
|
|
%163 = insertvalue %variant undef, i8* %162, 0
|
|
%164 = insertvalue %variant %163, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1
|
|
%165 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots111, i64 0, i64 0
|
|
store %variant %164, %variant* %165, align 16
|
|
%166 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg110, i32 0, i32 1
|
|
store i64 1, i64* %166, align 8
|
|
%167 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg110, i32 0, i32 0
|
|
%168 = bitcast [1 x %variant]* %varargslots111 to %variant*
|
|
store %variant* %168, %variant** %167, align 8
|
|
%169 = bitcast %"variant[]"* %vararg110 to { i8*, i64 }*
|
|
%170 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 0
|
|
%lo113 = load i8*, i8** %170, align 8
|
|
%171 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 1
|
|
%hi114 = load i64, i64* %171, align 8
|
|
%172 = call i64 @std_io_printfln(i64* %retparam106, i8* %lo108, i64 %hi109, i8* %lo113, i64 %hi114)
|
|
%not_err115 = icmp eq i64 %172, 0
|
|
br i1 %not_err115, label %after_check116, label %voiderr117
|
|
|
|
after_check116: ; preds = %voiderr105
|
|
br label %voiderr117
|
|
|
|
voiderr117: ; preds = %after_check116, %voiderr105
|
|
store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i32 0, i32 0), i64 2 }, %"char[]"* %taddr119, align 8
|
|
%173 = bitcast %"char[]"* %taddr119 to { i8*, i64 }*
|
|
%174 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %173, i32 0, i32 0
|
|
%lo120 = load i8*, i8** %174, align 8
|
|
%175 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %173, i32 0, i32 1
|
|
%hi121 = load i64, i64* %175, align 8
|
|
%176 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8
|
|
%177 = call { i8*, i64 } @"std_map$$int.double_HashMap_value_list"(%HashMap.3* %map2, %Allocator* %176)
|
|
%178 = bitcast %"double[]"* %result124 to { i8*, i64 }*
|
|
store { i8*, i64 } %177, { i8*, i64 }* %178, align 8
|
|
%179 = bitcast %"double[]"* %result124 to i8*
|
|
%180 = insertvalue %variant undef, i8* %179, 0
|
|
%181 = insertvalue %variant %180, i64 ptrtoint (%.introspect* @"ct$sa$double" to i64), 1
|
|
%182 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots123, i64 0, i64 0
|
|
store %variant %181, %variant* %182, align 16
|
|
%183 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg122, i32 0, i32 1
|
|
store i64 1, i64* %183, align 8
|
|
%184 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg122, i32 0, i32 0
|
|
%185 = bitcast [1 x %variant]* %varargslots123 to %variant*
|
|
store %variant* %185, %variant** %184, align 8
|
|
%186 = bitcast %"variant[]"* %vararg122 to { i8*, i64 }*
|
|
%187 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %186, i32 0, i32 0
|
|
%lo125 = load i8*, i8** %187, align 8
|
|
%188 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %186, i32 0, i32 1
|
|
%hi126 = load i64, i64* %188, align 8
|
|
%189 = call i64 @std_io_printfln(i64* %retparam118, i8* %lo120, i64 %hi121, i8* %lo125, i64 %hi126)
|
|
%not_err127 = icmp eq i64 %189, 0
|
|
br i1 %not_err127, label %after_check128, label %voiderr129
|
|
|
|
after_check128: ; preds = %voiderr117
|
|
br label %voiderr129
|
|
|
|
voiderr129: ; preds = %after_check128, %voiderr117
|
|
%190 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
|
|
%not = icmp eq %TempAllocator* %190, null
|
|
br i1 %not, label %if.then, label %if.exit
|
|
|
|
if.then: ; preds = %voiderr129
|
|
%191 = call i64 @std_core_mem_allocator_new_temp(%TempAllocator** %retparam130, i64 131072, %Allocator* @std_core_mem_allocator__SYSTEM_ALLOCATOR)
|
|
%not_err131 = icmp eq i64 %191, 0
|
|
br i1 %not_err131, label %after_check132, label %assign_optional
|
|
|
|
assign_optional: ; preds = %if.then
|
|
store i64 %191, i64* %error_var, align 8
|
|
br label %panic_block
|
|
|
|
after_check132: ; preds = %if.then
|
|
%192 = load %TempAllocator*, %TempAllocator** %retparam130, align 8
|
|
br label %noerr_block
|
|
|
|
panic_block: ; preds = %assign_optional
|
|
call void @std_core_builtin_panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.zstr.11, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.12, i64 0, i64 0), i32 245)
|
|
unreachable
|
|
|
|
noerr_block: ; preds = %after_check132
|
|
store %TempAllocator* %192, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
|
|
br label %if.exit
|
|
|
|
if.exit: ; preds = %noerr_block, %voiderr129
|
|
%193 = load %TempAllocator*, %TempAllocator** @std_core_mem_thread_temp_allocator, align 8
|
|
store %TempAllocator* %193, %TempAllocator** %temp, align 8
|
|
%194 = load %TempAllocator*, %TempAllocator** %temp, align 8
|
|
%195 = getelementptr inbounds %TempAllocator, %TempAllocator* %194, i32 0, i32 3
|
|
%196 = load i64, i64* %195, align 8
|
|
store i64 %196, i64* %mark, align 8
|
|
%197 = bitcast %HashMap.3* %map3 to i8*
|
|
call void @llvm.memset.p0i8.i64(i8* align 8 %197, i8 0, i64 40, i1 false)
|
|
call void @"std_map$$int.double_HashMap_tinit"(%HashMap.3* %map3, i32 16, float 7.500000e-01)
|
|
%198 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 5, double 3.200000e+00)
|
|
%199 = call i8 @"std_map$$int.double_HashMap_set"(%HashMap.3* %map3, i32 7, double 5.200000e+00)
|
|
store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i32 0, i32 0), i64 2 }, %"char[]"* %taddr134, align 8
|
|
%200 = bitcast %"char[]"* %taddr134 to { i8*, i64 }*
|
|
%201 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %200, i32 0, i32 0
|
|
%lo135 = load i8*, i8** %201, align 8
|
|
%202 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %200, i32 0, i32 1
|
|
%hi136 = load i64, i64* %202, align 8
|
|
%203 = load %Allocator*, %Allocator** @std_core_mem_thread_allocator, align 8
|
|
%204 = call { i8*, i64 } @"std_map$$int.double_HashMap_key_list"(%HashMap.3* %map3, %Allocator* %203)
|
|
%205 = bitcast %"int[]"* %result139 to { i8*, i64 }*
|
|
store { i8*, i64 } %204, { i8*, i64 }* %205, align 8
|
|
%206 = bitcast %"int[]"* %result139 to i8*
|
|
%207 = insertvalue %variant undef, i8* %206, 0
|
|
%208 = insertvalue %variant %207, i64 ptrtoint (%.introspect* @"ct$sa$int" to i64), 1
|
|
%209 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots138, i64 0, i64 0
|
|
store %variant %208, %variant* %209, align 16
|
|
%210 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg137, i32 0, i32 1
|
|
store i64 1, i64* %210, align 8
|
|
%211 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg137, i32 0, i32 0
|
|
%212 = bitcast [1 x %variant]* %varargslots138 to %variant*
|
|
store %variant* %212, %variant** %211, align 8
|
|
%213 = bitcast %"variant[]"* %vararg137 to { i8*, i64 }*
|
|
%214 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %213, i32 0, i32 0
|
|
%lo140 = load i8*, i8** %214, align 8
|
|
%215 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %213, i32 0, i32 1
|
|
%hi141 = load i64, i64* %215, align 8
|
|
%216 = call i64 @std_io_printfln(i64* %retparam133, i8* %lo135, i64 %hi136, i8* %lo140, i64 %hi141)
|
|
%not_err142 = icmp eq i64 %216, 0
|
|
br i1 %not_err142, label %after_check143, label %voiderr144
|
|
|
|
after_check143: ; preds = %if.exit
|
|
br label %voiderr144
|
|
|
|
voiderr144: ; preds = %after_check143, %if.exit
|
|
%217 = load %TempAllocator*, %TempAllocator** %temp, align 8
|
|
%218 = getelementptr inbounds %TempAllocator, %TempAllocator* %217, i32 0, i32 0
|
|
%219 = load i64, i64* %mark, align 8
|
|
call void @std_core_mem_allocator_Allocator_reset(%Allocator* %218, i64 %219)
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define i32 @main(i32 %0, i8** %1) #0 {
|
|
entry:
|
|
call void @test_main()
|
|
ret i32 0
|
|
}
|
|
|
|
; Function Attrs: argmemonly nofree nounwind willreturn writeonly
|
|
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #1
|
|
|
|
declare void @"std_map$$int.test_Foo_HashMap_tinit"(%HashMap.0*, i32, float)
|
|
|
|
declare i64 @std_io_printfln(i64*, i8*, i64, i8*, i64)
|
|
|
|
declare i8 @"std_map$$int.test_Foo_HashMap_set"(%HashMap.0*, i32, i64, i8*)
|
|
|
|
declare i64 @"std_map$$int.test_Foo_HashMap_get"(%Foo*, %HashMap.0*, i32)
|
|
|
|
declare i8 @"std_map$$int.test_Foo_HashMap_has_key"(%HashMap.0*, i32)
|
|
|
|
declare { i8*, i64 } @"std_map$$int.test_Foo_HashMap_value_list"(%HashMap.0*, %Allocator*)
|
|
|
|
declare void @"std_map$$int.double_HashMap_tinit"(%HashMap.3*, i32, float)
|
|
|
|
declare i8 @"std_map$$int.double_HashMap_set"(%HashMap.3*, i32, double)
|