e7790fbed3
This new option is set to `false` by default. It should be set only in Canonicalizer tests to detect faulty canonicalization patterns. I.e., patterns that prevent the canonicalizer from converging. The canonicalizer should always convergence on such small unit tests that we have in `canonicalize.mlir`. Two faulty canonicalization patterns were detected and fixed with this change. Differential Revision: https://reviews.llvm.org/D140873
468 lines
14 KiB
MLIR
468 lines
14 KiB
MLIR
// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='builtin.module(func.func(canonicalize{test-convergence}))' -split-input-file | FileCheck --dump-input-context 20 %s
|
|
|
|
/// Test the folding of BranchOp.
|
|
|
|
// CHECK-LABEL: func @br_folding(
|
|
func.func @br_folding() -> i32 {
|
|
// CHECK-NEXT: %[[CST:.*]] = arith.constant 0 : i32
|
|
// CHECK-NEXT: return %[[CST]] : i32
|
|
%c0_i32 = arith.constant 0 : i32
|
|
cf.br ^bb1(%c0_i32 : i32)
|
|
^bb1(%x : i32):
|
|
return %x : i32
|
|
}
|
|
|
|
/// Test that pass-through successors of BranchOp get folded.
|
|
|
|
// CHECK-LABEL: func @br_passthrough(
|
|
// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32
|
|
func.func @br_passthrough(%arg0 : i32, %arg1 : i32) -> (i32, i32) {
|
|
"foo.switch"() [^bb1, ^bb2, ^bb3] : () -> ()
|
|
|
|
^bb1:
|
|
// CHECK: ^bb1:
|
|
// CHECK-NEXT: cf.br ^bb3(%[[ARG0]], %[[ARG1]] : i32, i32)
|
|
|
|
cf.br ^bb2(%arg0 : i32)
|
|
|
|
^bb2(%arg2 : i32):
|
|
cf.br ^bb3(%arg2, %arg1 : i32, i32)
|
|
|
|
^bb3(%arg4 : i32, %arg5 : i32):
|
|
return %arg4, %arg5 : i32, i32
|
|
}
|
|
|
|
/// Test the folding of CondBranchOp with a constant condition.
|
|
|
|
// CHECK-LABEL: func @cond_br_folding(
|
|
func.func @cond_br_folding(%cond : i1, %a : i32) {
|
|
// CHECK-NEXT: return
|
|
|
|
%false_cond = arith.constant false
|
|
%true_cond = arith.constant true
|
|
cf.cond_br %cond, ^bb1, ^bb2(%a : i32)
|
|
|
|
^bb1:
|
|
cf.cond_br %true_cond, ^bb3, ^bb2(%a : i32)
|
|
|
|
^bb2(%x : i32):
|
|
cf.cond_br %false_cond, ^bb2(%x : i32), ^bb3
|
|
|
|
^bb3:
|
|
return
|
|
}
|
|
|
|
/// Test the folding of CondBranchOp when the successors are identical.
|
|
|
|
// CHECK-LABEL: func @cond_br_same_successor(
|
|
func.func @cond_br_same_successor(%cond : i1, %a : i32) {
|
|
// CHECK-NEXT: return
|
|
|
|
cf.cond_br %cond, ^bb1(%a : i32), ^bb1(%a : i32)
|
|
|
|
^bb1(%result : i32):
|
|
return
|
|
}
|
|
|
|
/// Test the folding of CondBranchOp when the successors are identical, but the
|
|
/// arguments are different.
|
|
|
|
// CHECK-LABEL: func @cond_br_same_successor_insert_select(
|
|
// CHECK-SAME: %[[COND:.*]]: i1, %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32
|
|
// CHECK-SAME: %[[ARG2:.*]]: tensor<2xi32>, %[[ARG3:.*]]: tensor<2xi32>
|
|
func.func @cond_br_same_successor_insert_select(
|
|
%cond : i1, %a : i32, %b : i32, %c : tensor<2xi32>, %d : tensor<2xi32>
|
|
) -> (i32, tensor<2xi32>) {
|
|
// CHECK: %[[RES:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG1]]
|
|
// CHECK: %[[RES2:.*]] = arith.select %[[COND]], %[[ARG2]], %[[ARG3]]
|
|
// CHECK: return %[[RES]], %[[RES2]]
|
|
|
|
cf.cond_br %cond, ^bb1(%a, %c : i32, tensor<2xi32>), ^bb1(%b, %d : i32, tensor<2xi32>)
|
|
|
|
^bb1(%result : i32, %result2 : tensor<2xi32>):
|
|
return %result, %result2 : i32, tensor<2xi32>
|
|
}
|
|
|
|
/// Test the compound folding of BranchOp and CondBranchOp.
|
|
|
|
// CHECK-LABEL: func @cond_br_and_br_folding(
|
|
func.func @cond_br_and_br_folding(%a : i32) {
|
|
// CHECK-NEXT: return
|
|
|
|
%false_cond = arith.constant false
|
|
%true_cond = arith.constant true
|
|
cf.cond_br %true_cond, ^bb2, ^bb1(%a : i32)
|
|
|
|
^bb1(%x : i32):
|
|
cf.cond_br %false_cond, ^bb1(%x : i32), ^bb2
|
|
|
|
^bb2:
|
|
return
|
|
}
|
|
|
|
/// Test that pass-through successors of CondBranchOp get folded.
|
|
|
|
// CHECK-LABEL: func @cond_br_passthrough(
|
|
// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32, %[[ARG2:.*]]: i32, %[[COND:.*]]: i1
|
|
func.func @cond_br_passthrough(%arg0 : i32, %arg1 : i32, %arg2 : i32, %cond : i1) -> (i32, i32) {
|
|
// CHECK: %[[RES:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG2]]
|
|
// CHECK: %[[RES2:.*]] = arith.select %[[COND]], %[[ARG1]], %[[ARG2]]
|
|
// CHECK: return %[[RES]], %[[RES2]]
|
|
|
|
cf.cond_br %cond, ^bb1(%arg0 : i32), ^bb2(%arg2, %arg2 : i32, i32)
|
|
|
|
^bb1(%arg3: i32):
|
|
cf.br ^bb2(%arg3, %arg1 : i32, i32)
|
|
|
|
^bb2(%arg4: i32, %arg5: i32):
|
|
return %arg4, %arg5 : i32, i32
|
|
}
|
|
|
|
/// Test the failure modes of collapsing CondBranchOp pass-throughs successors.
|
|
|
|
// CHECK-LABEL: func @cond_br_pass_through_fail(
|
|
func.func @cond_br_pass_through_fail(%cond : i1) {
|
|
// CHECK: cf.cond_br %{{.*}}, ^bb1, ^bb2
|
|
|
|
cf.cond_br %cond, ^bb1, ^bb2
|
|
|
|
^bb1:
|
|
// CHECK: ^bb1:
|
|
// CHECK: "foo.op"
|
|
// CHECK: cf.br ^bb2
|
|
|
|
// Successors can't be collapsed if they contain other operations.
|
|
"foo.op"() : () -> ()
|
|
cf.br ^bb2
|
|
|
|
^bb2:
|
|
return
|
|
}
|
|
|
|
|
|
/// Test the folding of SwitchOp
|
|
|
|
// CHECK-LABEL: func @switch_only_default(
|
|
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
|
|
func.func @switch_only_default(%flag : i32, %caseOperand0 : f32) {
|
|
// add predecessors for all blocks to avoid other canonicalizations.
|
|
"foo.pred"() [^bb1, ^bb2] : () -> ()
|
|
^bb1:
|
|
// CHECK-NOT: cf.switch
|
|
// CHECK: cf.br ^[[BB2:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
|
|
cf.switch %flag : i32, [
|
|
default: ^bb2(%caseOperand0 : f32)
|
|
]
|
|
// CHECK: ^[[BB2]]({{.*}}):
|
|
^bb2(%bb2Arg : f32):
|
|
// CHECK-NEXT: "foo.bb2Terminator"
|
|
"foo.bb2Terminator"(%bb2Arg) : (f32) -> ()
|
|
}
|
|
|
|
|
|
// CHECK-LABEL: func @switch_case_matching_default(
|
|
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
|
|
func.func @switch_case_matching_default(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32) {
|
|
// add predecessors for all blocks to avoid other canonicalizations.
|
|
"foo.pred"() [^bb1, ^bb2, ^bb3] : () -> ()
|
|
^bb1:
|
|
// CHECK: cf.switch %[[FLAG]]
|
|
// CHECK-NEXT: default: ^[[BB1:.+]](%[[CASE_OPERAND_0]] : f32)
|
|
// CHECK-NEXT: 10: ^[[BB2:.+]](%[[CASE_OPERAND_1]] : f32)
|
|
// CHECK-NEXT: ]
|
|
cf.switch %flag : i32, [
|
|
default: ^bb2(%caseOperand0 : f32),
|
|
42: ^bb2(%caseOperand0 : f32),
|
|
10: ^bb3(%caseOperand1 : f32),
|
|
17: ^bb2(%caseOperand0 : f32)
|
|
]
|
|
^bb2(%bb2Arg : f32):
|
|
"foo.bb2Terminator"(%bb2Arg) : (f32) -> ()
|
|
^bb3(%bb3Arg : f32):
|
|
"foo.bb3Terminator"(%bb3Arg) : (f32) -> ()
|
|
}
|
|
|
|
|
|
// CHECK-LABEL: func @switch_on_const_no_match(
|
|
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
|
|
func.func @switch_on_const_no_match(%caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) {
|
|
// add predecessors for all blocks to avoid other canonicalizations.
|
|
"foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4] : () -> ()
|
|
^bb1:
|
|
// CHECK-NOT: cf.switch
|
|
// CHECK: cf.br ^[[BB2:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
|
|
%c0_i32 = arith.constant 0 : i32
|
|
cf.switch %c0_i32 : i32, [
|
|
default: ^bb2(%caseOperand0 : f32),
|
|
-1: ^bb3(%caseOperand1 : f32),
|
|
1: ^bb4(%caseOperand2 : f32)
|
|
]
|
|
// CHECK: ^[[BB2]]({{.*}}):
|
|
// CHECK-NEXT: "foo.bb2Terminator"
|
|
^bb2(%bb2Arg : f32):
|
|
"foo.bb2Terminator"(%bb2Arg) : (f32) -> ()
|
|
^bb3(%bb3Arg : f32):
|
|
"foo.bb3Terminator"(%bb3Arg) : (f32) -> ()
|
|
^bb4(%bb4Arg : f32):
|
|
"foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
|
|
}
|
|
|
|
// CHECK-LABEL: func @switch_on_const_with_match(
|
|
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
|
|
func.func @switch_on_const_with_match(%caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) {
|
|
// add predecessors for all blocks to avoid other canonicalizations.
|
|
"foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4] : () -> ()
|
|
^bb1:
|
|
// CHECK-NOT: cf.switch
|
|
// CHECK: cf.br ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]]
|
|
%c0_i32 = arith.constant 1 : i32
|
|
cf.switch %c0_i32 : i32, [
|
|
default: ^bb2(%caseOperand0 : f32),
|
|
-1: ^bb3(%caseOperand1 : f32),
|
|
1: ^bb4(%caseOperand2 : f32)
|
|
]
|
|
^bb2(%bb2Arg : f32):
|
|
"foo.bb2Terminator"(%bb2Arg) : (f32) -> ()
|
|
^bb3(%bb3Arg : f32):
|
|
"foo.bb3Terminator"(%bb3Arg) : (f32) -> ()
|
|
// CHECK: ^[[BB4]]({{.*}}):
|
|
// CHECK-NEXT: "foo.bb4Terminator"
|
|
^bb4(%bb4Arg : f32):
|
|
"foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
|
|
}
|
|
|
|
// CHECK-LABEL: func @switch_passthrough(
|
|
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_3:[a-zA-Z0-9_]+]]
|
|
func.func @switch_passthrough(%flag : i32,
|
|
%caseOperand0 : f32,
|
|
%caseOperand1 : f32,
|
|
%caseOperand2 : f32,
|
|
%caseOperand3 : f32) {
|
|
// add predecessors for all blocks to avoid other canonicalizations.
|
|
"foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4, ^bb5, ^bb6] : () -> ()
|
|
|
|
^bb1:
|
|
// CHECK: cf.switch %[[FLAG]]
|
|
// CHECK-NEXT: default: ^[[BB5:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
|
|
// CHECK-NEXT: 43: ^[[BB6:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_1]]
|
|
// CHECK-NEXT: 44: ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]]
|
|
// CHECK-NEXT: ]
|
|
cf.switch %flag : i32, [
|
|
default: ^bb2(%caseOperand0 : f32),
|
|
43: ^bb3(%caseOperand1 : f32),
|
|
44: ^bb4(%caseOperand2 : f32)
|
|
]
|
|
^bb2(%bb2Arg : f32):
|
|
cf.br ^bb5(%bb2Arg : f32)
|
|
^bb3(%bb3Arg : f32):
|
|
cf.br ^bb6(%bb3Arg : f32)
|
|
^bb4(%bb4Arg : f32):
|
|
"foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
|
|
|
|
// CHECK: ^[[BB5]]({{.*}}):
|
|
// CHECK-NEXT: "foo.bb5Terminator"
|
|
^bb5(%bb5Arg : f32):
|
|
"foo.bb5Terminator"(%bb5Arg) : (f32) -> ()
|
|
|
|
// CHECK: ^[[BB6]]({{.*}}):
|
|
// CHECK-NEXT: "foo.bb6Terminator"
|
|
^bb6(%bb6Arg : f32):
|
|
"foo.bb6Terminator"(%bb6Arg) : (f32) -> ()
|
|
}
|
|
|
|
// CHECK-LABEL: func @switch_from_switch_with_same_value_with_match(
|
|
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
|
|
func.func @switch_from_switch_with_same_value_with_match(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32) {
|
|
// add predecessors for all blocks except ^bb3 to avoid other canonicalizations.
|
|
"foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5] : () -> ()
|
|
|
|
^bb1:
|
|
// CHECK: cf.switch %[[FLAG]]
|
|
cf.switch %flag : i32, [
|
|
default: ^bb2,
|
|
42: ^bb3
|
|
]
|
|
|
|
^bb2:
|
|
"foo.bb2Terminator"() : () -> ()
|
|
^bb3:
|
|
// prevent this block from being simplified away
|
|
"foo.op"() : () -> ()
|
|
// CHECK-NOT: cf.switch %[[FLAG]]
|
|
// CHECK: cf.br ^[[BB5:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_1]]
|
|
cf.switch %flag : i32, [
|
|
default: ^bb4(%caseOperand0 : f32),
|
|
42: ^bb5(%caseOperand1 : f32)
|
|
]
|
|
|
|
^bb4(%bb4Arg : f32):
|
|
"foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
|
|
|
|
// CHECK: ^[[BB5]]({{.*}}):
|
|
// CHECK-NEXT: "foo.bb5Terminator"
|
|
^bb5(%bb5Arg : f32):
|
|
"foo.bb5Terminator"(%bb5Arg) : (f32) -> ()
|
|
}
|
|
|
|
// CHECK-LABEL: func @switch_from_switch_with_same_value_no_match(
|
|
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
|
|
func.func @switch_from_switch_with_same_value_no_match(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) {
|
|
// add predecessors for all blocks except ^bb3 to avoid other canonicalizations.
|
|
"foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5, ^bb6] : () -> ()
|
|
|
|
^bb1:
|
|
// CHECK: cf.switch %[[FLAG]]
|
|
cf.switch %flag : i32, [
|
|
default: ^bb2,
|
|
42: ^bb3
|
|
]
|
|
|
|
^bb2:
|
|
"foo.bb2Terminator"() : () -> ()
|
|
^bb3:
|
|
"foo.op"() : () -> ()
|
|
// CHECK-NOT: cf.switch %[[FLAG]]
|
|
// CHECK: cf.br ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
|
|
cf.switch %flag : i32, [
|
|
default: ^bb4(%caseOperand0 : f32),
|
|
0: ^bb5(%caseOperand1 : f32),
|
|
43: ^bb6(%caseOperand2 : f32)
|
|
]
|
|
|
|
// CHECK: ^[[BB4]]({{.*}})
|
|
// CHECK-NEXT: "foo.bb4Terminator"
|
|
^bb4(%bb4Arg : f32):
|
|
"foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
|
|
|
|
^bb5(%bb5Arg : f32):
|
|
"foo.bb5Terminator"(%bb5Arg) : (f32) -> ()
|
|
|
|
^bb6(%bb6Arg : f32):
|
|
"foo.bb6Terminator"(%bb6Arg) : (f32) -> ()
|
|
}
|
|
|
|
// CHECK-LABEL: func @switch_from_switch_default_with_same_value(
|
|
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
|
|
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
|
|
func.func @switch_from_switch_default_with_same_value(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) {
|
|
// add predecessors for all blocks except ^bb3 to avoid other canonicalizations.
|
|
"foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5, ^bb6] : () -> ()
|
|
|
|
^bb1:
|
|
// CHECK: cf.switch %[[FLAG]]
|
|
cf.switch %flag : i32, [
|
|
default: ^bb3,
|
|
42: ^bb2
|
|
]
|
|
|
|
^bb2:
|
|
"foo.bb2Terminator"() : () -> ()
|
|
^bb3:
|
|
"foo.op"() : () -> ()
|
|
// CHECK: cf.switch %[[FLAG]]
|
|
// CHECK-NEXT: default: ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
|
|
// CHECK-NEXT: 43: ^[[BB6:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]]
|
|
// CHECK-NOT: 42
|
|
cf.switch %flag : i32, [
|
|
default: ^bb4(%caseOperand0 : f32),
|
|
42: ^bb5(%caseOperand1 : f32),
|
|
43: ^bb6(%caseOperand2 : f32)
|
|
]
|
|
|
|
// CHECK: ^[[BB4]]({{.*}}):
|
|
// CHECK-NEXT: "foo.bb4Terminator"
|
|
^bb4(%bb4Arg : f32):
|
|
"foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
|
|
|
|
^bb5(%bb5Arg : f32):
|
|
"foo.bb5Terminator"(%bb5Arg) : (f32) -> ()
|
|
|
|
// CHECK: ^[[BB6]]({{.*}}):
|
|
// CHECK-NEXT: "foo.bb6Terminator"
|
|
^bb6(%bb6Arg : f32):
|
|
"foo.bb6Terminator"(%bb6Arg) : (f32) -> ()
|
|
}
|
|
|
|
/// Test folding conditional branches that are successors of conditional
|
|
/// branches with the same condition.
|
|
|
|
// CHECK-LABEL: func @cond_br_from_cond_br_with_same_condition
|
|
func.func @cond_br_from_cond_br_with_same_condition(%cond : i1) {
|
|
// CHECK: cf.cond_br %{{.*}}, ^bb1, ^bb2
|
|
// CHECK: ^bb1:
|
|
// CHECK: return
|
|
|
|
cf.cond_br %cond, ^bb1, ^bb2
|
|
|
|
^bb1:
|
|
cf.cond_br %cond, ^bb3, ^bb2
|
|
|
|
^bb2:
|
|
"foo.terminator"() : () -> ()
|
|
|
|
^bb3:
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// Erase assertion if condition is known to be true at compile time.
|
|
// CHECK-LABEL: @assert_true
|
|
func.func @assert_true() {
|
|
// CHECK-NOT: cf.assert
|
|
%true = arith.constant true
|
|
cf.assert %true, "Computer says no"
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// Keep assertion if condition unknown at compile time.
|
|
// CHECK-LABEL: @cf.assert
|
|
// CHECK-SAME: (%[[ARG:.*]]: i1)
|
|
func.func @cf.assert(%arg : i1) {
|
|
// CHECK: cf.assert %[[ARG]], "Computer says no"
|
|
cf.assert %arg, "Computer says no"
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: @branchCondProp
|
|
// CHECK: %[[trueval:.+]] = arith.constant true
|
|
// CHECK: %[[falseval:.+]] = arith.constant false
|
|
// CHECK: "test.consumer1"(%[[trueval]]) : (i1) -> ()
|
|
// CHECK: "test.consumer2"(%[[falseval]]) : (i1) -> ()
|
|
func.func @branchCondProp(%arg0: i1) {
|
|
cf.cond_br %arg0, ^trueB, ^falseB
|
|
|
|
^trueB:
|
|
"test.consumer1"(%arg0) : (i1) -> ()
|
|
cf.br ^exit
|
|
|
|
^falseB:
|
|
"test.consumer2"(%arg0) : (i1) -> ()
|
|
cf.br ^exit
|
|
|
|
^exit:
|
|
return
|
|
}
|