From 3b9f69879d1776d424b7d7c92df7644712cff853 Mon Sep 17 00:00:00 2001 From: Krito Date: Fri, 14 Jun 2024 02:22:29 +0800 Subject: [PATCH] [CIR][Transforms] Move RemoveRedundantBranches logic into BrOp::fold method (#663) This pr is a part of #593 . Move RemoveRedundantBranches logic into BrOp::fold method and modify tests. --- clang/include/clang/CIR/Dialect/IR/CIROps.td | 2 + clang/lib/CIR/CodeGen/CIRPasses.cpp | 1 + clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 36 +++++ .../CIR/Dialect/Transforms/MergeCleanups.cpp | 35 ----- clang/test/CIR/CodeGen/goto.cpp | 106 ++++++--------- clang/test/CIR/CodeGen/switch-gnurange.cpp | 10 -- clang/test/CIR/CodeGen/var-arg-scope.c | 8 +- clang/test/CIR/Lowering/ThroughMLIR/goto.cir | 14 +- clang/test/CIR/Lowering/cast.cir | 90 ++++++++----- clang/test/CIR/Lowering/dot.cir | 18 +-- clang/test/CIR/Lowering/goto.cir | 14 +- clang/test/CIR/Lowering/loop.cir | 12 +- clang/test/CIR/Lowering/loops-with-break.cir | 55 +------- .../test/CIR/Lowering/loops-with-continue.cir | 127 ++++++------------ clang/test/CIR/Lowering/region-simplify.cir | 7 +- clang/test/CIR/Lowering/scope.cir | 18 +-- clang/test/CIR/Lowering/switch.cir | 37 ++--- clang/test/CIR/Lowering/ternary.cir | 2 - clang/test/CIR/Lowering/unary-not.cir | 67 ++++++--- clang/test/CIR/Transforms/loop.cir | 16 +-- clang/test/CIR/Transforms/scope.cir | 8 +- clang/test/CIR/Transforms/switch.cir | 40 ++---- clang/test/CIR/Transforms/ternary.cir | 6 - 23 files changed, 287 insertions(+), 442 deletions(-) diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td index 0a2dca2a27b3..c7b3c673c545 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIROps.td +++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td @@ -1599,6 +1599,8 @@ def BrOp : CIR_Op<"br", let assemblyFormat = [{ $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict }]; + + let hasFolder = 1; } //===----------------------------------------------------------------------===// diff --git a/clang/lib/CIR/CodeGen/CIRPasses.cpp b/clang/lib/CIR/CodeGen/CIRPasses.cpp index dcc613a89925..4c4982d7f599 100644 --- a/clang/lib/CIR/CodeGen/CIRPasses.cpp +++ b/clang/lib/CIR/CodeGen/CIRPasses.cpp @@ -91,6 +91,7 @@ namespace mlir { void populateCIRPreLoweringPasses(OpPassManager &pm) { pm.addPass(createFlattenCFGPass()); pm.addPass(createGotoSolverPass()); + pm.addPass(createMergeCleanupsPass()); } } // namespace mlir diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp index 9847bafe8b84..5d1cfb3c1124 100644 --- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp @@ -944,6 +944,42 @@ mlir::SuccessorOperands BrOp::getSuccessorOperands(unsigned index) { Block *BrOp::getSuccessorForOperands(ArrayRef) { return getDest(); } +/// Removes branches between two blocks if it is the only branch. +/// +/// From: +/// ^bb0: +/// cir.br ^bb1 +/// ^bb1: // pred: ^bb0 +/// cir.return +/// +/// To: +/// ^bb0: +/// cir.return +LogicalResult BrOp::fold(FoldAdaptor adaptor, + SmallVectorImpl &results) { + Block *block = getOperation()->getBlock(); + Block *dest = getDest(); + + if (isa(dest->front())) { + return failure(); + } + + if (block->getNumSuccessors() == 1 && dest->getSinglePredecessor() == block) { + getOperation()->erase(); + block->getOperations().splice(block->end(), dest->getOperations()); + auto eraseBlock = [](Block *block) { + for (auto &op : llvm::make_early_inc_range(*block)) + op.erase(); + block->erase(); + }; + eraseBlock(dest); + + return success(); + } + + return failure(); +} + //===----------------------------------------------------------------------===// // BrCondOp //===----------------------------------------------------------------------===// diff --git a/clang/lib/CIR/Dialect/Transforms/MergeCleanups.cpp b/clang/lib/CIR/Dialect/Transforms/MergeCleanups.cpp index 106065c6b6e3..d9d87a94635b 100644 --- a/clang/lib/CIR/Dialect/Transforms/MergeCleanups.cpp +++ b/clang/lib/CIR/Dialect/Transforms/MergeCleanups.cpp @@ -23,40 +23,6 @@ using namespace cir; namespace { -/// Removes branches between two blocks if it is the only branch. -/// -/// From: -/// ^bb0: -/// cir.br ^bb1 -/// ^bb1: // pred: ^bb0 -/// cir.return -/// -/// To: -/// ^bb0: -/// cir.return -struct RemoveRedundantBranches : public OpRewritePattern { - using OpRewritePattern::OpRewritePattern; - - LogicalResult matchAndRewrite(BrOp op, - PatternRewriter &rewriter) const final { - Block *block = op.getOperation()->getBlock(); - Block *dest = op.getDest(); - - if (isa(dest->front())) - return failure(); - - // Single edge between blocks: merge it. - if (block->getNumSuccessors() == 1 && - dest->getSinglePredecessor() == block) { - rewriter.eraseOp(op); - rewriter.mergeBlocks(dest, block); - return success(); - } - - return failure(); - } -}; - struct RemoveEmptyScope : public OpRewritePattern { using OpRewritePattern::OpRewritePattern; @@ -104,7 +70,6 @@ struct MergeCleanupsPass : public MergeCleanupsBase { void populateMergeCleanupPatterns(RewritePatternSet &patterns) { // clang-format off patterns.add< - RemoveRedundantBranches, RemoveEmptyScope, RemoveEmptySwitch >(patterns.getContext()); diff --git a/clang/test/CIR/CodeGen/goto.cpp b/clang/test/CIR/CodeGen/goto.cpp index 06870feba910..f064d1b215ad 100644 --- a/clang/test/CIR/CodeGen/goto.cpp +++ b/clang/test/CIR/CodeGen/goto.cpp @@ -159,25 +159,19 @@ int jumpIntoLoop(int* ar) { // CHECK: cir.func @_Z12jumpIntoLoopPi // CHECK: cir.brcond {{.*}} ^bb[[#BLK2:]], ^bb[[#BLK3:]] // CHECK: ^bb[[#BLK2]]: -// CHECK: cir.br ^bb[[#BODY:]] +// CHECK: cir.br ^bb[[#BLK7:]] // CHECK: ^bb[[#BLK3]]: // CHECK: cir.br ^bb[[#BLK4:]] // CHECK: ^bb[[#BLK4]]: -// CHECK: cir.br ^bb[[#RETURN:]] -// CHECK: ^bb[[#RETURN]]: // CHECK: cir.return // CHECK: ^bb[[#BLK5:]]: // CHECK: cir.br ^bb[[#BLK6:]] -// CHECK: ^bb[[#BLK6]]: -// CHECK: cir.br ^bb[[#COND:]] -// CHECK: ^bb[[#COND]]: -// CHECK: cir.brcond {{.*}} ^bb[[#BODY]], ^bb[[#EXIT:]] -// CHECK: ^bb[[#BODY]]: -// CHECK: cir.br ^bb[[#COND]] -// CHECK: ^bb[[#EXIT]]: -// CHECK: cir.br ^bb[[#BLK7:]] +// CHECK: ^bb[[#BLK6]]: +// CHECK: cir.brcond {{.*}} ^bb[[#BLK7:]], ^bb[[#BLK8:]] // CHECK: ^bb[[#BLK7]]: -// CHECK: cir.br ^bb[[#RETURN]] +// CHECK: cir.br ^bb[[#BLK6]] +// CHECK: ^bb[[#BLK8]]: +// CHECK: cir.br ^bb[[#BLK4]] @@ -197,31 +191,21 @@ int jumpFromLoop(int* ar) { return 0; } // CHECK: cir.func @_Z12jumpFromLoopPi -// CHECK: cir.brcond {{.*}} ^bb[[#RETURN1:]], ^bb[[#BLK3:]] -// CHECK: ^bb[[#RETURN1]]: -// CHECK: cir.return -// CHECK: ^bb[[#BLK3]]: -// CHECK: cir.br ^bb[[#BLK4:]] -// CHECK: ^bb[[#BLK4]]: -// CHECK: cir.br ^bb[[#BLK5:]] -// CHECK: ^bb[[#BLK5]]: -// CHECK: cir.br ^bb[[#COND:]] -// CHECK: ^bb[[#COND]]: -// CHECK: cir.brcond {{.*}} ^bb[[#BODY:]], ^bb[[#EXIT:]] -// CHECK: ^bb[[#BODY]]: -// CHECK: cir.br ^bb[[#IF42:]] -// CHECK: ^bb[[#IF42]]: -// CHECK: cir.brcond {{.*}} ^bb[[#IF42TRUE:]], ^bb[[#IF42FALSE:]] -// CHECK: ^bb[[#IF42TRUE]]: -// CHECK: cir.br ^bb[[#RETURN1]] -// CHECK: ^bb[[#IF42FALSE]]: -// CHECK: cir.br ^bb[[#BLK11:]] -// CHECK: ^bb[[#BLK11]]: -// CHECK: cir.br ^bb[[#COND]] -// CHECK: ^bb[[#EXIT]]: -// CHECK: cir.br ^bb[[#RETURN2:]] -// CHECK: ^bb[[#RETURN2]]: -// CHECK: cir.return +// CHECK: cir.brcond {{.*}} ^bb[[#BLK1:]], ^bb[[#BLK2:]] +// CHECK: ^bb[[#BLK1:]]: +// CHECK: cir.return {{.*}} +// CHECK: ^bb[[#BLK2:]]: +// CHECK: cir.br ^bb[[#BLK3:]] +// CHECK: ^bb[[#BLK3:]]: +// CHECK: cir.brcond {{.*}} ^bb[[#BLK4:]], ^bb[[#BLK7:]] +// CHECK: ^bb[[#BLK4:]]: +// CHECK: cir.brcond {{.*}} ^bb[[#BLK5:]], ^bb[[#BLK6:]] +// CHECK: ^bb[[#BLK5:]]: +// CHECK: cir.br ^bb[[#BLK1:]] +// CHECK: ^bb[[#BLK6:]]: +// CHECK: cir.br ^bb[[#BLK3:]] +// CHECK: ^bb[[#BLK7:]]: +// CHECK: cir.return {{.*}} void flatLoopWithNoTerminatorInFront(int* ptr) { @@ -240,35 +224,21 @@ void flatLoopWithNoTerminatorInFront(int* ptr) { ; } -// CHECK: cir.func @_Z31flatLoopWithNoTerminatorInFrontPi -// CHECK: cir.brcond {{.*}} ^bb[[#BLK2:]], ^bb[[#BLK3:]] -// CHECK: ^bb[[#BLK2]]: -// CHECK: cir.br ^bb[[#LABEL_LOOP:]] -// CHECK: ^bb[[#BLK3]]: -// CHECK: cir.br ^bb[[#BLK4:]] -// CHECK: ^bb[[#BLK4]]: -// CHECK: cir.br ^bb[[#BLK5:]] -// CHECK: ^bb[[#BLK5]]: -// CHECK: cir.br ^bb[[#BODY:]] -// CHECK: ^bb[[#COND]]: -// CHECK: cir.brcond {{.*}} ^bb[[#BODY]], ^bb[[#EXIT:]] -// CHECK: ^bb[[#BODY]]: +// CHECK-LABEL: cir.func @_Z31flatLoopWithNoTerminatorInFrontPi +// CHECK: cir.brcond {{.*}} ^bb[[#BLK1:]], ^bb[[#BLK2:]] +// CHECK: ^bb[[#BLK1:]]: +// CHECK: cir.br ^bb[[#BLK6:]] +// CHECK: ^bb[[#BLK2:]]: +// CHECK: cir.br ^bb[[#BLK3:]] +// CHECK: ^bb[[#BLK3:]]: // 2 preds: ^bb[[#BLK2:]], ^bb[[#BLK6:]] +// CHECK: cir.brcond {{.*}} ^bb[[#BLK4:]], ^bb[[#BLK5:]] +// CHECK: ^bb[[#BLK4:]]: // CHECK: cir.br ^bb[[#BLK8:]] -// CHECK: ^bb[[#BLK8]]: -// CHECK: cir.brcond {{.*}} ^bb[[#BLK9:]], ^bb[[#BLK10:]] -// CHECK: ^bb[[#BLK9]]: -// CHECK: cir.br ^bb[[#RETURN:]] -// CHECK: ^bb[[#BLK10]]: -// CHECK: cir.br ^bb[[#BLK11:]] -// CHECK: ^bb[[#BLK11]]: -// CHECK: cir.br ^bb[[#LABEL_LOOP]] -// CHECK: ^bb[[#LABEL_LOOP]]: -// CHECK: cir.br ^bb[[#COND]] -// CHECK: ^bb[[#EXIT]]: -// CHECK: cir.br ^bb[[#BLK14:]] -// CHECK: ^bb[[#BLK14]]: -// CHECK: cir.br ^bb[[#RETURN]] -// CHECK: ^bb[[#RETURN]]: -// CHECK: cir.return -// CHECK: } -// CHECK:} \ No newline at end of file +// CHECK: ^bb[[#BLK5:]]: +// CHECK: cir.br ^bb[[#BLK6:]] +// CHECK: ^bb[[#BLK6:]]: // 2 preds: ^bb[[#BLK1:]], ^bb[[#BLK5:]] +// CHECK: cir.brcond {{.*}} ^bb[[#BLK3:]], ^bb[[#BLK7:]] +// CHECK: ^bb[[#BLK7:]]: +// CHECK: cir.br ^bb[[#BLK8:]] +// CHECK: ^bb[[#BLK8:]]: // 2 preds: ^bb[[#BLK4:]], ^bb[[#BLK7:]] +// CHECK: cir.return \ No newline at end of file diff --git a/clang/test/CIR/CodeGen/switch-gnurange.cpp b/clang/test/CIR/CodeGen/switch-gnurange.cpp index f48a32506252..99f558f3070d 100644 --- a/clang/test/CIR/CodeGen/switch-gnurange.cpp +++ b/clang/test/CIR/CodeGen/switch-gnurange.cpp @@ -172,8 +172,6 @@ void sw3(enum letter c) { // LLVM: store i32 4, ptr %[[X]] // LLVM: br label %[[EPILOG]] // LLVM: [[EPILOG]]: -// LLVM-NEXT: br label %[[EPILOG_END:[0-9]+]] -// LLVM: [[EPILOG_END]]: // LLVM-NEXT: ret void void sw4(int x) { @@ -213,8 +211,6 @@ void sw4(int x) { // LLVM-NEXT: %[[DIFF_CMP:[0-9]+]] = icmp ule i32 %[[DIFF]], 167 // LLVM: br i1 %[[DIFF_CMP]], label %[[CASE_66_233]], label %[[EPILOG]] // LLVM: [[EPILOG]]: -// LLVM-NEXT: br label %[[EPILOG_END:[0-9]+]] -// LLVM: [[EPILOG_END]]: // LLVM-NEXT: ret void void sw5(int x) { @@ -241,8 +237,6 @@ void sw5(int x) { // LLVM-NEXT: store i32 1, ptr %[[Y:[0-9]+]] // LLVM-NEXT: br label %[[EPILOG]] // LLVM: [[EPILOG]]: -// LLVM-NEXT: br label %[[EPILOG_END:[0-9]+]] -// LLVM: [[EPILOG_END]]: // LLVM-NEXT: ret void void sw6(int x) { @@ -273,8 +267,6 @@ void sw6(int x) { // LLVM-NEXT: %[[DIFF_CMP:[0-9]+]] = icmp ule i32 %[[DIFF]], -1 // LLVM-NEXT: br i1 %[[DIFF_CMP]], label %[[CASE_MIN_MAX]], label %[[EPILOG]] // LLVM: [[EPILOG]]: -// LLVM-NEXT: br label %[[EPILOG_END:[0-9]+]] -// LLVM: [[EPILOG_END]]: // LLVM-NEXT: ret void void sw7(int x) { @@ -346,7 +338,5 @@ void sw7(int x) { // LLVM: [[CASE_500_600]]: // LLVM-NEXT: br label %[[EPILOG]] // LLVM: [[EPILOG]]: -// LLVM-NEXT: br label %[[EPILOG_END:[0-9]+]] -// LLVM: [[EPILOG_END]]: // LLVM-NEXT: ret void diff --git a/clang/test/CIR/CodeGen/var-arg-scope.c b/clang/test/CIR/CodeGen/var-arg-scope.c index abea8ec6b9e1..fc056b98e38b 100644 --- a/clang/test/CIR/CodeGen/var-arg-scope.c +++ b/clang/test/CIR/CodeGen/var-arg-scope.c @@ -68,9 +68,6 @@ void f1(__builtin_va_list c) { // LLVM: %struct.__va_list = type { ptr, ptr, ptr, i32, i32 } // LLVM: define void @f1(%struct.__va_list %0) // LLVM: [[VARLIST:%.*]] = alloca %struct.__va_list, i64 1, align 8, -// LLVM: br label %[[SCOPE_FRONT:.*]], - -// LLVM: [[SCOPE_FRONT]]: ; preds = %1 // LLVM: [[GR_OFFS_P:%.*]] = getelementptr %struct.__va_list, ptr [[VARLIST]], i32 0, i32 3 // LLVM: [[GR_OFFS:%.*]] = load i32, ptr [[GR_OFFS_P]], align 4, // LLVM-NEXT: [[CMP0:%.*]] = icmp sge i32 [[GR_OFFS]], 0, @@ -99,7 +96,4 @@ void f1(__builtin_va_list c) { // LLVM: [[BB_END]]: ; preds = %[[BB_ON_STACK]], %[[BB_IN_REG]] // LLVM-NEXT: [[PHIP:%.*]] = phi ptr [ [[IN_REG_OUTPUT]], %[[BB_IN_REG]] ], [ [[STACK_V]], %[[BB_ON_STACK]] ] // LLVM-NEXT: [[PHIV:%.*]] = load ptr, ptr [[PHIP]], align 8, -// LLVM-NEXT: br label %[[OUT_SCOPE:.*]], - -// LLVM: [[OUT_SCOPE]]: ; preds = %[[BB_END]] -// LLVM-NEXT: ret void, +// LLVM: ret void, diff --git a/clang/test/CIR/Lowering/ThroughMLIR/goto.cir b/clang/test/CIR/Lowering/ThroughMLIR/goto.cir index 6c1d5c66fffa..fd85a142d7e0 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/goto.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/goto.cir @@ -7,13 +7,17 @@ module { %0 = cir.alloca !u32i, !cir.ptr, ["b", init] {alignment = 4 : i64} %1 = cir.const #cir.int<1> : !u32i cir.store %1, %0 : !u32i, !cir.ptr - cir.br ^bb2 - ^bb1: // no predecessors + %c = cir.const #cir.int<0> : !u32i + %cond = cir.cast(int_to_bool, %c : !u32i), !cir.bool + cir.brcond %cond ^bb1, ^bb2 + + ^bb1: %2 = cir.load %0 : !cir.ptr, !u32i %3 = cir.const #cir.int<1> : !u32i %4 = cir.binop(add, %2, %3) : !u32i cir.store %4, %0 : !u32i, !cir.ptr cir.br ^bb2 + ^bb2: // 2 preds: ^bb0, ^bb1 %5 = cir.load %0 : !cir.ptr, !u32i %6 = cir.const #cir.int<2> : !u32i @@ -25,8 +29,10 @@ module { // MLIR: module { // MLIR-NEXT: func @foo -// MLIR: cf.br ^bb1 -// MLIR: ^bb1: +// MLIR: cf.cond_br %{{.+}}, ^bb[[#BLK1:]], ^bb[[#BLK2:]] +// MLIR: ^bb[[#BLK1:]]: +// MLIR: cf.br ^bb[[#BLK2:]] +// MLIR: ^bb[[#BLK2:]]: // MLIR: return // LLVM: br label %[[Value:[0-9]+]] diff --git a/clang/test/CIR/Lowering/cast.cir b/clang/test/CIR/Lowering/cast.cir index e100e0c2f07e..a3586f6c156f 100644 --- a/clang/test/CIR/Lowering/cast.cir +++ b/clang/test/CIR/Lowering/cast.cir @@ -11,10 +11,10 @@ module { cir.func @cStyleCasts(%arg0: !u32i, %arg1: !s32i, %arg2: !cir.float, %arg3: !cir.double) -> !s32i { - // CHECK: llvm.func @cStyleCasts + // CHECK: llvm.func @cStyleCasts %0 = cir.alloca !u32i, !cir.ptr, ["x1", init] {alignment = 4 : i64} %1 = cir.alloca !s32i, !cir.ptr, ["x2", init] {alignment = 4 : i64} - %20 = cir.alloca !s16i, !cir.ptr, ["x4", init] {alignment = 2 : i64} + %44 = cir.alloca !s16i, !cir.ptr, ["x4", init] {alignment = 2 : i64} %2 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} %3 = cir.alloca !s8i, !cir.ptr, ["a", init] {alignment = 1 : i64} %4 = cir.alloca !s16i, !cir.ptr, ["b", init] {alignment = 2 : i64} @@ -22,64 +22,86 @@ module { %6 = cir.alloca !s64i, !cir.ptr, ["d", init] {alignment = 8 : i64} %7 = cir.alloca !cir.array, !cir.ptr>, ["arr"] {alignment = 4 : i64} %8 = cir.alloca !cir.ptr, !cir.ptr>, ["e", init] {alignment = 8 : i64} + %9 = cir.alloca !s8i, !cir.ptr, ["tmp1"] {alignment = 1 : i64} + %10 = cir.alloca !s16i, !cir.ptr, ["tmp2"] {alignment = 2 : i64} + %11 = cir.alloca !s64i, !cir.ptr, ["tmp3"] {alignment = 8 : i64} + %12 = cir.alloca !u64i, !cir.ptr, ["tmp4"] {alignment = 8 : i64} + %13 = cir.alloca !cir.ptr, !cir.ptr>, ["tmp5"] {alignment = 8 : i64} + %14 = cir.alloca !s32i, !cir.ptr, ["tmp6"] {alignment = 4 : i64} + %15 = cir.alloca !cir.bool, !cir.ptr, ["tmp7"] {alignment = 1 : i64} + %16 = cir.alloca !cir.float, !cir.ptr, ["tmp8"] {alignment = 4 : i64} + %17 = cir.alloca !cir.float, !cir.ptr, ["tmp9"] {alignment = 4 : i64} + %18 = cir.alloca !u32i, !cir.ptr, ["tmp10"] {alignment = 4 : i64} + %19 = cir.alloca !s32i, !cir.ptr, ["tmp11"] {alignment = 4 : i64} cir.store %arg0, %0 : !u32i, !cir.ptr cir.store %arg1, %1 : !s32i, !cir.ptr // Integer casts. - %9 = cir.load %0 : !cir.ptr, !u32i - %10 = cir.cast(integral, %9 : !u32i), !s8i + %20 = cir.load %0 : !cir.ptr, !u32i + %21 = cir.cast(integral, %20 : !u32i), !s8i // CHECK: %{{[0-9]+}} = llvm.trunc %{{[0-9]+}} : i32 to i8 - cir.store %10, %3 : !s8i, !cir.ptr - %11 = cir.load %1 : !cir.ptr, !s32i - %12 = cir.cast(integral, %11 : !s32i), !s16i + cir.store %21, %3 : !s8i, !cir.ptr + %22 = cir.load %1 : !cir.ptr, !s32i + %23 = cir.cast(integral, %22 : !s32i), !s16i // CHECK: %{{[0-9]+}} = llvm.trunc %{{[0-9]+}} : i32 to i16 - cir.store %12, %4 : !s16i, !cir.ptr - %13 = cir.load %0 : !cir.ptr, !u32i - %14 = cir.cast(integral, %13 : !u32i), !s64i + cir.store %23, %4 : !s16i, !cir.ptr + %24 = cir.load %0 : !cir.ptr, !u32i + %25 = cir.cast(integral, %24 : !u32i), !s64i // CHECK: %{{[0-9]+}} = llvm.zext %{{[0-9]+}} : i32 to i64 - cir.store %14, %5 : !s64i, !cir.ptr - %15 = cir.load %1 : !cir.ptr, !s32i - %16 = cir.cast(integral, %15 : !s32i), !s64i + cir.store %25, %5 : !s64i, !cir.ptr + %26 = cir.load %1 : !cir.ptr, !s32i + %27 = cir.cast(integral, %26 : !s32i), !s64i // CHECK: %{{[0-9]+}} = llvm.sext %{{[0-9]+}} : i32 to i64 - %30 = cir.cast(integral, %arg1 : !s32i), !u32i + cir.store %27, %6 : !s64i, !cir.ptr + %28 = cir.cast(integral, %arg1 : !s32i), !u32i + cir.store %28, %18 : !u32i, !cir.ptr // Should not produce a cast. - %32 = cir.cast(integral, %arg0 : !u32i), !s32i + %29 = cir.cast(integral, %arg0 : !u32i), !s32i + cir.store %29, %19 : !s32i, !cir.ptr // Should not produce a cast. - %21 = cir.load %20 : !cir.ptr, !s16i - %22 = cir.cast(integral, %21 : !s16i), !u64i + %30 = cir.load %44 : !cir.ptr, !s16i + %31 = cir.cast(integral, %30 : !s16i), !u64i // CHECK: %[[TMP:[0-9]+]] = llvm.sext %{{[0-9]+}} : i16 to i64 - %33 = cir.cast(int_to_bool, %arg1 : !s32i), !cir.bool + cir.store %31, %12 : !u64i, !cir.ptr + %32 = cir.cast(int_to_bool, %arg1 : !s32i), !cir.bool + cir.store %32, %15 : !cir.bool, !cir.ptr // CHECK: %[[#ZERO:]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[#CMP:]] = llvm.icmp "ne" %arg1, %[[#ZERO]] : i32 // CHECK: %{{.+}} = llvm.zext %[[#CMP]] : i1 to i8 // Pointer casts. - cir.store %16, %6 : !s64i, !cir.ptr - %17 = cir.cast(array_to_ptrdecay, %7 : !cir.ptr>), !cir.ptr - cir.store %17, %8 : !cir.ptr, !cir.ptr> + %33 = cir.cast(array_to_ptrdecay, %7 : !cir.ptr>), !cir.ptr + cir.store %33, %8 : !cir.ptr, !cir.ptr> // CHECK: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, i32 - %23 = cir.cast(int_to_ptr, %22 : !u64i), !cir.ptr + %34 = cir.cast(int_to_ptr, %31 : !u64i), !cir.ptr + cir.store %34, %13 : !cir.ptr, !cir.ptr> // CHECK: %[[TMP2:[0-9]+]] = llvm.inttoptr %[[TMP]] : i64 to !llvm.ptr - %24 = cir.cast(ptr_to_int, %23 : !cir.ptr), !s32i + %35 = cir.cast(ptr_to_int, %34 : !cir.ptr), !s32i + cir.store %35, %14 : !s32i, !cir.ptr // CHECK: %{{[0-9]+}} = llvm.ptrtoint %[[TMP2]] : !llvm.ptr to i32 - %29 = cir.cast(ptr_to_bool, %23 : !cir.ptr), !cir.bool + %36 = cir.cast(ptr_to_bool, %34 : !cir.ptr), !cir.bool + cir.store %36, %15 : !cir.bool, !cir.ptr // Floating point casts. - %25 = cir.cast(int_to_float, %arg1 : !s32i), !cir.float + %37 = cir.cast(int_to_float, %arg1 : !s32i), !cir.float + cir.store %37, %16 : !cir.float, !cir.ptr // CHECK: %{{.+}} = llvm.sitofp %{{.+}} : i32 to f32 - %26 = cir.cast(int_to_float, %arg0 : !u32i), !cir.float + %38 = cir.cast(int_to_float, %arg0 : !u32i), !cir.float + cir.store %38, %16 : !cir.float, !cir.ptr // CHECK: %{{.+}} = llvm.uitofp %{{.+}} : i32 to f32 - %27 = cir.cast(float_to_int, %arg2 : !cir.float), !s32i + %39 = cir.cast(float_to_int, %arg2 : !cir.float), !s32i + cir.store %39, %14 : !s32i, !cir.ptr // CHECK: %{{.+}} = llvm.fptosi %{{.+}} : f32 to i32 - %28 = cir.cast(float_to_int, %arg2 : !cir.float), !u32i + %40 = cir.cast(float_to_int, %arg2 : !cir.float), !u32i + cir.store %40, %18 : !u32i, !cir.ptr // CHECK: %{{.+}} = llvm.fptoui %{{.+}} : f32 to i32 - %18 = cir.const #cir.int<0> : !s32i - // CHECK: %{{.+}} = llvm.fptrunc %{{.+}} : f64 to f32 - %34 = cir.cast(floating, %arg3 : !cir.double), !cir.float + %41 = cir.cast(floating, %arg3 : !cir.double), !cir.float + cir.store %41, %17 : !cir.float, !cir.ptr - cir.store %18, %2 : !s32i, !cir.ptr - %19 = cir.load %2 : !cir.ptr, !s32i - cir.return %19 : !s32i + %42 = cir.const #cir.int<0> : !s32i + cir.store %42, %2 : !s32i, !cir.ptr + %43 = cir.load %2 : !cir.ptr, !s32i + cir.return %43 : !s32i } cir.func @testBoolToIntCast(%arg0: !cir.bool) { diff --git a/clang/test/CIR/Lowering/dot.cir b/clang/test/CIR/Lowering/dot.cir index 5c5ed4736f7a..b0df3eecdf85 100644 --- a/clang/test/CIR/Lowering/dot.cir +++ b/clang/test/CIR/Lowering/dot.cir @@ -68,22 +68,20 @@ module { // MLIR: llvm.store {{.*}}, %[[VAL_8]] {{.*}}: i32, !llvm.ptr // MLIR: %[[VAL_13:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64 // MLIR: llvm.store %[[VAL_13]], %[[VAL_12]] {{.*}}: f64, !llvm.ptr -// MLIR: llvm.br ^bb1 -// MLIR: ^bb1: // MLIR: %[[VAL_14:.*]] = llvm.mlir.constant(1 : index) : i64 // MLIR: %[[VAL_15:.*]] = llvm.alloca %[[VAL_14]] x i32 {alignment = 4 : i64} : (i64) -> !llvm.ptr // MLIR: %[[VAL_16:.*]] = llvm.mlir.constant(0 : i32) : i32 // MLIR: llvm.store %[[VAL_16]], %[[VAL_15]] {{.*}}: i32, !llvm.ptr -// MLIR: llvm.br ^bb2 -// MLIR: ^bb2: +// MLIR: llvm.br ^bb1 +// MLIR: ^bb1: // MLIR: %[[VAL_17:.*]] = llvm.load %[[VAL_15]] {alignment = 4 : i64} : !llvm.ptr -> i32 // MLIR: %[[VAL_18:.*]] = llvm.load %[[VAL_8]] {alignment = 4 : i64} : !llvm.ptr -> i32 // MLIR: %[[VAL_19:.*]] = llvm.icmp "slt" %[[VAL_17]], %[[VAL_18]] : i32 // MLIR: %[[VAL_20:.*]] = llvm.zext %[[VAL_19]] : i1 to i32 // MLIR: %[[VAL_21:.*]] = llvm.mlir.constant(0 : i32) : i32 // MLIR: %[[VAL_22:.*]] = llvm.icmp "ne" %[[VAL_20]], %[[VAL_21]] : i32 -// MLIR: llvm.cond_br %[[VAL_22]], ^bb3, ^bb5 -// MLIR: ^bb3: +// MLIR: llvm.cond_br %[[VAL_22]], ^bb2, ^bb3 +// MLIR: ^bb2: // MLIR: %[[VAL_23:.*]] = llvm.load %[[VAL_4]] {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr // MLIR: %[[VAL_24:.*]] = llvm.load %[[VAL_15]] {alignment = 4 : i64} : !llvm.ptr -> i32 // MLIR: %[[VAL_25:.*]] = llvm.sext %[[VAL_24]] : i32 to i64 @@ -98,16 +96,12 @@ module { // MLIR: %[[VAL_34:.*]] = llvm.load %[[VAL_12]] {alignment = 8 : i64} : !llvm.ptr -> f64 // MLIR: %[[VAL_35:.*]] = llvm.fadd %[[VAL_34]], %[[VAL_33]] : f64 // MLIR: llvm.store %[[VAL_35]], %[[VAL_12]] {{.*}}: f64, !llvm.ptr -// MLIR: llvm.br ^bb4 -// MLIR: ^bb4: // MLIR: %[[VAL_36:.*]] = llvm.load %[[VAL_15]] {alignment = 4 : i64} : !llvm.ptr -> i32 // MLIR: %[[VAL_37:.*]] = llvm.mlir.constant(1 : i32) : i32 // MLIR: %[[VAL_38:.*]] = llvm.add %[[VAL_36]], %[[VAL_37]] : i32 // MLIR: llvm.store %[[VAL_38]], %[[VAL_15]] {{.*}}: i32, !llvm.ptr -// MLIR: llvm.br ^bb2 -// MLIR: ^bb5: -// MLIR: llvm.br ^bb6 -// MLIR: ^bb6: +// MLIR: llvm.br ^bb1 +// MLIR: ^bb3: // MLIR: %[[VAL_39:.*]] = llvm.load %[[VAL_12]] {alignment = 8 : i64} : !llvm.ptr -> f64 // MLIR: llvm.store %[[VAL_39]], %[[VAL_10]] {{.*}}: f64, !llvm.ptr // MLIR: %[[VAL_40:.*]] = llvm.load %[[VAL_10]] {alignment = 8 : i64} : !llvm.ptr -> f64 diff --git a/clang/test/CIR/Lowering/goto.cir b/clang/test/CIR/Lowering/goto.cir index a2f00b6cf17b..75f16e1d3ae4 100644 --- a/clang/test/CIR/Lowering/goto.cir +++ b/clang/test/CIR/Lowering/goto.cir @@ -36,18 +36,14 @@ module { // MLIR: %[[#Zero:]] = llvm.mlir.constant(0 : i32) : i32 // MLIR: llvm.cond_br {{.*}}, ^bb[[#COND_YES:]], ^bb[[#COND_NO:]] // MLIR: ^bb[[#COND_YES]]: -// MLIR: llvm.br ^bb[[#GOTO_BLK:]] -// MLIR: ^bb[[#COND_NO]]: -// MLIR: llvm.br ^bb[[#BLK:]] -// MLIR: ^bb[[#BLK]]: -// MLIR: llvm.store %[[#Zero]], %[[#Ret_val_addr:]] {{.*}}: i32, !llvm.ptr +// MLIR: %[[#Neg_one:]] = llvm.sub %[[#Zero]], %[[#One]] : i32 +// MLIR: llvm.store %[[#Neg_one]], %[[#Ret_val_addr:]] {{.*}}: i32, !llvm.ptr // MLIR: llvm.br ^bb[[#RETURN:]] +// MLIR: ^bb[[#COND_NO]]: +// MLIR: llvm.store %[[#Zero]], %[[#Ret_val_addr]] {{.*}}: i32, !llvm.ptr +// MLIR: llvm.br ^bb[[#RETURN]] // MLIR: ^bb[[#RETURN]]: // MLIR: %[[#Ret_val:]] = llvm.load %[[#Ret_val_addr]] {alignment = 4 : i64} : !llvm.ptr -> i32 // MLIR: llvm.return %[[#Ret_val]] : i32 -// MLIR: ^bb[[#GOTO_BLK]]: -// MLIR: %[[#Neg_one:]] = llvm.sub %[[#Zero]], %[[#One]] : i32 -// MLIR: llvm.store %[[#Neg_one]], %[[#Ret_val_addr]] {{.*}}: i32, !llvm.ptr -// MLIR: llvm.br ^bb[[#RETURN]] // MLIR: } } \ No newline at end of file diff --git a/clang/test/CIR/Lowering/loop.cir b/clang/test/CIR/Lowering/loop.cir index d15479a76a0d..3e9a47e80f8f 100644 --- a/clang/test/CIR/Lowering/loop.cir +++ b/clang/test/CIR/Lowering/loop.cir @@ -22,8 +22,6 @@ module { // CHECK: ^bb[[#COND]]: // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: -// CHECK: llvm.br ^bb[[#STEP:]] -// CHECK: ^bb[[#STEP]]: // CHECK: llvm.br ^bb[[#COND]] // CHECK: ^bb[[#EXIT]]: @@ -60,11 +58,9 @@ module { } // CHECK: @testDoWhile -// CHECK: llvm.br ^bb[[#BODY:]] +// CHECK: llvm.br ^bb[[#COND]] // CHECK: ^bb[[#COND:]]: // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] -// CHECK: ^bb[[#BODY]]: -// CHECK: llvm.br ^bb[[#COND]] // CHECK: ^bb[[#EXIT]]: @@ -83,8 +79,6 @@ module { } // CHECK: @testWhileWithBreakTerminatedBody -// CHECK: llvm.br ^bb[[#COND:]] -// CHECK: ^bb[[#COND]]: // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: // CHECK: llvm.br ^bb[[#EXIT]] @@ -115,12 +109,8 @@ module { // CHECK: ^bb[[#COND:]]: // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: -// CHECK: llvm.br ^bb[[#SCOPE_IN:]] -// CHECK: ^bb[[#SCOPE_IN]]: // CHECK: llvm.br ^bb[[#EXIT]] // CHECK: ^bb[[#SCOPE_EXIT:]]: -// CHECK: llvm.br ^bb[[#STEP:]] -// CHECK: ^bb[[#STEP]]: // CHECK: llvm.br ^bb[[#COND]] // CHECK: ^bb[[#EXIT]]: } diff --git a/clang/test/CIR/Lowering/loops-with-break.cir b/clang/test/CIR/Lowering/loops-with-break.cir index 34b6bfd7618e..9b9090c12900 100644 --- a/clang/test/CIR/Lowering/loops-with-break.cir +++ b/clang/test/CIR/Lowering/loops-with-break.cir @@ -44,21 +44,11 @@ module { // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preBREAK1:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#preBREAK1]]: - // CHECK: llvm.br ^bb[[#preBREAK2:]] - // CHECK: ^bb[[#preBREAK2]]: - // CHECK: llvm.br ^bb[[#BREAK:]] - // CHECK: ^bb[[#BREAK]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preEXIT1:]], ^bb[[#preBODY0:]] // CHECK: ^bb[[#preEXIT1]]: // CHECK: llvm.br ^bb[[#EXIT:]] // CHECK: ^bb[[#preBODY0]]: - // CHECK: llvm.br ^bb[[#preBODY1:]] - // CHECK: ^bb[[#preBODY1]]: - // CHECK: llvm.br ^bb[[#BODY:]] - // CHECK: ^bb[[#BODY]]: - // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#STEP]]: // [...] // CHECK: llvm.br ^bb[[#COND:]] // CHECK: ^bb[[#EXIT]]: @@ -127,40 +117,21 @@ module { // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preNESTED1:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#preNESTED1]]: - // CHECK: llvm.br ^bb[[#preNESTED2:]] - // CHECK: ^bb[[#preNESTED2]]: - // CHECK: llvm.br ^bb[[#NESTED:]] - // CHECK: ^bb[[#NESTED]]: // [...] // CHECK: llvm.br ^bb[[#COND_NESTED:]] // CHECK: ^bb[[#COND_NESTED]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preBREAK1:]], ^bb[[#EXIT_NESTED:]] // CHECK: ^bb[[#preBREAK1]]: - // CHECK: llvm.br ^bb[[#preBREAK2:]] - // CHECK: ^bb[[#preBREAK2]]: - // CHECK: llvm.br ^bb[[#BREAK:]] - // CHECK: ^bb[[#BREAK]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preEXIT2:]], ^bb[[#preBODY0:]] // CHECK: ^bb[[#preEXIT2]]: // CHECK: llvm.br ^bb[[#EXIT_NESTED:]] // CHECK: ^bb[[#preBODY0]]: - // CHECK: llvm.br ^bb[[#preBODY1:]] - // CHECK: ^bb[[#preBODY1]]: - // CHECK: llvm.br ^bb[[#BODY_NESTED:]] - // CHECK: ^bb[[#BODY_NESTED]]: - // CHECK: llvm.br ^bb[[#STEP_NESTED:]] - // CHECK: ^bb[[#STEP_NESTED]]: // [...] // CHECK: llvm.br ^bb[[#COND_NESTED:]] // CHECK: ^bb[[#EXIT_NESTED]]: // [...] - // CHECK: llvm.br ^bb[[#BODY:]] - // CHECK: ^bb[[#BODY]]: - // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#STEP]]: - // [...] // CHECK: llvm.br ^bb[[#COND:]] // CHECK: ^bb[[#EXIT]]: // [...] @@ -205,18 +176,11 @@ module { // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: // [...] - // CHECK: llvm.br ^bb[[#BREAK:]] - // CHECK: ^bb[[#BREAK]]: - // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preEXIT1:]], ^bb[[#preCOND0:]] // CHECK: ^bb[[#preEXIT1]]: - // CHECK: llvm.br ^bb[[#preEXIT2:]] + // CHECK: llvm.br ^bb[[#EXIT:]] // CHECK: ^bb[[#preCOND0]]: - // CHECK: llvm.br ^bb[[#preCOND1:]] - // CHECK: ^bb[[#preCOND1]]: // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#preEXIT2]]: - // CHECK: llvm.br ^bb[[#EXIT:]] // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } @@ -256,21 +220,12 @@ cir.func @testDoWhile() { // CHECK: llvm.br ^bb[[#COND:]] // CHECK: ^bb[[#COND]]: // [...] - // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#BODY]]: - // [...] - // CHECK: llvm.br ^bb[[#BREAK:]] - // CHECK: ^bb[[#BREAK]]: - // [...] - // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preEXIT1:]], ^bb[[#preCOND0:]] + // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preEXIT1:]], ^bb[[#BODY:]] // CHECK: ^bb[[#preEXIT1]]: - // CHECK: llvm.br ^bb[[#preEXIT2:]] - // CHECK: ^bb[[#preCOND0]]: - // CHECK: llvm.br ^bb[[#preCOND1:]] - // CHECK: ^bb[[#preCOND1]]: - // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#preEXIT2]]: // CHECK: llvm.br ^bb[[#EXIT:]] + // CHECK: ^bb[[#BODY]]: + // [...] + // CHECK: llvm.cond_br %{{.+}}, ^bb[[#COND]], ^bb[[#EXIT]] // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } diff --git a/clang/test/CIR/Lowering/loops-with-continue.cir b/clang/test/CIR/Lowering/loops-with-continue.cir index 0371d416b61d..c3fb6406bd6b 100644 --- a/clang/test/CIR/Lowering/loops-with-continue.cir +++ b/clang/test/CIR/Lowering/loops-with-continue.cir @@ -37,33 +37,21 @@ module { cir.return } - // CHECK: llvm.func @testFor() - // [...] - // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#COND]]: - // [...] - // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preCONTINUE1:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#preCONTINUE1]]: - // CHECK: llvm.br ^bb[[#preCONTINUE2:]] - // CHECK: ^bb[[#preCONTINUE2]]: - // CHECK: llvm.br ^bb[[#CONTINUE:]] - // CHECK: ^bb[[#CONTINUE]]: - // [...] - // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preSTEP:]], ^bb[[#preBODY0:]] - // CHECK: ^bb[[#preSTEP]]: - // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#preBODY0]]: - // CHECK: llvm.br ^bb[[#preBODY1:]] - // CHECK: ^bb[[#preBODY1]]: - // CHECK: llvm.br ^bb[[#BODY:]] - // CHECK: ^bb[[#BODY]]: - // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#STEP]]: - // [...] - // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#EXIT]]: - // [...] - // CHECK: } +// CHECK: llvm.func @testFor() +// CHECK: llvm.br ^bb[[#COND:]] +// CHECK: ^bb[[#COND]]: +// CHECK: llvm.cond_br %8, ^bb[[#CONTINUE:]], ^bb[[#EXIT:]] +// CHECK: ^bb[[#CONTINUE]]: +// CHECK: llvm.cond_br %14, ^bb[[#preSTEP:]], ^bb[[#BODY:]] +// CHECK: ^bb[[#preSTEP]]: +// CHECK: llvm.br ^bb[[#STEP:]] +// CHECK: ^bb[[#BODY]]: +// CHECK: llvm.br ^bb[[#STEP:]] +// CHECK: ^bb[[#STEP]]: +// CHECK: llvm.br ^bb[[#COND:]] +// CHECK: ^bb[[#EXIT]]: +// CHECK: llvm.return +// CHECK: } cir.func @testForNested() { @@ -121,50 +109,27 @@ module { cir.return } - // CHECK: llvm.func @testForNested() - // [...] - // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#COND]]: - // [...] - // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preNESTED1:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#preNESTED1]]: - // CHECK: llvm.br ^bb[[#preNESTED2:]] - // CHECK: ^bb[[#preNESTED2]]: - // CHECK: llvm.br ^bb[[#NESTED:]] - // CHECK: ^bb[[#NESTED]]: - // [...] - // CHECK: llvm.br ^bb[[#COND_NESTED:]] - // CHECK: ^bb[[#COND_NESTED]]: - // [...] - // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preCONTINUE1:]], ^bb[[#EXIT_NESTED:]] - // CHECK: ^bb[[#preCONTINUE1]]: - // CHECK: llvm.br ^bb[[#preCONTINUE2:]] - // CHECK: ^bb[[#preCONTINUE2]]: - // CHECK: llvm.br ^bb[[#CONTINUE:]] - // CHECK: ^bb[[#CONTINUE]]: - // [...] - // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preSTEP0:]], ^bb[[#preBODY0:]] - // CHECK: ^bb[[#preSTEP0]]: - // CHECK: llvm.br ^bb[[#STEP_NESTED:]] - // CHECK: ^bb[[#preBODY0]]: - // CHECK: llvm.br ^bb[[#preBODY1:]] - // CHECK: ^bb[[#preBODY1]]: - // CHECK: llvm.br ^bb[[#BODY_NESTED:]] - // CHECK: ^bb[[#BODY_NESTED]]: - // CHECK: llvm.br ^bb[[#STEP_NESTED:]] - // CHECK: ^bb[[#STEP_NESTED]]: - // [...] - // CHECK: llvm.br ^bb[[#COND_NESTED:]] - // CHECK: ^bb[[#EXIT_NESTED]]: - // CHECK: llvm.br ^bb[[#BODY:]] - // CHECK: ^bb[[#BODY]]: - // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#STEP]]: - // [...] - // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#EXIT]]: - // [...] - // CHECK: } +// CHECK: llvm.func @testForNested() +// CHECK: llvm.br ^bb[[#COND1:]] +// CHECK: ^bb[[#COND1]]: +// CHECK: llvm.cond_br %{{.+}}, ^bb[[#LOOP1BODY:]], ^bb[[#EXIT:]] +// CHECK: ^bb[[#LOOP1BODY]]: +// CHECK: llvm.br ^bb[[#COND2:]] +// CHECK: ^bb[[#COND2]]: +// CHECK: llvm.cond_br %{{.+}}, ^bb[[#LOOP2BODY:]], ^bb[[#LOOP1CONTINUE:]] +// CHECK: ^bb[[#LOOP2BODY]]: +// CHECK: llvm.cond_br %{{.+}}, ^bb[[#IFBODY1:]], ^bb[[#IFBODY2:]] +// CHECK: ^bb[[#IFBODY1]]: +// CHECK: llvm.br ^bb[[#STEP2:]] +// CHECK: ^bb[[#IFBODY2]]: +// CHECK: llvm.br ^bb[[#STEP2:]] +// CHECK: ^bb[[#STEP2]]: +// CHECK: llvm.br ^bb[[#COND2]] +// CHECK: ^bb[[#LOOP1CONTINUE]]: +// CHECK: llvm.br ^bb[[#COND1]] +// CHECK: ^bb[[#EXIT]]: +// CHECK: llvm.return +// CHECK: } cir.func @testWhile() { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} @@ -198,22 +163,14 @@ cir.func @testWhile() { // CHECK: llvm.func @testWhile() // [...] - // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#COND]]: - // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: // [...] - // CHECK: llvm.br ^bb[[#CONTINUE:]] - // CHECK: ^bb[[#CONTINUE]]: - // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preCOND0:]], ^bb[[#preCOND1:]] // CHECK: ^bb[[#preCOND0]]: - // CHECK: llvm.br ^bb[[#COND:]] + // CHECK: llvm.br ^bb[[#COND]] // CHECK: ^bb[[#preCOND1]]: - // CHECK: llvm.br ^bb[[#preCOND2:]] - // CHECK: ^bb[[#preCOND2]]: - // CHECK: llvm.br ^bb[[#COND:]] + // CHECK: llvm.br ^bb[[#COND]] // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } @@ -251,21 +208,13 @@ cir.func @testWhile() { // CHECK: llvm.func @testDoWhile() // [...] - // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#COND]]: - // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: // [...] - // CHECK: llvm.br ^bb[[#CONTINUE:]] - // CHECK: ^bb[[#CONTINUE]]: - // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preCOND0:]], ^bb[[#preCOND1:]] // CHECK: ^bb[[#preCOND0]]: // CHECK: llvm.br ^bb[[#COND:]] // CHECK: ^bb[[#preCOND1]]: - // CHECK: llvm.br ^bb[[#preCOND2:]] - // CHECK: ^bb[[#preCOND2]]: // CHECK: llvm.br ^bb[[#COND:]] // CHECK: ^bb[[#EXIT]]: // [...] diff --git a/clang/test/CIR/Lowering/region-simplify.cir b/clang/test/CIR/Lowering/region-simplify.cir index 5f32205cb032..0ebedfc6eb62 100644 --- a/clang/test/CIR/Lowering/region-simplify.cir +++ b/clang/test/CIR/Lowering/region-simplify.cir @@ -1,5 +1,5 @@ -// RUN: cir-opt %s -canonicalize -cir-to-llvm -o - | FileCheck %s -check-prefix=MLIR -// RUN: cir-opt %s -canonicalize -o - | cir-translate -cir-to-llvmir | FileCheck %s -check-prefix=LLVM +// RUN: cir-opt %s -cir-to-llvm -canonicalize -o - | FileCheck %s -check-prefix=MLIR +// RUN: cir-opt %s -cir-to-llvm -canonicalize -o - | cir-translate -cir-to-llvmir | FileCheck %s -check-prefix=LLVM !u32i = !cir.int @@ -8,7 +8,7 @@ module { %0 = cir.alloca !u32i, !cir.ptr, ["b", init] {alignment = 4 : i64} %1 = cir.const #cir.int<1> : !u32i cir.store %1, %0 : !u32i, !cir.ptr - cir.br ^bb2 + cir.goto "err" ^bb1: // no predecessors %2 = cir.load %0 : !cir.ptr, !u32i %3 = cir.const #cir.int<1> : !u32i @@ -16,6 +16,7 @@ module { cir.store %4, %0 : !u32i, !cir.ptr cir.br ^bb2 ^bb2: // 2 preds: ^bb0, ^bb1 + cir.label "err" %5 = cir.load %0 : !cir.ptr, !u32i %6 = cir.const #cir.int<2> : !u32i %7 = cir.binop(add, %5, %6) : !u32i diff --git a/clang/test/CIR/Lowering/scope.cir b/clang/test/CIR/Lowering/scope.cir index add46429cba2..e04272cbec12 100644 --- a/clang/test/CIR/Lowering/scope.cir +++ b/clang/test/CIR/Lowering/scope.cir @@ -14,26 +14,16 @@ module { } // MLIR: llvm.func @foo() -// MLIR-NEXT: llvm.br ^bb1 -// MLIR-NEXT: ^bb1: // MLIR-DAG: [[v1:%[0-9]]] = llvm.mlir.constant(4 : i32) : i32 // MLIR-DAG: [[v2:%[0-9]]] = llvm.mlir.constant(1 : index) : i64 // MLIR-DAG: [[v3:%[0-9]]] = llvm.alloca [[v2]] x i32 {alignment = 4 : i64} : (i64) -> !llvm.ptr // MLIR-NEXT: llvm.store [[v1]], [[v3]] {{.*}}: i32, !llvm.ptr -// MLIR-NEXT: llvm.br ^bb2 -// MLIR-NEXT: ^bb2: // MLIR-NEXT: llvm.return // LLVM: define void @foo() -// LLVM-NEXT: br label %1 -// LLVM-EMPTY: -// LLVM-NEXT: 1: -// LLVM-NEXT: %2 = alloca i32, i64 1, align 4 -// LLVM-NEXT: store i32 4, ptr %2, align 4 -// LLVM-NEXT: br label %3 -// LLVM-EMPTY: -// LLVM-NEXT: 3: +// LLVM: %1 = alloca i32, i64 1, align 4 +// LLVM-NEXT: store i32 4, ptr %1, align 4 // LLVM-NEXT: ret void // LLVM-NEXT: } @@ -64,13 +54,11 @@ module { // MLIR: llvm.func @scope_with_return() // MLIR-NEXT: [[v0:%.*]] = llvm.mlir.constant(1 : index) : i64 // MLIR-NEXT: [[v1:%.*]] = llvm.alloca [[v0]] x i32 {alignment = 4 : i64} : (i64) -> !llvm.ptr - // MLIR-NEXT: llvm.br ^bb1 - // MLIR-NEXT: ^bb1: // pred: ^bb0 // MLIR-NEXT: [[v2:%.*]] = llvm.mlir.constant(0 : i32) : i32 // MLIR-NEXT: llvm.store [[v2]], [[v1]] {{.*}}: i32, !llvm.ptr // MLIR-NEXT: [[v3:%.*]] = llvm.load [[v1]] {alignment = 4 : i64} : !llvm.ptr -> i32 // MLIR-NEXT: llvm.return [[v3]] : i32 - // MLIR-NEXT: ^bb2: // no predecessors + // MLIR-NEXT: ^bb1: // no predecessors // MLIR-NEXT: [[v4:%.*]] = llvm.load [[v1]] {alignment = 4 : i64} : !llvm.ptr -> i32 // MLIR-NEXT: llvm.return [[v4]] : i32 // MLIR-NEXT: } diff --git a/clang/test/CIR/Lowering/switch.cir b/clang/test/CIR/Lowering/switch.cir index dee8e98db858..b362753145ce 100644 --- a/clang/test/CIR/Lowering/switch.cir +++ b/clang/test/CIR/Lowering/switch.cir @@ -122,17 +122,14 @@ module { cir.return } // CHECK: llvm.func @shouldLowerMultiBlockCase - // CHECK: ^bb1: // pred: ^bb0 - // CHECK: llvm.switch {{.*}} : i32, ^bb4 [ - // CHECK: 3: ^bb2 + // CHECK: llvm.switch {{.*}} : i32, ^bb3 [ + // CHECK: 3: ^bb1 // CHECK: ] - // CHECK: ^bb2: // pred: ^bb1 + // CHECK: ^bb1: // pred: ^bb0 // CHECK: llvm.return - // CHECK: ^bb3: // no predecessors - // CHECK: llvm.br ^bb4 - // CHECK: ^bb4: // 2 preds: ^bb1, ^bb3 - // CHECK: llvm.br ^bb5 - // CHECK: ^bb5: // pred: ^bb4 + // CHECK: ^bb2: // no predecessors + // CHECK: llvm.br ^bb3 + // CHECK: ^bb3: // 2 preds: ^bb0, ^bb2 // CHECK: llvm.return // CHECK: } @@ -165,21 +162,15 @@ module { cir.return %4 : !s32i } // CHECK: llvm.func @shouldLowerNestedBreak - // CHECK: llvm.switch %6 : i32, ^bb7 [ - // CHECK: 0: ^bb2 + // CHECK: llvm.switch %6 : i32, ^bb4 [ + // CHECK: 0: ^bb1 // CHECK: ] + // CHECK: ^bb1: // pred: ^bb0 + // CHECK: llvm.cond_br {{%.*}}, ^bb2, ^bb3 // CHECK: ^bb2: // pred: ^bb1 - // CHECK: llvm.br ^bb3 - // CHECK: ^bb3: // pred: ^bb2 - // CHECK: llvm.cond_br {{%.*}}, ^bb4, ^bb5 - // CHECK: ^bb4: // pred: ^bb3 - // CHECK: llvm.br ^bb7 - // CHECK: ^bb5: // pred: ^bb3 - // CHECK: llvm.br ^bb6 - // CHECK: ^bb6: // pred: ^bb5 - // CHECK: llvm.br ^bb7 - // CHECK: ^bb7: // 3 preds: ^bb1, ^bb4, ^bb6 - // CHECK: llvm.br ^bb8 - // CHECK: ^bb8: // pred: ^bb7 + // CHECK: llvm.br ^bb4 + // CHECK: ^bb3: // pred: ^bb1 + // CHECK: llvm.br ^bb4 + // CHECK: ^bb4: // 3 preds: ^bb0, ^bb2, ^bb3 // CHECK: llvm.return } diff --git a/clang/test/CIR/Lowering/ternary.cir b/clang/test/CIR/Lowering/ternary.cir index 6e469f388d79..b79d7eac726f 100644 --- a/clang/test/CIR/Lowering/ternary.cir +++ b/clang/test/CIR/Lowering/ternary.cir @@ -41,8 +41,6 @@ cir.func @_Z1xi(%arg0: !s32i) -> !s32i { // MLIR-NEXT: %8 = llvm.mlir.constant(5 : i32) : i32 // MLIR-NEXT: llvm.br ^bb3(%8 : i32) // MLIR-NEXT: ^bb3(%9: i32): // 2 preds: ^bb1, ^bb2 -// MLIR-NEXT: llvm.br ^bb4 -// MLIR-NEXT: ^bb4: // pred: ^bb3 // MLIR-NEXT: llvm.store %9, %3 {{.*}}: i32, !llvm.ptr // MLIR-NEXT: %10 = llvm.load %3 {alignment = 4 : i64} : !llvm.ptr -> i32 // MLIR-NEXT: llvm.return %10 : i32 diff --git a/clang/test/CIR/Lowering/unary-not.cir b/clang/test/CIR/Lowering/unary-not.cir index 48e2705e756d..b1eac868133e 100644 --- a/clang/test/CIR/Lowering/unary-not.cir +++ b/clang/test/CIR/Lowering/unary-not.cir @@ -22,41 +22,67 @@ module { cir.func @floatingPoint(%arg0: !cir.float, %arg1: !cir.double) { - // MLIR: llvm.func @floatingPoint + // MLIR: llvm.func @floatingPoint %0 = cir.alloca !cir.float, !cir.ptr, ["f", init] {alignment = 4 : i64} %1 = cir.alloca !cir.double, !cir.ptr, ["d", init] {alignment = 8 : i64} + %2 = cir.alloca !cir.bool, !cir.ptr, ["tmp1"] {alignment = 1 : i64} + %3 = cir.alloca !cir.bool, !cir.ptr, ["tmp2"] {alignment = 1 : i64} + %4 = cir.alloca !cir.bool, !cir.ptr, ["tmp3"] {alignment = 1 : i64} + %5 = cir.alloca !cir.bool, !cir.ptr, ["tmp4"] {alignment = 1 : i64} + cir.store %arg0, %0 : !cir.float, !cir.ptr cir.store %arg1, %1 : !cir.double, !cir.ptr - %2 = cir.load %0 : !cir.ptr, !cir.float - %3 = cir.cast(float_to_bool, %2 : !cir.float), !cir.bool + + %6 = cir.load %0 : !cir.ptr, !cir.float + %7 = cir.cast(float_to_bool, %6 : !cir.float), !cir.bool + cir.store %7, %2 : !cir.bool, !cir.ptr // MLIR: %[[#F_ZERO:]] = llvm.mlir.constant(0.000000e+00 : f32) : f32 // MLIR: %[[#F_BOOL:]] = llvm.fcmp "une" %{{.+}}, %[[#F_ZERO]] : f32 // MLIR: %[[#F_ZEXT:]] = llvm.zext %[[#F_BOOL]] : i1 to i8 - %4 = cir.unary(not, %3) : !cir.bool, !cir.bool + + %8 = cir.unary(not, %7) : !cir.bool, !cir.bool + cir.store %8, %3 : !cir.bool, !cir.ptr // MLIR: %[[#F_ONE:]] = llvm.mlir.constant(1 : i8) : i8 // MLIR: = llvm.xor %[[#F_ZEXT]], %[[#F_ONE]] : i8 - %5 = cir.load %1 : !cir.ptr, !cir.double - %6 = cir.cast(float_to_bool, %5 : !cir.double), !cir.bool + + %9 = cir.load %1 : !cir.ptr, !cir.double + %10 = cir.cast(float_to_bool, %9 : !cir.double), !cir.bool + cir.store %10, %4 : !cir.bool, !cir.ptr // MLIR: %[[#D_ZERO:]] = llvm.mlir.constant(0.000000e+00 : f64) : f64 // MLIR: %[[#D_BOOL:]] = llvm.fcmp "une" %{{.+}}, %[[#D_ZERO]] : f64 // MLIR: %[[#D_ZEXT:]] = llvm.zext %[[#D_BOOL]] : i1 to i8 - %7 = cir.unary(not, %6) : !cir.bool, !cir.bool + + %11 = cir.unary(not, %10) : !cir.bool, !cir.bool + cir.store %11, %5 : !cir.bool, !cir.ptr // MLIR: %[[#D_ONE:]] = llvm.mlir.constant(1 : i8) : i8 // MLIR: = llvm.xor %[[#D_ZEXT]], %[[#D_ONE]] : i8 + cir.return } cir.func @CStyleValueNegation(%arg0: !s32i, %arg1: !cir.float) { - // MLIR: llvm.func @CStyleValueNegation + // MLIR: llvm.func @CStyleValueNegation %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %3 = cir.alloca !cir.float, !cir.ptr, ["f", init] {alignment = 4 : i64} + %1 = cir.alloca !cir.float, !cir.ptr, ["f", init] {alignment = 4 : i64} + %2 = cir.alloca !cir.bool, !cir.ptr, ["tmp1"] {alignment = 1 : i64} + %3 = cir.alloca !cir.bool, !cir.ptr, ["tmp2"] {alignment = 1 : i64} + %4 = cir.alloca !s32i, !cir.ptr, ["tmp3"] {alignment = 4 : i64} + %5 = cir.alloca !cir.bool, !cir.ptr, ["tmp4"] {alignment = 1 : i64} + %6 = cir.alloca !cir.bool, !cir.ptr, ["tmp5"] {alignment = 1 : i64} + %7 = cir.alloca !s32i, !cir.ptr, ["tmp6"] {alignment = 4 : i64} + cir.store %arg0, %0 : !s32i, !cir.ptr - cir.store %arg1, %3 : !cir.float, !cir.ptr + cir.store %arg1, %1 : !cir.float, !cir.ptr - %5 = cir.load %0 : !cir.ptr, !s32i - %6 = cir.cast(int_to_bool, %5 : !s32i), !cir.bool - %7 = cir.unary(not, %6) : !cir.bool, !cir.bool - %8 = cir.cast(bool_to_int, %7 : !cir.bool), !s32i + %8 = cir.load %0 : !cir.ptr, !s32i + %9 = cir.cast(int_to_bool, %8 : !s32i), !cir.bool + cir.store %9, %2 : !cir.bool, !cir.ptr + + %10 = cir.unary(not, %9) : !cir.bool, !cir.bool + cir.store %10, %3 : !cir.bool, !cir.ptr + + %11 = cir.cast(bool_to_int, %10 : !cir.bool), !s32i + cir.store %11, %4 : !s32i, !cir.ptr // MLIR: %[[#INT:]] = llvm.load %{{.+}} : !llvm.ptr // MLIR: %[[#IZERO:]] = llvm.mlir.constant(0 : i32) : i32 // MLIR: %[[#ICMP:]] = llvm.icmp "ne" %[[#INT]], %[[#IZERO]] : i32 @@ -65,10 +91,15 @@ module { // MLIR: %[[#IXOR:]] = llvm.xor %[[#IEXT]], %[[#IONE]] : i8 // MLIR: = llvm.zext %[[#IXOR]] : i8 to i32 - %17 = cir.load %3 : !cir.ptr, !cir.float - %18 = cir.cast(float_to_bool, %17 : !cir.float), !cir.bool - %19 = cir.unary(not, %18) : !cir.bool, !cir.bool - %20 = cir.cast(bool_to_int, %19 : !cir.bool), !s32i + %12 = cir.load %1 : !cir.ptr, !cir.float + %13 = cir.cast(float_to_bool, %12 : !cir.float), !cir.bool + cir.store %13, %5 : !cir.bool, !cir.ptr + + %14 = cir.unary(not, %13) : !cir.bool, !cir.bool + cir.store %14, %6 : !cir.bool, !cir.ptr + + %15 = cir.cast(bool_to_int, %14 : !cir.bool), !s32i + cir.store %15, %7 : !s32i, !cir.ptr // MLIR: %[[#FLOAT:]] = llvm.load %{{.+}} : !llvm.ptr // MLIR: %[[#FZERO:]] = llvm.mlir.constant(0.000000e+00 : f32) : f32 // MLIR: %[[#FCMP:]] = llvm.fcmp "une" %[[#FLOAT]], %[[#FZERO]] : f32 diff --git a/clang/test/CIR/Transforms/loop.cir b/clang/test/CIR/Transforms/loop.cir index 8204216b6f52..ff1caf9dae53 100644 --- a/clang/test/CIR/Transforms/loop.cir +++ b/clang/test/CIR/Transforms/loop.cir @@ -19,8 +19,6 @@ module { // CHECK: ^bb[[#COND]]: // CHECK: cir.brcond %arg0 ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: -// CHECK: cir.br ^bb[[#STEP:]] -// CHECK: ^bb[[#STEP]]: // CHECK: cir.br ^bb[[#COND:]] // CHECK: ^bb[[#EXIT]]: // CHECK: cir.return @@ -56,10 +54,8 @@ module { } // CHECK: cir.func @testDoWhile(%arg0: !cir.bool) { // CHECK: cir.br ^bb[[#BODY:]] -// CHECK: ^bb[[#COND]]: -// CHECK: cir.brcond %arg0 ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: -// CHECK: cir.br ^bb[[#COND:]] +// CHECK: cir.brcond %arg0 ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#EXIT]]: // CHECK: cir.return // CHECK: } @@ -77,8 +73,6 @@ module { cir.return } // CHECK: cir.func @testWhileWithBreakTerminatedBody(%arg0: !cir.bool) { -// CHECK: cir.br ^bb[[#COND:]] -// CHECK: ^bb[[#COND]]: // CHECK: cir.brcond %arg0 ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: // CHECK: cir.br ^bb[[#EXIT]] @@ -108,13 +102,9 @@ module { // CHECK: ^bb[[#COND]]: // CHECK: cir.brcond %arg0 ^bb[[#BODY:]], ^bb[[#EXIT:]] // CHECK: ^bb[[#BODY]]: -// CHECK: cir.br ^bb[[#EX_SCOPE_IN:]] -// CHECK: ^bb[[#EX_SCOPE_IN]]: -// CHECK: cir.br ^bb[[#EXIT:]] +// CHECK: cir.br ^bb[[#EXIT]] // CHECK: ^bb[[#EX_SCOPE_EXIT:]]: -// CHECK: cir.br ^bb[[#STEP:]] -// CHECK: ^bb[[#STEP]]: -// CHECK: cir.br ^bb[[#COND:]] +// CHECK: cir.br ^bb[[#COND]] // CHECK: ^bb[[#EXIT]]: // CHECK: cir.return // CHECK: } diff --git a/clang/test/CIR/Transforms/scope.cir b/clang/test/CIR/Transforms/scope.cir index 2d14784c33f8..b5ba0f7aac2e 100644 --- a/clang/test/CIR/Transforms/scope.cir +++ b/clang/test/CIR/Transforms/scope.cir @@ -12,13 +12,9 @@ module { cir.return } // CHECK: cir.func @foo() { -// CHECK: cir.br ^bb1 -// CHECK: ^bb1: // pred: ^bb0 // CHECK: %0 = cir.alloca !u32i, !cir.ptr, ["a", init] {alignment = 4 : i64} // CHECK: %1 = cir.const #cir.int<4> : !u32i // CHECK: cir.store %1, %0 : !u32i, !cir.ptr -// CHECK: cir.br ^bb2 -// CHECK: ^bb2: // pred: ^bb1 // CHECK: cir.return // CHECK: } @@ -46,13 +42,11 @@ module { // CHECK: cir.func @scope_with_return() -> !u32i { // CHECK: %0 = cir.alloca !u32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} -// CHECK: cir.br ^bb1 -// CHECK: ^bb1: // pred: ^bb0 // CHECK: %1 = cir.const #cir.int<0> : !u32i // CHECK: cir.store %1, %0 : !u32i, !cir.ptr // CHECK: %2 = cir.load %0 : !cir.ptr, !u32i // CHECK: cir.return %2 : !u32i -// CHECK: ^bb2: // no predecessors +// CHECK: ^bb1: // no predecessors // CHECK: %3 = cir.load %0 : !cir.ptr, !u32i // CHECK: cir.return %3 : !u32i // CHECK: } diff --git a/clang/test/CIR/Transforms/switch.cir b/clang/test/CIR/Transforms/switch.cir index 177dfc98c8af..6d0422bbf5eb 100644 --- a/clang/test/CIR/Transforms/switch.cir +++ b/clang/test/CIR/Transforms/switch.cir @@ -139,19 +139,15 @@ module { // CHECK: cir.func @shouldFlatMultiBlockCase(%arg0: !s32i) { // CHECK: %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} // CHECK: cir.store %arg0, %0 : !s32i, !cir.ptr -// CHECK: cir.br ^bb1 -// CHECK: ^bb1: // pred: ^bb0 // CHECK: %1 = cir.load %0 : !cir.ptr, !s32i -// CHECK: cir.switch.flat %1 : !s32i, ^bb4 [ -// CHECK: 3: ^bb2 +// CHECK: cir.switch.flat %1 : !s32i, ^bb3 [ +// CHECK: 3: ^bb1 // CHECK: ] -// CHECK: ^bb2: // pred: ^bb1 +// CHECK: ^bb1: // pred: ^bb0 // CHECK: cir.return -// CHECK: ^bb3: // no predecessors -// CHECK: cir.br ^bb4 -// CHECK: ^bb4: // 2 preds: ^bb1, ^bb3 -// CHECK: cir.br ^bb5 -// CHECK: ^bb5: // pred: ^bb4 +// CHECK: ^bb2: // no predecessors +// CHECK: cir.br ^bb3 +// CHECK: ^bb3: // 2 preds: ^bb0, ^bb2 // CHECK: cir.return // CHECK: } @@ -185,22 +181,16 @@ module { cir.return %4 : !s32i } // CHECK: cir.func @shouldFlatNestedBreak(%arg0: !s32i, %arg1: !s32i) -> !s32i { -// CHECK: cir.switch.flat %3 : !s32i, ^bb7 [ -// CHECK: 0: ^bb2 +// CHECK: cir.switch.flat %3 : !s32i, ^bb4 [ +// CHECK: 0: ^bb1 // CHECK: ] +// CHECK: ^bb1: // pred: ^bb0 +// CHECK: cir.brcond {{%.*}} ^bb2, ^bb3 // CHECK: ^bb2: // pred: ^bb1 -// CHECK: cir.br ^bb3 -// CHECK: ^bb3: // pred: ^bb2 -// CHECK: cir.brcond {{%.*}} ^bb4, ^bb5 -// CHECK: ^bb4: // pred: ^bb3 -// CHECK: cir.br ^bb7 -// CHECK: ^bb5: // pred: ^bb3 -// CHECK: cir.br ^bb6 -// CHECK: ^bb6: // pred: ^bb5 -// CHECK: cir.br ^bb7 -// CHECK: ^bb7: // 3 preds: ^bb1, ^bb4, ^bb6 -// CHECK: cir.br ^bb8 -// CHECK: ^bb8: // pred: ^bb7 +// CHECK: cir.br ^bb4 +// CHECK: ^bb3: // pred: ^bb1 +// CHECK: cir.br ^bb4 +// CHECK: ^bb4: // 3 preds: ^bb0, ^bb2, ^bb3 // CHECK: cir.return %9 : !s32i // CHECK: } @@ -260,8 +250,6 @@ module { // CHECK-NEXT: ^[[CASE_DEFAULT]]: // CHECK-NEXT: cir.int<3> // CHECK-NEXT: cir.store -// CHECK-NEXT: cir.br ^[[EPILOG]] -// CHECK-NEXT: ^[[EPILOG]]: // CHECK-NEXT: cir.br ^[[EPILOG_END:bb[0-9]+]] // CHECK-NEXT: ^[[EPILOG_END]]: // CHECK: cir.return diff --git a/clang/test/CIR/Transforms/ternary.cir b/clang/test/CIR/Transforms/ternary.cir index 67ef7f95a6b5..833084602338 100644 --- a/clang/test/CIR/Transforms/ternary.cir +++ b/clang/test/CIR/Transforms/ternary.cir @@ -35,10 +35,6 @@ module { // CHECK: cir.br ^bb3(%5 : !s32i) // CHECK: ^bb2: // pred: ^bb0 // CHECK: %6 = cir.const #cir.int<5> : !s32i -// CHECK: cir.br ^bb3(%6 : !s32i) -// CHECK: ^bb3(%7: !s32i): // 2 preds: ^bb1, ^bb2 -// CHECK: cir.br ^bb4 -// CHECK: ^bb4: // pred: ^bb3 // CHECK: cir.store %7, %1 : !s32i, !cir.ptr // CHECK: %8 = cir.load %1 : !cir.ptr, !s32i // CHECK: cir.return %8 : !s32i @@ -60,8 +56,6 @@ module { // CHECK: ^bb2: // pred: ^bb0 // CHECK: cir.br ^bb3 // CHECK: ^bb3: // 2 preds: ^bb1, ^bb2 -// CHECK: cir.br ^bb4 -// CHECK: ^bb4: // pred: ^bb3 // CHECK: cir.return // CHECK: }