diff --git a/clang/include/clang/CIR/MissingFeatures.h b/clang/include/clang/CIR/MissingFeatures.h index 484822c351746..9f3e5d007d66c 100644 --- a/clang/include/clang/CIR/MissingFeatures.h +++ b/clang/include/clang/CIR/MissingFeatures.h @@ -114,7 +114,6 @@ struct MissingFeatures { static bool opUnaryPromotionType() { return false; } // SwitchOp handling - static bool foldCascadingCases() { return false; } static bool foldRangeCase() { return false; } // Clang early optimizations or things defered to LLVM lowering. diff --git a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp index cc96e65e4ce1d..7f1ecbda414bd 100644 --- a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp @@ -531,12 +531,6 @@ mlir::LogicalResult CIRGenFunction::emitCaseStmt(const CaseStmt &s, value = builder.getArrayAttr({cir::IntAttr::get(condType, intVal), cir::IntAttr::get(condType, endVal)}); kind = cir::CaseOpKind::Range; - - // We don't currently fold case range statements with other case statements. - // TODO(cir): Add this capability. Folding these cases is going to be - // implemented in CIRSimplify when it is upstreamed. - assert(!cir::MissingFeatures::foldRangeCase()); - assert(!cir::MissingFeatures::foldCascadingCases()); } else { value = builder.getArrayAttr({cir::IntAttr::get(condType, intVal)}); kind = cir::CaseOpKind::Equal; diff --git a/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp b/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp index b969569b0081c..67ed4124f26cc 100644 --- a/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp +++ b/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp @@ -159,6 +159,107 @@ struct SimplifySelect : public OpRewritePattern { } }; +/// Simplify `cir.switch` operations by folding cascading cases +/// into a single `cir.case` with the `anyof` kind. +/// +/// This pattern identifies cascading cases within a `cir.switch` operation. +/// Cascading cases are defined as consecutive `cir.case` operations of kind +/// `equal`, each containing a single `cir.yield` operation in their body. +/// +/// The pattern merges these cascading cases into a single `cir.case` operation +/// with kind `anyof`, aggregating all the case values. +/// +/// The merging process continues until a `cir.case` with a different body +/// (e.g., containing `cir.break` or compound stmt) is encountered, which +/// breaks the chain. +/// +/// Example: +/// +/// Before: +/// cir.case equal, [#cir.int<0> : !s32i] { +/// cir.yield +/// } +/// cir.case equal, [#cir.int<1> : !s32i] { +/// cir.yield +/// } +/// cir.case equal, [#cir.int<2> : !s32i] { +/// cir.break +/// } +/// +/// After applying SimplifySwitch: +/// cir.case anyof, [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : +/// !s32i] { +/// cir.break +/// } +struct SimplifySwitch : public OpRewritePattern { + using OpRewritePattern::OpRewritePattern; + LogicalResult matchAndRewrite(SwitchOp op, + PatternRewriter &rewriter) const override { + + LogicalResult changed = mlir::failure(); + SmallVector cases; + SmallVector cascadingCases; + SmallVector cascadingCaseValues; + + op.collectCases(cases); + if (cases.empty()) + return mlir::failure(); + + auto flushMergedOps = [&]() { + for (CaseOp &c : cascadingCases) + rewriter.eraseOp(c); + cascadingCases.clear(); + cascadingCaseValues.clear(); + }; + + auto mergeCascadingInto = [&](CaseOp &target) { + rewriter.modifyOpInPlace(target, [&]() { + target.setValueAttr(rewriter.getArrayAttr(cascadingCaseValues)); + target.setKind(CaseOpKind::Anyof); + }); + changed = mlir::success(); + }; + + for (CaseOp c : cases) { + cir::CaseOpKind kind = c.getKind(); + if (kind == cir::CaseOpKind::Equal && + isa(c.getCaseRegion().front().front())) { + // If the case contains only a YieldOp, collect it for cascading merge + cascadingCases.push_back(c); + cascadingCaseValues.push_back(c.getValue()[0]); + } else if (kind == cir::CaseOpKind::Equal && !cascadingCases.empty()) { + // merge previously collected cascading cases + cascadingCaseValues.push_back(c.getValue()[0]); + mergeCascadingInto(c); + flushMergedOps(); + } else if (kind != cir::CaseOpKind::Equal && cascadingCases.size() > 1) { + // If a Default, Anyof or Range case is found and there are previous + // cascading cases, merge all of them into the last cascading case. + // We don't currently fold case range statements with other case + // statements. + assert(!cir::MissingFeatures::foldRangeCase()); + CaseOp lastCascadingCase = cascadingCases.back(); + mergeCascadingInto(lastCascadingCase); + cascadingCases.pop_back(); + flushMergedOps(); + } else { + cascadingCases.clear(); + cascadingCaseValues.clear(); + } + } + + // Edge case: all cases are simple cascading cases + if (cascadingCases.size() == cases.size()) { + CaseOp lastCascadingCase = cascadingCases.back(); + mergeCascadingInto(lastCascadingCase); + cascadingCases.pop_back(); + flushMergedOps(); + } + + return changed; + } +}; + //===----------------------------------------------------------------------===// // CIRSimplifyPass //===----------------------------------------------------------------------===// @@ -173,7 +274,8 @@ void populateMergeCleanupPatterns(RewritePatternSet &patterns) { // clang-format off patterns.add< SimplifyTernary, - SimplifySelect + SimplifySelect, + SimplifySwitch >(patterns.getContext()); // clang-format on } @@ -186,7 +288,7 @@ void CIRSimplifyPass::runOnOperation() { // Collect operations to apply patterns. llvm::SmallVector ops; getOperation()->walk([&](Operation *op) { - if (isa(op)) + if (isa(op)) ops.push_back(op); }); diff --git a/clang/test/CIR/Transforms/switch-fold.cir b/clang/test/CIR/Transforms/switch-fold.cir new file mode 100644 index 0000000000000..62a94f4fde2c3 --- /dev/null +++ b/clang/test/CIR/Transforms/switch-fold.cir @@ -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 + +module { + cir.func @foldCascade(%arg0: !s32i) { + %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} + cir.store %arg0, %0 : !s32i, !cir.ptr + cir.scope { + %1 = cir.load %0 : !cir.ptr, !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 + 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 + //CHECK-NEXT: cir.break + //CHECK-NEXT: } + //CHECK-NEXT: cir.yield + //CHECK-NEXT: } + + cir.func @foldCascade2(%arg0: !s32i) { + %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} + cir.store %arg0, %0 : !s32i, !cir.ptr + cir.scope { + %1 = cir.load %0 : !cir.ptr, !s32i + cir.switch (%1 : !s32i) { + cir.case(equal, [#cir.int<0> : !s32i]) { + cir.yield + } + cir.case(equal, [#cir.int<2> : !s32i]) { + cir.yield + } + cir.case(equal, [#cir.int<4> : !s32i]) { + cir.break + } + cir.case(equal, [#cir.int<1> : !s32i]) { + cir.yield + } + cir.case(equal, [#cir.int<3> : !s32i]) { + cir.yield + } + cir.case(equal, [#cir.int<5> : !s32i]) { + cir.break + } + cir.yield + } + } + cir.return + } + //CHECK: @foldCascade2 + //CHECK: cir.switch (%[[COND2:.*]] : !s32i) { + //CHECK: cir.case(anyof, [#cir.int<0> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i]) { + //CHECK: cir.break + //cehck: } + //CHECK: cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i]) { + //CHECK: cir.break + //CHECK: } + //CHECK: cir.yield + //CHECK: } + cir.func @foldCascade3(%arg0: !s32i ) { + %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} + cir.store %arg0, %0 : !s32i, !cir.ptr + cir.scope { + %1 = cir.alloca !s32i, !cir.ptr, ["x"] {alignment = 4 : i64} + %2 = cir.load %0 : !cir.ptr, !s32i + cir.switch (%2 : !s32i) { + cir.case(equal, [#cir.int<0> : !s32i]) { + cir.yield + } + 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]) { + cir.yield + } + cir.case(equal, [#cir.int<4> : !s32i]) { + cir.yield + } + cir.case(equal, [#cir.int<5> : !s32i]) { + cir.break + } + cir.yield + } + } + cir.return + } + //CHECK: cir.func @foldCascade3 + //CHECK: cir.switch (%[[COND3:.*]] : !s32i) { + //CHECK: cir.case(anyof, [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i, #cir.int<5> : !s32i]) { + //CHECK: cir.break + //CHECK: } + //CHECK: cir.yield + //CHECK: } + cir.func @foldCascadeWithDefault(%arg0: !s32i ) { + %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} + cir.store %arg0, %0 : !s32i, !cir.ptr + cir.scope { + %1 = cir.load %0 : !cir.ptr, !s32i + cir.switch (%1 : !s32i) { + cir.case(equal, [#cir.int<3> : !s32i]) { + cir.break + } + cir.case(equal, [#cir.int<4> : !s32i]) { + cir.yield + } + cir.case(equal, [#cir.int<5> : !s32i]) { + cir.yield + } + cir.case(default, []) { + cir.yield + } + cir.case(equal, [#cir.int<6> : !s32i]) { + cir.yield + } + cir.case(equal, [#cir.int<7> : !s32i]) { + cir.break + } + cir.yield + } + } + cir.return + } + //CHECK: cir.func @foldCascadeWithDefault + //CHECK: cir.switch (%[[COND:.*]] : !s32i) { + //CHECK: cir.case(equal, [#cir.int<3> : !s32i]) { + //CHECK: cir.break + //CHECK: } + //CHECK: cir.case(anyof, [#cir.int<4> : !s32i, #cir.int<5> : !s32i]) { + //CHECK: cir.yield + //CHECK: } + //CHECK: cir.case(default, []) { + //CHECK: cir.yield + //CHECK: } + //CHECK: cir.case(anyof, [#cir.int<6> : !s32i, #cir.int<7> : !s32i]) { + //CHECK: cir.break + //CHECK: } + //CHECK: cir.yield + //CHECK: } + cir.func @foldAllCascade(%arg0: !s32i ) { + %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} + cir.store %arg0, %0 : !s32i, !cir.ptr + cir.scope { + %1 = cir.load %0 : !cir.ptr, !s32i + cir.switch (%1 : !s32i) { + cir.case(equal, [#cir.int<0> : !s32i]) { + cir.yield + } + 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]) { + cir.yield + } + cir.case(equal, [#cir.int<4> : !s32i]) { + cir.yield + } + cir.case(equal, [#cir.int<5> : !s32i]) { + cir.yield + } + cir.yield + } + } + cir.return + } + //CHECK: cir.func @foldAllCascade + //CHECK: cir.switch (%[[COND:.*]] : !s32i) { + //CHECK: cir.case(anyof, [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i, #cir.int<5> : !s32i]) { + //CHECK: cir.yield + //CHECK: } + //CHECK: cir.yield + //CHECK: } +}