| // RUN: mlir-opt -split-input-file -test-liveness-analysis %s 2>&1 | FileCheck %s |
| |
| // Positive test: Type (1.a) "is an operand of an op with memory effects" |
| // zero is live because it is stored in memory. |
| // CHECK-LABEL: test_tag: zero: |
| // CHECK-NEXT: result #0: live |
| func.func @test_1_type_1.a(%arg0: memref<i32>) { |
| %c0_i32 = arith.constant {tag = "zero"} 0 : i32 |
| memref.store %c0_i32, %arg0[] : memref<i32> |
| return |
| } |
| |
| // ----- |
| |
| // Positive test: Type (1.b) "is a non-forwarded branch operand and a block |
| // where its op could take the control has an op with memory effects" |
| // %arg2 is live because it can make the control go into a block with a memory |
| // effecting op. |
| // CHECK-LABEL: test_tag: br: |
| // CHECK-NEXT: operand #0: live |
| // CHECK-NEXT: operand #1: live |
| // CHECK-NEXT: operand #2: live |
| func.func @test_2_RegionBranchOpInterface_type_1.b(%arg0: memref<i32>, %arg1: memref<i32>, %arg2: i1) { |
| %c0_i32 = arith.constant 0 : i32 |
| cf.cond_br %arg2, ^bb1(%c0_i32 : i32), ^bb2(%c0_i32 : i32) {tag = "br"} |
| ^bb1(%0 : i32): |
| memref.store %0, %arg0[] : memref<i32> |
| cf.br ^bb3 |
| ^bb2(%1 : i32): |
| memref.store %1, %arg1[] : memref<i32> |
| cf.br ^bb3 |
| ^bb3: |
| return |
| } |
| |
| // ----- |
| |
| // Positive test: Type (1.b) "is a non-forwarded branch operand and a block |
| // where its op could take the control has an op with memory effects" |
| // %arg0 is live because it can make the control go into a block with a memory |
| // effecting op. |
| // CHECK-LABEL: test_tag: flag: |
| // CHECK-NEXT: operand #0: live |
| func.func @test_3_BranchOpInterface_type_1.b(%arg0: i32, %arg1: memref<i32>, %arg2: memref<i32>) { |
| %c0_i32 = arith.constant 0 : i32 |
| cf.switch %arg0 : i32, [ |
| default: ^bb1, |
| 42: ^bb2 |
| ] {tag = "flag"} |
| ^bb1: |
| memref.store %c0_i32, %arg1[] : memref<i32> |
| cf.br ^bb3 |
| ^bb2: |
| memref.store %c0_i32, %arg2[] : memref<i32> |
| cf.br ^bb3 |
| ^bb3: |
| return |
| } |
| |
| // ----- |
| |
| func.func private @private(%arg0 : i32, %arg1 : i32) { |
| func.return |
| } |
| |
| // Positive test: Type (1.c) "is a non-forwarded call operand" |
| // CHECK-LABEL: test_tag: call |
| // CHECK-LABEL: operand #0: not live |
| // CHECK-LABEL: operand #1: not live |
| // CHECK-LABEL: operand #2: live |
| func.func @test_4_type_1.c(%arg0: i32, %arg1: i32, %device: i32, %m0: memref<i32>) { |
| test.call_on_device @private(%arg0, %arg1), %device {tag = "call"} : (i32, i32, i32) -> () |
| return |
| } |
| |
| // ----- |
| |
| // Positive test: Type (2) "is returned by a public function" |
| // zero is live because it is returned by a public function. |
| // CHECK-LABEL: test_tag: zero: |
| // CHECK-NEXT: result #0: live |
| func.func @test_5_type_2() -> (f32){ |
| %0 = arith.constant {tag = "zero"} 0.0 : f32 |
| return %0 : f32 |
| } |
| |
| // ----- |
| |
| // Positive test: Type (3) "is used to compute a value of type (1) or (2)" |
| // %arg1 is live because the scf.while has a live result and %arg1 is a |
| // non-forwarded branch operand. |
| // %arg2 is live because it is forwarded to the live result of the scf.while |
| // op. |
| // %arg5 is live because it is forwarded to %arg8 which is live. |
| // %arg8 is live because it is forwarded to %arg4 which is live as it writes |
| // to memory. |
| // Negative test: |
| // %arg3 is not live even though %arg1, %arg2, and %arg5 are live because it |
| // is neither a non-forwarded branch operand nor a forwarded operand that |
| // forwards to a live value. It actually is a forwarded operand that forwards |
| // to non-live values %0#1 and %arg7. |
| // CHECK-LABEL: test_tag: condition: |
| // CHECK-NEXT: operand #0: live |
| // CHECK-NEXT: operand #1: live |
| // CHECK-NEXT: operand #2: not live |
| // CHECK-NEXT: operand #3: live |
| // CHECK-LABEL: test_tag: add: |
| // CHECK-NEXT: operand #0: live |
| func.func @test_6_RegionBranchTerminatorOpInterface_type_3(%arg0: memref<i32>, %arg1: i1) -> (i32) { |
| %c0_i32 = arith.constant 0 : i32 |
| %c1_i32 = arith.constant 1 : i32 |
| %c2_i32 = arith.constant 2 : i32 |
| %0:3 = scf.while (%arg2 = %c0_i32, %arg3 = %c1_i32, %arg4 = %c2_i32, %arg5 = %c2_i32) : (i32, i32, i32, i32) -> (i32, i32, i32) { |
| memref.store %arg4, %arg0[] : memref<i32> |
| scf.condition(%arg1) {tag = "condition"} %arg2, %arg3, %arg5 : i32, i32, i32 |
| } do { |
| ^bb0(%arg6: i32, %arg7: i32, %arg8: i32): |
| %1 = arith.addi %arg8, %arg8 {tag = "add"} : i32 |
| %c3_i32 = arith.constant 3 : i32 |
| scf.yield %arg6, %arg7, %arg8, %c3_i32 : i32, i32, i32, i32 |
| } |
| return %0#0 : i32 |
| } |
| |
| // ----- |
| |
| func.func private @private0(%0 : i32) -> i32 { |
| %1 = arith.addi %0, %0 {tag = "in_private0"} : i32 |
| func.return %1 : i32 |
| } |
| |
| // Positive test: Type (3) "is used to compute a value of type (1) or (2)" |
| // zero, ten, and one are live because they are used to decide the number of |
| // times the `for` loop executes, which in turn decides the value stored in |
| // memory. |
| // in_private0 and x are also live because they decide the value stored in |
| // memory. |
| // Negative test: |
| // y is not live even though the non-forwarded branch operand and x are live. |
| // CHECK-LABEL: test_tag: in_private0: |
| // CHECK-NEXT: operand #0: live |
| // CHECK-NEXT: operand #1: live |
| // CHECK-NEXT: result #0: live |
| // CHECK-LABEL: test_tag: zero: |
| // CHECK-NEXT: result #0: live |
| // CHECK-LABEL: test_tag: ten: |
| // CHECK-NEXT: result #0: live |
| // CHECK-LABEL: test_tag: one: |
| // CHECK-NEXT: result #0: live |
| // CHECK-LABEL: test_tag: x: |
| // CHECK-NEXT: result #0: live |
| // CHECK-LABEL: test_tag: y: |
| // CHECK-NEXT: result #0: not live |
| func.func @test_7_type_3(%arg0: memref<i32>) { |
| %c0 = arith.constant {tag = "zero"} 0 : index |
| %c10 = arith.constant {tag = "ten"} 10 : index |
| %c1 = arith.constant {tag = "one"} 1 : index |
| %x = arith.constant {tag = "x"} 0 : i32 |
| %y = arith.constant {tag = "y"} 1 : i32 |
| %0:2 = scf.for %arg1 = %c0 to %c10 step %c1 iter_args(%arg2 = %x, %arg3 = %y) -> (i32, i32) { |
| %1 = arith.addi %x, %x : i32 |
| %2 = func.call @private0(%1) : (i32) -> i32 |
| scf.yield %2, %arg3 : i32, i32 |
| } |
| memref.store %0#0, %arg0[] : memref<i32> |
| return |
| } |
| |
| // ----- |
| |
| func.func private @private1(%0 : i32) -> i32 { |
| %1 = func.call @private2(%0) : (i32) -> i32 |
| %2 = arith.muli %0, %1 {tag = "in_private1"} : i32 |
| func.return %2 : i32 |
| } |
| |
| func.func private @private2(%0 : i32) -> i32 { |
| %cond = arith.index_cast %0 {tag = "in_private2"} : i32 to index |
| %1 = scf.index_switch %cond -> i32 |
| case 1 { |
| %ten = arith.constant 10 : i32 |
| scf.yield %ten : i32 |
| } |
| case 2 { |
| %twenty = arith.constant 20 : i32 |
| scf.yield %twenty : i32 |
| } |
| default { |
| %thirty = arith.constant 30 : i32 |
| scf.yield %thirty : i32 |
| } |
| func.return %1 : i32 |
| } |
| |
| // Positive test: Type (3) "is used to compute a value of type (1) or (2)" |
| // in_private1, in_private2, and final are live because they are used to compute |
| // the value returned by this public function. |
| // CHECK-LABEL: test_tag: in_private1: |
| // CHECK-NEXT: operand #0: live |
| // CHECK-NEXT: operand #1: live |
| // CHECK-NEXT: result #0: live |
| // CHECK-LABEL: test_tag: in_private2: |
| // CHECK-NEXT: operand #0: live |
| // CHECK-NEXT: result #0: live |
| // CHECK-LABEL: test_tag: final: |
| // CHECK-NEXT: operand #0: live |
| // CHECK-NEXT: operand #1: live |
| // CHECK-NEXT: result #0: live |
| func.func @test_8_type_3(%arg: i32) -> (i32) { |
| %0 = func.call @private1(%arg) : (i32) -> i32 |
| %final = arith.muli %0, %arg {tag = "final"} : i32 |
| return %final : i32 |
| } |
| |
| // ----- |
| |
| // Negative test: None of the types (1), (2), or (3) |
| // zero is not live because it has no effect outside the program: it doesn't |
| // affect the memory or the program output. |
| // CHECK-LABEL: test_tag: zero: |
| // CHECK-NEXT: result #0: not live |
| // CHECK-LABEL: test_tag: one: |
| // CHECK-NEXT: result #0: live |
| func.func @test_9_negative() -> (f32){ |
| %0 = arith.constant {tag = "zero"} 0.0 : f32 |
| %1 = arith.constant {tag = "one"} 1.0 : f32 |
| return %1 : f32 |
| } |
| |
| // ----- |
| |
| // Negative test: None of the types (1), (2), or (3) |
| // %1 is not live because it has no effect outside the program: it doesn't |
| // affect the memory or the program output. Even though it is returned by the |
| // function `@private_1`, it is never used by the caller. |
| // Note that this test clearly shows how this liveness analysis utility differs |
| // from the existing liveness utility present at |
| // llvm-project/mlir/include/mlir/Analysis/Liveness.h. The latter marks %1 as |
| // live as it exists the block of function `@private_1`, simply because it is |
| // computed inside and returned by the block, irrespective of whether or not it |
| // is used by the caller. |
| // CHECK-LABEL: test_tag: one: |
| // CHECK: result #0: not live |
| func.func private @private_1() -> (i32, i32) { |
| %0 = arith.constant 0 : i32 |
| %1 = arith.addi %0, %0 {tag = "one"} : i32 |
| return %0, %1 : i32, i32 |
| } |
| func.func @test_10_negative() -> (i32) { |
| %0:2 = func.call @private_1() : () -> (i32, i32) |
| return %0#0 : i32 |
| } |