================
@@ -0,0 +1,196 @@
+// RUN: cir-opt -cir-canonicalize -cir-simplify -o %t.cir %s
+// RUN: FileCheck --input-file=%t.cir %s
+
+!s32i = !cir.int<s, 32>
+
+module {
+ cir.func @foldCascade(%arg0: !s32i) {
+ %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
+ cir.scope {
+ %1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+ cir.switch (%1 : !s32i) {
+ cir.case(equal, [#cir.int<1> : !s32i]) {
+ cir.yield
+ }
+ cir.case(equal, [#cir.int<2> : !s32i]) {
+ cir.yield
+ }
+ cir.case(equal, [#cir.int<3> : !s32i]) {
+ %2 = cir.const #cir.int<2> : !s32i
+ cir.store %2, %0 : !s32i, !cir.ptr<!s32i>
+ cir.break
+ }
+ cir.yield
+ }
+ }
+ cir.return
+ }
+ //CHECK: cir.func @foldCascade
+ //CHECK: cir.switch (%[[COND:.*]] : !s32i) {
+ //CHECK-NEXT: cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i,
#cir.int<3> : !s32i]) {
+ //CHECK-NEXT: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
+ //CHECK-NEXT: cir.store %[[TWO]], %[[ARG0:.*]] : !s32i, !cir.ptr<!s32i>
+ //CHECK-NEXT: cir.break
+ //CHECK-NEXT: }
+ //CHECK-NEXT: cir.yield
+ //CHECK-NEXT: }
+
+ cir.func @foldCascade2(%arg0: !s32i) {
+ %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
+ cir.scope {
+ %1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+ cir.switch (%1 : !s32i) {
+ cir.case(equal, [#cir.int<0> : !s32i]) {
----------------
andykaylor wrote:
I'd like to see a test case where the values aren't continuous. For instance,
0, 2, and 4 in one group and 1, 3, and 5 in another. This doesn't need to be a
new test case. You could modify this one. The point is just to verify that the
values aren't required to be in sequence.
https://github.com/llvm/llvm-project/pull/140649
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
