mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 20:11:17 +00:00
570 lines
25 KiB
C
570 lines
25 KiB
C
// #target: macos-x64
|
|
module test;
|
|
import std::io;
|
|
|
|
bitstruct Foo : ulong
|
|
{
|
|
uint x : 0..31;
|
|
uint y : 32..62;
|
|
bool w : 63;
|
|
}
|
|
|
|
bitstruct Bar : char[8]
|
|
{
|
|
uint x : 0..31;
|
|
uint y : 32..62;
|
|
bool w : 63;
|
|
}
|
|
struct Abc
|
|
{
|
|
int x;
|
|
Foo b;
|
|
}
|
|
|
|
fn void hello(int z)
|
|
{
|
|
Foo x;
|
|
x = { .x = z, .w = z < 100 };
|
|
Abc y = { .b.x = 32, .b.y = 10 };
|
|
Abc d = { .b = { 23, 11, true } };
|
|
Bar b;
|
|
b = { .x = z, .w = z < 100 };
|
|
io::printfln("%s %s %s", x.x, x.y, x.w);
|
|
io::printfln("%s %s %s", y.b.x, y.b.y, y.b.w);
|
|
io::printfln("%s %s %s", b.x, b.y, b.w);
|
|
x = { z + 1, 1, z > 100 };
|
|
y.b = { 33, 11, true };
|
|
b = { z + 1, 1, z > 100 };
|
|
io::printfln("%s %s %s", x.x, x.y, x.w);
|
|
io::printfln("%s %s %s", y.b.x, y.b.y, y.b.w);
|
|
io::printfln("%s %s %s", b.x, b.y, b.w);
|
|
|
|
}
|
|
|
|
fn void main()
|
|
{
|
|
hello(12);
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
define void @test_hello(i32 %0) #0 {
|
|
entry:
|
|
%x = alloca i64, align 8
|
|
%y = alloca %Abc, align 8
|
|
%d = alloca %Abc, align 8
|
|
%b = alloca [8 x i8], align 1
|
|
%retparam = alloca i64, align 8
|
|
%varargslots = alloca [3 x %variant], align 16
|
|
%taddr = alloca i32, align 4
|
|
%taddr13 = alloca i32, align 4
|
|
%taddr16 = alloca i8, align 1
|
|
%taddr17 = alloca %"variant[]", align 8
|
|
%retparam18 = alloca i64, align 8
|
|
%varargslots19 = alloca [3 x %variant], align 16
|
|
%taddr21 = alloca i32, align 4
|
|
%taddr24 = alloca i32, align 4
|
|
%taddr27 = alloca i8, align 1
|
|
%taddr28 = alloca %"variant[]", align 8
|
|
%retparam34 = alloca i64, align 8
|
|
%varargslots35 = alloca [3 x %variant], align 16
|
|
%taddr43 = alloca i32, align 4
|
|
%taddr51 = alloca i32, align 4
|
|
%taddr53 = alloca i8, align 1
|
|
%taddr54 = alloca %"variant[]", align 8
|
|
%retparam74 = alloca i64, align 8
|
|
%varargslots75 = alloca [3 x %variant], align 16
|
|
%taddr77 = alloca i32, align 4
|
|
%taddr80 = alloca i32, align 4
|
|
%taddr83 = alloca i8, align 1
|
|
%taddr84 = alloca %"variant[]", align 8
|
|
%retparam90 = alloca i64, align 8
|
|
%varargslots91 = alloca [3 x %variant], align 16
|
|
%taddr93 = alloca i32, align 4
|
|
%taddr96 = alloca i32, align 4
|
|
%taddr99 = alloca i8, align 1
|
|
%taddr100 = alloca %"variant[]", align 8
|
|
%retparam106 = alloca i64, align 8
|
|
%varargslots107 = alloca [3 x %variant], align 16
|
|
%taddr115 = alloca i32, align 4
|
|
%taddr123 = alloca i32, align 4
|
|
%taddr125 = alloca i8, align 1
|
|
%taddr126 = alloca %"variant[]", align 8
|
|
store i64 0, i64* %x, align 8
|
|
%zext = zext i32 %0 to i64
|
|
%1 = and i64 %zext, 4294967295
|
|
%lt = icmp slt i32 %0, 100
|
|
%2 = zext i1 %lt to i8
|
|
%zext1 = zext i8 %2 to i64
|
|
%shl = shl i64 %zext1, 63
|
|
%3 = and i64 %shl, -9223372036854775808
|
|
%4 = and i64 %1, 9223372036854775807
|
|
%5 = or i64 %4, %3
|
|
store i64 %5, i64* %x, align 8
|
|
%6 = bitcast %Abc* %y to i8*
|
|
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %6, i8* align 8 bitcast (%Abc* @.__const to i8*), i32 16, i1 false)
|
|
%7 = bitcast %Abc* %d to i8*
|
|
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %7, i8* align 8 bitcast (%Abc* @.__const.1 to i8*), i32 16, i1 false)
|
|
%8 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
store i8 0, i8* %8, align 1
|
|
%9 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
store i8 0, i8* %9, align 1
|
|
%10 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
store i8 0, i8* %10, align 1
|
|
%11 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
store i8 0, i8* %11, align 1
|
|
%12 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
store i8 0, i8* %12, align 1
|
|
%13 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
store i8 0, i8* %13, align 1
|
|
%14 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
store i8 0, i8* %14, align 1
|
|
%15 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
store i8 0, i8* %15, align 1
|
|
%16 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
store i8 0, i8* %16, align 1
|
|
%17 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
store i8 0, i8* %17, align 1
|
|
%18 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
store i8 0, i8* %18, align 1
|
|
%19 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
store i8 0, i8* %19, align 1
|
|
%20 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
store i8 0, i8* %20, align 1
|
|
%21 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
store i8 0, i8* %21, align 1
|
|
%22 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
store i8 0, i8* %22, align 1
|
|
%23 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
store i8 0, i8* %23, align 1
|
|
%24 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
%ztrunc = trunc i32 %0 to i8
|
|
store i8 %ztrunc, i8* %24, align 1
|
|
%lshrl = lshr i32 %0, 8
|
|
%25 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
%ztrunc2 = trunc i32 %lshrl to i8
|
|
store i8 %ztrunc2, i8* %25, align 1
|
|
%lshrl3 = lshr i32 %lshrl, 8
|
|
%26 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
%ztrunc4 = trunc i32 %lshrl3 to i8
|
|
store i8 %ztrunc4, i8* %26, align 1
|
|
%lshrl5 = lshr i32 %lshrl3, 8
|
|
%27 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
%ztrunc6 = trunc i32 %lshrl5 to i8
|
|
store i8 %ztrunc6, i8* %27, align 1
|
|
%lshrl7 = lshr i32 %lshrl5, 8
|
|
%lt8 = icmp slt i32 %0, 100
|
|
%28 = zext i1 %lt8 to i8
|
|
%shl9 = shl i8 %28, 7
|
|
%29 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%30 = load i8, i8* %29, align 1
|
|
%31 = and i8 %30, 127
|
|
%32 = or i8 %31, %shl9
|
|
store i8 %32, i8* %29, align 1
|
|
%33 = load i64, i64* %x, align 8
|
|
%34 = and i64 4294967295, %33
|
|
%ztrunc10 = trunc i64 %34 to i32
|
|
store i32 %ztrunc10, i32* %taddr, align 4
|
|
%35 = bitcast i32* %taddr to i8*
|
|
%36 = insertvalue %variant undef, i8* %35, 0
|
|
%37 = insertvalue %variant %36, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%38 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 0
|
|
store %variant %37, %variant* %38, align 16
|
|
%39 = load i64, i64* %x, align 8
|
|
%lshrl11 = lshr i64 %39, 32
|
|
%40 = and i64 2147483647, %lshrl11
|
|
%ztrunc12 = trunc i64 %40 to i32
|
|
store i32 %ztrunc12, i32* %taddr13, align 4
|
|
%41 = bitcast i32* %taddr13 to i8*
|
|
%42 = insertvalue %variant undef, i8* %41, 0
|
|
%43 = insertvalue %variant %42, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%44 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 1
|
|
store %variant %43, %variant* %44, align 16
|
|
%45 = load i64, i64* %x, align 8
|
|
%lshrl14 = lshr i64 %45, 63
|
|
%46 = and i64 1, %lshrl14
|
|
%ztrunc15 = trunc i64 %46 to i8
|
|
store i8 %ztrunc15, i8* %taddr16, align 1
|
|
%47 = insertvalue %variant undef, i8* %taddr16, 0
|
|
%48 = insertvalue %variant %47, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%49 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 2
|
|
store %variant %48, %variant* %49, align 16
|
|
%50 = bitcast [3 x %variant]* %varargslots to %variant*
|
|
%51 = insertvalue %"variant[]" undef, %variant* %50, 0
|
|
%52 = insertvalue %"variant[]" %51, i64 3, 1
|
|
store %"variant[]" %52, %"variant[]"* %taddr17, align 8
|
|
%53 = bitcast %"variant[]"* %taddr17 to { i8*, i64 }*
|
|
%54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 0
|
|
%lo = load i8*, i8** %54, align 8
|
|
%55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 1
|
|
%hi = load i64, i64* %55, align 8
|
|
%56 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8, i8* %lo, i64 %hi)
|
|
%not_err = icmp eq i64 %56, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
%57 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%58 = load i64, i64* %57, align 8
|
|
%59 = and i64 4294967295, %58
|
|
%ztrunc20 = trunc i64 %59 to i32
|
|
store i32 %ztrunc20, i32* %taddr21, align 4
|
|
%60 = bitcast i32* %taddr21 to i8*
|
|
%61 = insertvalue %variant undef, i8* %60, 0
|
|
%62 = insertvalue %variant %61, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%63 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 0
|
|
store %variant %62, %variant* %63, align 16
|
|
%64 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%65 = load i64, i64* %64, align 8
|
|
%lshrl22 = lshr i64 %65, 32
|
|
%66 = and i64 2147483647, %lshrl22
|
|
%ztrunc23 = trunc i64 %66 to i32
|
|
store i32 %ztrunc23, i32* %taddr24, align 4
|
|
%67 = bitcast i32* %taddr24 to i8*
|
|
%68 = insertvalue %variant undef, i8* %67, 0
|
|
%69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%70 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 1
|
|
store %variant %69, %variant* %70, align 16
|
|
%71 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%72 = load i64, i64* %71, align 8
|
|
%lshrl25 = lshr i64 %72, 63
|
|
%73 = and i64 1, %lshrl25
|
|
%ztrunc26 = trunc i64 %73 to i8
|
|
store i8 %ztrunc26, i8* %taddr27, align 1
|
|
%74 = insertvalue %variant undef, i8* %taddr27, 0
|
|
%75 = insertvalue %variant %74, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%76 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 2
|
|
store %variant %75, %variant* %76, align 16
|
|
%77 = bitcast [3 x %variant]* %varargslots19 to %variant*
|
|
%78 = insertvalue %"variant[]" undef, %variant* %77, 0
|
|
%79 = insertvalue %"variant[]" %78, i64 3, 1
|
|
store %"variant[]" %79, %"variant[]"* %taddr28, align 8
|
|
%80 = bitcast %"variant[]"* %taddr28 to { i8*, i64 }*
|
|
%81 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 0
|
|
%lo29 = load i8*, i8** %81, align 8
|
|
%82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 1
|
|
%hi30 = load i64, i64* %82, align 8
|
|
%83 = call i64 @std_io_printfln(i64* %retparam18, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8, i8* %lo29, i64 %hi30)
|
|
%not_err31 = icmp eq i64 %83, 0
|
|
br i1 %not_err31, label %after_check32, label %voiderr33
|
|
|
|
after_check32: ; preds = %voiderr
|
|
br label %voiderr33
|
|
|
|
voiderr33: ; preds = %after_check32, %voiderr
|
|
%84 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
%85 = load i8, i8* %84, align 1
|
|
%zext36 = zext i8 %85 to i32
|
|
%86 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
%87 = load i8, i8* %86, align 1
|
|
%zext37 = zext i8 %87 to i32
|
|
%shl38 = shl i32 %zext37, 8
|
|
%88 = or i32 %shl38, %zext36
|
|
%89 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
%90 = load i8, i8* %89, align 1
|
|
%zext39 = zext i8 %90 to i32
|
|
%shl40 = shl i32 %zext39, 16
|
|
%91 = or i32 %shl40, %88
|
|
%92 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
%93 = load i8, i8* %92, align 1
|
|
%zext41 = zext i8 %93 to i32
|
|
%shl42 = shl i32 %zext41, 24
|
|
%94 = or i32 %shl42, %91
|
|
store i32 %94, i32* %taddr43, align 4
|
|
%95 = bitcast i32* %taddr43 to i8*
|
|
%96 = insertvalue %variant undef, i8* %95, 0
|
|
%97 = insertvalue %variant %96, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%98 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 0
|
|
store %variant %97, %variant* %98, align 16
|
|
%99 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
%100 = load i8, i8* %99, align 1
|
|
%zext44 = zext i8 %100 to i32
|
|
%101 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
%102 = load i8, i8* %101, align 1
|
|
%zext45 = zext i8 %102 to i32
|
|
%shl46 = shl i32 %zext45, 8
|
|
%103 = or i32 %shl46, %zext44
|
|
%104 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
%105 = load i8, i8* %104, align 1
|
|
%zext47 = zext i8 %105 to i32
|
|
%shl48 = shl i32 %zext47, 16
|
|
%106 = or i32 %shl48, %103
|
|
%107 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%108 = load i8, i8* %107, align 1
|
|
%zext49 = zext i8 %108 to i32
|
|
%shl50 = shl i32 %zext49, 24
|
|
%109 = or i32 %shl50, %106
|
|
%110 = and i32 2147483647, %109
|
|
store i32 %110, i32* %taddr51, align 4
|
|
%111 = bitcast i32* %taddr51 to i8*
|
|
%112 = insertvalue %variant undef, i8* %111, 0
|
|
%113 = insertvalue %variant %112, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%114 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 1
|
|
store %variant %113, %variant* %114, align 16
|
|
%115 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%116 = load i8, i8* %115, align 1
|
|
%lshrl52 = lshr i8 %116, 7
|
|
%117 = trunc i8 %lshrl52 to i1
|
|
%118 = zext i1 %117 to i8
|
|
store i8 %118, i8* %taddr53, align 1
|
|
%119 = insertvalue %variant undef, i8* %taddr53, 0
|
|
%120 = insertvalue %variant %119, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%121 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 2
|
|
store %variant %120, %variant* %121, align 16
|
|
%122 = bitcast [3 x %variant]* %varargslots35 to %variant*
|
|
%123 = insertvalue %"variant[]" undef, %variant* %122, 0
|
|
%124 = insertvalue %"variant[]" %123, i64 3, 1
|
|
store %"variant[]" %124, %"variant[]"* %taddr54, align 8
|
|
%125 = bitcast %"variant[]"* %taddr54 to { i8*, i64 }*
|
|
%126 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %125, i32 0, i32 0
|
|
%lo55 = load i8*, i8** %126, align 8
|
|
%127 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %125, i32 0, i32 1
|
|
%hi56 = load i64, i64* %127, align 8
|
|
%128 = call i64 @std_io_printfln(i64* %retparam34, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0), i64 8, i8* %lo55, i64 %hi56)
|
|
%not_err57 = icmp eq i64 %128, 0
|
|
br i1 %not_err57, label %after_check58, label %voiderr59
|
|
|
|
after_check58: ; preds = %voiderr33
|
|
br label %voiderr59
|
|
|
|
voiderr59: ; preds = %after_check58, %voiderr33
|
|
%add = add i32 %0, 1
|
|
%zext60 = zext i32 %add to i64
|
|
%129 = and i64 %zext60, 4294967295
|
|
%130 = and i64 %129, -9223372032559808513
|
|
%131 = or i64 %130, 4294967296
|
|
%gt = icmp sgt i32 %0, 100
|
|
%132 = zext i1 %gt to i8
|
|
%zext61 = zext i8 %132 to i64
|
|
%shl62 = shl i64 %zext61, 63
|
|
%133 = and i64 %shl62, -9223372036854775808
|
|
%134 = and i64 %131, 9223372036854775807
|
|
%135 = or i64 %134, %133
|
|
store i64 %135, i64* %x, align 8
|
|
%136 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
store i64 -9223371989610135519, i64* %136, align 8
|
|
%137 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
store i8 0, i8* %137, align 1
|
|
%138 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
store i8 0, i8* %138, align 1
|
|
%139 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
store i8 0, i8* %139, align 1
|
|
%140 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
store i8 0, i8* %140, align 1
|
|
%141 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
store i8 0, i8* %141, align 1
|
|
%142 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
store i8 0, i8* %142, align 1
|
|
%143 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
store i8 0, i8* %143, align 1
|
|
%144 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
store i8 0, i8* %144, align 1
|
|
%add63 = add i32 %0, 1
|
|
%145 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
%ztrunc64 = trunc i32 %add63 to i8
|
|
store i8 %ztrunc64, i8* %145, align 1
|
|
%lshrl65 = lshr i32 %add63, 8
|
|
%146 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
%ztrunc66 = trunc i32 %lshrl65 to i8
|
|
store i8 %ztrunc66, i8* %146, align 1
|
|
%lshrl67 = lshr i32 %lshrl65, 8
|
|
%147 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
%ztrunc68 = trunc i32 %lshrl67 to i8
|
|
store i8 %ztrunc68, i8* %147, align 1
|
|
%lshrl69 = lshr i32 %lshrl67, 8
|
|
%148 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
%ztrunc70 = trunc i32 %lshrl69 to i8
|
|
store i8 %ztrunc70, i8* %148, align 1
|
|
%lshrl71 = lshr i32 %lshrl69, 8
|
|
%149 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
store i8 1, i8* %149, align 1
|
|
%150 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
store i8 0, i8* %150, align 1
|
|
%151 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
store i8 0, i8* %151, align 1
|
|
%152 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%153 = load i8, i8* %152, align 1
|
|
%154 = and i8 %153, -128
|
|
store i8 %154, i8* %152, align 1
|
|
%gt72 = icmp sgt i32 %0, 100
|
|
%155 = zext i1 %gt72 to i8
|
|
%shl73 = shl i8 %155, 7
|
|
%156 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%157 = load i8, i8* %156, align 1
|
|
%158 = and i8 %157, 127
|
|
%159 = or i8 %158, %shl73
|
|
store i8 %159, i8* %156, align 1
|
|
%160 = load i64, i64* %x, align 8
|
|
%161 = and i64 4294967295, %160
|
|
%ztrunc76 = trunc i64 %161 to i32
|
|
store i32 %ztrunc76, i32* %taddr77, align 4
|
|
%162 = bitcast i32* %taddr77 to i8*
|
|
%163 = insertvalue %variant undef, i8* %162, 0
|
|
%164 = insertvalue %variant %163, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%165 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 0
|
|
store %variant %164, %variant* %165, align 16
|
|
%166 = load i64, i64* %x, align 8
|
|
%lshrl78 = lshr i64 %166, 32
|
|
%167 = and i64 2147483647, %lshrl78
|
|
%ztrunc79 = trunc i64 %167 to i32
|
|
store i32 %ztrunc79, i32* %taddr80, align 4
|
|
%168 = bitcast i32* %taddr80 to i8*
|
|
%169 = insertvalue %variant undef, i8* %168, 0
|
|
%170 = insertvalue %variant %169, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%171 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 1
|
|
store %variant %170, %variant* %171, align 16
|
|
%172 = load i64, i64* %x, align 8
|
|
%lshrl81 = lshr i64 %172, 63
|
|
%173 = and i64 1, %lshrl81
|
|
%ztrunc82 = trunc i64 %173 to i8
|
|
store i8 %ztrunc82, i8* %taddr83, align 1
|
|
%174 = insertvalue %variant undef, i8* %taddr83, 0
|
|
%175 = insertvalue %variant %174, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%176 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 2
|
|
store %variant %175, %variant* %176, align 16
|
|
%177 = bitcast [3 x %variant]* %varargslots75 to %variant*
|
|
%178 = insertvalue %"variant[]" undef, %variant* %177, 0
|
|
%179 = insertvalue %"variant[]" %178, i64 3, 1
|
|
store %"variant[]" %179, %"variant[]"* %taddr84, align 8
|
|
%180 = bitcast %"variant[]"* %taddr84 to { i8*, i64 }*
|
|
%181 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %180, i32 0, i32 0
|
|
%lo85 = load i8*, i8** %181, align 8
|
|
%182 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %180, i32 0, i32 1
|
|
%hi86 = load i64, i64* %182, align 8
|
|
%183 = call i64 @std_io_printfln(i64* %retparam74, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i32 0, i32 0), i64 8, i8* %lo85, i64 %hi86)
|
|
%not_err87 = icmp eq i64 %183, 0
|
|
br i1 %not_err87, label %after_check88, label %voiderr89
|
|
|
|
after_check88: ; preds = %voiderr59
|
|
br label %voiderr89
|
|
|
|
voiderr89: ; preds = %after_check88, %voiderr59
|
|
%184 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%185 = load i64, i64* %184, align 8
|
|
%186 = and i64 4294967295, %185
|
|
%ztrunc92 = trunc i64 %186 to i32
|
|
store i32 %ztrunc92, i32* %taddr93, align 4
|
|
%187 = bitcast i32* %taddr93 to i8*
|
|
%188 = insertvalue %variant undef, i8* %187, 0
|
|
%189 = insertvalue %variant %188, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%190 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 0
|
|
store %variant %189, %variant* %190, align 16
|
|
%191 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%192 = load i64, i64* %191, align 8
|
|
%lshrl94 = lshr i64 %192, 32
|
|
%193 = and i64 2147483647, %lshrl94
|
|
%ztrunc95 = trunc i64 %193 to i32
|
|
store i32 %ztrunc95, i32* %taddr96, align 4
|
|
%194 = bitcast i32* %taddr96 to i8*
|
|
%195 = insertvalue %variant undef, i8* %194, 0
|
|
%196 = insertvalue %variant %195, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%197 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 1
|
|
store %variant %196, %variant* %197, align 16
|
|
%198 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%199 = load i64, i64* %198, align 8
|
|
%lshrl97 = lshr i64 %199, 63
|
|
%200 = and i64 1, %lshrl97
|
|
%ztrunc98 = trunc i64 %200 to i8
|
|
store i8 %ztrunc98, i8* %taddr99, align 1
|
|
%201 = insertvalue %variant undef, i8* %taddr99, 0
|
|
%202 = insertvalue %variant %201, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%203 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 2
|
|
store %variant %202, %variant* %203, align 16
|
|
%204 = bitcast [3 x %variant]* %varargslots91 to %variant*
|
|
%205 = insertvalue %"variant[]" undef, %variant* %204, 0
|
|
%206 = insertvalue %"variant[]" %205, i64 3, 1
|
|
store %"variant[]" %206, %"variant[]"* %taddr100, align 8
|
|
%207 = bitcast %"variant[]"* %taddr100 to { i8*, i64 }*
|
|
%208 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %207, i32 0, i32 0
|
|
%lo101 = load i8*, i8** %208, align 8
|
|
%209 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %207, i32 0, i32 1
|
|
%hi102 = load i64, i64* %209, align 8
|
|
%210 = call i64 @std_io_printfln(i64* %retparam90, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i32 0, i32 0), i64 8, i8* %lo101, i64 %hi102)
|
|
%not_err103 = icmp eq i64 %210, 0
|
|
br i1 %not_err103, label %after_check104, label %voiderr105
|
|
|
|
after_check104: ; preds = %voiderr89
|
|
br label %voiderr105
|
|
|
|
voiderr105: ; preds = %after_check104, %voiderr89
|
|
%211 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
%212 = load i8, i8* %211, align 1
|
|
%zext108 = zext i8 %212 to i32
|
|
%213 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
%214 = load i8, i8* %213, align 1
|
|
%zext109 = zext i8 %214 to i32
|
|
%shl110 = shl i32 %zext109, 8
|
|
%215 = or i32 %shl110, %zext108
|
|
%216 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
%217 = load i8, i8* %216, align 1
|
|
%zext111 = zext i8 %217 to i32
|
|
%shl112 = shl i32 %zext111, 16
|
|
%218 = or i32 %shl112, %215
|
|
%219 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
%220 = load i8, i8* %219, align 1
|
|
%zext113 = zext i8 %220 to i32
|
|
%shl114 = shl i32 %zext113, 24
|
|
%221 = or i32 %shl114, %218
|
|
store i32 %221, i32* %taddr115, align 4
|
|
%222 = bitcast i32* %taddr115 to i8*
|
|
%223 = insertvalue %variant undef, i8* %222, 0
|
|
%224 = insertvalue %variant %223, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%225 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 0
|
|
store %variant %224, %variant* %225, align 16
|
|
%226 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
%227 = load i8, i8* %226, align 1
|
|
%zext116 = zext i8 %227 to i32
|
|
%228 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
%229 = load i8, i8* %228, align 1
|
|
%zext117 = zext i8 %229 to i32
|
|
%shl118 = shl i32 %zext117, 8
|
|
%230 = or i32 %shl118, %zext116
|
|
%231 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
%232 = load i8, i8* %231, align 1
|
|
%zext119 = zext i8 %232 to i32
|
|
%shl120 = shl i32 %zext119, 16
|
|
%233 = or i32 %shl120, %230
|
|
%234 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%235 = load i8, i8* %234, align 1
|
|
%zext121 = zext i8 %235 to i32
|
|
%shl122 = shl i32 %zext121, 24
|
|
%236 = or i32 %shl122, %233
|
|
%237 = and i32 2147483647, %236
|
|
store i32 %237, i32* %taddr123, align 4
|
|
%238 = bitcast i32* %taddr123 to i8*
|
|
%239 = insertvalue %variant undef, i8* %238, 0
|
|
%240 = insertvalue %variant %239, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%241 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 1
|
|
store %variant %240, %variant* %241, align 16
|
|
%242 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%243 = load i8, i8* %242, align 1
|
|
%lshrl124 = lshr i8 %243, 7
|
|
%244 = trunc i8 %lshrl124 to i1
|
|
%245 = zext i1 %244 to i8
|
|
store i8 %245, i8* %taddr125, align 1
|
|
%246 = insertvalue %variant undef, i8* %taddr125, 0
|
|
%247 = insertvalue %variant %246, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%248 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 2
|
|
store %variant %247, %variant* %248, align 16
|
|
%249 = bitcast [3 x %variant]* %varargslots107 to %variant*
|
|
%250 = insertvalue %"variant[]" undef, %variant* %249, 0
|
|
%251 = insertvalue %"variant[]" %250, i64 3, 1
|
|
store %"variant[]" %251, %"variant[]"* %taddr126, align 8
|
|
%252 = bitcast %"variant[]"* %taddr126 to { i8*, i64 }*
|
|
%253 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %252, i32 0, i32 0
|
|
%lo127 = load i8*, i8** %253, align 8
|
|
%254 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %252, i32 0, i32 1
|
|
%hi128 = load i64, i64* %254, align 8
|
|
%255 = call i64 @std_io_printfln(i64* %retparam106, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i32 0, i32 0), i64 8, i8* %lo127, i64 %hi128)
|
|
%not_err129 = icmp eq i64 %255, 0
|
|
br i1 %not_err129, label %after_check130, label %voiderr131
|
|
|
|
after_check130: ; preds = %voiderr105
|
|
br label %voiderr131
|
|
|
|
voiderr131: ; preds = %after_check130, %voiderr105
|
|
ret void
|
|
}
|