mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
267 lines
13 KiB
Plaintext
267 lines
13 KiB
Plaintext
// #target: macos-x64
|
|
|
|
module test;
|
|
import std::io;
|
|
import std::collections::map;
|
|
|
|
struct Foo (Printable) { int x; void* bar; }
|
|
|
|
alias IntFooMap = HashMap { int, Foo };
|
|
alias IntDoubleMap = HashMap { int, double };
|
|
|
|
fn String Foo.to_new_string(Foo* foo, Allocator allocator = allocator::heap()) @dynamic
|
|
{
|
|
DString s = dstring::new_with_capacity(allocator, 128);
|
|
s.appendf("{%s, %p}", foo.x, foo.bar);
|
|
return s.str_view();
|
|
}
|
|
|
|
|
|
|
|
fn void main()
|
|
{
|
|
IntFooMap map;
|
|
map.init(mem);
|
|
io::printfn("Map size: %d", map.count);
|
|
map.set(1, { 1, null });
|
|
io::printfn("Map size: %d", map.count);
|
|
map.set(1, { 2, null });
|
|
io::printfn("Map size: %d", map.count);
|
|
(void)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, { 4, null });
|
|
io::printfn("Values: %s", map.values(mem));
|
|
IntDoubleMap map2;
|
|
map2.init(mem);
|
|
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.keys(mem));
|
|
io::printfn("%s", map2.values(mem));
|
|
@pool()
|
|
{
|
|
IntDoubleMap map3;
|
|
map3.init(mem);
|
|
map3.set(5, 3.2);
|
|
map3.set(7, 5.2);
|
|
io::printfn("%s", map3.keys(mem));
|
|
};
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
@"$sel.to_new_string" = linkonce_odr constant [14 x i8] c"to_new_string\00", align 1
|
|
@"$c3_dynamic" = internal global [1 x { ptr, ptr, i64 }] [{ ptr, ptr, i64 } { ptr @test.Foo.to_new_string, ptr @"$sel.to_new_string", i64 ptrtoint (ptr @"$ct.test.Foo" to i64) }], section "__DATA,__c3_dynamic", no_sanitize_address, align 8
|
|
|
|
define { ptr, i64 } @test.Foo.to_new_string(ptr %0, i64 %1, ptr %2) #0 {
|
|
entry:
|
|
%allocator = alloca %any, align 8
|
|
%s = alloca ptr, align 8
|
|
%varargslots = alloca [2 x %any], align 16
|
|
%retparam = alloca i64, align 8
|
|
%result = alloca %"char[]", align 8
|
|
store i64 %1, ptr %allocator, align 8
|
|
%ptradd = getelementptr inbounds i8, ptr %allocator, i64 8
|
|
store ptr %2, ptr %ptradd, align 8
|
|
%lo = load i64, ptr %allocator, align 8
|
|
%ptradd1 = getelementptr inbounds i8, ptr %allocator, i64 8
|
|
%hi = load ptr, ptr %ptradd1, align 8
|
|
%3 = call ptr @std.core.dstring.new_with_capacity(i64 %lo, ptr %hi, i64 128)
|
|
store ptr %3, ptr %s, align 8
|
|
%4 = insertvalue %any undef, ptr %0, 0
|
|
%5 = insertvalue %any %4, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
store %any %5, ptr %varargslots, align 16
|
|
%ptradd2 = getelementptr inbounds i8, ptr %0, i64 8
|
|
%6 = insertvalue %any undef, ptr %ptradd2, 0
|
|
%7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.p$void" to i64), 1
|
|
%ptradd3 = getelementptr inbounds i8, ptr %varargslots, i64 16
|
|
store %any %7, ptr %ptradd3, align 16
|
|
%8 = call i64 @std.core.dstring.DString.appendf(ptr %retparam, ptr %s, ptr @.str.14, i64 8, ptr %varargslots, i64 2)
|
|
%9 = load ptr, ptr %s, align 8
|
|
%10 = call { ptr, i64 } @std.core.dstring.DString.str_view(ptr %9)
|
|
store { ptr, i64 } %10, ptr %result, align 8
|
|
%11 = load { ptr, i64 }, ptr %result, align 8
|
|
ret { ptr, i64 } %11
|
|
}
|
|
|
|
define void @test.main() #0 {
|
|
entry:
|
|
%map = alloca %HashMap, align 8
|
|
%varargslots = alloca [1 x %any], align 16
|
|
%retparam = alloca i64, align 8
|
|
%literal = alloca %Foo, align 8
|
|
%varargslots5 = alloca [1 x %any], align 16
|
|
%retparam7 = alloca i64, align 8
|
|
%literal8 = alloca %Foo, align 8
|
|
%varargslots12 = alloca [1 x %any], align 16
|
|
%retparam14 = alloca i64, align 8
|
|
%varargslots15 = alloca [1 x %any], align 16
|
|
%retparam16 = alloca %Foo, align 8
|
|
%retparam17 = alloca i64, align 8
|
|
%varargslots20 = alloca [1 x %any], align 16
|
|
%taddr = alloca i8, align 1
|
|
%retparam21 = alloca i64, align 8
|
|
%varargslots24 = alloca [1 x %any], align 16
|
|
%taddr25 = alloca i8, align 1
|
|
%retparam26 = alloca i64, align 8
|
|
%literal29 = alloca %Foo, align 8
|
|
%varargslots33 = alloca [1 x %any], align 16
|
|
%result = alloca %"Foo[]", align 8
|
|
%retparam37 = alloca i64, align 8
|
|
%map2 = alloca %HashMap.0, align 8
|
|
%varargslots43 = alloca [1 x %any], align 16
|
|
%taddr44 = alloca i8, align 1
|
|
%retparam45 = alloca i64, align 8
|
|
%varargslots48 = alloca [1 x %any], align 16
|
|
%taddr49 = alloca i8, align 1
|
|
%retparam50 = alloca i64, align 8
|
|
%varargslots53 = alloca [1 x %any], align 16
|
|
%result57 = alloca %"int[]", align 8
|
|
%retparam58 = alloca i64, align 8
|
|
%varargslots61 = alloca [1 x %any], align 16
|
|
%result65 = alloca %"double[]", align 8
|
|
%retparam66 = alloca i64, align 8
|
|
%state = alloca ptr, align 8
|
|
%map3 = alloca %HashMap.0, align 8
|
|
%varargslots72 = alloca [1 x %any], align 16
|
|
%result76 = alloca %"int[]", align 8
|
|
%retparam77 = alloca i64, align 8
|
|
call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 48, i1 false)
|
|
%0 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator)
|
|
%lo = load i64, ptr %0, align 8
|
|
%ptradd = getelementptr inbounds i8, ptr %0, i64 8
|
|
%hi = load ptr, ptr %ptradd, align 8
|
|
%1 = call ptr @"std_collections_map$int$test.Foo$.HashMap.init"(ptr %map, i64 %lo, ptr %hi, i32 16, float 7.500000e-01)
|
|
%ptradd1 = getelementptr inbounds i8, ptr %map, i64 32
|
|
%2 = insertvalue %any undef, ptr %ptradd1, 0
|
|
%3 = insertvalue %any %2, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
|
|
store %any %3, ptr %varargslots, align 16
|
|
%4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
|
|
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false)
|
|
%lo2 = load i32, ptr %literal, align 8
|
|
%ptradd3 = getelementptr inbounds i8, ptr %literal, i64 8
|
|
%hi4 = load ptr, ptr %ptradd3, align 8
|
|
%5 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo2, ptr %hi4)
|
|
%ptradd6 = getelementptr inbounds i8, ptr %map, i64 32
|
|
%6 = insertvalue %any undef, ptr %ptradd6, 0
|
|
%7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
|
|
store %any %7, ptr %varargslots5, align 16
|
|
%8 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 12, ptr %varargslots5, i64 1)
|
|
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal8, ptr align 8 @.__const.2, i32 16, i1 false)
|
|
%lo9 = load i32, ptr %literal8, align 8
|
|
%ptradd10 = getelementptr inbounds i8, ptr %literal8, i64 8
|
|
%hi11 = load ptr, ptr %ptradd10, align 8
|
|
%9 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo9, ptr %hi11)
|
|
%ptradd13 = getelementptr inbounds i8, ptr %map, i64 32
|
|
%10 = insertvalue %any undef, ptr %ptradd13, 0
|
|
%11 = insertvalue %any %10, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
|
|
store %any %11, ptr %varargslots12, align 16
|
|
%12 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.3, i64 12, ptr %varargslots12, i64 1)
|
|
%13 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam16, ptr %map, i32 1)
|
|
%not_err = icmp eq i64 %13, 0
|
|
%14 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
|
|
br i1 %14, label %after_check, label %after_check19
|
|
|
|
after_check: ; preds = %entry
|
|
%15 = insertvalue %any undef, ptr %retparam16, 0
|
|
%16 = insertvalue %any %15, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
store %any %16, ptr %varargslots15, align 16
|
|
%17 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.4, i64 7, ptr %varargslots15, i64 1)
|
|
%not_err18 = icmp eq i64 %17, 0
|
|
%18 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true)
|
|
br i1 %18, label %after_check19, label %after_check19
|
|
|
|
after_check19: ; preds = %entry, %after_check, %after_check
|
|
%19 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1)
|
|
store i8 %19, ptr %taddr, align 1
|
|
%20 = insertvalue %any undef, ptr %taddr, 0
|
|
%21 = insertvalue %any %20, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
store %any %21, ptr %varargslots20, align 16
|
|
%22 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.5, i64 9, ptr %varargslots20, i64 1)
|
|
%23 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2)
|
|
store i8 %23, ptr %taddr25, align 1
|
|
%24 = insertvalue %any undef, ptr %taddr25, 0
|
|
%25 = insertvalue %any %24, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
store %any %25, ptr %varargslots24, align 16
|
|
%26 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.6, i64 9, ptr %varargslots24, i64 1)
|
|
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal29, ptr align 8 @.__const.7, i32 16, i1 false)
|
|
%lo30 = load i32, ptr %literal29, align 8
|
|
%ptradd31 = getelementptr inbounds i8, ptr %literal29, i64 8
|
|
%hi32 = load ptr, ptr %ptradd31, align 8
|
|
%27 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo30, ptr %hi32)
|
|
%28 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator)
|
|
%lo34 = load i64, ptr %28, align 8
|
|
%ptradd35 = getelementptr inbounds i8, ptr %28, i64 8
|
|
%hi36 = load ptr, ptr %ptradd35, align 8
|
|
%29 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.values"(ptr %map, i64 %lo34, ptr %hi36)
|
|
store { ptr, i64 } %29, ptr %result, align 8
|
|
%30 = insertvalue %any undef, ptr %result, 0
|
|
%31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1
|
|
store %any %31, ptr %varargslots33, align 16
|
|
%32 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.8, i64 10, ptr %varargslots33, i64 1)
|
|
call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 48, i1 false)
|
|
%33 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator)
|
|
%lo40 = load i64, ptr %33, align 8
|
|
%ptradd41 = getelementptr inbounds i8, ptr %33, i64 8
|
|
%hi42 = load ptr, ptr %ptradd41, align 8
|
|
%34 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map2, i64 %lo40, ptr %hi42, i32 16, float 7.500000e-01)
|
|
%35 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00)
|
|
%36 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00)
|
|
store i8 %36, ptr %taddr44, align 1
|
|
%37 = insertvalue %any undef, ptr %taddr44, 0
|
|
%38 = insertvalue %any %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
store %any %38, ptr %varargslots43, align 16
|
|
%39 = call i64 @std.io.printfn(ptr %retparam45, ptr @.str.9, i64 12, ptr %varargslots43, i64 1)
|
|
%40 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00)
|
|
store i8 %40, ptr %taddr49, align 1
|
|
%41 = insertvalue %any undef, ptr %taddr49, 0
|
|
%42 = insertvalue %any %41, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
store %any %42, ptr %varargslots48, align 16
|
|
%43 = call i64 @std.io.printfn(ptr %retparam50, ptr @.str.10, i64 12, ptr %varargslots48, i64 1)
|
|
%44 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00)
|
|
%45 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator)
|
|
%lo54 = load i64, ptr %45, align 8
|
|
%ptradd55 = getelementptr inbounds i8, ptr %45, i64 8
|
|
%hi56 = load ptr, ptr %ptradd55, align 8
|
|
%46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map2, i64 %lo54, ptr %hi56)
|
|
store { ptr, i64 } %46, ptr %result57, align 8
|
|
%47 = insertvalue %any undef, ptr %result57, 0
|
|
%48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
|
|
store %any %48, ptr %varargslots53, align 16
|
|
%49 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.11, i64 2, ptr %varargslots53, i64 1)
|
|
%50 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator)
|
|
%lo62 = load i64, ptr %50, align 8
|
|
%ptradd63 = getelementptr inbounds i8, ptr %50, i64 8
|
|
%hi64 = load ptr, ptr %ptradd63, align 8
|
|
%51 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.values"(ptr %map2, i64 %lo62, ptr %hi64)
|
|
store { ptr, i64 } %51, ptr %result65, align 8
|
|
%52 = insertvalue %any undef, ptr %result65, 0
|
|
%53 = insertvalue %any %52, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1
|
|
store %any %53, ptr %varargslots61, align 16
|
|
%54 = call i64 @std.io.printfn(ptr %retparam66, ptr @.str.12, i64 2, ptr %varargslots61, i64 1)
|
|
%55 = call ptr @std.core.mem.allocator.push_pool(i64 0) #5
|
|
store ptr %55, ptr %state, align 8
|
|
call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 48, i1 false)
|
|
%56 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator)
|
|
%lo69 = load i64, ptr %56, align 8
|
|
%ptradd70 = getelementptr inbounds i8, ptr %56, i64 8
|
|
%hi71 = load ptr, ptr %ptradd70, align 8
|
|
%57 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map3, i64 %lo69, ptr %hi71, i32 16, float 7.500000e-01)
|
|
%58 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00)
|
|
%59 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
|
|
%60 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator)
|
|
%lo73 = load i64, ptr %60, align 8
|
|
%ptradd74 = getelementptr inbounds i8, ptr %60, i64 8
|
|
%hi75 = load ptr, ptr %ptradd74, align 8
|
|
%61 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map3, i64 %lo73, ptr %hi75)
|
|
store { ptr, i64 } %61, ptr %result76, align 8
|
|
%62 = insertvalue %any undef, ptr %result76, 0
|
|
%63 = insertvalue %any %62, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
|
|
store %any %63, ptr %varargslots72, align 16
|
|
%64 = call i64 @std.io.printfn(ptr %retparam77, ptr @.str.13, i64 2, ptr %varargslots72, i64 1)
|
|
%65 = load ptr, ptr %state, align 8
|
|
call void @std.core.mem.allocator.pop_pool(ptr %65) #5
|
|
ret void
|
|
} |