test.ll

; x = 5;
; fac = fun(x){
;     if(x <= 1){
; 	     return x;
;     }
;     v = fac(x-1);
;     print("fac of " + (x-1) + " is " + v);
;     return x * v;
; };
;
; z = fac(x);
; print("fac of " + (x) + " is " + z);

; ModuleID = 'module'
source_filename = "module"

%mitc.val = type { i64, i64 }

@global.x = global %mitc.val zeroinitializer
@global.fac = global %mitc.val zeroinitializer
@const.str0 = internal constant [8 x i8] c"fac of \00"
@const.str1 = internal constant [5 x i8] c" is \00"
@global.print = global %mitc.val zeroinitializer
@global.z = global %mitc.val zeroinitializer

; Function Attrs: noreturn nounwind
declare void @llvm.trap() #0

declare %mitc.val @mitc.eq(%mitc.val, %mitc.val)

declare %mitc.val @mitc.add(%mitc.val, %mitc.val)

declare %mitc.val @mitc.call(%mitc.val, %mitc.val*, i64)

declare %mitc.val @mitc.alloc_closure(i64*, %mitc.val*, i64)

declare %mitc.val @mitc.get_global(i8*)

declare void @mitc.set_global(i8*, %mitc.val)

define void @mitc.assert_type(%mitc.val %val, i64 %tag) {
entry:
  %0 = extractvalue %mitc.val %val, 0
  %1 = icmp eq i64 %0, %tag
  br i1 %1, label %valid, label %panic

panic:                                            ; preds = %entry
  call void @llvm.trap()

valid:                                            ; preds = %entry
  ret void
}

define %mitc.val @func_0x7f8b60a33190() {
bb0:
  store %mitc.val { i64 1, i64 5 }, %mitc.val* @global.x
  %0 = alloca [0 x %mitc.val]
  %1 = getelementptr [0 x %mitc.val], [0 x %mitc.val]* %0, i64 0, i64 0
  %2 = call %mitc.val @mitc.alloc_closure(i64* bitcast (%mitc.val (%mitc.val)* @func_0x7f8b60a33250 to i64*), %mitc.val* %1, i64 0)
  store %mitc.val %2, %mitc.val* @global.fac
  %3 = load %mitc.val, %mitc.val* @global.x
  %4 = load %mitc.val, %mitc.val* @global.fac
  call void @mitc.assert_type(%mitc.val { i64 1, i64 1 }, i64 5)
  %5 = alloca [1 x %mitc.val]
  %6 = getelementptr [1 x %mitc.val], [1 x %mitc.val]* %5, i64 0, i64 0
  store %mitc.val %3, %mitc.val* %6
  %7 = getelementptr [1 x %mitc.val], [1 x %mitc.val]* %5, i64 0, i64 0
  %8 = call %mitc.val @mitc.call(%mitc.val { i64 1, i64 1 }, %mitc.val* %7, i64 1)
  store %mitc.val %8, %mitc.val* @global.z
  %9 = load %mitc.val, %mitc.val* @global.x
  %10 = call %mitc.val @mitc.add(%mitc.val %9, %mitc.val { i64 3, i64 ptrtoint ([8 x i8]* @const.str0 to i64) })
  %11 = call %mitc.val @mitc.add(%mitc.val { i64 3, i64 ptrtoint ([5 x i8]* @const.str1 to i64) }, %mitc.val %10)
  %12 = load %mitc.val, %mitc.val* @global.z
  %13 = call %mitc.val @mitc.add(%mitc.val %12, %mitc.val %11)
  %14 = load %mitc.val, %mitc.val* @global.print
  call void @mitc.assert_type(%mitc.val { i64 1, i64 1 }, i64 5)
  %15 = alloca [1 x %mitc.val]
  %16 = getelementptr [1 x %mitc.val], [1 x %mitc.val]* %15, i64 0, i64 0
  store %mitc.val %13, %mitc.val* %16
  %17 = getelementptr [1 x %mitc.val], [1 x %mitc.val]* %15, i64 0, i64 0
  %18 = call %mitc.val @mitc.call(%mitc.val { i64 1, i64 1 }, %mitc.val* %17, i64 1)
  ret %mitc.val zeroinitializer
}

define %mitc.val @func_0x7f8b60a33250(%mitc.val %param0) {
bb0:
  %local0 = alloca %mitc.val
  %local1 = alloca %mitc.val
  store %mitc.val %param0, %mitc.val* %local0
  %0 = load %mitc.val, %mitc.val* %local0
  call void @mitc.assert_type(%mitc.val { i64 1, i64 1 }, i64 1)
  call void @mitc.assert_type(%mitc.val %0, i64 1)
  %1 = extractvalue %mitc.val %0, 1
  %2 = icmp sge i64 1, %1
  %3 = sext i1 %2 to i64
  %4 = insertvalue %mitc.val { i64 2, i64 undef }, i64 %3, 1
  call void @mitc.assert_type(%mitc.val %4, i64 2)
  %5 = extractvalue %mitc.val %4, 1
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %bb1, label %bb2

bb1:                                              ; preds = %bb0
  %7 = load %mitc.val, %mitc.val* %local0
  ret %mitc.val %7
  br label %bb2

bb2:                                              ; preds = %bb1, %bb0
  %8 = load %mitc.val, %mitc.val* %local0
  call void @mitc.assert_type(%mitc.val { i64 1, i64 1 }, i64 1)
  call void @mitc.assert_type(%mitc.val %8, i64 1)
  %9 = extractvalue %mitc.val %8, 1
  %10 = sub i64 1, %9
  %11 = insertvalue %mitc.val { i64 1, i64 undef }, i64 %10, 1
  %12 = load %mitc.val, %mitc.val* @global.fac
  call void @mitc.assert_type(%mitc.val { i64 1, i64 1 }, i64 5)
  %13 = alloca [1 x %mitc.val]
  %14 = getelementptr [1 x %mitc.val], [1 x %mitc.val]* %13, i64 0, i64 0
  store %mitc.val %11, %mitc.val* %14
  %15 = getelementptr [1 x %mitc.val], [1 x %mitc.val]* %13, i64 0, i64 0
  %16 = call %mitc.val @mitc.call(%mitc.val { i64 1, i64 1 }, %mitc.val* %15, i64 1)
  store %mitc.val %16, %mitc.val* %local1
  %17 = load %mitc.val, %mitc.val* %local0
  call void @mitc.assert_type(%mitc.val { i64 1, i64 1 }, i64 1)
  call void @mitc.assert_type(%mitc.val %17, i64 1)
  %18 = extractvalue %mitc.val %17, 1
  %19 = sub i64 1, %18
  %20 = insertvalue %mitc.val { i64 1, i64 undef }, i64 %19, 1
  %21 = call %mitc.val @mitc.add(%mitc.val %20, %mitc.val { i64 3, i64 ptrtoint ([8 x i8]* @const.str0 to i64) })
  %22 = call %mitc.val @mitc.add(%mitc.val { i64 3, i64 ptrtoint ([5 x i8]* @const.str1 to i64) }, %mitc.val %21)
  %23 = load %mitc.val, %mitc.val* %local1
  %24 = call %mitc.val @mitc.add(%mitc.val %23, %mitc.val %22)
  %25 = load %mitc.val, %mitc.val* @global.print
  call void @mitc.assert_type(%mitc.val { i64 1, i64 1 }, i64 5)
  %26 = alloca [1 x %mitc.val]
  %27 = getelementptr [1 x %mitc.val], [1 x %mitc.val]* %26, i64 0, i64 0
  store %mitc.val %24, %mitc.val* %27
  %28 = getelementptr [1 x %mitc.val], [1 x %mitc.val]* %26, i64 0, i64 0
  %29 = call %mitc.val @mitc.call(%mitc.val { i64 1, i64 1 }, %mitc.val* %28, i64 1)
  %30 = load %mitc.val, %mitc.val* %local0
  %31 = load %mitc.val, %mitc.val* %local1
  call void @mitc.assert_type(%mitc.val %31, i64 1)
  %32 = extractvalue %mitc.val %31, 1
  call void @mitc.assert_type(%mitc.val %30, i64 1)
  %33 = extractvalue %mitc.val %30, 1
  %34 = mul i64 %32, %33
  %35 = insertvalue %mitc.val { i64 1, i64 undef }, i64 %34, 1
  ret %mitc.val %35
  ret %mitc.val zeroinitializer
}

attributes #0 = { noreturn nounwind }