mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
329 lines
16 KiB
C
329 lines
16 KiB
C
// #target: macos-x64
|
|
|
|
module test;
|
|
import std::io;
|
|
import std::collections::map;
|
|
|
|
struct Foo { int x; void* bar; }
|
|
|
|
def IntFooMap = HashMap<int, Foo>;
|
|
def IntDoubleMap = HashMap<int, double>;
|
|
|
|
fn String Foo.to_string(Foo* foo, Allocator* allocator = mem::heap()) @dynamic
|
|
{
|
|
DString s = dstring::new_with_capacity(128, allocator);
|
|
s.printf("{%s, %p}", foo.x, foo.bar);
|
|
return s.str();
|
|
}
|
|
|
|
|
|
|
|
fn void main()
|
|
{
|
|
IntFooMap map;
|
|
map.init();
|
|
io::printfn("Map size: %d", map.count);
|
|
map.set(1, Foo { 1, null });
|
|
io::printfn("Map size: %d", map.count);
|
|
map.set(1, Foo { 2, null });
|
|
io::printfn("Map size: %d", map.count);
|
|
io::printfn("Val: %d", map.get(1).x);
|
|
io::printfn("Has 1: %s", map.has_key(1));
|
|
io::printfn("Has 2: %s", map.has_key(2));
|
|
map.set(7, Foo { 4, null });
|
|
io::printfn("Values: %s", map.value_list());
|
|
IntDoubleMap map2;
|
|
map2.init();
|
|
map2.set(4, 1.3);
|
|
io::printfn("Map find: %s", map2.has_value(1.3));
|
|
io::printfn("Map find: %s", map2.has_value(1.2));
|
|
map2.set(100, 3.4);
|
|
io::printfn("%s", map2.key_list());
|
|
io::printfn("%s", map2.value_list());
|
|
@pool()
|
|
{
|
|
IntDoubleMap map3;
|
|
map3.init();
|
|
map3.set(5, 3.2);
|
|
map3.set(7, 5.2);
|
|
io::printfn("%s", map3.key_list());
|
|
};
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 1, ptr @.static_initialize.0, ptr null }]
|
|
|
|
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 %any], align 16
|
|
%result = alloca %"char[]", align 8
|
|
%2 = call ptr @std.core.dstring.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 %any undef, ptr %3, 0
|
|
%5 = insertvalue %any %4, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
%6 = getelementptr inbounds [2 x %any], ptr %varargslots, i64 0, i64 0
|
|
store %any %5, ptr %6, align 16
|
|
%7 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 1
|
|
%8 = insertvalue %any undef, ptr %7, 0
|
|
%9 = insertvalue %any %8, i64 ptrtoint (ptr @"$ct.p$void" to i64), 1
|
|
%10 = getelementptr inbounds [2 x %any], ptr %varargslots, i64 0, i64 1
|
|
store %any %9, ptr %10, align 16
|
|
%11 = call i64 @std.core.dstring.DString.printf(ptr %retparam, ptr %s, ptr @.str.12, i64 8, ptr %varargslots, i64 2)
|
|
%12 = load ptr, ptr %s, align 8
|
|
%13 = call { ptr, i64 } @std.core.dstring.DString.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, align 8
|
|
%retparam = alloca i64, align 8
|
|
%varargslots = alloca [1 x %any], align 16
|
|
%literal = alloca %Foo, align 8
|
|
%retparam1 = alloca i64, align 8
|
|
%varargslots2 = alloca [1 x %any], align 16
|
|
%literal3 = alloca %Foo, align 8
|
|
%retparam6 = alloca i64, align 8
|
|
%varargslots7 = alloca [1 x %any], align 16
|
|
%retparam8 = alloca i64, align 8
|
|
%varargslots9 = alloca [1 x %any], align 16
|
|
%retparam10 = alloca %Foo, align 8
|
|
%retparam13 = alloca i64, align 8
|
|
%varargslots14 = alloca [1 x %any], align 16
|
|
%taddr = alloca i8, align 1
|
|
%retparam17 = alloca i64, align 8
|
|
%varargslots18 = alloca [1 x %any], align 16
|
|
%taddr19 = alloca i8, align 1
|
|
%literal22 = alloca %Foo, align 8
|
|
%retparam25 = alloca i64, align 8
|
|
%varargslots26 = alloca [1 x %any], align 16
|
|
%result = alloca %"Foo[]", align 8
|
|
%map2 = alloca %HashMap.0, align 8
|
|
%retparam29 = alloca i64, align 8
|
|
%varargslots30 = alloca [1 x %any], align 16
|
|
%taddr31 = alloca i8, align 1
|
|
%retparam34 = alloca i64, align 8
|
|
%varargslots35 = alloca [1 x %any], align 16
|
|
%taddr36 = alloca i8, align 1
|
|
%retparam39 = alloca i64, align 8
|
|
%varargslots40 = alloca [1 x %any], align 16
|
|
%result41 = alloca %"int[]", align 8
|
|
%retparam44 = alloca i64, align 8
|
|
%varargslots45 = alloca [1 x %any], align 16
|
|
%result46 = alloca %"double[]", align 8
|
|
%allocator = alloca ptr, align 8
|
|
%error_var = alloca i64, align 8
|
|
%retparam49 = alloca ptr, align 8
|
|
%varargslots52 = alloca [1 x %any], align 16
|
|
%indirectarg = alloca %"any[]", align 8
|
|
%mark = alloca i64, align 8
|
|
%map3 = alloca %HashMap.0, align 8
|
|
%retparam53 = alloca i64, align 8
|
|
%varargslots54 = alloca [1 x %any], align 16
|
|
%result55 = alloca %"int[]", align 8
|
|
%allocator58 = alloca ptr, align 8
|
|
%mark59 = alloca i64, align 8
|
|
%retparam60 = alloca ptr, 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.collections.map$int$test.Foo$.HashMap.init"(ptr %map, i32 16, float 7.500000e-01, ptr %0)
|
|
%1 = getelementptr inbounds %HashMap, ptr %map, i32 0, i32 2
|
|
%2 = insertvalue %any undef, ptr %1, 0
|
|
%3 = insertvalue %any %2, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
|
|
%4 = getelementptr inbounds [1 x %any], ptr %varargslots, i64 0, i64 0
|
|
store %any %3, ptr %4, align 16
|
|
%5 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
|
|
%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.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo, ptr %hi)
|
|
%11 = getelementptr inbounds %HashMap, ptr %map, i32 0, i32 2
|
|
%12 = insertvalue %any undef, ptr %11, 0
|
|
%13 = insertvalue %any %12, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
|
|
%14 = getelementptr inbounds [1 x %any], ptr %varargslots2, i64 0, i64 0
|
|
store %any %13, ptr %14, align 16
|
|
%15 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.1, i64 12, ptr %varargslots2, i64 1)
|
|
%16 = getelementptr inbounds %Foo, ptr %literal3, i32 0, i32 0
|
|
store i32 2, ptr %16, align 8
|
|
%17 = getelementptr inbounds %Foo, ptr %literal3, i32 0, i32 1
|
|
store ptr null, ptr %17, align 8
|
|
%18 = getelementptr inbounds { i64, ptr }, ptr %literal3, i32 0, i32 0
|
|
%lo4 = load i64, ptr %18, align 8
|
|
%19 = getelementptr inbounds { i64, ptr }, ptr %literal3, i32 0, i32 1
|
|
%hi5 = load ptr, ptr %19, align 8
|
|
%20 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo4, ptr %hi5)
|
|
%21 = getelementptr inbounds %HashMap, ptr %map, i32 0, i32 2
|
|
%22 = insertvalue %any undef, ptr %21, 0
|
|
%23 = insertvalue %any %22, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
|
|
%24 = getelementptr inbounds [1 x %any], ptr %varargslots7, i64 0, i64 0
|
|
store %any %23, ptr %24, align 16
|
|
%25 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.2, i64 12, ptr %varargslots7, i64 1)
|
|
%26 = call i64 @"std.collections.map$int$test.Foo$.HashMap.get"(ptr %retparam10, ptr %map, i32 1)
|
|
%not_err = icmp eq i64 %26, 0
|
|
%27 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
|
|
br i1 %27, label %after_check, label %after_check12
|
|
after_check: ; preds = %entry
|
|
%28 = getelementptr inbounds %Foo, ptr %retparam10, i32 0, i32 0
|
|
%29 = insertvalue %any undef, ptr %28, 0
|
|
%30 = insertvalue %any %29, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
%31 = getelementptr inbounds [1 x %any], ptr %varargslots9, i64 0, i64 0
|
|
store %any %30, ptr %31, align 16
|
|
%32 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.3, i64 7, ptr %varargslots9, i64 1)
|
|
%not_err11 = icmp eq i64 %32, 0
|
|
%33 = call i1 @llvm.expect.i1(i1 %not_err11, i1 true)
|
|
br i1 %33, label %after_check12, label %after_check12
|
|
after_check12: ; preds = %entry, %after_check, %after_check
|
|
%34 = call i8 @"std.collections.map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1)
|
|
store i8 %34, ptr %taddr, align 1
|
|
%35 = insertvalue %any undef, ptr %taddr, 0
|
|
%36 = insertvalue %any %35, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%37 = getelementptr inbounds [1 x %any], ptr %varargslots14, i64 0, i64 0
|
|
store %any %36, ptr %37, align 16
|
|
%38 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.4, i64 9, ptr %varargslots14, i64 1)
|
|
%39 = call i8 @"std.collections.map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2)
|
|
store i8 %39, ptr %taddr19, align 1
|
|
%40 = insertvalue %any undef, ptr %taddr19, 0
|
|
%41 = insertvalue %any %40, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%42 = getelementptr inbounds [1 x %any], ptr %varargslots18, i64 0, i64 0
|
|
store %any %41, ptr %42, align 16
|
|
%43 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.5, i64 9, ptr %varargslots18, i64 1)
|
|
%44 = getelementptr inbounds %Foo, ptr %literal22, i32 0, i32 0
|
|
store i32 4, ptr %44, align 8
|
|
%45 = getelementptr inbounds %Foo, ptr %literal22, i32 0, i32 1
|
|
store ptr null, ptr %45, align 8
|
|
%46 = getelementptr inbounds { i64, ptr }, ptr %literal22, i32 0, i32 0
|
|
%lo23 = load i64, ptr %46, align 8
|
|
%47 = getelementptr inbounds { i64, ptr }, ptr %literal22, i32 0, i32 1
|
|
%hi24 = load ptr, ptr %47, align 8
|
|
%48 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i64 %lo23, ptr %hi24)
|
|
%49 = load ptr, ptr @std.core.mem.thread_allocator, align 8
|
|
%50 = call { ptr, i64 } @"std.collections.map$int$test.Foo$.HashMap.value_list"(ptr %map, ptr %49)
|
|
store { ptr, i64 } %50, ptr %result, align 8
|
|
%51 = insertvalue %any undef, ptr %result, 0
|
|
%52 = insertvalue %any %51, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1
|
|
%53 = getelementptr inbounds [1 x %any], ptr %varargslots26, i64 0, i64 0
|
|
store %any %52, ptr %53, align 16
|
|
%54 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 10, ptr %varargslots26, i64 1)
|
|
call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 40, i1 false)
|
|
%55 = load ptr, ptr @std.core.mem.thread_allocator, align 8
|
|
call void @"std.collections.map$int$double$.HashMap.init"(ptr %map2, i32 16, float 7.500000e-01, ptr %55)
|
|
%56 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00)
|
|
%57 = call i8 @"std.collections.map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00)
|
|
store i8 %57, ptr %taddr31, align 1
|
|
%58 = insertvalue %any undef, ptr %taddr31, 0
|
|
%59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%60 = getelementptr inbounds [1 x %any], ptr %varargslots30, i64 0, i64 0
|
|
store %any %59, ptr %60, align 16
|
|
%61 = call i64 @std.io.printfn(ptr %retparam29, ptr @.str.7, i64 12, ptr %varargslots30, i64 1)
|
|
%62 = call i8 @"std.collections.map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00)
|
|
store i8 %62, ptr %taddr36, align 1
|
|
%63 = insertvalue %any undef, ptr %taddr36, 0
|
|
%64 = insertvalue %any %63, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%65 = getelementptr inbounds [1 x %any], ptr %varargslots35, i64 0, i64 0
|
|
store %any %64, ptr %65, align 16
|
|
%66 = call i64 @std.io.printfn(ptr %retparam34, ptr @.str.8, i64 12, ptr %varargslots35, i64 1)
|
|
%67 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00)
|
|
%68 = load ptr, ptr @std.core.mem.thread_allocator, align 8
|
|
%69 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_list"(ptr %map2, ptr %68)
|
|
store { ptr, i64 } %69, ptr %result41, align 8
|
|
%70 = insertvalue %any undef, ptr %result41, 0
|
|
%71 = insertvalue %any %70, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
|
|
%72 = getelementptr inbounds [1 x %any], ptr %varargslots40, i64 0, i64 0
|
|
store %any %71, ptr %72, align 16
|
|
%73 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.9, i64 2, ptr %varargslots40, i64 1)
|
|
%74 = load ptr, ptr @std.core.mem.thread_allocator, align 8
|
|
%75 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.value_list"(ptr %map2, ptr %74)
|
|
store { ptr, i64 } %75, ptr %result46, align 8
|
|
%76 = insertvalue %any undef, ptr %result46, 0
|
|
%77 = insertvalue %any %76, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1
|
|
%78 = getelementptr inbounds [1 x %any], ptr %varargslots45, i64 0, i64 0
|
|
store %any %77, ptr %78, align 16
|
|
%79 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.10, i64 2, ptr %varargslots45, i64 1)
|
|
%80 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8
|
|
%not = icmp eq ptr %80, null
|
|
br i1 %not, label %if.then, label %if.exit
|
|
if.then: ; preds = %after_check12
|
|
%81 = load ptr, ptr @std.core.mem.thread_allocator, align 8
|
|
%82 = call i64 @std.core.mem.allocator.new_temp(ptr %retparam49, i64 262144, ptr %81)
|
|
%not_err50 = icmp eq i64 %82, 0
|
|
%83 = call i1 @llvm.expect.i1(i1 %not_err50, i1 true)
|
|
br i1 %83, label %after_check51, label %assign_optional
|
|
assign_optional: ; preds = %if.then
|
|
store i64 %82, ptr %error_var, align 8
|
|
br label %panic_block
|
|
after_check51: ; preds = %if.then
|
|
%84 = load ptr, ptr %retparam49, align 8
|
|
br label %noerr_block
|
|
panic_block: ; preds = %assign_optional
|
|
%85 = insertvalue %any undef, ptr %error_var, 0
|
|
%86 = insertvalue %any %85, i64 ptrtoint (ptr @"$ct.anyfault" to i64), 1
|
|
%87 = getelementptr inbounds [1 x %any], ptr %varargslots52, i64 0, i64 0
|
|
store %any %86, ptr %87, align 16
|
|
%88 = insertvalue %"any[]" undef, ptr %varargslots52, 0
|
|
%89 = insertvalue %"any[]" %88, i64 1, 1
|
|
store %"any[]" %89, ptr %indirectarg, align 8
|
|
call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, ptr @.file, i64 6, ptr @.func, i64 4, i32 399, ptr byval(%"any[]") align 8 %indirectarg)
|
|
unreachable
|
|
noerr_block: ; preds = %after_check51
|
|
store ptr %84, ptr @std.core.mem.thread_temp_allocator, align 8
|
|
br label %if.exit
|
|
if.exit: ; preds = %noerr_block, %after_check12
|
|
%90 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8
|
|
store ptr %90, ptr %allocator, align 8
|
|
%91 = load ptr, ptr %allocator, align 8
|
|
%92 = getelementptr inbounds %TempAllocator, ptr %91, i32 0, i32 3
|
|
%93 = load i64, ptr %92, align 8
|
|
store i64 %93, ptr %mark, align 8
|
|
call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 40, i1 false)
|
|
%94 = load ptr, ptr @std.core.mem.thread_allocator, align 8
|
|
call void @"std.collections.map$int$double$.HashMap.init"(ptr %map3, i32 16, float 7.500000e-01, ptr %94)
|
|
%95 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00)
|
|
%96 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
|
|
%97 = load ptr, ptr @std.core.mem.thread_allocator, align 8
|
|
%98 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_list"(ptr %map3, ptr %97)
|
|
store { ptr, i64 } %98, ptr %result55, align 8
|
|
%99 = insertvalue %any undef, ptr %result55, 0
|
|
%100 = insertvalue %any %99, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
|
|
%101 = getelementptr inbounds [1 x %any], ptr %varargslots54, i64 0, i64 0
|
|
store %any %100, ptr %101, align 16
|
|
%102 = call i64 @std.io.printfn(ptr %retparam53, ptr @.str.11, i64 2, ptr %varargslots54, i64 1)
|
|
%103 = load ptr, ptr %allocator, align 8
|
|
%104 = getelementptr inbounds %TempAllocator, ptr %103, i32 0, i32 0
|
|
store ptr %104, ptr %allocator58, align 8
|
|
%105 = load i64, ptr %mark, align 8
|
|
store i64 %105, ptr %mark59, align 8
|
|
%106 = load ptr, ptr %allocator58, align 8
|
|
%107 = getelementptr inbounds %Allocator, ptr %106, i32 0, i32 0
|
|
%108 = load ptr, ptr %107, align 8
|
|
%109 = load ptr, ptr %allocator58, align 8
|
|
%110 = load i64, ptr %mark59, align 8
|
|
%111 = call i64 %108(ptr %retparam60, ptr %109, i64 %110, i64 0, i64 0, ptr null, i32 8)
|
|
ret void
|
|
}
|
|
define internal void @.static_initialize.0() {
|
|
entry:
|
|
br label %dtable_check
|
|
dtable_check: ; preds = %dtable_next, %entry
|
|
%dtable_ref = phi ptr [ getelementptr inbounds (%.introspect, ptr @"$ct.test.Foo", i32 0, i32 1), %entry ], [ %next_dtable_ref, %dtable_next ]
|
|
%dtable_ptr = load ptr, ptr %dtable_ref, align 8
|
|
%0 = icmp eq ptr %dtable_ptr, null
|
|
br i1 %0, label %dtable_found, label %dtable_next
|
|
dtable_next: ; preds = %dtable_check
|
|
%next_dtable_ref = getelementptr inbounds { ptr, ptr, ptr }, ptr %dtable_ptr, i32 0, i32 2
|
|
br label %dtable_check
|
|
dtable_found: ; preds = %dtable_check
|
|
store ptr @"$ct.dyn.test.Foo.to_string", ptr %dtable_ref, align 8
|
|
ret void
|
|
}
|