mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
618 lines
28 KiB
C
618 lines
28 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
|
|
%taddr = alloca %"char[]", align 8
|
|
%vararg = alloca %"variant[]", align 8
|
|
%varargslots = alloca [3 x %variant], align 16
|
|
%taddr11 = alloca i32, align 4
|
|
%taddr14 = alloca i32, align 4
|
|
%taddr17 = alloca i8, align 1
|
|
%retparam20 = alloca i64, align 8
|
|
%taddr21 = alloca %"char[]", align 8
|
|
%vararg24 = alloca %"variant[]", align 8
|
|
%varargslots25 = alloca [3 x %variant], align 16
|
|
%taddr27 = alloca i32, align 4
|
|
%taddr30 = alloca i32, align 4
|
|
%taddr33 = alloca i8, align 1
|
|
%retparam39 = alloca i64, align 8
|
|
%taddr40 = alloca %"char[]", align 8
|
|
%vararg43 = alloca %"variant[]", align 8
|
|
%varargslots44 = alloca [3 x %variant], align 16
|
|
%taddr52 = alloca i32, align 4
|
|
%taddr60 = alloca i32, align 4
|
|
%taddr62 = alloca i8, align 1
|
|
%retparam82 = alloca i64, align 8
|
|
%taddr83 = alloca %"char[]", align 8
|
|
%vararg86 = alloca %"variant[]", align 8
|
|
%varargslots87 = alloca [3 x %variant], align 16
|
|
%taddr89 = alloca i32, align 4
|
|
%taddr92 = alloca i32, align 4
|
|
%taddr95 = alloca i8, align 1
|
|
%retparam101 = alloca i64, align 8
|
|
%taddr102 = alloca %"char[]", align 8
|
|
%vararg105 = alloca %"variant[]", align 8
|
|
%varargslots106 = alloca [3 x %variant], align 16
|
|
%taddr108 = alloca i32, align 4
|
|
%taddr111 = alloca i32, align 4
|
|
%taddr114 = alloca i8, align 1
|
|
%retparam120 = alloca i64, align 8
|
|
%taddr121 = alloca %"char[]", align 8
|
|
%vararg124 = alloca %"variant[]", align 8
|
|
%varargslots125 = alloca [3 x %variant], align 16
|
|
%taddr133 = alloca i32, align 4
|
|
%taddr141 = alloca i32, align 4
|
|
%taddr143 = alloca i8, align 1
|
|
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
|
|
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8 }, %"char[]"* %taddr, align 8
|
|
%33 = bitcast %"char[]"* %taddr to { i8*, i64 }*
|
|
%34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 0
|
|
%lo = load i8*, i8** %34, align 8
|
|
%35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %33, i32 0, i32 1
|
|
%hi = load i64, i64* %35, align 8
|
|
%36 = load i64, i64* %x, align 8
|
|
%37 = and i64 4294967295, %36
|
|
%ztrunc10 = trunc i64 %37 to i32
|
|
store i32 %ztrunc10, i32* %taddr11, align 4
|
|
%38 = bitcast i32* %taddr11 to i8*
|
|
%39 = insertvalue %variant undef, i8* %38, 0
|
|
%40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%41 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 0
|
|
store %variant %40, %variant* %41, align 16
|
|
%42 = load i64, i64* %x, align 8
|
|
%lshrl12 = lshr i64 %42, 32
|
|
%43 = and i64 2147483647, %lshrl12
|
|
%ztrunc13 = trunc i64 %43 to i32
|
|
store i32 %ztrunc13, i32* %taddr14, align 4
|
|
%44 = bitcast i32* %taddr14 to i8*
|
|
%45 = insertvalue %variant undef, i8* %44, 0
|
|
%46 = insertvalue %variant %45, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%47 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 1
|
|
store %variant %46, %variant* %47, align 16
|
|
%48 = load i64, i64* %x, align 8
|
|
%lshrl15 = lshr i64 %48, 63
|
|
%49 = and i64 1, %lshrl15
|
|
%ztrunc16 = trunc i64 %49 to i8
|
|
store i8 %ztrunc16, i8* %taddr17, align 1
|
|
%50 = insertvalue %variant undef, i8* %taddr17, 0
|
|
%51 = insertvalue %variant %50, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%52 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 2
|
|
store %variant %51, %variant* %52, align 16
|
|
%53 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
|
|
store i64 3, i64* %53, align 8
|
|
%54 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
|
|
%55 = bitcast [3 x %variant]* %varargslots to %variant*
|
|
store %variant* %55, %variant** %54, align 8
|
|
%56 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
|
|
%57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 0
|
|
%lo18 = load i8*, i8** %57, align 8
|
|
%58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %56, i32 0, i32 1
|
|
%hi19 = load i64, i64* %58, align 8
|
|
%59 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo18, i64 %hi19)
|
|
%not_err = icmp eq i64 %59, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8 }, %"char[]"* %taddr21, align 8
|
|
%60 = bitcast %"char[]"* %taddr21 to { i8*, i64 }*
|
|
%61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0
|
|
%lo22 = load i8*, i8** %61, align 8
|
|
%62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1
|
|
%hi23 = load i64, i64* %62, align 8
|
|
%63 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%64 = load i64, i64* %63, align 8
|
|
%65 = and i64 4294967295, %64
|
|
%ztrunc26 = trunc i64 %65 to i32
|
|
store i32 %ztrunc26, i32* %taddr27, align 4
|
|
%66 = bitcast i32* %taddr27 to i8*
|
|
%67 = insertvalue %variant undef, i8* %66, 0
|
|
%68 = insertvalue %variant %67, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%69 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 0
|
|
store %variant %68, %variant* %69, align 16
|
|
%70 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%71 = load i64, i64* %70, align 8
|
|
%lshrl28 = lshr i64 %71, 32
|
|
%72 = and i64 2147483647, %lshrl28
|
|
%ztrunc29 = trunc i64 %72 to i32
|
|
store i32 %ztrunc29, i32* %taddr30, align 4
|
|
%73 = bitcast i32* %taddr30 to i8*
|
|
%74 = insertvalue %variant undef, i8* %73, 0
|
|
%75 = insertvalue %variant %74, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%76 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 1
|
|
store %variant %75, %variant* %76, align 16
|
|
%77 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%78 = load i64, i64* %77, align 8
|
|
%lshrl31 = lshr i64 %78, 63
|
|
%79 = and i64 1, %lshrl31
|
|
%ztrunc32 = trunc i64 %79 to i8
|
|
store i8 %ztrunc32, i8* %taddr33, align 1
|
|
%80 = insertvalue %variant undef, i8* %taddr33, 0
|
|
%81 = insertvalue %variant %80, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%82 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots25, i64 0, i64 2
|
|
store %variant %81, %variant* %82, align 16
|
|
%83 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg24, i32 0, i32 1
|
|
store i64 3, i64* %83, align 8
|
|
%84 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg24, i32 0, i32 0
|
|
%85 = bitcast [3 x %variant]* %varargslots25 to %variant*
|
|
store %variant* %85, %variant** %84, align 8
|
|
%86 = bitcast %"variant[]"* %vararg24 to { i8*, i64 }*
|
|
%87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 0
|
|
%lo34 = load i8*, i8** %87, align 8
|
|
%88 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 1
|
|
%hi35 = load i64, i64* %88, align 8
|
|
%89 = call i64 @std_io_printfln(i64* %retparam20, i8* %lo22, i64 %hi23, i8* %lo34, i64 %hi35)
|
|
%not_err36 = icmp eq i64 %89, 0
|
|
br i1 %not_err36, label %after_check37, label %voiderr38
|
|
|
|
after_check37: ; preds = %voiderr
|
|
br label %voiderr38
|
|
|
|
voiderr38: ; preds = %after_check37, %voiderr
|
|
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0), i64 8 }, %"char[]"* %taddr40, align 8
|
|
%90 = bitcast %"char[]"* %taddr40 to { i8*, i64 }*
|
|
%91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 0
|
|
%lo41 = load i8*, i8** %91, align 8
|
|
%92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %90, i32 0, i32 1
|
|
%hi42 = load i64, i64* %92, align 8
|
|
%93 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
%94 = load i8, i8* %93, align 1
|
|
%zext45 = zext i8 %94 to i32
|
|
%95 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
%96 = load i8, i8* %95, align 1
|
|
%zext46 = zext i8 %96 to i32
|
|
%shl47 = shl i32 %zext46, 8
|
|
%97 = or i32 %shl47, %zext45
|
|
%98 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
%99 = load i8, i8* %98, align 1
|
|
%zext48 = zext i8 %99 to i32
|
|
%shl49 = shl i32 %zext48, 16
|
|
%100 = or i32 %shl49, %97
|
|
%101 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
%102 = load i8, i8* %101, align 1
|
|
%zext50 = zext i8 %102 to i32
|
|
%shl51 = shl i32 %zext50, 24
|
|
%103 = or i32 %shl51, %100
|
|
store i32 %103, i32* %taddr52, align 4
|
|
%104 = bitcast i32* %taddr52 to i8*
|
|
%105 = insertvalue %variant undef, i8* %104, 0
|
|
%106 = insertvalue %variant %105, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%107 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 0
|
|
store %variant %106, %variant* %107, align 16
|
|
%108 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
%109 = load i8, i8* %108, align 1
|
|
%zext53 = zext i8 %109 to i32
|
|
%110 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
%111 = load i8, i8* %110, align 1
|
|
%zext54 = zext i8 %111 to i32
|
|
%shl55 = shl i32 %zext54, 8
|
|
%112 = or i32 %shl55, %zext53
|
|
%113 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
%114 = load i8, i8* %113, align 1
|
|
%zext56 = zext i8 %114 to i32
|
|
%shl57 = shl i32 %zext56, 16
|
|
%115 = or i32 %shl57, %112
|
|
%116 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%117 = load i8, i8* %116, align 1
|
|
%zext58 = zext i8 %117 to i32
|
|
%shl59 = shl i32 %zext58, 24
|
|
%118 = or i32 %shl59, %115
|
|
%119 = and i32 2147483647, %118
|
|
store i32 %119, i32* %taddr60, align 4
|
|
%120 = bitcast i32* %taddr60 to i8*
|
|
%121 = insertvalue %variant undef, i8* %120, 0
|
|
%122 = insertvalue %variant %121, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%123 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 1
|
|
store %variant %122, %variant* %123, align 16
|
|
%124 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%125 = load i8, i8* %124, align 1
|
|
%lshrl61 = lshr i8 %125, 7
|
|
%126 = trunc i8 %lshrl61 to i1
|
|
%127 = zext i1 %126 to i8
|
|
store i8 %127, i8* %taddr62, align 1
|
|
%128 = insertvalue %variant undef, i8* %taddr62, 0
|
|
%129 = insertvalue %variant %128, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%130 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots44, i64 0, i64 2
|
|
store %variant %129, %variant* %130, align 16
|
|
%131 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg43, i32 0, i32 1
|
|
store i64 3, i64* %131, align 8
|
|
%132 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg43, i32 0, i32 0
|
|
%133 = bitcast [3 x %variant]* %varargslots44 to %variant*
|
|
store %variant* %133, %variant** %132, align 8
|
|
%134 = bitcast %"variant[]"* %vararg43 to { i8*, i64 }*
|
|
%135 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %134, i32 0, i32 0
|
|
%lo63 = load i8*, i8** %135, align 8
|
|
%136 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %134, i32 0, i32 1
|
|
%hi64 = load i64, i64* %136, align 8
|
|
%137 = call i64 @std_io_printfln(i64* %retparam39, i8* %lo41, i64 %hi42, i8* %lo63, i64 %hi64)
|
|
%not_err65 = icmp eq i64 %137, 0
|
|
br i1 %not_err65, label %after_check66, label %voiderr67
|
|
|
|
after_check66: ; preds = %voiderr38
|
|
br label %voiderr67
|
|
|
|
voiderr67: ; preds = %after_check66, %voiderr38
|
|
%add = add i32 %0, 1
|
|
%zext68 = zext i32 %add to i64
|
|
%138 = and i64 %zext68, 4294967295
|
|
%139 = and i64 %138, -9223372032559808513
|
|
%140 = or i64 %139, 4294967296
|
|
%gt = icmp sgt i32 %0, 100
|
|
%141 = zext i1 %gt to i8
|
|
%zext69 = zext i8 %141 to i64
|
|
%shl70 = shl i64 %zext69, 63
|
|
%142 = and i64 %shl70, -9223372036854775808
|
|
%143 = and i64 %140, 9223372036854775807
|
|
%144 = or i64 %143, %142
|
|
store i64 %144, i64* %x, align 8
|
|
%145 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
store i64 -9223371989610135519, i64* %145, align 8
|
|
%146 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
store i8 0, i8* %146, align 1
|
|
%147 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
store i8 0, i8* %147, align 1
|
|
%148 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
store i8 0, i8* %148, align 1
|
|
%149 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
store i8 0, i8* %149, align 1
|
|
%150 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
store i8 0, i8* %150, align 1
|
|
%151 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
store i8 0, i8* %151, align 1
|
|
%152 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
store i8 0, i8* %152, align 1
|
|
%153 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
store i8 0, i8* %153, align 1
|
|
%add71 = add i32 %0, 1
|
|
%154 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
%ztrunc72 = trunc i32 %add71 to i8
|
|
store i8 %ztrunc72, i8* %154, align 1
|
|
%lshrl73 = lshr i32 %add71, 8
|
|
%155 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
%ztrunc74 = trunc i32 %lshrl73 to i8
|
|
store i8 %ztrunc74, i8* %155, align 1
|
|
%lshrl75 = lshr i32 %lshrl73, 8
|
|
%156 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
%ztrunc76 = trunc i32 %lshrl75 to i8
|
|
store i8 %ztrunc76, i8* %156, align 1
|
|
%lshrl77 = lshr i32 %lshrl75, 8
|
|
%157 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
%ztrunc78 = trunc i32 %lshrl77 to i8
|
|
store i8 %ztrunc78, i8* %157, align 1
|
|
%lshrl79 = lshr i32 %lshrl77, 8
|
|
%158 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
store i8 1, i8* %158, align 1
|
|
%159 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
store i8 0, i8* %159, align 1
|
|
%160 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
store i8 0, i8* %160, align 1
|
|
%161 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%162 = load i8, i8* %161, align 1
|
|
%163 = and i8 %162, -128
|
|
store i8 %163, i8* %161, align 1
|
|
%gt80 = icmp sgt i32 %0, 100
|
|
%164 = zext i1 %gt80 to i8
|
|
%shl81 = shl i8 %164, 7
|
|
%165 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%166 = load i8, i8* %165, align 1
|
|
%167 = and i8 %166, 127
|
|
%168 = or i8 %167, %shl81
|
|
store i8 %168, i8* %165, align 1
|
|
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i32 0, i32 0), i64 8 }, %"char[]"* %taddr83, align 8
|
|
%169 = bitcast %"char[]"* %taddr83 to { i8*, i64 }*
|
|
%170 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 0
|
|
%lo84 = load i8*, i8** %170, align 8
|
|
%171 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %169, i32 0, i32 1
|
|
%hi85 = load i64, i64* %171, align 8
|
|
%172 = load i64, i64* %x, align 8
|
|
%173 = and i64 4294967295, %172
|
|
%ztrunc88 = trunc i64 %173 to i32
|
|
store i32 %ztrunc88, i32* %taddr89, align 4
|
|
%174 = bitcast i32* %taddr89 to i8*
|
|
%175 = insertvalue %variant undef, i8* %174, 0
|
|
%176 = insertvalue %variant %175, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%177 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 0
|
|
store %variant %176, %variant* %177, align 16
|
|
%178 = load i64, i64* %x, align 8
|
|
%lshrl90 = lshr i64 %178, 32
|
|
%179 = and i64 2147483647, %lshrl90
|
|
%ztrunc91 = trunc i64 %179 to i32
|
|
store i32 %ztrunc91, i32* %taddr92, align 4
|
|
%180 = bitcast i32* %taddr92 to i8*
|
|
%181 = insertvalue %variant undef, i8* %180, 0
|
|
%182 = insertvalue %variant %181, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%183 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 1
|
|
store %variant %182, %variant* %183, align 16
|
|
%184 = load i64, i64* %x, align 8
|
|
%lshrl93 = lshr i64 %184, 63
|
|
%185 = and i64 1, %lshrl93
|
|
%ztrunc94 = trunc i64 %185 to i8
|
|
store i8 %ztrunc94, i8* %taddr95, align 1
|
|
%186 = insertvalue %variant undef, i8* %taddr95, 0
|
|
%187 = insertvalue %variant %186, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%188 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots87, i64 0, i64 2
|
|
store %variant %187, %variant* %188, align 16
|
|
%189 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 1
|
|
store i64 3, i64* %189, align 8
|
|
%190 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg86, i32 0, i32 0
|
|
%191 = bitcast [3 x %variant]* %varargslots87 to %variant*
|
|
store %variant* %191, %variant** %190, align 8
|
|
%192 = bitcast %"variant[]"* %vararg86 to { i8*, i64 }*
|
|
%193 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %192, i32 0, i32 0
|
|
%lo96 = load i8*, i8** %193, align 8
|
|
%194 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %192, i32 0, i32 1
|
|
%hi97 = load i64, i64* %194, align 8
|
|
%195 = call i64 @std_io_printfln(i64* %retparam82, i8* %lo84, i64 %hi85, i8* %lo96, i64 %hi97)
|
|
%not_err98 = icmp eq i64 %195, 0
|
|
br i1 %not_err98, label %after_check99, label %voiderr100
|
|
|
|
after_check99: ; preds = %voiderr67
|
|
br label %voiderr100
|
|
|
|
voiderr100: ; preds = %after_check99, %voiderr67
|
|
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i32 0, i32 0), i64 8 }, %"char[]"* %taddr102, align 8
|
|
%196 = bitcast %"char[]"* %taddr102 to { i8*, i64 }*
|
|
%197 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %196, i32 0, i32 0
|
|
%lo103 = load i8*, i8** %197, align 8
|
|
%198 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %196, i32 0, i32 1
|
|
%hi104 = load i64, i64* %198, align 8
|
|
%199 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%200 = load i64, i64* %199, align 8
|
|
%201 = and i64 4294967295, %200
|
|
%ztrunc107 = trunc i64 %201 to i32
|
|
store i32 %ztrunc107, i32* %taddr108, align 4
|
|
%202 = bitcast i32* %taddr108 to i8*
|
|
%203 = insertvalue %variant undef, i8* %202, 0
|
|
%204 = insertvalue %variant %203, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%205 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 0
|
|
store %variant %204, %variant* %205, align 16
|
|
%206 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%207 = load i64, i64* %206, align 8
|
|
%lshrl109 = lshr i64 %207, 32
|
|
%208 = and i64 2147483647, %lshrl109
|
|
%ztrunc110 = trunc i64 %208 to i32
|
|
store i32 %ztrunc110, i32* %taddr111, align 4
|
|
%209 = bitcast i32* %taddr111 to i8*
|
|
%210 = insertvalue %variant undef, i8* %209, 0
|
|
%211 = insertvalue %variant %210, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%212 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 1
|
|
store %variant %211, %variant* %212, align 16
|
|
%213 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
|
|
%214 = load i64, i64* %213, align 8
|
|
%lshrl112 = lshr i64 %214, 63
|
|
%215 = and i64 1, %lshrl112
|
|
%ztrunc113 = trunc i64 %215 to i8
|
|
store i8 %ztrunc113, i8* %taddr114, align 1
|
|
%216 = insertvalue %variant undef, i8* %taddr114, 0
|
|
%217 = insertvalue %variant %216, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%218 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots106, i64 0, i64 2
|
|
store %variant %217, %variant* %218, align 16
|
|
%219 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg105, i32 0, i32 1
|
|
store i64 3, i64* %219, align 8
|
|
%220 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg105, i32 0, i32 0
|
|
%221 = bitcast [3 x %variant]* %varargslots106 to %variant*
|
|
store %variant* %221, %variant** %220, align 8
|
|
%222 = bitcast %"variant[]"* %vararg105 to { i8*, i64 }*
|
|
%223 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %222, i32 0, i32 0
|
|
%lo115 = load i8*, i8** %223, align 8
|
|
%224 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %222, i32 0, i32 1
|
|
%hi116 = load i64, i64* %224, align 8
|
|
%225 = call i64 @std_io_printfln(i64* %retparam101, i8* %lo103, i64 %hi104, i8* %lo115, i64 %hi116)
|
|
%not_err117 = icmp eq i64 %225, 0
|
|
br i1 %not_err117, label %after_check118, label %voiderr119
|
|
|
|
after_check118: ; preds = %voiderr100
|
|
br label %voiderr119
|
|
|
|
voiderr119: ; preds = %after_check118, %voiderr100
|
|
store %"char[]" { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i32 0, i32 0), i64 8 }, %"char[]"* %taddr121, align 8
|
|
%226 = bitcast %"char[]"* %taddr121 to { i8*, i64 }*
|
|
%227 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %226, i32 0, i32 0
|
|
%lo122 = load i8*, i8** %227, align 8
|
|
%228 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %226, i32 0, i32 1
|
|
%hi123 = load i64, i64* %228, align 8
|
|
%229 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
|
|
%230 = load i8, i8* %229, align 1
|
|
%zext126 = zext i8 %230 to i32
|
|
%231 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
|
|
%232 = load i8, i8* %231, align 1
|
|
%zext127 = zext i8 %232 to i32
|
|
%shl128 = shl i32 %zext127, 8
|
|
%233 = or i32 %shl128, %zext126
|
|
%234 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
|
|
%235 = load i8, i8* %234, align 1
|
|
%zext129 = zext i8 %235 to i32
|
|
%shl130 = shl i32 %zext129, 16
|
|
%236 = or i32 %shl130, %233
|
|
%237 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
|
|
%238 = load i8, i8* %237, align 1
|
|
%zext131 = zext i8 %238 to i32
|
|
%shl132 = shl i32 %zext131, 24
|
|
%239 = or i32 %shl132, %236
|
|
store i32 %239, i32* %taddr133, align 4
|
|
%240 = bitcast i32* %taddr133 to i8*
|
|
%241 = insertvalue %variant undef, i8* %240, 0
|
|
%242 = insertvalue %variant %241, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%243 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 0
|
|
store %variant %242, %variant* %243, align 16
|
|
%244 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
|
|
%245 = load i8, i8* %244, align 1
|
|
%zext134 = zext i8 %245 to i32
|
|
%246 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
|
|
%247 = load i8, i8* %246, align 1
|
|
%zext135 = zext i8 %247 to i32
|
|
%shl136 = shl i32 %zext135, 8
|
|
%248 = or i32 %shl136, %zext134
|
|
%249 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
|
|
%250 = load i8, i8* %249, align 1
|
|
%zext137 = zext i8 %250 to i32
|
|
%shl138 = shl i32 %zext137, 16
|
|
%251 = or i32 %shl138, %248
|
|
%252 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%253 = load i8, i8* %252, align 1
|
|
%zext139 = zext i8 %253 to i32
|
|
%shl140 = shl i32 %zext139, 24
|
|
%254 = or i32 %shl140, %251
|
|
%255 = and i32 2147483647, %254
|
|
store i32 %255, i32* %taddr141, align 4
|
|
%256 = bitcast i32* %taddr141 to i8*
|
|
%257 = insertvalue %variant undef, i8* %256, 0
|
|
%258 = insertvalue %variant %257, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
|
|
%259 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 1
|
|
store %variant %258, %variant* %259, align 16
|
|
%260 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
|
|
%261 = load i8, i8* %260, align 1
|
|
%lshrl142 = lshr i8 %261, 7
|
|
%262 = trunc i8 %lshrl142 to i1
|
|
%263 = zext i1 %262 to i8
|
|
store i8 %263, i8* %taddr143, align 1
|
|
%264 = insertvalue %variant undef, i8* %taddr143, 0
|
|
%265 = insertvalue %variant %264, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%266 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots125, i64 0, i64 2
|
|
store %variant %265, %variant* %266, align 16
|
|
%267 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg124, i32 0, i32 1
|
|
store i64 3, i64* %267, align 8
|
|
%268 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg124, i32 0, i32 0
|
|
%269 = bitcast [3 x %variant]* %varargslots125 to %variant*
|
|
store %variant* %269, %variant** %268, align 8
|
|
%270 = bitcast %"variant[]"* %vararg124 to { i8*, i64 }*
|
|
%271 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 0
|
|
%lo144 = load i8*, i8** %271, align 8
|
|
%272 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %270, i32 0, i32 1
|
|
%hi145 = load i64, i64* %272, align 8
|
|
%273 = call i64 @std_io_printfln(i64* %retparam120, i8* %lo122, i64 %hi123, i8* %lo144, i64 %hi145)
|
|
%not_err146 = icmp eq i64 %273, 0
|
|
br i1 %not_err146, label %after_check147, label %voiderr148
|
|
|
|
after_check147: ; preds = %voiderr119
|
|
br label %voiderr148
|
|
|
|
voiderr148: ; preds = %after_check147, %voiderr119
|
|
ret void
|
|
}
|