mirror of
https://github.com/kmc7468/cs420.git
synced 2026-11-04 00:00:29 +09:00
Add tests
This commit is contained in:
Jeehoon Kang committed
1 parent
ea97330e03
commit
ea9e6afcf8
258 files changed
+149921
-26
No files matched your search
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -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:
|
||||
@@ -1,5 +1,5 @@
|
||||
struct %t0 : { [4 x i32] }
|
||||
struct %t1 : { i8, struct %t0, i64 }
|
||||
struct %t0 : { [4 x i32] }
|
||||
|
||||
fun i32 @main () {
|
||||
init:
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
+15940
File diff suppressed because it is too large.
Load diff
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
var i8 @temp = 0x00l
|
||||
|
||||
fun i32 @main () {
|
||||
init:
|
||||
bid: b0
|
||||
allocations:
|
||||
|
||||
|
||||
block b0:
|
||||
%b0:i0:i8 = typecast 61238:i64 to i8
|
||||
%b0:i1:unit = store %b0:i0:i8 @temp:*i8
|
||||
%b0:i2:i64 = typecast %b0:i0:i8 to i64
|
||||
%b0:i3:u1 = cmp ge %b0:i2:i64 2:i64
|
||||
%b0:i4:i32 = typecast %b0:i3:u1 to i32
|
||||
ret %b0:i4:i32
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
|
||||
fun i32 @main () {
|
||||
init:
|
||||
bid: b0
|
||||
allocations:
|
||||
%l0:i32:a
|
||||
%l1:*const i32:b
|
||||
|
||||
block b0:
|
||||
%b0:i0:unit = store 0:i32 %l0:*i32
|
||||
%b0:i1:i32 = load %l0:*i32
|
||||
%b0:i2:unit = store %l0:*i32 %l1:**const i32
|
||||
%b0:i3:*i32 = load %l1:**const i32
|
||||
%b0:i4:unit = store 1:i32 %b0:i3:*i32
|
||||
%b0:i5:*i32 = load %l1:**const i32
|
||||
%b0:i6:i32 = load %b0:i5:*i32
|
||||
ret %b0:i6:i32
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
|
||||
fun i32 @main () {
|
||||
init:
|
||||
bid: b0
|
||||
allocations:
|
||||
%l0:u8:temp
|
||||
|
||||
block b0:
|
||||
%b0:i0:u8 = typecast 0:i64 to u8
|
||||
%b0:i1:unit = store %b0:i0:u8 %l0:*u8
|
||||
%b0:i2:u8 = load %l0:*u8
|
||||
%b0:i3:u8 = sub %b0:i2:u8 1:u8
|
||||
%b0:i4:unit = store %b0:i3:u8 %l0:*u8
|
||||
%b0:i5:i32 = typecast %b0:i3:u8 to i32
|
||||
%b0:i6:u1 = cmp gt 1:i32 %b0:i5:i32
|
||||
%b0:i7:i32 = typecast %b0:i6:u1 to i32
|
||||
ret %b0:i7:i32
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
|
||||
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 b1()
|
||||
|
||||
block b1:
|
||||
%b1:i0:i32 = load %l1:*i32
|
||||
%b1:i1:u1 = cmp lt %b1:i0:i32 10:i32
|
||||
br %b1:i1:u1, b2(), b3()
|
||||
|
||||
block b2:
|
||||
%b2:i0:i32 = load %l1:*i32
|
||||
%b2:i1:u1 = cmp eq %b2:i0:i32 3:i32
|
||||
br %b2:i1:u1, b4(), b5()
|
||||
|
||||
block b3:
|
||||
%b3:i0:i32 = load %l0:*i32
|
||||
ret %b3:i0:i32
|
||||
|
||||
block b4:
|
||||
%b4:i0:i32 = load %l1:*i32
|
||||
%b4:i1:i32 = add %b4:i0:i32 1:i32
|
||||
%b4:i2:unit = store %b4:i1:i32 %l1:*i32
|
||||
j b1()
|
||||
|
||||
block b5:
|
||||
%b5:i0:i32 = load %l0:*i32
|
||||
%b5:i1:i32 = load %l1:*i32
|
||||
%b5:i2:i32 = add %b5:i0:i32 %b5:i1:i32
|
||||
%b5:i3:unit = store %b5:i2:i32 %l0:*i32
|
||||
%b5:i4:i32 = load %l1:*i32
|
||||
%b5:i5:i32 = add %b5:i4:i32 1:i32
|
||||
%b5:i6:unit = store %b5:i5:i32 %l1:*i32
|
||||
%b5:i7:i32 = load %l1:*i32
|
||||
%b5:i8:u1 = cmp eq %b5:i7:i32 5:i32
|
||||
br %b5:i8:u1, b3(), b1()
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
Loaded 100 of 258 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user