mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
233 lines
10 KiB
C
233 lines
10 KiB
C
// #target: x64-darwin
|
|
|
|
module mymodule;
|
|
|
|
extern func void printf(char *, ...);
|
|
|
|
func void main()
|
|
{
|
|
|
|
char[] y = "hodo";
|
|
char[] z = "hodo";
|
|
if (y == "hodo")
|
|
{
|
|
printf("This works\n");
|
|
}
|
|
if (y == z)
|
|
{
|
|
printf("This works too\n");
|
|
}
|
|
switch (y)
|
|
{
|
|
case "mixx":
|
|
printf("Wut\n");
|
|
case "hodot":
|
|
printf("Nope\n");
|
|
case "hodo":
|
|
printf("Winning!\n");
|
|
default:
|
|
printf("Hodohell\n");
|
|
}
|
|
|
|
}
|
|
|
|
// #expect: mymodule.ll
|
|
|
|
define void @main() #0 {
|
|
entry:
|
|
%y = alloca %"char[]", align 8
|
|
%z = alloca %"char[]", align 8
|
|
%cmp.idx = alloca i64, align 8
|
|
%cmp.idx5 = alloca i64, align 8
|
|
%switch = alloca %"char[]", align 8
|
|
%cmp.idx18 = alloca i64, align 8
|
|
%cmp.idx29 = alloca i64, align 8
|
|
%cmp.idx42 = alloca i64, align 8
|
|
store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0), i64 4 }, %"char[]"* %y, align 8
|
|
store %"char[]" { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i32 0, i32 0), i64 4 }, %"char[]"* %z, align 8
|
|
%0 = load %"char[]", %"char[]"* %y, align 8
|
|
%1 = extractvalue %"char[]" %0, 1
|
|
%2 = extractvalue %"char[]" %0, 0
|
|
%eq = icmp eq i64 %1, 4
|
|
br i1 %eq, label %subarray_cmp_values, label %subarray_cmp_exit
|
|
|
|
subarray_cmp_values: ; preds = %entry
|
|
store i64 0, i64* %cmp.idx, align 8
|
|
br label %subarray_loop_start
|
|
|
|
subarray_loop_start: ; preds = %subarray_loop_comparison, %subarray_cmp_values
|
|
%3 = load i64, i64* %cmp.idx, align 8
|
|
%lt = icmp ult i64 %3, %1
|
|
br i1 %lt, label %subarray_loop_comparison, label %subarray_cmp_exit
|
|
|
|
subarray_loop_comparison: ; preds = %subarray_loop_start
|
|
%ptroffset = getelementptr inbounds i8, i8* %2, i64 %3
|
|
%ptroffset1 = getelementptr inbounds i8, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0), i64 %3
|
|
%4 = load i8, i8* %ptroffset, align 1
|
|
%5 = load i8, i8* %ptroffset1, align 1
|
|
%eq2 = icmp eq i8 %4, %5
|
|
%6 = add i64 %3, 1
|
|
store i64 %6, i64* %cmp.idx, align 8
|
|
br i1 %eq2, label %subarray_loop_start, label %subarray_cmp_exit
|
|
|
|
subarray_cmp_exit: ; preds = %subarray_loop_comparison, %subarray_loop_start, %entry
|
|
%subarray_cmp_phi = phi i1 [ true, %subarray_loop_start ], [ false, %entry ], [ false, %subarray_loop_comparison ]
|
|
br i1 %subarray_cmp_phi, label %if.then, label %if.exit
|
|
|
|
if.then: ; preds = %subarray_cmp_exit
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i32 0, i32 0))
|
|
br label %if.exit
|
|
|
|
if.exit: ; preds = %if.then, %subarray_cmp_exit
|
|
%7 = load %"char[]", %"char[]"* %y, align 8
|
|
%8 = load %"char[]", %"char[]"* %z, align 8
|
|
%9 = extractvalue %"char[]" %7, 1
|
|
%10 = extractvalue %"char[]" %8, 1
|
|
%11 = extractvalue %"char[]" %7, 0
|
|
%12 = extractvalue %"char[]" %8, 0
|
|
%eq3 = icmp eq i64 %9, %10
|
|
br i1 %eq3, label %subarray_cmp_values4, label %subarray_cmp_exit12
|
|
|
|
subarray_cmp_values4: ; preds = %if.exit
|
|
store i64 0, i64* %cmp.idx5, align 8
|
|
br label %subarray_loop_start6
|
|
|
|
subarray_loop_start6: ; preds = %subarray_loop_comparison8, %subarray_cmp_values4
|
|
%13 = load i64, i64* %cmp.idx5, align 8
|
|
%lt7 = icmp ult i64 %13, %9
|
|
br i1 %lt7, label %subarray_loop_comparison8, label %subarray_cmp_exit12
|
|
|
|
subarray_loop_comparison8: ; preds = %subarray_loop_start6
|
|
%ptroffset9 = getelementptr inbounds i8, i8* %11, i64 %13
|
|
%ptroffset10 = getelementptr inbounds i8, i8* %12, i64 %13
|
|
%14 = load i8, i8* %ptroffset9, align 1
|
|
%15 = load i8, i8* %ptroffset10, align 1
|
|
%eq11 = icmp eq i8 %14, %15
|
|
%16 = add i64 %13, 1
|
|
store i64 %16, i64* %cmp.idx5, align 8
|
|
br i1 %eq11, label %subarray_loop_start6, label %subarray_cmp_exit12
|
|
|
|
subarray_cmp_exit12: ; preds = %subarray_loop_comparison8, %subarray_loop_start6, %if.exit
|
|
%subarray_cmp_phi13 = phi i1 [ true, %subarray_loop_start6 ], [ false, %if.exit ], [ false, %subarray_loop_comparison8 ]
|
|
br i1 %subarray_cmp_phi13, label %if.then14, label %if.exit15
|
|
|
|
if.then14: ; preds = %subarray_cmp_exit12
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i32 0, i32 0))
|
|
br label %if.exit15
|
|
|
|
if.exit15: ; preds = %if.then14, %subarray_cmp_exit12
|
|
%17 = bitcast %"char[]"* %switch to i8*
|
|
%18 = bitcast %"char[]"* %y to i8*
|
|
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %17, i8* align 8 %18, i32 16, i1 false)
|
|
br label %switch.entry
|
|
|
|
switch.entry: ; preds = %if.exit15
|
|
%19 = load %"char[]", %"char[]"* %switch, align 8
|
|
%20 = extractvalue %"char[]" %19, 1
|
|
%21 = extractvalue %"char[]" %19, 0
|
|
%eq16 = icmp eq i64 4, %20
|
|
br i1 %eq16, label %subarray_cmp_values17, label %subarray_cmp_exit25
|
|
|
|
subarray_cmp_values17: ; preds = %switch.entry
|
|
store i64 0, i64* %cmp.idx18, align 8
|
|
br label %subarray_loop_start19
|
|
|
|
subarray_loop_start19: ; preds = %subarray_loop_comparison21, %subarray_cmp_values17
|
|
%22 = load i64, i64* %cmp.idx18, align 8
|
|
%lt20 = icmp ult i64 %22, 4
|
|
br i1 %lt20, label %subarray_loop_comparison21, label %subarray_cmp_exit25
|
|
|
|
subarray_loop_comparison21: ; preds = %subarray_loop_start19
|
|
%ptroffset22 = getelementptr inbounds i8, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i32 0, i32 0), i64 %22
|
|
%ptroffset23 = getelementptr inbounds i8, i8* %21, i64 %22
|
|
%23 = load i8, i8* %ptroffset22, align 1
|
|
%24 = load i8, i8* %ptroffset23, align 1
|
|
%eq24 = icmp eq i8 %23, %24
|
|
%25 = add i64 %22, 1
|
|
store i64 %25, i64* %cmp.idx18, align 8
|
|
br i1 %eq24, label %subarray_loop_start19, label %subarray_cmp_exit25
|
|
|
|
subarray_cmp_exit25: ; preds = %subarray_loop_comparison21, %subarray_loop_start19, %switch.entry
|
|
%subarray_cmp_phi26 = phi i1 [ true, %subarray_loop_start19 ], [ false, %switch.entry ], [ false, %subarray_loop_comparison21 ]
|
|
br i1 %subarray_cmp_phi26, label %switch.case, label %next_if
|
|
|
|
switch.case: ; preds = %subarray_cmp_exit25
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0))
|
|
br label %switch.exit
|
|
|
|
next_if: ; preds = %subarray_cmp_exit25
|
|
%26 = extractvalue %"char[]" %19, 1
|
|
%27 = extractvalue %"char[]" %19, 0
|
|
%eq27 = icmp eq i64 5, %26
|
|
br i1 %eq27, label %subarray_cmp_values28, label %subarray_cmp_exit36
|
|
|
|
subarray_cmp_values28: ; preds = %next_if
|
|
store i64 0, i64* %cmp.idx29, align 8
|
|
br label %subarray_loop_start30
|
|
|
|
subarray_loop_start30: ; preds = %subarray_loop_comparison32, %subarray_cmp_values28
|
|
%28 = load i64, i64* %cmp.idx29, align 8
|
|
%lt31 = icmp ult i64 %28, 5
|
|
br i1 %lt31, label %subarray_loop_comparison32, label %subarray_cmp_exit36
|
|
|
|
subarray_loop_comparison32: ; preds = %subarray_loop_start30
|
|
%ptroffset33 = getelementptr inbounds i8, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i32 0, i32 0), i64 %28
|
|
%ptroffset34 = getelementptr inbounds i8, i8* %27, i64 %28
|
|
%29 = load i8, i8* %ptroffset33, align 1
|
|
%30 = load i8, i8* %ptroffset34, align 1
|
|
%eq35 = icmp eq i8 %29, %30
|
|
%31 = add i64 %28, 1
|
|
store i64 %31, i64* %cmp.idx29, align 8
|
|
br i1 %eq35, label %subarray_loop_start30, label %subarray_cmp_exit36
|
|
|
|
subarray_cmp_exit36: ; preds = %subarray_loop_comparison32, %subarray_loop_start30, %next_if
|
|
%subarray_cmp_phi37 = phi i1 [ true, %subarray_loop_start30 ], [ false, %next_if ], [ false, %subarray_loop_comparison32 ]
|
|
br i1 %subarray_cmp_phi37, label %switch.case38, label %next_if39
|
|
|
|
switch.case38: ; preds = %subarray_cmp_exit36
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i32 0, i32 0))
|
|
br label %switch.exit
|
|
|
|
next_if39: ; preds = %subarray_cmp_exit36
|
|
%32 = extractvalue %"char[]" %19, 1
|
|
%33 = extractvalue %"char[]" %19, 0
|
|
%eq40 = icmp eq i64 4, %32
|
|
br i1 %eq40, label %subarray_cmp_values41, label %subarray_cmp_exit49
|
|
|
|
subarray_cmp_values41: ; preds = %next_if39
|
|
store i64 0, i64* %cmp.idx42, align 8
|
|
br label %subarray_loop_start43
|
|
|
|
subarray_loop_start43: ; preds = %subarray_loop_comparison45, %subarray_cmp_values41
|
|
%34 = load i64, i64* %cmp.idx42, align 8
|
|
%lt44 = icmp ult i64 %34, 4
|
|
br i1 %lt44, label %subarray_loop_comparison45, label %subarray_cmp_exit49
|
|
|
|
subarray_loop_comparison45: ; preds = %subarray_loop_start43
|
|
%ptroffset46 = getelementptr inbounds i8, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i32 0, i32 0), i64 %34
|
|
%ptroffset47 = getelementptr inbounds i8, i8* %33, i64 %34
|
|
%35 = load i8, i8* %ptroffset46, align 1
|
|
%36 = load i8, i8* %ptroffset47, align 1
|
|
%eq48 = icmp eq i8 %35, %36
|
|
%37 = add i64 %34, 1
|
|
store i64 %37, i64* %cmp.idx42, align 8
|
|
br i1 %eq48, label %subarray_loop_start43, label %subarray_cmp_exit49
|
|
|
|
subarray_cmp_exit49: ; preds = %subarray_loop_comparison45, %subarray_loop_start43, %next_if39
|
|
%subarray_cmp_phi50 = phi i1 [ true, %subarray_loop_start43 ], [ false, %next_if39 ], [ false, %subarray_loop_comparison45 ]
|
|
br i1 %subarray_cmp_phi50, label %switch.case51, label %next_if52
|
|
|
|
switch.case51: ; preds = %subarray_cmp_exit49
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i32 0, i32 0))
|
|
br label %switch.exit
|
|
|
|
next_if52: ; preds = %subarray_cmp_exit49
|
|
br label %switch.default
|
|
|
|
switch.default: ; preds = %next_if52
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i32 0, i32 0))
|
|
br label %switch.exit
|
|
|
|
switch.exit: ; preds = %switch.default, %switch.case51, %switch.case38, %switch.case
|
|
ret void
|
|
} |