Add tests

Jenkinsfile

@@ -40,8 +40,8 @@ pipeline {
                 // can cause `stack-overflow` error when testing stack-intensive code.
                 // For this reason, we need to increase the default size of stack to `8 MiB`.
                 // TODO: delete `--skip test_examples_asmgen`
-                sh "RUST_MIN_STACK=8388608 cargo test -- --skip test_examples_asmgen"
-                sh "RUST_MIN_STACK=8388608 cargo test --release -- --skip test_examples_asmgen"
+                sh "RUST_MIN_STACK=8388608 cargo test -- --skip test_examples_asmgen --skip test_examples_end_to_end"
+                sh "RUST_MIN_STACK=8388608 cargo test --release -- --skip test_examples_asmgen --skip test_examples_end_to_end"
             }
         }
     }

README.md

@@ -30,15 +30,27 @@ cargo run --release -- examples/c/fibonacci.c  # compile with release build
 
 ## Test
 
-```
+```sh
 RUST_MIN_STACK=8388608 cargo test             # debug build test
 RUST_MIN_STACK=8388608 cargo test --release   # release build test
 
-RUST_MIN_STACK=8388608 cargo test <test-name> # run a particular test
+RUST_MIN_STACK=8388608 cargo test test_examples_write_c       # run write_c test
+
+RUST_MIN_STACK=8388608 cargo test test_examples_irgen_small   # run irgen test using a small subset of examples
+RUST_MIN_STACK=8388608 cargo test test_examples_irgen         # run irgen test
+
+RUST_MIN_STACK=8388608 cargo test test_examples_simplify_cfg  # run simplify_cfg test
+RUST_MIN_STACK=8388608 cargo test test_examples_mem2reg       # run mem2reg test
+RUST_MIN_STACK=8388608 cargo test test_examples_deadcode      # run deadcode test
+RUST_MIN_STACK=8388608 cargo test test_examples_gvn           # run gvn test
+
+RUST_MIN_STACK=8388608 cargo test test_examples_asmgen_small  # run asmgen test using a small subset of examples
+RUST_MIN_STACK=8388608 cargo test test_examples_asmgen        # run asmgen test
+
+RUST_MIN_STACK=8388608 cargo test test_examples_end_to_end    # run irgen, optimize and asmgen pipeline test
 ```
 
-`RUST_MIN_STACK=8388608` is necessary for deep call stack for irgen tests. `<test-name>` can be
-`test_examples_write_c`, `test_examples_irgen`, ...
+`RUST_MIN_STACK=8388608` is necessary for deep call stack for irgen tests.
 
 
 ## Fuzzing

bin/fuzz.rs

@@ -48,6 +48,11 @@ fn main() {
         todo!("test gvn");
     }
 
+    if matches.is_present("end-to-end") {
+        kecc::test_end_to_end(Path::new(&input));
+        return;
+    }
+
     assert_eq!(
         Path::new(input).extension(),
         Some(std::ffi::OsStr::new("ir"))

bin/fuzz_cli.yml

@@ -23,6 +23,9 @@ args:
     - gvn:
         long: gvn
         help: Performs gvn
+    - end-to-end:
+        long: end-to-end
+        help: Fuzzes irgen, optimize and asmgen pipeline
     - INPUT:
         help: Sets the input file to use
         required: true

examples/ir0/struct.ir

@@ -1,5 +1,5 @@
-struct %t0 : { [4 x [5 x i32]] }
 struct %t1 : { i8,  struct %t0, f64 }
+struct %t0 : { [4 x [5 x i32]] }
 
 fun unit @init (i32, i32, *[5 x i32]) {
 init:

examples/ir0/struct2.ir

@@ -1,5 +1,5 @@
-struct %t0 : { [4 x i32] }
 struct %t1 : { i8,  struct %t0, i64 }
+struct %t0 : { [4 x i32] }
 
 fun i32 @main () {
 init:

examples/ir1/alignof.ir

@@ -0,0 +1,13 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:u64 = typecast 4:i32 to u64
+  %b0:i1:u1 = cmp eq 4:u64 %b0:i0:u64
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/array.ir

@@ -0,0 +1,83 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:[5 x i32]:a
+    %l1:i32:len
+    %l2:i32:i
+
+block b0:
+  %b0:i0:unit = store 5:i32 %l1:*i32
+  %b0:i1:unit = store 0:i32 %l2:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l2:*i32
+  %b2:i1:i32 = load %l1:*i32
+  %b2:i2:u1 = cmp lt %b2:i0:i32 %b2:i1:i32
+  br %b2:i2:u1, b3(), b5()
+
+block b3:
+  %b3:i0:*i32 = getelementptr %l0:*[5 x i32] offset 0:i32
+  %b3:i1:i32 = load %l2:*i32
+  %b3:i2:i64 = typecast %b3:i1:i32 to i64
+  %b3:i3:i64 = mul %b3:i2:i64 4:i64
+  %b3:i4:*i32 = getelementptr %b3:i0:*i32 offset %b3:i3:i64
+  %b3:i5:i32 = load %l2:*i32
+  %b3:i6:unit = store %b3:i5:i32 %b3:i4:*i32
+  %b3:i7:i32 = load %l2:*i32
+  %b3:i8:i32 = add %b3:i7:i32 1:i32
+  %b3:i9:unit = store %b3:i8:i32 %l2:*i32
+  j b2()
+
+block b5:
+  %b5:i0:i32 = load %l1:*i32
+  %b5:i1:*i32 = getelementptr %l0:*[5 x i32] offset 0:i32
+  %b5:i2:i32 = call @sum:*[ret:i32 params:(i32, *i32)](%b5:i0:i32, %b5:i1:*i32)
+  %b5:i3:u1 = cmp eq %b5:i2:i32 10:i32
+  %b5:i4:i32 = typecast %b5:i3:u1 to i32
+  ret %b5:i4:i32
+}
+
+fun i32 @sum (i32, *i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:len
+    %l1:*i32:p
+    %l2:i32:result
+    %l3:i32:i
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:*i32 %l1:**i32
+  %b0:i2:unit = store 0:i32 %l2:*i32
+  %b0:i3:unit = store 0:i32 %l3:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l3:*i32
+  %b2:i1:i32 = load %l0:*i32
+  %b2:i2:u1 = cmp lt %b2:i0:i32 %b2:i1:i32
+  br %b2:i2:u1, b3(), b5()
+
+block b3:
+  %b3:i0:i32 = load %l2:*i32
+  %b3:i1:*i32 = load %l1:**i32
+  %b3:i2:i32 = load %l3:*i32
+  %b3:i3:i64 = typecast %b3:i2:i32 to i64
+  %b3:i4:i64 = mul %b3:i3:i64 4:i64
+  %b3:i5:*i32 = getelementptr %b3:i1:*i32 offset %b3:i4:i64
+  %b3:i6:i32 = load %b3:i5:*i32
+  %b3:i7:i32 = add %b3:i0:i32 %b3:i6:i32
+  %b3:i8:unit = store %b3:i7:i32 %l2:*i32
+  %b3:i9:i32 = load %l3:*i32
+  %b3:i10:i32 = add %b3:i9:i32 1:i32
+  %b3:i11:unit = store %b3:i10:i32 %l3:*i32
+  j b2()
+
+block b5:
+  %b5:i0:i32 = load %l2:*i32
+  ret %b5:i0:i32
+}

examples/ir1/array2.ir

@@ -0,0 +1,92 @@
+
+fun unit @init (i32, i32, *[5 x i32]) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:row
+    %l1:i32:col
+    %l2:*[5 x i32]:a
+    %l3:i32:i
+    %l4:i32:j
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:i32 %l1:*i32
+  %b0:i2:unit = store %b0:p2:*[5 x i32] %l2:**[5 x i32]
+  %b0:i3:unit = store 0:i32 %l3:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l3:*i32
+  %b2:i1:i32 = load %l0:*i32
+  %b2:i2:u1 = cmp lt %b2:i0:i32 %b2:i1:i32
+  br %b2:i2:u1, b3(), b5()
+
+block b3:
+  %b3:i0:unit = store 0:i32 %l4:*i32
+  j b7()
+
+block b5:
+  ret unit:unit
+
+block b7:
+  %b7:i0:i32 = load %l4:*i32
+  %b7:i1:i32 = load %l1:*i32
+  %b7:i2:u1 = cmp lt %b7:i0:i32 %b7:i1:i32
+  br %b7:i2:u1, b8(), b10()
+
+block b8:
+  %b8:i0:*[5 x i32] = load %l2:**[5 x i32]
+  %b8:i1:i32 = load %l3:*i32
+  %b8:i2:i64 = typecast %b8:i1:i32 to i64
+  %b8:i3:i64 = mul %b8:i2:i64 20:i64
+  %b8:i4:*[5 x i32] = getelementptr %b8:i0:*[5 x i32] offset %b8:i3:i64
+  %b8:i5:*i32 = getelementptr %b8:i4:*[5 x i32] offset 0:i32
+  %b8:i6:i32 = load %l4:*i32
+  %b8:i7:i64 = typecast %b8:i6:i32 to i64
+  %b8:i8:i64 = mul %b8:i7:i64 4:i64
+  %b8:i9:*i32 = getelementptr %b8:i5:*i32 offset %b8:i8:i64
+  %b8:i10:i32 = load %l3:*i32
+  %b8:i11:i32 = load %l4:*i32
+  %b8:i12:i32 = mul %b8:i10:i32 %b8:i11:i32
+  %b8:i13:unit = store %b8:i12:i32 %b8:i9:*i32
+  %b8:i14:i32 = load %l4:*i32
+  %b8:i15:i32 = add %b8:i14:i32 1:i32
+  %b8:i16:unit = store %b8:i15:i32 %l4:*i32
+  j b7()
+
+block b10:
+  %b10:i0:i32 = load %l3:*i32
+  %b10:i1:i32 = add %b10:i0:i32 1:i32
+  %b10:i2:unit = store %b10:i1:i32 %l3:*i32
+  j b2()
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:[4 x [5 x i32]]:a
+    %l1:i32:row
+    %l2:i32:col
+
+block b0:
+  %b0:i0:unit = store 4:i32 %l1:*i32
+  %b0:i1:unit = store 5:i32 %l2:*i32
+  %b0:i2:i32 = load %l1:*i32
+  %b0:i3:i32 = load %l2:*i32
+  %b0:i4:*[5 x i32] = getelementptr %l0:*[4 x [5 x i32]] offset 0:i32
+  %b0:i5:unit = call @init:*[ret:unit params:(i32, i32, *[5 x i32])](%b0:i2:i32, %b0:i3:i32, %b0:i4:*[5 x i32])
+  %b0:i6:*[5 x i32] = getelementptr %l0:*[4 x [5 x i32]] offset 0:i32
+  %b0:i7:i64 = typecast 2:i32 to i64
+  %b0:i8:i64 = mul %b0:i7:i64 20:i64
+  %b0:i9:*[5 x i32] = getelementptr %b0:i6:*[5 x i32] offset %b0:i8:i64
+  %b0:i10:*i32 = getelementptr %b0:i9:*[5 x i32] offset 0:i32
+  %b0:i11:i64 = typecast 3:i32 to i64
+  %b0:i12:i64 = mul %b0:i11:i64 4:i64
+  %b0:i13:*i32 = getelementptr %b0:i10:*i32 offset %b0:i12:i64
+  %b0:i14:i32 = load %b0:i13:*i32
+  %b0:i15:u1 = cmp eq %b0:i14:i32 6:i32
+  %b0:i16:i32 = typecast %b0:i15:u1 to i32
+  ret %b0:i16:i32
+}

examples/ir1/array3.ir

@@ -0,0 +1,53 @@
+
+fun *i32 @foo (*i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:*i32:a
+
+block b0:
+  %b0:i0:unit = store %b0:p0:*i32 %l0:**i32
+  %b0:i1:*i32 = load %l0:**i32
+  ret %b0:i1:*i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:[10 x i32]:a
+    %l1:i32:i
+
+block b0:
+  %b0:i0:unit = store 0:i32 %l1:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l1:*i32
+  %b2:i1:u1 = cmp lt %b2:i0:i32 10:i32
+  br %b2:i1:u1, b3(), b5()
+
+block b3:
+  %b3:i0:*i32 = getelementptr %l0:*[10 x i32] offset 0:i32
+  %b3:i1:*i32 = call @foo:*[ret:*i32 params:(*i32)](%b3:i0:*i32)
+  %b3:i2:i32 = load %l1:*i32
+  %b3:i3:i64 = typecast %b3:i2:i32 to i64
+  %b3:i4:i64 = mul %b3:i3:i64 4:i64
+  %b3:i5:*i32 = getelementptr %b3:i1:*i32 offset %b3:i4:i64
+  %b3:i6:i32 = load %l1:*i32
+  %b3:i7:unit = store %b3:i6:i32 %b3:i5:*i32
+  %b3:i8:i32 = load %l1:*i32
+  %b3:i9:i32 = add %b3:i8:i32 1:i32
+  %b3:i10:unit = store %b3:i9:i32 %l1:*i32
+  j b2()
+
+block b5:
+  %b5:i0:*i32 = getelementptr %l0:*[10 x i32] offset 0:i32
+  %b5:i1:i64 = typecast 5:i32 to i64
+  %b5:i2:i64 = mul %b5:i1:i64 4:i64
+  %b5:i3:*i32 = getelementptr %b5:i0:*i32 offset %b5:i2:i64
+  %b5:i4:i32 = load %b5:i3:*i32
+  %b5:i5:u1 = cmp eq %b5:i4:i32 5:i32
+  %b5:i6:i32 = typecast %b5:i5:u1 to i32
+  ret %b5:i6:i32
+}

examples/ir1/array4.ir

@@ -0,0 +1,42 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:[10 x i32]:a
+    %l1:*i32:p
+    %l2:i32:i
+
+block b0:
+  %b0:i0:*i32 = getelementptr %l0:*[10 x i32] offset 0:i32
+  %b0:i1:unit = store %b0:i0:*i32 %l1:**i32
+  %b0:i2:unit = store 0:i32 %l2:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l2:*i32
+  %b2:i1:u1 = cmp lt %b2:i0:i32 10:i32
+  br %b2:i1:u1, b3(), b5()
+
+block b3:
+  %b3:i0:*i32 = load %l1:**i32
+  %b3:i1:i64 = mul 1:i64 4:i64
+  %b3:i2:*i32 = getelementptr %b3:i0:*i32 offset %b3:i1:i64
+  %b3:i3:unit = store %b3:i2:*i32 %l1:**i32
+  %b3:i4:i32 = load %l2:*i32
+  %b3:i5:unit = store %b3:i4:i32 %b3:i0:*i32
+  %b3:i6:i32 = load %l2:*i32
+  %b3:i7:i32 = add %b3:i6:i32 1:i32
+  %b3:i8:unit = store %b3:i7:i32 %l2:*i32
+  j b2()
+
+block b5:
+  %b5:i0:*i32 = getelementptr %l0:*[10 x i32] offset 0:i32
+  %b5:i1:i64 = typecast 5:i32 to i64
+  %b5:i2:i64 = mul %b5:i1:i64 4:i64
+  %b5:i3:*i32 = getelementptr %b5:i0:*i32 offset %b5:i2:i64
+  %b5:i4:i32 = load %b5:i3:*i32
+  %b5:i5:u1 = cmp eq %b5:i4:i32 5:i32
+  %b5:i6:i32 = typecast %b5:i5:u1 to i32
+  ret %b5:i6:i32
+}

examples/ir1/array5.ir

@@ -0,0 +1,68 @@
+var [5 x i32] @g_a = {1, 2, 3}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:init
+    %l1:[5 x i32]:a
+    %l2:i32:sum
+    %l3:i32:i
+
+block b0:
+  %b0:i0:unit = store 1:i32 %l0:*i32
+  %b0:i1:*i32 = getelementptr %l1:*[5 x i32] offset 0:i32
+  %b0:i2:i64 = mul 0:i64 4:i64
+  %b0:i3:*i32 = getelementptr %b0:i1:*i32 offset %b0:i2:i64
+  %b0:i4:i32 = load %l0:*i32
+  %b0:i5:unit = store %b0:i4:i32 %b0:i3:*i32
+  %b0:i6:i64 = mul 1:i64 4:i64
+  %b0:i7:*i32 = getelementptr %b0:i1:*i32 offset %b0:i6:i64
+  %b0:i8:unit = store 2:i32 %b0:i7:*i32
+  %b0:i9:i64 = mul 2:i64 4:i64
+  %b0:i10:*i32 = getelementptr %b0:i1:*i32 offset %b0:i9:i64
+  %b0:i11:unit = store 3:i32 %b0:i10:*i32
+  %b0:i12:i64 = mul 3:i64 4:i64
+  %b0:i13:*i32 = getelementptr %b0:i1:*i32 offset %b0:i12:i64
+  %b0:i14:unit = store 4:i32 %b0:i13:*i32
+  %b0:i15:i64 = mul 4:i64 4:i64
+  %b0:i16:*i32 = getelementptr %b0:i1:*i32 offset %b0:i15:i64
+  %b0:i17:i32 = minus 5:i32
+  %b0:i18:unit = store %b0:i17:i32 %b0:i16:*i32
+  %b0:i19:unit = store 0:i32 %l2:*i32
+  %b0:i20:unit = store 0:i32 %l3:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l3:*i32
+  %b2:i1:u1 = cmp lt %b2:i0:i32 5:i32
+  br %b2:i1:u1, b3(), b5()
+
+block b3:
+  %b3:i0:i32 = load %l2:*i32
+  %b3:i1:*i32 = getelementptr %l1:*[5 x i32] offset 0:i32
+  %b3:i2:i32 = load %l3:*i32
+  %b3:i3:i64 = typecast %b3:i2:i32 to i64
+  %b3:i4:i64 = mul %b3:i3:i64 4:i64
+  %b3:i5:*i32 = getelementptr %b3:i1:*i32 offset %b3:i4:i64
+  %b3:i6:i32 = load %b3:i5:*i32
+  %b3:i7:i32 = add %b3:i0:i32 %b3:i6:i32
+  %b3:i8:unit = store %b3:i7:i32 %l2:*i32
+  %b3:i9:i32 = load %l2:*i32
+  %b3:i10:*i32 = getelementptr @g_a:*[5 x i32] offset 0:i32
+  %b3:i11:i32 = load %l3:*i32
+  %b3:i12:i64 = typecast %b3:i11:i32 to i64
+  %b3:i13:i64 = mul %b3:i12:i64 4:i64
+  %b3:i14:*i32 = getelementptr %b3:i10:*i32 offset %b3:i13:i64
+  %b3:i15:i32 = load %b3:i14:*i32
+  %b3:i16:i32 = add %b3:i9:i32 %b3:i15:i32
+  %b3:i17:unit = store %b3:i16:i32 %l2:*i32
+  %b3:i18:i32 = load %l3:*i32
+  %b3:i19:i32 = add %b3:i18:i32 1:i32
+  %b3:i20:unit = store %b3:i19:i32 %l3:*i32
+  j b2()
+
+block b5:
+  %b5:i0:i32 = load %l2:*i32
+  ret %b5:i0:i32
+}

examples/ir1/bar.ir

@@ -0,0 +1,54 @@
+
+fun i32 @bar (i32, i32, i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:x
+    %l1:i32:y
+    %l2:i32:z
+    %l3:i32:arith_mean
+    %l4:i32:ugly_mean
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:i32 %l1:*i32
+  %b0:i2:unit = store %b0:p2:i32 %l2:*i32
+  %b0:i3:i32 = load %l0:*i32
+  %b0:i4:i32 = load %l1:*i32
+  %b0:i5:i32 = add %b0:i3:i32 %b0:i4:i32
+  %b0:i6:i32 = load %l2:*i32
+  %b0:i7:i32 = add %b0:i5:i32 %b0:i6:i32
+  %b0:i8:i32 = div %b0:i7:i32 3:i32
+  %b0:i9:unit = store %b0:i8:i32 %l3:*i32
+  %b0:i10:i32 = load %l0:*i32
+  %b0:i11:i32 = load %l1:*i32
+  %b0:i12:i32 = add %b0:i10:i32 %b0:i11:i32
+  %b0:i13:i32 = div %b0:i12:i32 2:i32
+  %b0:i14:i32 = mul %b0:i13:i32 2:i32
+  %b0:i15:i32 = load %l2:*i32
+  %b0:i16:i32 = add %b0:i14:i32 %b0:i15:i32
+  %b0:i17:i32 = div %b0:i16:i32 3:i32
+  %b0:i18:unit = store %b0:i17:i32 %l4:*i32
+  %b0:i19:i32 = load %l0:*i32
+  %b0:i20:i32 = load %l1:*i32
+  %b0:i21:u1 = cmp eq %b0:i19:i32 %b0:i20:i32
+  br %b0:i21:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l1:*i32
+  ret %b1:i0:i32
+
+block b2:
+  %b2:i0:i32 = load %l2:*i32
+  ret %b2:i0:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  ret 1:i32
+}

examples/ir1/bitwise.ir

@@ -0,0 +1,147 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:u8:a
+    %l1:u8:b
+    %l2:u8:c
+    %l3:u8:d
+    %l4:u8:e
+    %l5:u8:f
+    %l6:u8:g
+    %l7:u8:h
+    %l8:u8:i
+    %l9:u1:t0
+    %l10:u1:t1
+    %l11:u1:t2
+    %l12:u1:t3
+    %l13:u1:t4
+
+block b0:
+  %b0:i0:i32 = minus 1:i32
+  %b0:i1:u8 = typecast %b0:i0:i32 to u8
+  %b0:i2:unit = store %b0:i1:u8 %l0:*u8
+  %b0:i3:i32 = minus 128:i32
+  %b0:i4:u8 = typecast %b0:i3:i32 to u8
+  %b0:i5:unit = store %b0:i4:u8 %l1:*u8
+  %b0:i6:u8 = typecast 127:i32 to u8
+  %b0:i7:unit = store %b0:i6:u8 %l2:*u8
+  %b0:i8:u8 = load %l1:*u8
+  %b0:i9:u8 = load %l0:*u8
+  %b0:i10:i32 = typecast %b0:i8:u8 to i32
+  %b0:i11:i32 = typecast %b0:i9:u8 to i32
+  %b0:i12:i32 = or %b0:i10:i32 %b0:i11:i32
+  %b0:i13:u8 = typecast %b0:i12:i32 to u8
+  %b0:i14:unit = store %b0:i13:u8 %l3:*u8
+  %b0:i15:u8 = load %l1:*u8
+  %b0:i16:u8 = load %l0:*u8
+  %b0:i17:i32 = typecast %b0:i15:u8 to i32
+  %b0:i18:i32 = typecast %b0:i16:u8 to i32
+  %b0:i19:i32 = and %b0:i17:i32 %b0:i18:i32
+  %b0:i20:u8 = typecast %b0:i19:i32 to u8
+  %b0:i21:unit = store %b0:i20:u8 %l4:*u8
+  %b0:i22:u8 = load %l1:*u8
+  %b0:i23:u8 = load %l2:*u8
+  %b0:i24:i32 = typecast %b0:i22:u8 to i32
+  %b0:i25:i32 = typecast %b0:i23:u8 to i32
+  %b0:i26:i32 = and %b0:i24:i32 %b0:i25:i32
+  %b0:i27:u8 = typecast %b0:i26:i32 to u8
+  %b0:i28:unit = store %b0:i27:u8 %l5:*u8
+  %b0:i29:u8 = load %l1:*u8
+  %b0:i30:u8 = load %l2:*u8
+  %b0:i31:i32 = typecast %b0:i29:u8 to i32
+  %b0:i32:i32 = typecast %b0:i30:u8 to i32
+  %b0:i33:i32 = or %b0:i31:i32 %b0:i32:i32
+  %b0:i34:u8 = typecast %b0:i33:i32 to u8
+  %b0:i35:unit = store %b0:i34:u8 %l6:*u8
+  %b0:i36:i32 = minus 1:i32
+  %b0:i37:i32 = minus 1:i32
+  %b0:i38:i32 = xor %b0:i36:i32 %b0:i37:i32
+  %b0:i39:u8 = typecast %b0:i38:i32 to u8
+  %b0:i40:unit = store %b0:i39:u8 %l7:*u8
+  %b0:i41:i32 = minus 1:i32
+  %b0:i42:i32 = xor %b0:i41:i32 0:i32
+  %b0:i43:u8 = typecast %b0:i42:i32 to u8
+  %b0:i44:unit = store %b0:i43:u8 %l8:*u8
+  %b0:i45:u8 = load %l3:*u8
+  %b0:i46:i32 = typecast %b0:i45:u8 to i32
+  %b0:i47:u1 = cmp eq %b0:i46:i32 255:i32
+  br %b0:i47:u1, b13(), b14()
+
+block b1:
+  %b1:i0:u8 = load %l8:*u8
+  %b1:i1:i32 = typecast %b1:i0:u8 to i32
+  %b1:i2:u1 = cmp eq %b1:i1:i32 255:i32
+  %b1:i3:unit = store %b1:i2:u1 %l13:*u1
+  j b3()
+
+block b2:
+  %b2:i0:unit = store 0:u1 %l13:*u1
+  j b3()
+
+block b3:
+  %b3:i0:u1 = load %l13:*u1
+  %b3:i1:i32 = typecast %b3:i0:u1 to i32
+  ret %b3:i1:i32
+
+block b4:
+  %b4:i0:u8 = load %l7:*u8
+  %b4:i1:i32 = typecast %b4:i0:u8 to i32
+  %b4:i2:u1 = cmp eq %b4:i1:i32 0:i32
+  %b4:i3:unit = store %b4:i2:u1 %l12:*u1
+  j b6()
+
+block b5:
+  %b5:i0:unit = store 0:u1 %l12:*u1
+  j b6()
+
+block b6:
+  %b6:i0:u1 = load %l12:*u1
+  br %b6:i0:u1, b1(), b2()
+
+block b7:
+  %b7:i0:u8 = load %l6:*u8
+  %b7:i1:i32 = typecast %b7:i0:u8 to i32
+  %b7:i2:u1 = cmp eq %b7:i1:i32 255:i32
+  %b7:i3:unit = store %b7:i2:u1 %l11:*u1
+  j b9()
+
+block b8:
+  %b8:i0:unit = store 0:u1 %l11:*u1
+  j b9()
+
+block b9:
+  %b9:i0:u1 = load %l11:*u1
+  br %b9:i0:u1, b4(), b5()
+
+block b10:
+  %b10:i0:u8 = load %l5:*u8
+  %b10:i1:i32 = typecast %b10:i0:u8 to i32
+  %b10:i2:u1 = cmp eq %b10:i1:i32 0:i32
+  %b10:i3:unit = store %b10:i2:u1 %l10:*u1
+  j b12()
+
+block b11:
+  %b11:i0:unit = store 0:u1 %l10:*u1
+  j b12()
+
+block b12:
+  %b12:i0:u1 = load %l10:*u1
+  br %b12:i0:u1, b7(), b8()
+
+block b13:
+  %b13:i0:u8 = load %l4:*u8
+  %b13:i1:i32 = typecast %b13:i0:u8 to i32
+  %b13:i2:u1 = cmp eq %b13:i1:i32 128:i32
+  %b13:i3:unit = store %b13:i2:u1 %l9:*u1
+  j b15()
+
+block b14:
+  %b14:i0:unit = store 0:u1 %l9:*u1
+  j b15()
+
+block b15:
+  %b15:i0:u1 = load %l9:*u1
+  br %b15:i0:u1, b10(), b11()
+}

examples/ir1/cmp.ir

@@ -0,0 +1,85 @@
+
+fun i32 @char_greater_than (i8, u8) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i8:i
+    %l1:u8:j
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i8 %l0:*i8
+  %b0:i1:unit = store %b0:p1:u8 %l1:*u8
+  %b0:i2:i8 = load %l0:*i8
+  %b0:i3:u8 = load %l1:*u8
+  %b0:i4:i32 = typecast %b0:i2:i8 to i32
+  %b0:i5:i32 = typecast %b0:i3:u8 to i32
+  %b0:i6:u1 = cmp gt %b0:i4:i32 %b0:i5:i32
+  br %b0:i6:u1, b1(), b2()
+
+block b1:
+  ret 1:i32
+
+block b2:
+  ret 0:i32
+}
+
+fun i32 @int_greater_than (i32, u32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:i
+    %l1:u32:j
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:u32 %l1:*u32
+  %b0:i2:i32 = load %l0:*i32
+  %b0:i3:u32 = load %l1:*u32
+  %b0:i4:u32 = typecast %b0:i2:i32 to u32
+  %b0:i5:u1 = cmp gt %b0:i4:u32 %b0:i3:u32
+  br %b0:i5:u1, b1(), b2()
+
+block b1:
+  ret 1:i32
+
+block b2:
+  ret 0:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:r1
+    %l1:i32:r2
+    %l2:u1:t0
+
+block b0:
+  %b0:i0:i32 = minus 1:i32
+  %b0:i1:u32 = typecast 1:i32 to u32
+  %b0:i2:i32 = call @int_greater_than:*[ret:i32 params:(i32, u32)](%b0:i0:i32, %b0:i1:u32)
+  %b0:i3:unit = store %b0:i2:i32 %l0:*i32
+  %b0:i4:i32 = minus 1:i32
+  %b0:i5:i8 = typecast %b0:i4:i32 to i8
+  %b0:i6:u8 = typecast 1:i32 to u8
+  %b0:i7:i32 = call @char_greater_than:*[ret:i32 params:(i8, u8)](%b0:i5:i8, %b0:i6:u8)
+  %b0:i8:unit = store %b0:i7:i32 %l1:*i32
+  %b0:i9:i32 = load %l0:*i32
+  %b0:i10:u1 = cmp eq %b0:i9:i32 1:i32
+  br %b0:i10:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l1:*i32
+  %b1:i1:u1 = cmp eq %b1:i0:i32 0:i32
+  %b1:i2:unit = store %b1:i1:u1 %l2:*u1
+  j b3()
+
+block b2:
+  %b2:i0:unit = store 0:u1 %l2:*u1
+  j b3()
+
+block b3:
+  %b3:i0:u1 = load %l2:*u1
+  %b3:i1:i32 = typecast %b3:i0:u1 to i32
+  ret %b3:i1:i32
+}

examples/ir1/comma.ir

@@ -0,0 +1,21 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:y
+    %l1:i32:x
+
+block b0:
+  %b0:i0:unit = store 2:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:i32 = add %b0:i1:i32 2:i32
+  %b0:i3:unit = store %b0:i2:i32 %l0:*i32
+  %b0:i4:i32 = load %l0:*i32
+  %b0:i5:i32 = add %b0:i4:i32 3:i32
+  %b0:i6:unit = store %b0:i5:i32 %l1:*i32
+  %b0:i7:i32 = load %l1:*i32
+  %b0:i8:u1 = cmp eq %b0:i7:i32 7:i32
+  %b0:i9:i32 = typecast %b0:i8:u1 to i32
+  ret %b0:i9:i32
+}

examples/ir1/cond.ir

@@ -0,0 +1,31 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:y
+    %l1:i32:x
+    %l2:i32:t0
+
+block b0:
+  %b0:i0:unit = store 1:i32 %l0:*i32
+  %b0:i1:unit = store 0:i32 %l1:*i32
+  %b0:i2:i32 = load %l1:*i32
+  %b0:i3:i32 = load %l0:*i32
+  %b0:i4:u1 = cmp eq %b0:i2:i32 %b0:i3:i32
+  br %b0:i4:u1, b1(), b2()
+
+block b1:
+  %b1:i0:unit = store 2:i32 %l2:*i32
+  j b3()
+
+block b2:
+  %b2:i0:unit = store 5:i32 %l2:*i32
+  j b3()
+
+block b3:
+  %b3:i0:i32 = load %l2:*i32
+  %b3:i1:u1 = cmp eq %b3:i0:i32 5:i32
+  %b3:i2:i32 = typecast %b3:i1:u1 to i32
+  ret %b3:i2:i32
+}

examples/ir1/cond_and_loop.ir

@@ -0,0 +1,112 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:i
+    %l1:i32:p
+    %l2:i32:q
+    %l3:i32:r
+    %l4:i32:t0
+    %l5:i32:t1
+    %l6:i32:t2
+
+block b0:
+  %b0:i0:unit = store 2:i32 %l1:*i32
+  %b0:i1:unit = store 5:i32 %l2:*i32
+  %b0:i2:u1 = cmp ne 0:i32 0:i32
+  br %b0:i2:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l1:*i32
+  %b1:i1:i32 = load %l2:*i32
+  %b1:i2:u1 = cmp gt %b1:i0:i32 %b1:i1:i32
+  br %b1:i2:u1, b4(), b5()
+
+block b2:
+  %b2:i0:i32 = load %l1:*i32
+  %b2:i1:i32 = load %l2:*i32
+  %b2:i2:i32 = add %b2:i0:i32 %b2:i1:i32
+  %b2:i3:unit = store %b2:i2:i32 %l5:*i32
+  j b3()
+
+block b3:
+  %b3:i0:i32 = load %l5:*i32
+  %b3:i1:unit = store %b3:i0:i32 %l3:*i32
+  %b3:i2:unit = store 0:i32 %l0:*i32
+  j b8()
+
+block b4:
+  %b4:i0:i32 = load %l1:*i32
+  %b4:i1:i32 = sub %b4:i0:i32 2:i32
+  %b4:i2:unit = store %b4:i1:i32 %l1:*i32
+  %b4:i3:unit = store %b4:i1:i32 %l4:*i32
+  j b6()
+
+block b5:
+  %b5:i0:i32 = load %l1:*i32
+  %b5:i1:i32 = add %b5:i0:i32 2:i32
+  %b5:i2:unit = store %b5:i1:i32 %l1:*i32
+  %b5:i3:unit = store %b5:i1:i32 %l4:*i32
+  j b6()
+
+block b6:
+  %b6:i0:i32 = load %l4:*i32
+  %b6:i1:unit = store %b6:i0:i32 %l5:*i32
+  j b3()
+
+block b8:
+  %b8:i0:i32 = load %l0:*i32
+  %b8:i1:u1 = cmp lt %b8:i0:i32 11:i32
+  br %b8:i1:u1, b9(), b11()
+
+block b9:
+  %b9:i0:i32 = load %l0:*i32
+  %b9:i1:i32 = mod %b9:i0:i32 2:i32
+  %b9:i2:u1 = cmp ne %b9:i1:i32 0:i32
+  br %b9:i2:u1, b12(), b13()
+
+block b11:
+  %b11:i0:i32 = load %l1:*i32
+  %b11:i1:u1 = cmp eq %b11:i0:i32 34:i32
+  %b11:i2:i32 = typecast %b11:i1:u1 to i32
+  ret %b11:i2:i32
+
+block b12:
+  %b12:i0:i32 = load %l1:*i32
+  %b12:i1:i32 = load %l2:*i32
+  %b12:i2:i32 = add %b12:i0:i32 %b12:i1:i32
+  %b12:i3:unit = store %b12:i2:i32 %l1:*i32
+  j b14()
+
+block b13:
+  %b13:i0:i32 = load %l1:*i32
+  %b13:i1:i32 = load %l3:*i32
+  %b13:i2:i32 = add %b13:i0:i32 %b13:i1:i32
+  %b13:i3:unit = store %b13:i2:i32 %l1:*i32
+  j b14()
+
+block b14:
+  %b14:i0:i32 = load %l0:*i32
+  %b14:i1:i32 = mod %b14:i0:i32 2:i32
+  %b14:i2:u1 = cmp ne %b14:i1:i32 0:i32
+  br %b14:i2:u1, b15(), b16()
+
+block b15:
+  %b15:i0:i32 = load %l0:*i32
+  %b15:i1:i32 = add %b15:i0:i32 2:i32
+  %b15:i2:unit = store %b15:i1:i32 %l0:*i32
+  %b15:i3:unit = store %b15:i1:i32 %l6:*i32
+  j b17()
+
+block b16:
+  %b16:i0:i32 = load %l0:*i32
+  %b16:i1:i32 = add %b16:i0:i32 1:i32
+  %b16:i2:unit = store %b16:i1:i32 %l0:*i32
+  %b16:i3:unit = store %b16:i1:i32 %l6:*i32
+  j b17()
+
+block b17:
+  %b17:i0:i32 = load %l6:*i32
+  j b8()
+}

examples/ir1/fib2.ir

@@ -0,0 +1,40 @@
+
+fun i32 @fibonacci (i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:n
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:u1 = cmp lt %b0:i1:i32 2:i32
+  br %b0:i2:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l0:*i32
+  ret %b1:i0:i32
+
+block b2:
+  %b2:i0:i32 = load %l0:*i32
+  %b2:i1:i32 = sub %b2:i0:i32 2:i32
+  %b2:i2:i32 = call @fibonacci:*[ret:i32 params:(i32)](%b2:i1:i32)
+  %b2:i3:i32 = load %l0:*i32
+  %b2:i4:i32 = sub %b2:i3:i32 1:i32
+  %b2:i5:i32 = call @fibonacci:*[ret:i32 params:(i32)](%b2:i4:i32)
+  %b2:i6:i32 = add %b2:i2:i32 %b2:i5:i32
+  ret %b2:i6:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = call @fibonacci:*[ret:i32 params:(i32)](9:i32)
+  %b0:i1:u1 = cmp eq %b0:i0:i32 34:i32
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/fib3.ir

@@ -0,0 +1,66 @@
+
+fun i32 @fibonacci (i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:n
+    %l1:i32:i
+    %l2:i32:t1
+    %l3:i32:t2
+    %l4:i32:next_term
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store 0:i32 %l1:*i32
+  %b0:i2:unit = store 0:i32 %l2:*i32
+  %b0:i3:unit = store 1:i32 %l3:*i32
+  %b0:i4:unit = store 0:i32 %l4:*i32
+  %b0:i5:i32 = load %l0:*i32
+  %b0:i6:u1 = cmp lt %b0:i5:i32 2:i32
+  br %b0:i6:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l0:*i32
+  ret %b1:i0:i32
+
+block b2:
+  %b2:i0:unit = store 1:i32 %l1:*i32
+  j b6()
+
+block b6:
+  %b6:i0:i32 = load %l1:*i32
+  %b6:i1:i32 = load %l0:*i32
+  %b6:i2:u1 = cmp lt %b6:i0:i32 %b6:i1:i32
+  br %b6:i2:u1, b7(), b9()
+
+block b7:
+  %b7:i0:i32 = load %l2:*i32
+  %b7:i1:i32 = load %l3:*i32
+  %b7:i2:i32 = add %b7:i0:i32 %b7:i1:i32
+  %b7:i3:unit = store %b7:i2:i32 %l4:*i32
+  %b7:i4:i32 = load %l3:*i32
+  %b7:i5:unit = store %b7:i4:i32 %l2:*i32
+  %b7:i6:i32 = load %l4:*i32
+  %b7:i7:unit = store %b7:i6:i32 %l3:*i32
+  %b7:i8:i32 = load %l1:*i32
+  %b7:i9:i32 = add %b7:i8:i32 1:i32
+  %b7:i10:unit = store %b7:i9:i32 %l1:*i32
+  j b6()
+
+block b9:
+  %b9:i0:i32 = load %l3:*i32
+  ret %b9:i0:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = call @fibonacci:*[ret:i32 params:(i32)](9:i32)
+  %b0:i1:u1 = cmp eq %b0:i0:i32 34:i32
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/fib4.ir

@@ -0,0 +1,66 @@
+
+fun i32 @fibonacci (i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:n
+    %l1:i32:i
+    %l2:i32:t1
+    %l3:i32:t2
+    %l4:i32:next_term
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store 0:i32 %l1:*i32
+  %b0:i2:unit = store 0:i32 %l2:*i32
+  %b0:i3:unit = store 1:i32 %l3:*i32
+  %b0:i4:unit = store 0:i32 %l4:*i32
+  %b0:i5:i32 = load %l0:*i32
+  %b0:i6:u1 = cmp lt %b0:i5:i32 2:i32
+  br %b0:i6:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l0:*i32
+  ret %b1:i0:i32
+
+block b2:
+  %b2:i0:unit = store 1:i32 %l1:*i32
+  j b5()
+
+block b5:
+  %b5:i0:i32 = load %l1:*i32
+  %b5:i1:i32 = load %l0:*i32
+  %b5:i2:u1 = cmp lt %b5:i0:i32 %b5:i1:i32
+  br %b5:i2:u1, b6(), b7()
+
+block b6:
+  %b6:i0:i32 = load %l2:*i32
+  %b6:i1:i32 = load %l3:*i32
+  %b6:i2:i32 = add %b6:i0:i32 %b6:i1:i32
+  %b6:i3:unit = store %b6:i2:i32 %l4:*i32
+  %b6:i4:i32 = load %l3:*i32
+  %b6:i5:unit = store %b6:i4:i32 %l2:*i32
+  %b6:i6:i32 = load %l4:*i32
+  %b6:i7:unit = store %b6:i6:i32 %l3:*i32
+  %b6:i8:i32 = load %l1:*i32
+  %b6:i9:i32 = add %b6:i8:i32 1:i32
+  %b6:i10:unit = store %b6:i9:i32 %l1:*i32
+  j b5()
+
+block b7:
+  %b7:i0:i32 = load %l3:*i32
+  ret %b7:i0:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = call @fibonacci:*[ret:i32 params:(i32)](9:i32)
+  %b0:i1:u1 = cmp eq %b0:i0:i32 34:i32
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/fib5.ir

@@ -0,0 +1,63 @@
+
+fun i32 @fibonacci (i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:n
+    %l1:i32:i
+    %l2:i32:t1
+    %l3:i32:t2
+    %l4:i32:next_term
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store 0:i32 %l1:*i32
+  %b0:i2:unit = store 0:i32 %l2:*i32
+  %b0:i3:unit = store 1:i32 %l3:*i32
+  %b0:i4:unit = store 0:i32 %l4:*i32
+  %b0:i5:i32 = load %l0:*i32
+  %b0:i6:u1 = cmp lt %b0:i5:i32 2:i32
+  br %b0:i6:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l0:*i32
+  ret %b1:i0:i32
+
+block b2:
+  %b2:i0:unit = store 1:i32 %l1:*i32
+  j b5()
+
+block b5:
+  %b5:i0:i32 = load %l2:*i32
+  %b5:i1:i32 = load %l3:*i32
+  %b5:i2:i32 = add %b5:i0:i32 %b5:i1:i32
+  %b5:i3:unit = store %b5:i2:i32 %l4:*i32
+  %b5:i4:i32 = load %l3:*i32
+  %b5:i5:unit = store %b5:i4:i32 %l2:*i32
+  %b5:i6:i32 = load %l4:*i32
+  %b5:i7:unit = store %b5:i6:i32 %l3:*i32
+  %b5:i8:i32 = load %l1:*i32
+  %b5:i9:i32 = add %b5:i8:i32 1:i32
+  %b5:i10:unit = store %b5:i9:i32 %l1:*i32
+  %b5:i11:i32 = load %l1:*i32
+  %b5:i12:i32 = load %l0:*i32
+  %b5:i13:u1 = cmp lt %b5:i11:i32 %b5:i12:i32
+  br %b5:i13:u1, b5(), b7()
+
+block b7:
+  %b7:i0:i32 = load %l3:*i32
+  ret %b7:i0:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = call @fibonacci:*[ret:i32 params:(i32)](9:i32)
+  %b0:i1:u1 = cmp eq %b0:i0:i32 34:i32
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/fibonacci.ir

@@ -0,0 +1,40 @@
+
+fun i32 @fibonacci (i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:n
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:u1 = cmp lt %b0:i1:i32 2:i32
+  br %b0:i2:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l0:*i32
+  ret %b1:i0:i32
+
+block b2:
+  %b2:i0:i32 = load %l0:*i32
+  %b2:i1:i32 = sub %b2:i0:i32 2:i32
+  %b2:i2:i32 = call @fibonacci:*[ret:i32 params:(i32)](%b2:i1:i32)
+  %b2:i3:i32 = load %l0:*i32
+  %b2:i4:i32 = sub %b2:i3:i32 1:i32
+  %b2:i5:i32 = call @fibonacci:*[ret:i32 params:(i32)](%b2:i4:i32)
+  %b2:i6:i32 = add %b2:i2:i32 %b2:i5:i32
+  ret %b2:i6:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = call @fibonacci:*[ret:i32 params:(i32)](9:i32)
+  %b0:i1:u1 = cmp eq %b0:i0:i32 34:i32
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/float.ir

@@ -0,0 +1,184 @@
+
+fun f64 @average (i32, *i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:len
+    %l1:*i32:a
+    %l2:i32:sum
+    %l3:i32:i
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:*i32 %l1:**i32
+  %b0:i2:unit = store 0:i32 %l2:*i32
+  %b0:i3:unit = store 0:i32 %l3:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l3:*i32
+  %b2:i1:i32 = load %l0:*i32
+  %b2:i2:u1 = cmp lt %b2:i0:i32 %b2:i1:i32
+  br %b2:i2:u1, b3(), b5()
+
+block b3:
+  %b3:i0:i32 = load %l2:*i32
+  %b3:i1:*i32 = load %l1:**i32
+  %b3:i2:i32 = load %l3:*i32
+  %b3:i3:i64 = typecast %b3:i2:i32 to i64
+  %b3:i4:i64 = mul %b3:i3:i64 4:i64
+  %b3:i5:*i32 = getelementptr %b3:i1:*i32 offset %b3:i4:i64
+  %b3:i6:i32 = load %b3:i5:*i32
+  %b3:i7:i32 = add %b3:i0:i32 %b3:i6:i32
+  %b3:i8:unit = store %b3:i7:i32 %l2:*i32
+  %b3:i9:i32 = load %l3:*i32
+  %b3:i10:i32 = add %b3:i9:i32 1:i32
+  %b3:i11:unit = store %b3:i10:i32 %l3:*i32
+  j b2()
+
+block b5:
+  %b5:i0:i32 = load %l2:*i32
+  %b5:i1:f64 = typecast %b5:i0:i32 to f64
+  %b5:i2:i32 = load %l0:*i32
+  %b5:i3:f64 = typecast %b5:i2:i32 to f64
+  %b5:i4:f64 = div %b5:i1:f64 %b5:i3:f64
+  ret %b5:i4:f64
+}
+
+fun f64 @custom_abs (f64) {
+init:
+  bid: b0
+  allocations: 
+    %l0:f64:a
+    %l1:f64:t0
+
+block b0:
+  %b0:i0:unit = store %b0:p0:f64 %l0:*f64
+  %b0:i1:f64 = load %l0:*f64
+  %b0:i2:f64 = typecast 0:i32 to f64
+  %b0:i3:u1 = cmp lt %b0:i1:f64 %b0:i2:f64
+  br %b0:i3:u1, b1(), b2()
+
+block b1:
+  %b1:i0:f64 = load %l0:*f64
+  %b1:i1:f64 = minus %b1:i0:f64
+  %b1:i2:unit = store %b1:i1:f64 %l1:*f64
+  j b3()
+
+block b2:
+  %b2:i0:f64 = load %l0:*f64
+  %b2:i1:unit = store %b2:i0:f64 %l1:*f64
+  j b3()
+
+block b3:
+  %b3:i0:f64 = load %l1:*f64
+  ret %b3:i0:f64
+}
+
+fun f64 @custom_max (f64, f64) {
+init:
+  bid: b0
+  allocations: 
+    %l0:f64:a
+    %l1:f64:b
+    %l2:f64:t0
+
+block b0:
+  %b0:i0:unit = store %b0:p0:f64 %l0:*f64
+  %b0:i1:unit = store %b0:p1:f64 %l1:*f64
+  %b0:i2:f64 = load %l0:*f64
+  %b0:i3:f64 = load %l1:*f64
+  %b0:i4:u1 = cmp gt %b0:i2:f64 %b0:i3:f64
+  br %b0:i4:u1, b1(), b2()
+
+block b1:
+  %b1:i0:f64 = load %l0:*f64
+  %b1:i1:unit = store %b1:i0:f64 %l2:*f64
+  j b3()
+
+block b2:
+  %b2:i0:f64 = load %l1:*f64
+  %b2:i1:unit = store %b2:i0:f64 %l2:*f64
+  j b3()
+
+block b3:
+  %b3:i0:f64 = load %l2:*f64
+  ret %b3:i0:f64
+}
+
+fun i32 @is_close (f64, f64, f64, f64) {
+init:
+  bid: b0
+  allocations: 
+    %l0:f64:a
+    %l1:f64:b
+    %l2:f64:rel_tol
+    %l3:f64:abs_tol
+
+block b0:
+  %b0:i0:unit = store %b0:p0:f64 %l0:*f64
+  %b0:i1:unit = store %b0:p1:f64 %l1:*f64
+  %b0:i2:unit = store %b0:p2:f64 %l2:*f64
+  %b0:i3:unit = store %b0:p3:f64 %l3:*f64
+  %b0:i4:f64 = load %l0:*f64
+  %b0:i5:f64 = load %l1:*f64
+  %b0:i6:f64 = sub %b0:i4:f64 %b0:i5:f64
+  %b0:i7:f64 = call @custom_abs:*[ret:f64 params:(f64)](%b0:i6:f64)
+  %b0:i8:f64 = load %l2:*f64
+  %b0:i9:f64 = load %l0:*f64
+  %b0:i10:f64 = call @custom_abs:*[ret:f64 params:(f64)](%b0:i9:f64)
+  %b0:i11:f64 = load %l1:*f64
+  %b0:i12:f64 = call @custom_abs:*[ret:f64 params:(f64)](%b0:i11:f64)
+  %b0:i13:f64 = call @custom_max:*[ret:f64 params:(f64, f64)](%b0:i10:f64, %b0:i12:f64)
+  %b0:i14:f64 = mul %b0:i8:f64 %b0:i13:f64
+  %b0:i15:f64 = load %l3:*f64
+  %b0:i16:f64 = call @custom_max:*[ret:f64 params:(f64, f64)](%b0:i14:f64, %b0:i15:f64)
+  %b0:i17:u1 = cmp le %b0:i7:f64 %b0:i16:f64
+  %b0:i18:i32 = typecast %b0:i17:u1 to i32
+  ret %b0:i18:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:[10 x i32]:a
+    %l1:i32:len
+    %l2:i32:i
+    %l3:f32:avg
+
+block b0:
+  %b0:i0:unit = store 10:i32 %l1:*i32
+  %b0:i1:unit = store 0:i32 %l2:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l2:*i32
+  %b2:i1:i32 = load %l1:*i32
+  %b2:i2:u1 = cmp lt %b2:i0:i32 %b2:i1:i32
+  br %b2:i2:u1, b3(), b5()
+
+block b3:
+  %b3:i0:*i32 = getelementptr %l0:*[10 x i32] offset 0:i32
+  %b3:i1:i32 = load %l2:*i32
+  %b3:i2:i64 = typecast %b3:i1:i32 to i64
+  %b3:i3:i64 = mul %b3:i2:i64 4:i64
+  %b3:i4:*i32 = getelementptr %b3:i0:*i32 offset %b3:i3:i64
+  %b3:i5:i32 = load %l2:*i32
+  %b3:i6:unit = store %b3:i5:i32 %b3:i4:*i32
+  %b3:i7:i32 = load %l2:*i32
+  %b3:i8:i32 = add %b3:i7:i32 1:i32
+  %b3:i9:unit = store %b3:i8:i32 %l2:*i32
+  j b2()
+
+block b5:
+  %b5:i0:i32 = load %l1:*i32
+  %b5:i1:*i32 = getelementptr %l0:*[10 x i32] offset 0:i32
+  %b5:i2:f64 = call @average:*[ret:f64 params:(i32, *i32)](%b5:i0:i32, %b5:i1:*i32)
+  %b5:i3:f32 = typecast %b5:i2:f64 to f32
+  %b5:i4:unit = store %b5:i3:f32 %l3:*f32
+  %b5:i5:f32 = load %l3:*f32
+  %b5:i6:f64 = typecast %b5:i5:f32 to f64
+  %b5:i7:i32 = call @is_close:*[ret:i32 params:(f64, f64, f64, f64)](%b5:i6:f64, 4.5:f64, 0.000000001:f64, 0.1:f64)
+  ret %b5:i7:i32
+}

examples/ir1/foo.ir

@@ -0,0 +1,41 @@
+
+fun i32 @foo (i32, i32, i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:x
+    %l1:i32:y
+    %l2:i32:z
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:i32 %l1:*i32
+  %b0:i2:unit = store %b0:p2:i32 %l2:*i32
+  %b0:i3:i32 = load %l0:*i32
+  %b0:i4:i32 = load %l1:*i32
+  %b0:i5:u1 = cmp eq %b0:i3:i32 %b0:i4:i32
+  br %b0:i5:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l1:*i32
+  ret %b1:i0:i32
+
+block b2:
+  %b2:i0:i32 = load %l2:*i32
+  ret %b2:i0:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = minus 1:i32
+  %b0:i1:i32 = call @foo:*[ret:i32 params:(i32, i32, i32)](0:i32, 1:i32, %b0:i0:i32)
+  %b0:i2:i32 = minus 1:i32
+  %b0:i3:u1 = cmp eq %b0:i1:i32 %b0:i2:i32
+  %b0:i4:i32 = typecast %b0:i3:u1 to i32
+  ret %b0:i4:i32
+}

examples/ir1/foo2.ir

@@ -0,0 +1,31 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:i
+    %l1:i32:i
+    %l2:i32:i
+    %l3:i32:k
+
+block b0:
+  %b0:i0:unit = store 0:i32 %l0:*i32
+  %b0:i1:unit = store 0:i32 %l1:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l1:*i32
+  %b2:i1:u1 = cmp lt %b2:i0:i32 10:i32
+  br %b2:i1:u1, b3(), b5()
+
+block b3:
+  %b3:i0:unit = store 0:i32 %l2:*i32
+  %b3:i1:unit = store 0:i32 %l3:*i32
+  %b3:i2:i32 = load %l1:*i32
+  %b3:i3:i32 = add %b3:i2:i32 1:i32
+  %b3:i4:unit = store %b3:i3:i32 %l1:*i32
+  j b2()
+
+block b5:
+  ret 1:i32
+}

examples/ir1/foo3.ir

@@ -0,0 +1,36 @@
+var i32 @g = 10
+
+fun i32 @foo (i32, i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:i
+    %l1:i32:j
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:i32 %l1:*i32
+  %b0:i2:i32 = load %l0:*i32
+  %b0:i3:i32 = load %l1:*i32
+  %b0:i4:i32 = add %b0:i2:i32 %b0:i3:i32
+  %b0:i5:i32 = load @g:*i32
+  %b0:i6:i32 = add %b0:i4:i32 %b0:i5:i32
+  ret %b0:i6:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:i
+
+block b0:
+  %b0:i0:i32 = load @g:*i32
+  %b0:i1:unit = store %b0:i0:i32 %l0:*i32
+  %b0:i2:i32 = load %l0:*i32
+  %b0:i3:i32 = load %l0:*i32
+  %b0:i4:i32 = call @foo:*[ret:i32 params:(i32, i32)](%b0:i2:i32, %b0:i3:i32)
+  %b0:i5:u1 = cmp eq %b0:i4:i32 30:i32
+  %b0:i6:i32 = typecast %b0:i5:u1 to i32
+  ret %b0:i6:i32
+}

examples/ir1/foo4.ir

@@ -0,0 +1,55 @@
+
+fun i32 @foo (i32, i32, i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:i
+    %l1:i32:j
+    %l2:i32:k
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:i32 %l1:*i32
+  %b0:i2:unit = store %b0:p2:i32 %l2:*i32
+  %b0:i3:i32 = load %l0:*i32
+  %b0:i4:i32 = load %l1:*i32
+  %b0:i5:i32 = add %b0:i3:i32 %b0:i4:i32
+  %b0:i6:i32 = load %l2:*i32
+  %b0:i7:i32 = add %b0:i5:i32 %b0:i6:i32
+  ret %b0:i7:i32
+}
+
+fun *[ret:i32 params:(i32, i32, i32)] @foo2 () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  ret @foo:*[ret:i32 params:(i32, i32, i32)]
+}
+
+fun *[ret:*[ret:i32 params:(i32, i32, i32)] params:()] @foo3 () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  ret @foo2:*[ret:*[ret:i32 params:(i32, i32, i32)] params:()]
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:*[ret:*[ret:i32 params:(i32, i32, i32)] params:()] = call @foo3:*[ret:*[ret:*[ret:i32 params:(i32, i32, i32)] params:()] params:()]()
+  %b0:i1:*[ret:i32 params:(i32, i32, i32)] = call %b0:i0:*[ret:*[ret:i32 params:(i32, i32, i32)] params:()]()
+  %b0:i2:i32 = call %b0:i1:*[ret:i32 params:(i32, i32, i32)](2:i32, 2:i32, 2:i32)
+  %b0:i3:u1 = cmp eq %b0:i2:i32 6:i32
+  %b0:i4:i32 = typecast %b0:i3:u1 to i32
+  ret %b0:i4:i32
+}

examples/ir1/for_continue_break.ir

@@ -0,0 +1,56 @@
+
+fun i32 @foo () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:sum
+    %l1:i32:i
+
+block b0:
+  %b0:i0:unit = store 0:i32 %l0:*i32
+  %b0:i1:unit = store 0:i32 %l1:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l1:*i32
+  %b2:i1:u1 = cmp eq %b2:i0:i32 5:i32
+  br %b2:i1:u1, b6(), b7()
+
+block b6:
+  %b6:i0:i32 = load %l0:*i32
+  ret %b6:i0:i32
+
+block b7:
+  %b7:i0:i32 = load %l1:*i32
+  %b7:i1:u1 = cmp eq %b7:i0:i32 3:i32
+  br %b7:i1:u1, b10(), b11()
+
+block b10:
+  %b10:i0:i32 = load %l1:*i32
+  %b10:i1:i32 = add %b10:i0:i32 1:i32
+  %b10:i2:unit = store %b10:i1:i32 %l1:*i32
+  j b2()
+
+block b11:
+  %b11:i0:i32 = load %l0:*i32
+  %b11:i1:i32 = load %l1:*i32
+  %b11:i2:i32 = add %b11:i0:i32 %b11:i1:i32
+  %b11:i3:unit = store %b11:i2:i32 %l0:*i32
+  %b11:i4:i32 = load %l1:*i32
+  %b11:i5:i32 = add %b11:i4:i32 1:i32
+  %b11:i6:unit = store %b11:i5:i32 %l1:*i32
+  j b2()
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = call @foo:*[ret:i32 params:()]()
+  %b0:i1:u1 = cmp eq %b0:i0:i32 7:i32
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/gcd.ir

@@ -0,0 +1,94 @@
+
+fun i32 @gcd (i32, i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:a
+    %l1:i32:b
+    %l2:i32:t0
+    %l3:i32:t1
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:i32 %l1:*i32
+  %b0:i2:i32 = load %l0:*i32
+  %b0:i3:u1 = cmp gt %b0:i2:i32 0:i32
+  br %b0:i3:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l0:*i32
+  %b1:i1:unit = store %b1:i0:i32 %l2:*i32
+  j b3()
+
+block b2:
+  %b2:i0:i32 = load %l0:*i32
+  %b2:i1:i32 = minus %b2:i0:i32
+  %b2:i2:unit = store %b2:i1:i32 %l2:*i32
+  j b3()
+
+block b3:
+  %b3:i0:i32 = load %l2:*i32
+  %b3:i1:unit = store %b3:i0:i32 %l0:*i32
+  %b3:i2:i32 = load %l1:*i32
+  %b3:i3:u1 = cmp gt %b3:i2:i32 0:i32
+  br %b3:i3:u1, b4(), b5()
+
+block b4:
+  %b4:i0:i32 = load %l1:*i32
+  %b4:i1:unit = store %b4:i0:i32 %l3:*i32
+  j b6()
+
+block b5:
+  %b5:i0:i32 = load %l1:*i32
+  %b5:i1:i32 = minus %b5:i0:i32
+  %b5:i2:unit = store %b5:i1:i32 %l3:*i32
+  j b6()
+
+block b6:
+  %b6:i0:i32 = load %l3:*i32
+  %b6:i1:unit = store %b6:i0:i32 %l1:*i32
+  j b7()
+
+block b7:
+  %b7:i0:i32 = load %l0:*i32
+  %b7:i1:i32 = load %l1:*i32
+  %b7:i2:u1 = cmp ne %b7:i0:i32 %b7:i1:i32
+  br %b7:i2:u1, b8(), b9()
+
+block b8:
+  %b8:i0:i32 = load %l0:*i32
+  %b8:i1:i32 = load %l1:*i32
+  %b8:i2:u1 = cmp gt %b8:i0:i32 %b8:i1:i32
+  br %b8:i2:u1, b10(), b11()
+
+block b9:
+  %b9:i0:i32 = load %l0:*i32
+  ret %b9:i0:i32
+
+block b10:
+  %b10:i0:i32 = load %l0:*i32
+  %b10:i1:i32 = load %l1:*i32
+  %b10:i2:i32 = sub %b10:i0:i32 %b10:i1:i32
+  %b10:i3:unit = store %b10:i2:i32 %l0:*i32
+  j b7()
+
+block b11:
+  %b11:i0:i32 = load %l1:*i32
+  %b11:i1:i32 = load %l0:*i32
+  %b11:i2:i32 = sub %b11:i0:i32 %b11:i1:i32
+  %b11:i3:unit = store %b11:i2:i32 %l1:*i32
+  j b7()
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = call @gcd:*[ret:i32 params:(i32, i32)](18:i32, 21:i32)
+  %b0:i1:u1 = cmp eq %b0:i0:i32 3:i32
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/integer_literal.ir

@@ -0,0 +1,22 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i16:temp
+    %l1:u32:temp2
+
+block b0:
+  %b0:i0:i16 = typecast 0:i32 to i16
+  %b0:i1:unit = store %b0:i0:i16 %l0:*i16
+  %b0:i2:unit = store 4294967163:u32 %l1:*u32
+  %b0:i3:i16 = load %l0:*i16
+  %b0:i4:u32 = load %l1:*u32
+  %b0:i5:u32 = typecast %b0:i3:i16 to u32
+  %b0:i6:u32 = xor %b0:i5:u32 %b0:i4:u32
+  %b0:i7:i8 = typecast %b0:i6:u32 to i8
+  %b0:i8:i32 = typecast %b0:i7:i8 to i32
+  %b0:i9:u1 = cmp eq %b0:i8:i32 123:i32
+  %b0:i10:i32 = typecast %b0:i9:u1 to i32
+  ret %b0:i10:i32
+}

examples/ir1/integer_literal2.ir

@@ -0,0 +1,15 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:temp
+
+block b0:
+  %b0:i0:unit = store 0:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:u32 = typecast %b0:i1:i32 to u32
+  %b0:i3:u1 = cmp lt %b0:i2:u32 4294967295:u32
+  %b0:i4:i32 = typecast %b0:i3:u1 to i32
+  ret %b0:i4:i32
+}

examples/ir1/logical_op.ir

@@ -0,0 +1,87 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:a
+    %l1:i32:b
+    %l2:i32:c
+    %l3:i32:d
+    %l4:u1:t0
+    %l5:u1:t1
+    %l6:u1:t2
+
+block b0:
+  %b0:i0:unit = store 0:i32 %l0:*i32
+  %b0:i1:unit = store 0:i32 %l1:*i32
+  %b0:i2:unit = store 0:i32 %l2:*i32
+  %b0:i3:unit = store 0:i32 %l3:*i32
+  %b0:i4:unit = store 1:i32 %l0:*i32
+  %b0:i5:u1 = cmp ne 1:i32 0:i32
+  br %b0:i5:u1, b4(), b5()
+
+block b1:
+  %b1:i0:i32 = load %l1:*i32
+  %b1:i1:i32 = add %b1:i0:i32 1:i32
+  %b1:i2:unit = store %b1:i1:i32 %l1:*i32
+  j b3()
+
+block b3:
+  %b3:i0:unit = store 1:i32 %l2:*i32
+  %b3:i1:u1 = cmp ne 1:i32 0:i32
+  br %b3:i1:u1, b10(), b11()
+
+block b4:
+  %b4:i0:unit = store 1:u1 %l4:*u1
+  j b6()
+
+block b5:
+  %b5:i0:unit = store 1:i32 %l1:*i32
+  %b5:i1:u1 = cmp ne 1:i32 0:i32
+  %b5:i2:unit = store %b5:i1:u1 %l4:*u1
+  j b6()
+
+block b6:
+  %b6:i0:u1 = load %l4:*u1
+  br %b6:i0:u1, b1(), b3()
+
+block b7:
+  %b7:i0:i32 = load %l3:*i32
+  %b7:i1:i32 = add %b7:i0:i32 1:i32
+  %b7:i2:unit = store %b7:i1:i32 %l3:*i32
+  j b9()
+
+block b9:
+  %b9:i0:i32 = load %l1:*i32
+  %b9:i1:u1 = cmp eq %b9:i0:i32 1:i32
+  br %b9:i1:u1, b13(), b14()
+
+block b10:
+  %b10:i0:unit = store 1:i32 %l3:*i32
+  %b10:i1:u1 = cmp ne 1:i32 0:i32
+  %b10:i2:unit = store %b10:i1:u1 %l5:*u1
+  j b12()
+
+block b11:
+  %b11:i0:unit = store 0:u1 %l5:*u1
+  j b12()
+
+block b12:
+  %b12:i0:u1 = load %l5:*u1
+  br %b12:i0:u1, b7(), b9()
+
+block b13:
+  %b13:i0:i32 = load %l3:*i32
+  %b13:i1:u1 = cmp eq %b13:i0:i32 2:i32
+  %b13:i2:unit = store %b13:i1:u1 %l6:*u1
+  j b15()
+
+block b14:
+  %b14:i0:unit = store 0:u1 %l6:*u1
+  j b15()
+
+block b15:
+  %b15:i0:u1 = load %l6:*u1
+  %b15:i1:i32 = typecast %b15:i0:u1 to i32
+  ret %b15:i1:i32
+}

examples/ir1/minus_constant.ir

@@ -0,0 +1,29 @@
+var i32 @a = -(1)
+var i64 @b = -(1l)
+var f32 @c = -(1.5f)
+var f64 @d = -(1.5)
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = load @a:*i32
+  %b0:i1:i64 = load @b:*i64
+  %b0:i2:i64 = typecast %b0:i0:i32 to i64
+  %b0:i3:i64 = add %b0:i2:i64 %b0:i1:i64
+  %b0:i4:f32 = load @c:*f32
+  %b0:i5:i32 = typecast %b0:i4:f32 to i32
+  %b0:i6:i64 = typecast %b0:i5:i32 to i64
+  %b0:i7:i64 = add %b0:i3:i64 %b0:i6:i64
+  %b0:i8:f64 = load @d:*f64
+  %b0:i9:i64 = typecast %b0:i8:f64 to i64
+  %b0:i10:i64 = add %b0:i7:i64 %b0:i9:i64
+  %b0:i11:i32 = minus 4:i32
+  %b0:i12:i64 = typecast %b0:i11:i32 to i64
+  %b0:i13:u1 = cmp eq %b0:i10:i64 %b0:i12:i64
+  %b0:i14:i32 = typecast %b0:i13:u1 to i32
+  ret %b0:i14:i32
+}

examples/ir1/negate.ir

@@ -0,0 +1,41 @@
+
+fun i32 @foo (i32, i32, i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:x
+    %l1:i32:y
+    %l2:i32:z
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:i32 %l1:*i32
+  %b0:i2:unit = store %b0:p2:i32 %l2:*i32
+  %b0:i3:i32 = load %l0:*i32
+  %b0:i4:i32 = load %l1:*i32
+  %b0:i5:u1 = cmp eq %b0:i3:i32 %b0:i4:i32
+  %b0:i6:u1 = negate %b0:i5:u1
+  br %b0:i6:u1, b1(), b2()
+
+block b1:
+  %b1:i0:i32 = load %l1:*i32
+  ret %b1:i0:i32
+
+block b2:
+  %b2:i0:i32 = load %l2:*i32
+  ret %b2:i0:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:i32 = minus 1:i32
+  %b0:i1:i32 = call @foo:*[ret:i32 params:(i32, i32, i32)](0:i32, 1:i32, %b0:i0:i32)
+  %b0:i2:u1 = cmp eq %b0:i1:i32 1:i32
+  %b0:i3:i32 = typecast %b0:i2:u1 to i32
+  ret %b0:i3:i32
+}

examples/ir1/pointer.ir

@@ -0,0 +1,62 @@
+
+fun *i32 @foo (*i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:*i32:a
+
+block b0:
+  %b0:i0:unit = store %b0:p0:*i32 %l0:**i32
+  %b0:i1:*i32 = load %l0:**i32
+  ret %b0:i1:*i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:a
+    %l1:*i32:p
+    %l2:**i32:p2
+    %l3:*i32:p3
+
+block b0:
+  %b0:i0:unit = store 1:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:unit = store %l0:*i32 %l1:**i32
+  %b0:i3:*i32 = load %l1:**i32
+  %b0:i4:*i32 = load %l1:**i32
+  %b0:i5:*i32 = load %l1:**i32
+  %b0:i6:unit = store %l1:**i32 %l2:***i32
+  %b0:i7:*i32 = load %l1:**i32
+  %b0:i8:*i32 = load %l1:**i32
+  %b0:i9:unit = store %b0:i8:*i32 %l3:**i32
+  %b0:i10:**i32 = load %l2:***i32
+  %b0:i11:*i32 = load %b0:i10:**i32
+  %b0:i12:*i32 = call @foo:*[ret:*i32 params:(*i32)](%b0:i11:*i32)
+  %b0:i13:i32 = load %b0:i12:*i32
+  %b0:i14:**i32 = load %l2:***i32
+  %b0:i15:*i32 = load %b0:i14:**i32
+  %b0:i16:*i32 = call @foo:*[ret:*i32 params:(*i32)](%b0:i15:*i32)
+  %b0:i17:**i32 = load %l2:***i32
+  %b0:i18:*i32 = load %b0:i17:**i32
+  %b0:i19:*i32 = call @foo:*[ret:*i32 params:(*i32)](%b0:i18:*i32)
+  %b0:i20:i32 = load %b0:i19:*i32
+  %b0:i21:**i32 = load %l2:***i32
+  %b0:i22:*i32 = load %b0:i21:**i32
+  %b0:i23:*i32 = call @foo:*[ret:*i32 params:(*i32)](%b0:i22:*i32)
+  %b0:i24:i32 = load %b0:i23:*i32
+  %b0:i25:i32 = add %b0:i24:i32 1:i32
+  %b0:i26:unit = store %b0:i25:i32 %b0:i16:*i32
+  %b0:i27:*i32 = load %l3:**i32
+  %b0:i28:*i32 = call @foo:*[ret:*i32 params:(*i32)](%b0:i27:*i32)
+  %b0:i29:*i32 = load %l3:**i32
+  %b0:i30:*i32 = call @foo:*[ret:*i32 params:(*i32)](%b0:i29:*i32)
+  %b0:i31:i32 = load %b0:i30:*i32
+  %b0:i32:i32 = add %b0:i31:i32 1:i32
+  %b0:i33:unit = store %b0:i32:i32 %b0:i28:*i32
+  %b0:i34:i32 = load %l0:*i32
+  %b0:i35:u1 = cmp eq %b0:i34:i32 3:i32
+  %b0:i36:i32 = typecast %b0:i35:u1 to i32
+  ret %b0:i36:i32
+}

examples/ir1/return_void.ir

@@ -0,0 +1,21 @@
+
+fun unit @foo () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  ret unit:unit
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:unit = call @foo:*[ret:unit params:()]()
+  ret 1:i32
+}

examples/ir1/shift.ir

@@ -0,0 +1,46 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i8:a
+    %l1:i8:b
+    %l2:u8:c
+    %l3:u1:t0
+
+block b0:
+  %b0:i0:i8 = typecast 127:i32 to i8
+  %b0:i1:unit = store %b0:i0:i8 %l0:*i8
+  %b0:i2:i8 = load %l0:*i8
+  %b0:i3:i32 = typecast %b0:i2:i8 to i32
+  %b0:i4:i32 = shl %b0:i3:i32 1:i32
+  %b0:i5:i8 = typecast %b0:i4:i32 to i8
+  %b0:i6:unit = store %b0:i5:i8 %l1:*i8
+  %b0:i7:i8 = load %l1:*i8
+  %b0:i8:u8 = typecast %b0:i7:i8 to u8
+  %b0:i9:i32 = typecast %b0:i8:u8 to i32
+  %b0:i10:i32 = shr %b0:i9:i32 1:i32
+  %b0:i11:u8 = typecast %b0:i10:i32 to u8
+  %b0:i12:unit = store %b0:i11:u8 %l2:*u8
+  %b0:i13:i8 = load %l1:*i8
+  %b0:i14:i32 = minus 2:i32
+  %b0:i15:i32 = typecast %b0:i13:i8 to i32
+  %b0:i16:u1 = cmp eq %b0:i15:i32 %b0:i14:i32
+  br %b0:i16:u1, b1(), b2()
+
+block b1:
+  %b1:i0:u8 = load %l2:*u8
+  %b1:i1:i32 = typecast %b1:i0:u8 to i32
+  %b1:i2:u1 = cmp eq %b1:i1:i32 127:i32
+  %b1:i3:unit = store %b1:i2:u1 %l3:*u1
+  j b3()
+
+block b2:
+  %b2:i0:unit = store 0:u1 %l3:*u1
+  j b3()
+
+block b3:
+  %b3:i0:u1 = load %l3:*u1
+  %b3:i1:i32 = typecast %b3:i0:u1 to i32
+  ret %b3:i1:i32
+}

examples/ir1/simple.ir

@@ -0,0 +1,11 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:x
+
+block b0:
+  %b0:i0:unit = store 1:i32 %l0:*i32
+  ret 1:i32
+}

examples/ir1/simple_cond.ir

@@ -0,0 +1,63 @@
+
+fun i32 @f (i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:x
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:i32 = add %b0:i1:i32 8:i32
+  ret %b0:i2:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:x
+    %l1:i32:y
+    %l2:i32:t0
+    %l3:i32:t1
+
+block b0:
+  %b0:i0:unit = store 0:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:i32 = add %b0:i1:i32 1:i32
+  %b0:i3:unit = store %b0:i2:i32 %l0:*i32
+  %b0:i4:u1 = cmp eq %b0:i1:i32 1:i32
+  br %b0:i4:u1, b1(), b2()
+
+block b1:
+  %b1:i0:unit = store 1:i32 %l2:*i32
+  j b3()
+
+block b2:
+  %b2:i0:unit = store 2:i32 %l2:*i32
+  j b3()
+
+block b3:
+  %b3:i0:i32 = load %l2:*i32
+  %b3:i1:unit = store %b3:i0:i32 %l1:*i32
+  %b3:i2:i32 = load %l0:*i32
+  %b3:i3:i32 = load %l1:*i32
+  %b3:i4:u1 = cmp lt %b3:i2:i32 %b3:i3:i32
+  br %b3:i4:u1, b4(), b5()
+
+block b4:
+  %b4:i0:i32 = load %l0:*i32
+  %b4:i1:unit = store %b4:i0:i32 %l3:*i32
+  j b6()
+
+block b5:
+  %b5:i0:unit = store 2:i32 %l3:*i32
+  j b6()
+
+block b6:
+  %b6:i0:i32 = load %l3:*i32
+  %b6:i1:i32 = call @f:*[ret:i32 params:(i32)](%b6:i0:i32)
+  %b6:i2:u1 = cmp eq %b6:i1:i32 9:i32
+  %b6:i3:i32 = typecast %b6:i2:u1 to i32
+  ret %b6:i3:i32
+}

examples/ir1/simple_for.ir

@@ -0,0 +1,34 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:i
+    %l1:i32:sum
+
+block b0:
+  %b0:i0:unit = store 0:i32 %l1:*i32
+  %b0:i1:unit = store 0:i32 %l0:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l0:*i32
+  %b2:i1:u1 = cmp lt %b2:i0:i32 11:i32
+  br %b2:i1:u1, b3(), b5()
+
+block b3:
+  %b3:i0:i32 = load %l1:*i32
+  %b3:i1:i32 = load %l0:*i32
+  %b3:i2:i32 = add %b3:i0:i32 %b3:i1:i32
+  %b3:i3:unit = store %b3:i2:i32 %l1:*i32
+  %b3:i4:i32 = load %l0:*i32
+  %b3:i5:i32 = add %b3:i4:i32 1:i32
+  %b3:i6:unit = store %b3:i5:i32 %l0:*i32
+  j b2()
+
+block b5:
+  %b5:i0:i32 = load %l1:*i32
+  %b5:i1:u1 = cmp eq %b5:i0:i32 55:i32
+  %b5:i2:i32 = typecast %b5:i1:u1 to i32
+  ret %b5:i2:i32
+}

examples/ir1/simple_if.ir

@@ -0,0 +1,39 @@
+
+fun i32 @fibonacci (i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:n
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:u1 = cmp lt %b0:i1:i32 2:i32
+  br %b0:i2:u1, b1(), b3()
+
+block b1:
+  %b1:i0:i32 = load %l0:*i32
+  %b1:i1:i32 = add %b1:i0:i32 2:i32
+  %b1:i2:unit = store %b1:i1:i32 %l0:*i32
+  j b3()
+
+block b3:
+  %b3:i0:i32 = load %l0:*i32
+  %b3:i1:i32 = sub %b3:i0:i32 2:i32
+  %b3:i2:i32 = call @fibonacci:*[ret:i32 params:(i32)](%b3:i1:i32)
+  %b3:i3:i32 = load %l0:*i32
+  %b3:i4:i32 = sub %b3:i3:i32 1:i32
+  %b3:i5:i32 = call @fibonacci:*[ret:i32 params:(i32)](%b3:i4:i32)
+  %b3:i6:i32 = add %b3:i2:i32 %b3:i5:i32
+  ret %b3:i6:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  ret 1:i32
+}

examples/ir1/sizeof.ir

@@ -0,0 +1,13 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  %b0:i0:u64 = typecast 4:i32 to u64
+  %b0:i1:u1 = cmp eq 4:u64 %b0:i0:u64
+  %b0:i2:i32 = typecast %b0:i1:u1 to i32
+  ret %b0:i2:i32
+}

examples/ir1/struct.ir

@@ -0,0 +1,99 @@
+struct %t0 : { [4 x [5 x i32]] }
+struct %t1 : { i8,  struct %t0, f64 }
+
+fun unit @init (i32, i32, *[5 x i32]) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:row
+    %l1:i32:col
+    %l2:*[5 x i32]:arr
+    %l3:i32:i
+    %l4:i32:j
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:unit = store %b0:p1:i32 %l1:*i32
+  %b0:i2:unit = store %b0:p2:*[5 x i32] %l2:**[5 x i32]
+  %b0:i3:unit = store 0:i32 %l3:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l3:*i32
+  %b2:i1:i32 = load %l0:*i32
+  %b2:i2:u1 = cmp lt %b2:i0:i32 %b2:i1:i32
+  br %b2:i2:u1, b3(), b5()
+
+block b3:
+  %b3:i0:unit = store 0:i32 %l4:*i32
+  j b7()
+
+block b5:
+  ret unit:unit
+
+block b7:
+  %b7:i0:i32 = load %l4:*i32
+  %b7:i1:i32 = load %l1:*i32
+  %b7:i2:u1 = cmp lt %b7:i0:i32 %b7:i1:i32
+  br %b7:i2:u1, b8(), b10()
+
+block b8:
+  %b8:i0:*[5 x i32] = load %l2:**[5 x i32]
+  %b8:i1:i32 = load %l3:*i32
+  %b8:i2:i64 = typecast %b8:i1:i32 to i64
+  %b8:i3:i64 = mul %b8:i2:i64 20:i64
+  %b8:i4:*[5 x i32] = getelementptr %b8:i0:*[5 x i32] offset %b8:i3:i64
+  %b8:i5:*i32 = getelementptr %b8:i4:*[5 x i32] offset 0:i32
+  %b8:i6:i32 = load %l4:*i32
+  %b8:i7:i64 = typecast %b8:i6:i32 to i64
+  %b8:i8:i64 = mul %b8:i7:i64 4:i64
+  %b8:i9:*i32 = getelementptr %b8:i5:*i32 offset %b8:i8:i64
+  %b8:i10:i32 = load %l3:*i32
+  %b8:i11:i32 = load %l4:*i32
+  %b8:i12:i32 = mul %b8:i10:i32 %b8:i11:i32
+  %b8:i13:unit = store %b8:i12:i32 %b8:i9:*i32
+  %b8:i14:i32 = load %l4:*i32
+  %b8:i15:i32 = add %b8:i14:i32 1:i32
+  %b8:i16:unit = store %b8:i15:i32 %l4:*i32
+  j b7()
+
+block b10:
+  %b10:i0:i32 = load %l3:*i32
+  %b10:i1:i32 = add %b10:i0:i32 1:i32
+  %b10:i2:unit = store %b10:i1:i32 %l3:*i32
+  j b2()
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0: struct %t1:temp
+    %l1:i32:row
+    %l2:i32:col
+    %l3: struct %t1:temp2
+
+block b0:
+  %b0:i0:unit = store 4:i32 %l1:*i32
+  %b0:i1:unit = store 5:i32 %l2:*i32
+  %b0:i2:i32 = load %l1:*i32
+  %b0:i3:i32 = load %l2:*i32
+  %b0:i4:*[4 x [5 x i32]] = getelementptr %l0:* struct %t1 offset 4:i64
+  %b0:i5:*[5 x i32] = getelementptr %b0:i4:*[4 x [5 x i32]] offset 0:i32
+  %b0:i6:unit = call @init:*[ret:unit params:(i32, i32, *[5 x i32])](%b0:i2:i32, %b0:i3:i32, %b0:i5:*[5 x i32])
+  %b0:i7: struct %t1 = load %l0:* struct %t1
+  %b0:i8:unit = store %b0:i7: struct %t1 %l3:* struct %t1
+  %b0:i9:*[4 x [5 x i32]] = getelementptr %l3:* struct %t1 offset 4:i64
+  %b0:i10:*[5 x i32] = getelementptr %b0:i9:*[4 x [5 x i32]] offset 0:i32
+  %b0:i11:i64 = typecast 2:i32 to i64
+  %b0:i12:i64 = mul %b0:i11:i64 20:i64
+  %b0:i13:*[5 x i32] = getelementptr %b0:i10:*[5 x i32] offset %b0:i12:i64
+  %b0:i14:*i32 = getelementptr %b0:i13:*[5 x i32] offset 0:i32
+  %b0:i15:i64 = typecast 3:i32 to i64
+  %b0:i16:i64 = mul %b0:i15:i64 4:i64
+  %b0:i17:*i32 = getelementptr %b0:i14:*i32 offset %b0:i16:i64
+  %b0:i18:i32 = load %b0:i17:*i32
+  %b0:i19:u1 = cmp eq %b0:i18:i32 6:i32
+  %b0:i20:i32 = typecast %b0:i19:u1 to i32
+  ret %b0:i20:i32
+}

examples/ir1/struct2.ir

@@ -0,0 +1,56 @@
+struct %t1 : { i8,  struct %t0, i64 }
+struct %t0 : { [4 x i32] }
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:const struct %t1:temp
+    %l1: struct %t1:temp2
+    %l2:i32:sum
+
+block b0:
+  %b0:i0:*i8 = getelementptr %l0:*const struct %t1 offset 0:i64
+  %b0:i1:i8 = typecast 1:i32 to i8
+  %b0:i2:unit = store %b0:i1:i8 %b0:i0:*i8
+  %b0:i3:* struct %t0 = getelementptr %l0:*const struct %t1 offset 4:i64
+  %b0:i4:*[4 x i32] = getelementptr %b0:i3:* struct %t0 offset 0:i64
+  %b0:i5:*i32 = getelementptr %b0:i4:*[4 x i32] offset 0:i32
+  %b0:i6:i64 = mul 0:i64 4:i64
+  %b0:i7:*i32 = getelementptr %b0:i5:*i32 offset %b0:i6:i64
+  %b0:i8:unit = store 2:i32 %b0:i7:*i32
+  %b0:i9:i64 = mul 1:i64 4:i64
+  %b0:i10:*i32 = getelementptr %b0:i5:*i32 offset %b0:i9:i64
+  %b0:i11:unit = store 3:i32 %b0:i10:*i32
+  %b0:i12:i64 = mul 2:i64 4:i64
+  %b0:i13:*i32 = getelementptr %b0:i5:*i32 offset %b0:i12:i64
+  %b0:i14:unit = store 4:i32 %b0:i13:*i32
+  %b0:i15:i64 = mul 3:i64 4:i64
+  %b0:i16:*i32 = getelementptr %b0:i5:*i32 offset %b0:i15:i64
+  %b0:i17:unit = store 5:i32 %b0:i16:*i32
+  %b0:i18:*i64 = getelementptr %l0:*const struct %t1 offset 24:i64
+  %b0:i19:i64 = typecast 6:i32 to i64
+  %b0:i20:unit = store %b0:i19:i64 %b0:i18:*i64
+  %b0:i21: struct %t1 = load %l0:*const struct %t1
+  %b0:i22:unit = store %b0:i21: struct %t1 %l1:* struct %t1
+  %b0:i23:*i8 = getelementptr %l1:* struct %t1 offset 0:i64
+  %b0:i24:i8 = load %b0:i23:*i8
+  %b0:i25:*[4 x i32] = getelementptr %l1:* struct %t1 offset 4:i64
+  %b0:i26:*i32 = getelementptr %b0:i25:*[4 x i32] offset 0:i32
+  %b0:i27:i64 = typecast 2:i32 to i64
+  %b0:i28:i64 = mul %b0:i27:i64 4:i64
+  %b0:i29:*i32 = getelementptr %b0:i26:*i32 offset %b0:i28:i64
+  %b0:i30:i32 = load %b0:i29:*i32
+  %b0:i31:i32 = typecast %b0:i24:i8 to i32
+  %b0:i32:i32 = add %b0:i31:i32 %b0:i30:i32
+  %b0:i33:*i64 = getelementptr %l1:* struct %t1 offset 24:i64
+  %b0:i34:i64 = load %b0:i33:*i64
+  %b0:i35:i64 = typecast %b0:i32:i32 to i64
+  %b0:i36:i64 = add %b0:i35:i64 %b0:i34:i64
+  %b0:i37:i32 = typecast %b0:i36:i64 to i32
+  %b0:i38:unit = store %b0:i37:i32 %l2:*i32
+  %b0:i39:i32 = load %l2:*i32
+  %b0:i40:u1 = cmp eq %b0:i39:i32 11:i32
+  %b0:i41:i32 = typecast %b0:i40:u1 to i32
+  ret %b0:i41:i32
+}

examples/ir1/struct3.ir

@@ -0,0 +1,80 @@
+struct Big : {  struct Sub,  struct Sub,  struct Sub }
+struct Sub : { i64, i64, i64, i64 }
+
+fun  struct Big @foo ( struct Big) {
+init:
+  bid: b0
+  allocations: 
+    %l0: struct Big:p1
+    %l1: struct Big:r
+
+block b0:
+  %b0:i0:unit = store %b0:p0: struct Big %l0:* struct Big
+  %b0:i1: struct Big = load %l0:* struct Big
+  %b0:i2:unit = store %b0:i1: struct Big %l1:* struct Big
+  %b0:i3:* struct Sub = getelementptr %l1:* struct Big offset 0:i64
+  %b0:i4:*i64 = getelementptr %b0:i3:* struct Sub offset 0:i64
+  %b0:i5:i64 = typecast 10:i32 to i64
+  %b0:i6:unit = store %b0:i5:i64 %b0:i4:*i64
+  %b0:i7: struct Big = load %l1:* struct Big
+  ret %b0:i7: struct Big
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0: struct Big:a
+    %l1: struct Big:r
+
+block b0:
+  %b0:i0:* struct Sub = getelementptr %l0:* struct Big offset 0:i64
+  %b0:i1:*i64 = getelementptr %b0:i0:* struct Sub offset 0:i64
+  %b0:i2:i64 = typecast 1:i32 to i64
+  %b0:i3:unit = store %b0:i2:i64 %b0:i1:*i64
+  %b0:i4:*i64 = getelementptr %b0:i0:* struct Sub offset 8:i64
+  %b0:i5:i64 = typecast 2:i32 to i64
+  %b0:i6:unit = store %b0:i5:i64 %b0:i4:*i64
+  %b0:i7:*i64 = getelementptr %b0:i0:* struct Sub offset 16:i64
+  %b0:i8:i64 = typecast 3:i32 to i64
+  %b0:i9:unit = store %b0:i8:i64 %b0:i7:*i64
+  %b0:i10:*i64 = getelementptr %b0:i0:* struct Sub offset 24:i64
+  %b0:i11:i64 = typecast 4:i32 to i64
+  %b0:i12:unit = store %b0:i11:i64 %b0:i10:*i64
+  %b0:i13:* struct Sub = getelementptr %l0:* struct Big offset 32:i64
+  %b0:i14:*i64 = getelementptr %b0:i13:* struct Sub offset 0:i64
+  %b0:i15:i64 = typecast 2:i32 to i64
+  %b0:i16:unit = store %b0:i15:i64 %b0:i14:*i64
+  %b0:i17:*i64 = getelementptr %b0:i13:* struct Sub offset 8:i64
+  %b0:i18:i64 = typecast 3:i32 to i64
+  %b0:i19:unit = store %b0:i18:i64 %b0:i17:*i64
+  %b0:i20:*i64 = getelementptr %b0:i13:* struct Sub offset 16:i64
+  %b0:i21:i64 = typecast 4:i32 to i64
+  %b0:i22:unit = store %b0:i21:i64 %b0:i20:*i64
+  %b0:i23:*i64 = getelementptr %b0:i13:* struct Sub offset 24:i64
+  %b0:i24:i64 = typecast 5:i32 to i64
+  %b0:i25:unit = store %b0:i24:i64 %b0:i23:*i64
+  %b0:i26:* struct Sub = getelementptr %l0:* struct Big offset 64:i64
+  %b0:i27:*i64 = getelementptr %b0:i26:* struct Sub offset 0:i64
+  %b0:i28:i64 = typecast 3:i32 to i64
+  %b0:i29:unit = store %b0:i28:i64 %b0:i27:*i64
+  %b0:i30:*i64 = getelementptr %b0:i26:* struct Sub offset 8:i64
+  %b0:i31:i64 = typecast 4:i32 to i64
+  %b0:i32:unit = store %b0:i31:i64 %b0:i30:*i64
+  %b0:i33:*i64 = getelementptr %b0:i26:* struct Sub offset 16:i64
+  %b0:i34:i64 = typecast 5:i32 to i64
+  %b0:i35:unit = store %b0:i34:i64 %b0:i33:*i64
+  %b0:i36:*i64 = getelementptr %b0:i26:* struct Sub offset 24:i64
+  %b0:i37:i64 = typecast 6:i32 to i64
+  %b0:i38:unit = store %b0:i37:i64 %b0:i36:*i64
+  %b0:i39: struct Big = load %l0:* struct Big
+  %b0:i40: struct Big = call @foo:*[ret: struct Big params:( struct Big)](%b0:i39: struct Big)
+  %b0:i41:unit = store %b0:i40: struct Big %l1:* struct Big
+  %b0:i42:* struct Sub = getelementptr %l1:* struct Big offset 0:i64
+  %b0:i43:*i64 = getelementptr %b0:i42:* struct Sub offset 0:i64
+  %b0:i44:i64 = load %b0:i43:*i64
+  %b0:i45:i64 = typecast 10:i32 to i64
+  %b0:i46:u1 = cmp eq %b0:i44:i64 %b0:i45:i64
+  %b0:i47:i32 = typecast %b0:i46:u1 to i32
+  ret %b0:i47:i32
+}

examples/ir1/switch.ir

@@ -0,0 +1,41 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:a
+    %l1:i32:b
+
+block b0:
+  %b0:i0:unit = store 1:i32 %l0:*i32
+  %b0:i1:unit = store 0:i32 %l1:*i32
+  %b0:i2:i32 = load %l0:*i32
+  switch %b0:i2:i32 default b4() [
+    0:i32 b2()
+    1:i32 b3()
+  ]
+
+block b1:
+  %b1:i0:i32 = load %l1:*i32
+  %b1:i1:u1 = cmp eq %b1:i0:i32 2:i32
+  %b1:i2:i32 = typecast %b1:i1:u1 to i32
+  ret %b1:i2:i32
+
+block b2:
+  %b2:i0:i32 = load %l1:*i32
+  %b2:i1:i32 = add %b2:i0:i32 1:i32
+  %b2:i2:unit = store %b2:i1:i32 %l1:*i32
+  j b1()
+
+block b3:
+  %b3:i0:i32 = load %l1:*i32
+  %b3:i1:i32 = add %b3:i0:i32 2:i32
+  %b3:i2:unit = store %b3:i1:i32 %l1:*i32
+  j b1()
+
+block b4:
+  %b4:i0:i32 = load %l1:*i32
+  %b4:i1:i32 = add %b4:i0:i32 3:i32
+  %b4:i2:unit = store %b4:i1:i32 %l1:*i32
+  j b1()
+}

examples/ir1/temp.ir

@@ -0,0 +1,32 @@
+
+fun i32 @fibonacci (i32) {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:n
+
+block b0:
+  %b0:i0:unit = store %b0:p0:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:i32 = load %l0:*i32
+  %b0:i3:i32 = add %b0:i1:i32 %b0:i2:i32
+  %b0:i4:u1 = cmp ne %b0:i3:i32 0:i32
+  br %b0:i4:u1, b2(), b3()
+
+block b2:
+  %b2:i0:i32 = load %l0:*i32
+  ret %b2:i0:i32
+
+block b3:
+  ret undef:i32
+}
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+
+
+block b0:
+  ret 1:i32
+}

examples/ir1/temp2.ir

@@ -0,0 +1,97 @@
+struct color : { i32, i8 }
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i32:temp
+    %l1: struct color:c
+    %l2:* struct color:cp
+    %l3:i32:i
+    %l4:i32:j
+    %l5:u1:t0
+
+block b0:
+  %b0:i0:unit = store 0:i32 %l0:*i32
+  %b0:i1:i32 = load %l0:*i32
+  %b0:i2:u64 = typecast %b0:i1:i32 to u64
+  %b0:i3:u64 = add %b0:i2:u64 1:u64
+  %b0:i4:i32 = typecast %b0:i3:u64 to i32
+  %b0:i5:unit = store %b0:i4:i32 %l0:*i32
+  %b0:i6:i32 = load %l0:*i32
+  %b0:i7:u64 = typecast %b0:i6:i32 to u64
+  %b0:i8:u64 = add %b0:i7:u64 1:u64
+  %b0:i9:i32 = typecast %b0:i8:u64 to i32
+  %b0:i10:unit = store %b0:i9:i32 %l0:*i32
+  %b0:i11:*i32 = getelementptr %l1:* struct color offset 0:i64
+  %b0:i12:unit = store 1:i32 %b0:i11:*i32
+  %b0:i13:*i8 = getelementptr %l1:* struct color offset 4:i64
+  %b0:i14:i8 = typecast 2:i32 to i8
+  %b0:i15:unit = store %b0:i14:i8 %b0:i13:*i8
+  %b0:i16:i32 = load %l0:*i32
+  %b0:i17:*i8 = getelementptr %l1:* struct color offset 4:i64
+  %b0:i18:i8 = load %b0:i17:*i8
+  %b0:i19:i32 = typecast %b0:i18:i8 to i32
+  %b0:i20:i32 = add %b0:i16:i32 %b0:i19:i32
+  %b0:i21:unit = store %b0:i20:i32 %l0:*i32
+  %b0:i22: struct color = load %l1:* struct color
+  %b0:i23:unit = store %l1:* struct color %l2:** struct color
+  %b0:i24:i32 = load %l0:*i32
+  %b0:i25:* struct color = load %l2:** struct color
+  %b0:i26:*i8 = getelementptr %b0:i25:* struct color offset 4:i64
+  %b0:i27:i8 = load %b0:i26:*i8
+  %b0:i28:i32 = typecast %b0:i27:i8 to i32
+  %b0:i29:i32 = add %b0:i24:i32 %b0:i28:i32
+  %b0:i30:unit = store %b0:i29:i32 %l0:*i32
+  %b0:i31:unit = store 0:i32 %l3:*i32
+  %b0:i32:unit = store 0:i32 %l4:*i32
+  j b2()
+
+block b2:
+  %b2:i0:i32 = load %l3:*i32
+  %b2:i1:u1 = cmp lt %b2:i0:i32 10:i32
+  br %b2:i1:u1, b3(), b5()
+
+block b3:
+  %b3:i0:i32 = load %l3:*i32
+  %b3:i1:u1 = cmp eq %b3:i0:i32 2:i32
+  br %b3:i1:u1, b9(), b10()
+
+block b5:
+  %b5:i0:i32 = load %l0:*i32
+  switch %b5:i0:i32 default b13() [
+    1:i32 b14()
+  ]
+
+block b7:
+  %b7:i0:i32 = load %l0:*i32
+  %b7:i1:i32 = load %l3:*i32
+  %b7:i2:i32 = add %b7:i0:i32 %b7:i1:i32
+  %b7:i3:unit = store %b7:i2:i32 %l0:*i32
+  %b7:i4:i32 = load %l3:*i32
+  %b7:i5:i32 = add %b7:i4:i32 1:i32
+  %b7:i6:unit = store %b7:i5:i32 %l3:*i32
+  j b2()
+
+block b9:
+  %b9:i0:i32 = load %l4:*i32
+  %b9:i1:u1 = cmp eq %b9:i0:i32 0:i32
+  %b9:i2:unit = store %b9:i1:u1 %l5:*u1
+  j b11()
+
+block b10:
+  %b10:i0:unit = store 0:u1 %l5:*u1
+  j b11()
+
+block b11:
+  %b11:i0:u1 = load %l5:*u1
+  br %b11:i0:u1, b5(), b7()
+
+block b13:
+  %b13:i0:i32 = load %l0:*i32
+  ret %b13:i0:i32
+
+block b14:
+  %b14:i0:unit = store 0:i32 %l0:*i32
+  j b13()
+}

examples/ir1/test.ir

@@ -0,0 +1,49 @@
+
+fun i32 @main () {
+init:
+  bid: b0
+  allocations: 
+    %l0:i64:l
+    %l1:i64:l2
+    %l2:i64:l3
+    %l3:i16:s
+    %l4:i16:s2
+    %l5:i32:i
+    %l6:i8:c
+
+block b0:
+  %b0:i0:i64 = typecast 1:i32 to i64
+  %b0:i1:unit = store %b0:i0:i64 %l0:*i64
+  %b0:i2:i64 = typecast 2:i32 to i64
+  %b0:i3:unit = store %b0:i2:i64 %l1:*i64
+  %b0:i4:i64 = typecast 3:i32 to i64
+  %b0:i5:unit = store %b0:i4:i64 %l2:*i64
+  %b0:i6:i16 = typecast 4:i32 to i16
+  %b0:i7:unit = store %b0:i6:i16 %l3:*i16
+  %b0:i8:i16 = typecast 5:i32 to i16
+  %b0:i9:unit = store %b0:i8:i16 %l4:*i16
+  %b0:i10:unit = store 6:i32 %l5:*i32
+  %b0:i11:i8 = typecast 7:i32 to i8
+  %b0:i12:unit = store %b0:i11:i8 %l6:*i8
+  %b0:i13:i64 = load %l0:*i64
+  %b0:i14:i64 = load %l1:*i64
+  %b0:i15:i64 = add %b0:i13:i64 %b0:i14:i64
+  %b0:i16:i64 = load %l2:*i64
+  %b0:i17:i64 = add %b0:i15:i64 %b0:i16:i64
+  %b0:i18:i16 = load %l3:*i16
+  %b0:i19:i64 = typecast %b0:i18:i16 to i64
+  %b0:i20:i64 = add %b0:i17:i64 %b0:i19:i64
+  %b0:i21:i16 = load %l4:*i16
+  %b0:i22:i64 = typecast %b0:i21:i16 to i64
+  %b0:i23:i64 = add %b0:i20:i64 %b0:i22:i64
+  %b0:i24:i32 = load %l5:*i32
+  %b0:i25:i64 = typecast %b0:i24:i32 to i64
+  %b0:i26:i64 = add %b0:i23:i64 %b0:i25:i64
+  %b0:i27:i8 = load %l6:*i8
+  %b0:i28:i64 = typecast %b0:i27:i8 to i64
+  %b0:i29:i64 = add %b0:i26:i64 %b0:i28:i64
+  %b0:i30:i64 = typecast 28:i32 to i64
+  %b0:i31:u1 = cmp eq %b0:i29:i64 %b0:i30:i64
+  %b0:i32:i32 = typecast %b0:i31:u1 to i32
+  ret %b0:i32:i32
+}