diff --git a/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIRIntrinsics.cpp b/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIRIntrinsics.cpp index 377cc44392028..0142fb0cfb0bb 100644 --- a/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIRIntrinsics.cpp +++ b/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIRIntrinsics.cpp @@ -18,12 +18,12 @@ #include "flang/Optimizer/HLFIR/HLFIROps.h" #include "flang/Optimizer/HLFIR/Passes.h" #include "mlir/IR/BuiltinDialect.h" +#include "mlir/IR/MLIRContext.h" #include "mlir/IR/PatternMatch.h" #include "mlir/Pass/Pass.h" #include "mlir/Pass/PassManager.h" #include "mlir/Support/LogicalResult.h" -#include "mlir/Transforms/DialectConversion.h" -#include +#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include namespace hlfir { @@ -176,14 +176,7 @@ class HlfirIntrinsicConversion : public mlir::OpRewritePattern { rewriter.eraseOp(use); } } - // TODO: This entire pass should be a greedy pattern rewrite or a manual - // IR traversal. A dialect conversion cannot be used here because - // `replaceAllUsesWith` is not supported. Similarly, `replaceOp` is not - // suitable because "op->getResult(0)" and "base" can have different types. - // In such a case, the dialect conversion will attempt to convert the type, - // but no type converter is specified in this pass. Also note that all - // patterns in this pass are actually rewrite patterns. - op->getResult(0).replaceAllUsesWith(base); + rewriter.replaceOp(op, base); } }; @@ -491,19 +484,19 @@ class LowerHLFIRIntrinsics ProductOpConversion, TransposeOpConversion, CountOpConversion, DotProductOpConversion, MaxvalOpConversion, MinvalOpConversion, MinlocOpConversion, MaxlocOpConversion>(context); - mlir::ConversionTarget target(*context); - target.addLegalDialect(); - target.addIllegalOp(); - target.markUnknownOpDynamicallyLegal( - [](mlir::Operation *) { return true; }); - if (mlir::failed( - mlir::applyFullConversion(module, target, std::move(patterns)))) { + + // While conceptually this pass is performing dialect conversion, we use + // pattern rewrites here instead of dialect conversion because this pass + // looses array bounds from some of the expressions e.g. + // !hlfir.expr<2xi32> -> !hlfir.expr + // MLIR thinks this is a different type so dialect conversion fails. + // Pattern rewriting only requires that the resulting IR is still valid + mlir::GreedyRewriteConfig config; + // Prevent the pattern driver from merging blocks + config.enableRegionSimplification = false; + + if (mlir::failed(mlir::applyPatternsAndFoldGreedily( + module, std::move(patterns), config))) { mlir::emitError(mlir::UnknownLoc::get(context), "failure in HLFIR intrinsic lowering"); signalPassFailure(); diff --git a/flang/test/HLFIR/all-lowering.fir b/flang/test/HLFIR/all-lowering.fir index dfd1ace947d68..e83378eacf9c9 100644 --- a/flang/test/HLFIR/all-lowering.fir +++ b/flang/test/HLFIR/all-lowering.fir @@ -34,6 +34,7 @@ func.func @_QPall2(%arg0: !fir.box>> {fir.bindc_n // CHECK: %[[ARG0:.*]]: !fir.box>> // CHECK: %[[ARG1:.*]]: !fir.box>> // CHECK: %[[ARG2:.*]]: !fir.ref +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] @@ -55,7 +56,6 @@ func.func @_QPall2(%arg0: !fir.box>> {fir.bindc_n // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>>, i1) -> !hlfir.expr> // CHECK: hlfir.assign %[[EXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[EXPR]] @@ -79,6 +79,7 @@ func.func @_QPall3(%arg0: !fir.ref>> {fir.bindc_nam } // CHECK-LABEL: func.func @_QPall3( // CHECK: %[[ARG0:.*]]: !fir.ref>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[RET_BOX:.*]] = fir.alloca !fir.box>>> // CHECK-DAG: %[[RET_ADDR:.*]] = fir.zero_bits !fir.heap>> // CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index @@ -101,7 +102,6 @@ func.func @_QPall3(%arg0: !fir.ref>> {fir.bindc_nam // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>>, i1) -> !hlfir.expr> // CHECK: hlfir.assign %[[EXPR]] to %[[RES]] // CHECK: hlfir.destroy %[[EXPR]] @@ -125,6 +125,7 @@ func.func @_QPall4(%arg0: !fir.box>> {fir.bindc_n // CHECK: %[[ARG0:.*]]: !fir.box>> // CHECK: %[[ARG1:.*]]: !fir.box>> // CHECK: %[[ARG2:.*]]: !fir.ref>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[DIM_ARG:.*]]:2 = hlfir.declare %[[ARG2]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] @@ -149,9 +150,8 @@ func.func @_QPall4(%arg0: !fir.box>> {fir.bindc_n // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>>, i1) -> !hlfir.expr> // CHECK: hlfir.assign %[[EXPR]] to %[[RES]] // CHECK: hlfir.destroy %[[EXPR]] // CHECK-NEXT: return -// CHECK-NEXT: } \ No newline at end of file +// CHECK-NEXT: } diff --git a/flang/test/HLFIR/any-lowering.fir b/flang/test/HLFIR/any-lowering.fir index ef8b895029319..039146727d3f5 100644 --- a/flang/test/HLFIR/any-lowering.fir +++ b/flang/test/HLFIR/any-lowering.fir @@ -36,6 +36,7 @@ func.func @_QPany2(%arg0: !fir.box>> {fir.bindc_n // CHECK: %[[ARG0:.*]]: !fir.box>> // CHECK: %[[ARG1:.*]]: !fir.box>> // CHECK: %[[ARG2:.*]]: !fir.ref +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] @@ -57,7 +58,6 @@ func.func @_QPany2(%arg0: !fir.box>> {fir.bindc_n // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>>, i1) -> !hlfir.expr> // CHECK: hlfir.assign %[[EXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[EXPR]] @@ -82,6 +82,7 @@ func.func @_QPany3(%arg0: !fir.ref>> {fir.bindc_nam } // CHECK-LABEL: func.func @_QPany3( // CHECK: %[[ARG0:.*]]: !fir.ref>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[RET_BOX:.*]] = fir.alloca !fir.box>>> // CHECK-DAG: %[[RET_ADDR:.*]] = fir.zero_bits !fir.heap>> // CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index @@ -104,7 +105,6 @@ func.func @_QPany3(%arg0: !fir.ref>> {fir.bindc_nam // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>>, i1) -> !hlfir.expr> // CHECK: hlfir.assign %[[EXPR]] to %[[RES]] // CHECK: hlfir.destroy %[[EXPR]] @@ -129,6 +129,7 @@ func.func @_QPany4(%arg0: !fir.box>> {fir.bindc_n // CHECK: %[[ARG0:.*]]: !fir.box>> // CHECK: %[[ARG1:.*]]: !fir.box>> // CHECK: %[[ARG2:.*]]: !fir.ref>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[DIM_ARG:.*]]:2 = hlfir.declare %[[ARG2]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] @@ -153,7 +154,6 @@ func.func @_QPany4(%arg0: !fir.box>> {fir.bindc_n // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>>, i1) -> !hlfir.expr> // CHECK: hlfir.assign %[[EXPR]] to %[[RES]] // CHECK: hlfir.destroy %[[EXPR]] diff --git a/flang/test/HLFIR/count-lowering-default-int-kinds.fir b/flang/test/HLFIR/count-lowering-default-int-kinds.fir index ea66c435e6a8a..68bc7fdbaad87 100644 --- a/flang/test/HLFIR/count-lowering-default-int-kinds.fir +++ b/flang/test/HLFIR/count-lowering-default-int-kinds.fir @@ -2,9 +2,9 @@ // RUN: fir-opt %s -lower-hlfir-intrinsics | FileCheck %s module attributes {fir.defaultkind = "a1c4d8i8l4r4", fir.kindmap = ""} { - func.func @test_i8(%arg0: !fir.box>> {fir.bindc_name = "x"}, %arg1: i64) { + func.func @test_i8(%arg0: !fir.box>> {fir.bindc_name = "x"}, %arg1: i64) -> !hlfir.expr { %4 = hlfir.count %arg0 dim %arg1 : (!fir.box>>, i64) -> !hlfir.expr - return + return %4 : !hlfir.expr } } // CHECK-LABEL: func.func @test_i8 @@ -12,9 +12,9 @@ module attributes {fir.defaultkind = "a1c4d8i8l4r4", fir.kindmap = ""} { // CHECK: fir.call @_FortranACountDim(%{{.*}}, %{{.*}}, %{{.*}}, %[[KIND]], %{{.*}}, %{{.*}}) : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32) -> none module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = ""} { - func.func @test_i4(%arg0: !fir.box>> {fir.bindc_name = "x"}, %arg1: i64) { + func.func @test_i4(%arg0: !fir.box>> {fir.bindc_name = "x"}, %arg1: i64) -> !hlfir.expr { %4 = hlfir.count %arg0 dim %arg1 : (!fir.box>>, i64) -> !hlfir.expr - return + return %4 : !hlfir.expr } } // CHECK-LABEL: func.func @test_i4 @@ -22,9 +22,9 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = ""} { // CHECK: fir.call @_FortranACountDim(%{{.*}}, %{{.*}}, %{{.*}}, %[[KIND]], %{{.*}}, %{{.*}}) : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32) -> none module attributes {fir.defaultkind = "a1c4d8i2l4r4", fir.kindmap = ""} { - func.func @test_i2(%arg0: !fir.box>> {fir.bindc_name = "x"}, %arg1: i64) { + func.func @test_i2(%arg0: !fir.box>> {fir.bindc_name = "x"}, %arg1: i64) -> !hlfir.expr { %4 = hlfir.count %arg0 dim %arg1 : (!fir.box>>, i64) -> !hlfir.expr - return + return %4 : !hlfir.expr } } // CHECK-LABEL: func.func @test_i2 @@ -32,9 +32,9 @@ module attributes {fir.defaultkind = "a1c4d8i2l4r4", fir.kindmap = ""} { // CHECK: fir.call @_FortranACountDim(%{{.*}}, %{{.*}}, %{{.*}}, %[[KIND]], %{{.*}}, %{{.*}}) : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32) -> none module attributes {fir.defaultkind = "a1c4d8i1l4r4", fir.kindmap = ""} { - func.func @test_i1(%arg0: !fir.box>> {fir.bindc_name = "x"}, %arg1: i64) { + func.func @test_i1(%arg0: !fir.box>> {fir.bindc_name = "x"}, %arg1: i64) -> !hlfir.expr { %4 = hlfir.count %arg0 dim %arg1 : (!fir.box>>, i64) -> !hlfir.expr - return + return %4 : !hlfir.expr } } // CHECK-LABEL: func.func @test_i1 diff --git a/flang/test/HLFIR/count-lowering.fir b/flang/test/HLFIR/count-lowering.fir index da0f250dceef3..c3309724981a3 100644 --- a/flang/test/HLFIR/count-lowering.fir +++ b/flang/test/HLFIR/count-lowering.fir @@ -34,6 +34,7 @@ func.func @_QPcount2(%arg0: !fir.box>> {fir.bindc // CHECK: %[[ARG0:.*]]: !fir.box>> // CHECK: %[[ARG1:.*]]: !fir.box // CHECK: %[[ARG2:.*]]: !fir.ref +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[KIND:.*]] = arith.constant 4 : i32 // CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]] @@ -56,7 +57,6 @@ func.func @_QPcount2(%arg0: !fir.box>> {fir.bindc // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK: hlfir.assign %[[EXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[EXPR]] @@ -80,6 +80,7 @@ func.func @_QPcount3(%arg0: !fir.ref> {fir.bindc_name = "s"}) } // CHECK-LABEL: func.func @_QPcount3( // CHECK: %[[ARG0:.*]]: !fir.ref> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[RET_BOX:.*]] = fir.alloca !fir.box>> // CHECK-DAG: %[[KIND:.*]] = arith.constant 4 : i32 // CHECK-DAG: %[[RET_ADDR:.*]] = fir.zero_bits !fir.heap> @@ -104,7 +105,6 @@ func.func @_QPcount3(%arg0: !fir.ref> {fir.bindc_name = "s"}) // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK: hlfir.assign %[[EXPR]] to %[[RES]] // CHECK: hlfir.destroy %[[EXPR]] @@ -133,6 +133,7 @@ func.func @_QPcount4(%arg0: !fir.box>> {fir.bindc // CHECK: %[[ARG0:.*]]: !fir.box>> // CHECK: %[[ARG1:.*]]: !fir.box // CHECK: %[[ARG2:.*]]: !fir.ref +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[MASK:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] @@ -155,7 +156,6 @@ func.func @_QPcount4(%arg0: !fir.box>> {fir.bindc // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: %[[OUT_SHAPE:.*]] = hlfir.shape_of %[[EXPR]] // CHECK-NEXT: %[[OUT:.*]] = hlfir.elemental %[[OUT_SHAPE]] : (!fir.shape<1>) -> !hlfir.expr diff --git a/flang/test/HLFIR/dot_product-lowering.fir b/flang/test/HLFIR/dot_product-lowering.fir index e4f91eabfc099..64d65665433f1 100644 --- a/flang/test/HLFIR/dot_product-lowering.fir +++ b/flang/test/HLFIR/dot_product-lowering.fir @@ -96,7 +96,6 @@ func.func @_QPdot_product4(%arg0: !fir.box>> {fir.b // CHECK: %[[VAL_2:.*]] = fir.alloca !fir.logical<4> // CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "_QFdot_product2Elhs"} : (!fir.box>>) -> (!fir.box>>, !fir.box>>) // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_1]] {uniq_name = "_QFdot_product2Erhs"} : (!fir.box>>) -> (!fir.box>>, !fir.box>>) -// CHECK: %[[VAL_5:.*]] = fir.absent !fir.box> // CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_3]]#1 : (!fir.box>>) -> !fir.box // CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_4]]#1 : (!fir.box>>) -> !fir.box // CHECK: %[[VAL_12:.*]] = fir.call @_FortranADotProductLogical(%[[VAL_9]], %[[VAL_10]], %{{.*}}, %{{.*}}) fastmath : (!fir.box, !fir.box, !fir.ref, i32) -> i1 diff --git a/flang/test/HLFIR/extents-of-shape-of.f90 b/flang/test/HLFIR/extents-of-shape-of.f90 index d807f8b70302b..1168004597d19 100644 --- a/flang/test/HLFIR/extents-of-shape-of.f90 +++ b/flang/test/HLFIR/extents-of-shape-of.f90 @@ -31,18 +31,17 @@ elemental subroutine elem_sub(x) ! CHECK-HLFIR-NEXT: hlfir.destroy %[[MUL]] ! ... +! CHECK-FIR-DAG: %[[C0:.*]] = arith.constant 0 : index +! CHECK-FIR-DAG: %[[C1:.*]] = arith.constant 1 : index +! CHECK-FIR-DAG: %[[C2:.*]] = arith.constant 2 : index ! CHECK-FIR: fir.call @_FortranAMatmul ! CHECK-FIR-NEXT: %[[MUL:.*]] = fir.load %[[MUL_BOX:.*]] : !fir.ref>>> -! CHECK-FIR-NEXT: %[[C0:.*]] = arith.constant 0 : index ! CHECK-FIR-NEXT: %[[DIMS0:.*]]:3 = fir.box_dims %[[MUL]], %[[C0]] -! CHECK-FIR-NEXT: %[[C1:.*]] = arith.constant 1 : index ! CHECK-FIR-NEXT: %[[DIMS1:.*]]:3 = fir.box_dims %[[MUL]], %[[C1]] ! ... ! CHECK-FIR: %[[SHAPE:.*]] = fir.shape %[[DIMS0]]#1, %[[DIMS1]]#1 -! CHECK-FIR-NEXT: %[[C2:.*]] = arith.constant 2 : index -! CHECK-FIR-NEXT: %[[C1_1:.*]] = arith.constant 1 : index -! CHECK-FIR-NEXT: fir.do_loop %[[ARG2:.*]] = %[[C1_1]] to %[[DIMS1]]#1 step %[[C1_1]] unordered { -! CHECK-FIR-NEXT: fir.do_loop %[[ARG3:.*]] = %[[C1_1]] to %[[C2]] step %[[C1_1]] unordered { +! CHECK-FIR-NEXT: fir.do_loop %[[ARG2:.*]] = %[[C1]] to %[[DIMS1]]#1 step %[[C1]] unordered { +! CHECK-FIR-NEXT: fir.do_loop %[[ARG3:.*]] = %[[C1]] to %[[C2]] step %[[C1]] unordered { ! ... ! CHECK-ALL: return diff --git a/flang/test/HLFIR/matmul-lowering.fir b/flang/test/HLFIR/matmul-lowering.fir index ee921da9a5256..85a73dd45160f 100644 --- a/flang/test/HLFIR/matmul-lowering.fir +++ b/flang/test/HLFIR/matmul-lowering.fir @@ -14,6 +14,7 @@ func.func @_QPmatmul1(%arg0: !fir.box> {fir.bindc_name = "lh // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "lhs"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "rhs"} // CHECK: %[[ARG2:.*]]: !fir.box> {fir.bindc_name = "res"} +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[LHS_VAR:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[RHS_VAR:.*]]:2 = hlfir.declare %[[ARG1]] // CHECK-DAG: %[[RES_VAR:.*]]:2 = hlfir.declare %[[ARG2]] @@ -37,7 +38,6 @@ func.func @_QPmatmul1(%arg0: !fir.box> {fir.bindc_name = "lh // TODO: fix alias analysis in hlfir.assign bufferization // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} // TODO: add shape information from original intrinsic op -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[ASEXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK: hlfir.assign %[[ASEXPR]] to %[[RES_VAR]]#0 // CHECK: hlfir.destroy %[[ASEXPR]] diff --git a/flang/test/HLFIR/maxloc-lowering.fir b/flang/test/HLFIR/maxloc-lowering.fir index 9e52a074a6e28..a51c9b483fa05 100644 --- a/flang/test/HLFIR/maxloc-lowering.fir +++ b/flang/test/HLFIR/maxloc-lowering.fir @@ -13,29 +13,28 @@ func.func @_QPmaxloc1(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK-LABEL: func.func @_QPmaxloc1( // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFmaxloc1Ea"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFmaxloc1Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 // CHECK-NEXT: %[[V3:.*]] = fir.absent !fir.box -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V4:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V5:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V5:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V6:.*]] = fir.embox %[[V4]](%[[V5]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V6]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V8:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V9:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V12:.*]] = fir.convert %[[V3]] : (!fir.box) -> !fir.box -// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMaxlocInteger4(%[[V8]], %[[V9]], %c4_i32, {{.*}}, {{.*}}, %[[V12]], %false) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMaxlocInteger4(%[[V8]], %[[V9]], %[[C4]], {{.*}}, {{.*}}, %[[V12]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V16:.*]] = fir.box_addr %[[V14]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V17:.*]] = fir.shape_shift %[[V15]]#0, %[[V15]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V18:.*]]:2 = hlfir.declare %[[V16]](%[[V17]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V19]] to %[[V2]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V19]] : !hlfir.expr @@ -55,32 +54,31 @@ func.func @_QPmaxloc2(%arg0: !fir.box> {fir.bindc_name = "a" // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} // CHECK: %[[ARG2:.*]]: !fir.ref -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFmaxloc2Ea"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG2]] {uniq_name = "_QFmaxloc2Ed"} : (!fir.ref) -> (!fir.ref, !fir.ref) // CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFmaxloc2Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V4:.*]] = fir.load %[[V2]]#0 : !fir.ref -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 // CHECK-NEXT: %[[V5:.*]] = fir.convert %[[V4]] : (index) -> i32 // CHECK-NEXT: %[[V6:.*]] = fir.absent !fir.box -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V7:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V8:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V8:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V9:.*]] = fir.embox %[[V7]](%[[V8]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V9]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V11:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V12:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V15:.*]] = fir.convert %[[V6]] : (!fir.box) -> !fir.box -// CHECK-NEXT: %[[V16:.*]] = fir.call @_FortranAMaxlocDim(%[[V11]], %[[V12]], %c4_i32, %[[V5]], {{.*}}, {{.*}}, %[[V15]], %false) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V16:.*]] = fir.call @_FortranAMaxlocDim(%[[V11]], %[[V12]], %[[C4]], %[[V5]], {{.*}}, {{.*}}, %[[V15]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V17:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V18:.*]]:3 = fir.box_dims %[[V17]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V18:.*]]:3 = fir.box_dims %[[V17]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V19:.*]] = fir.box_addr %[[V17]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V20:.*]] = fir.shape_shift %[[V18]]#0, %[[V18]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V21:.*]]:2 = hlfir.declare %[[V19]](%[[V20]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V22:.*]] = hlfir.as_expr %[[V21]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V22:.*]] = hlfir.as_expr %[[V21]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V22]] to %[[V3]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V22]] : !hlfir.expr // CHECK-NEXT: return @@ -100,30 +98,29 @@ func.func @_QPmaxloc3(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} // CHECK: %[[ARG2:.*]]: !fir.ref> -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFmaxloc3Ea"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG2]] {uniq_name = "_QFmaxloc3Em"} : (!fir.ref>) -> (!fir.ref>, !fir.ref>) // CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFmaxloc3Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 // CHECK-NEXT: %[[V4:.*]] = fir.embox %[[V2]]#1 : (!fir.ref>) -> !fir.box> -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V5:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V6:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V6:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V7:.*]] = fir.embox %[[V5]](%[[V6]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V7]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V9:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V10:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V13:.*]] = fir.convert %[[V4]] : (!fir.box>) -> !fir.box -// CHECK-NEXT: %[[V14:.*]] = fir.call @_FortranAMaxlocInteger4(%[[V9]], %[[V10]], %c4_i32, {{.*}}, {{.*}}, %[[V13]], %false) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V14:.*]] = fir.call @_FortranAMaxlocInteger4(%[[V9]], %[[V10]], %[[C4]], {{.*}}, {{.*}}, %[[V13]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V15:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V16:.*]]:3 = fir.box_dims %[[V15]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V16:.*]]:3 = fir.box_dims %[[V15]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V17:.*]] = fir.box_addr %[[V15]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V18:.*]] = fir.shape_shift %[[V16]]#0, %[[V16]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V19:.*]]:2 = hlfir.declare %[[V17]](%[[V18]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V20:.*]] = hlfir.as_expr %[[V19]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V20:.*]] = hlfir.as_expr %[[V19]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V20]] to %[[V3]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V20]] : !hlfir.expr // CHECK-NEXT: return @@ -143,29 +140,28 @@ func.func @_QPmaxloc4(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} // CHECK: %[[ARG2:.*]]: !fir.box>> -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFmaxloc4Ea"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG2]] {uniq_name = "_QFmaxloc4Em"} : (!fir.box>>) -> (!fir.box>>, !fir.box>>) // CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFmaxloc4Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V4:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V5:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V5:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V6:.*]] = fir.embox %[[V4]](%[[V5]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V6]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V8:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V9:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V12:.*]] = fir.convert %[[V2]]#1 : (!fir.box>>) -> !fir.box -// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMaxlocInteger4(%[[V8]], %[[V9]], %c4_i32, {{.*}}, {{.*}}, %[[V12]], %false) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMaxlocInteger4(%[[V8]], %[[V9]], %[[C4]], {{.*}}, {{.*}}, %[[V12]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V16:.*]] = fir.box_addr %[[V14]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V17:.*]] = fir.shape_shift %[[V15]]#0, %[[V15]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V18:.*]]:2 = hlfir.declare %[[V16]](%[[V17]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V19]] to %[[V3]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V19]] : !hlfir.expr // CHECK-NEXT: return @@ -205,42 +201,38 @@ func.func @_QPmaxloc5(%arg0: !fir.ref> {fir.bindc_name = "s"}) } // CHECK-LABEL: func.func @_QPmaxloc5( // CHECK: %[[ARG0:.*]]: !fir.ref> {fir.bindc_name = "s"} -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]] = fir.alloca !fir.logical<4> // CHECK-NEXT: %[[V2:.*]] = fir.address_of(@_QFmaxloc5Ea) : !fir.ref> -// CHECK-NEXT: %c2 = arith.constant 2 : index -// CHECK-NEXT: %c2_0 = arith.constant 2 : index -// CHECK-NEXT: %[[V3:.*]] = fir.shape %c2, %c2_0 : (index, index) -> !fir.shape<2> +// CHECK-NEXT: %[[V3:.*]] = fir.shape %[[C2]], %[[C2]] : (index, index) -> !fir.shape<2> // CHECK-NEXT: %[[V4:.*]]:2 = hlfir.declare %[[V2]](%[[V3]]) {uniq_name = "_QFmaxloc5Ea"} : (!fir.ref>, !fir.shape<2>) -> (!fir.ref>, !fir.ref>) -// CHECK-NEXT: %c2_1 = arith.constant 2 : index -// CHECK-NEXT: %[[V5:.*]] = fir.shape %c2_1 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V5:.*]] = fir.shape %[[C2]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V6:.*]]:2 = hlfir.declare %[[ARG0]](%[[V5]]) {uniq_name = "_QFmaxloc5Es"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) -// CHECK-NEXT: %c1_i32 = arith.constant 1 : i32 -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 -// CHECK-NEXT: %[[V7:.*]] = fir.shape %c2, %c2_0 : (index, index) -> !fir.shape<2> +// CHECK-NEXT: %[[V7:.*]] = fir.shape %[[C2]], %[[C2]] : (index, index) -> !fir.shape<2> // CHECK-NEXT: %[[V8:.*]] = fir.embox %[[V4]]#1(%[[V7]]) : (!fir.ref>, !fir.shape<2>) -> !fir.box> -// CHECK-NEXT: %[[V9:.*]] = fir.convert %true : (i1) -> !fir.logical<4> +// CHECK-NEXT: %[[V9:.*]] = fir.convert %[[TRUE]] : (i1) -> !fir.logical<4> // CHECK-NEXT: fir.store %[[V9]] to %[[V1]] : !fir.ref> // CHECK-NEXT: %[[V10:.*]] = fir.embox %[[V1]] : (!fir.ref>) -> !fir.box> -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V11:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V12:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V12:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V13:.*]] = fir.embox %[[V11]](%[[V12]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V13]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V15:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V16:.*]] = fir.convert %[[V8]] : (!fir.box>) -> !fir.box // CHECK: %[[V19:.*]] = fir.convert %[[V10]] : (!fir.box>) -> !fir.box -// CHECK-NEXT: %[[V20:.*]] = fir.call @_FortranAMaxlocDim(%[[V15]], %[[V16]], %c4_i32, %c1_i32, {{.*}}, {{.*}}, %[[V19]], %false) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V20:.*]] = fir.call @_FortranAMaxlocDim(%[[V15]], %[[V16]], %[[C4]], %[[C1]], {{.*}}, {{.*}}, %[[V19]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V21:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_2 = arith.constant 0 : index -// CHECK-NEXT: %[[V22:.*]]:3 = fir.box_dims %[[V21]], %c0_2 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V22:.*]]:3 = fir.box_dims %[[V21]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V23:.*]] = fir.box_addr %[[V21]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V24:.*]] = fir.shape_shift %[[V22]]#0, %[[V22]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V25:.*]]:2 = hlfir.declare %[[V23]](%[[V24]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true_3 = arith.constant true -// CHECK-NEXT: %[[V26:.*]] = hlfir.as_expr %[[V25]]#0 move %true_3 : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V26:.*]] = hlfir.as_expr %[[V25]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V26]] to %[[V6]]#0 : !hlfir.expr, !fir.ref> // CHECK-NEXT: hlfir.destroy %[[V26]] : !hlfir.expr // CHECK-NEXT: return @@ -258,29 +250,28 @@ func.func @_QPmaxloc6(%arg0: !fir.box>> {fir.bindc_n // CHECK-LABEL: func.func @_QPmaxloc6( // CHECK: %[[ARG0:.*]]: !fir.box>> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFmaxloc6Ea"} : (!fir.box>>) -> (!fir.box>>, !fir.box>>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFmaxloc4Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 // CHECK-NEXT: %[[V3:.*]] = fir.absent !fir.box -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V4:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V5:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V5:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V6:.*]] = fir.embox %[[V4]](%[[V5]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V6]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V8:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V9:.*]] = fir.convert %[[V1]]#1 : (!fir.box>>) -> !fir.box // CHECK: %[[V12:.*]] = fir.convert %[[V3]] : (!fir.box) -> !fir.box -// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMaxlocCharacter(%[[V8]], %[[V9]], %c4_i32, {{.*}}, {{.*}}, %[[V12]], %false) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMaxlocCharacter(%[[V8]], %[[V9]], %[[C4]], {{.*}}, {{.*}}, %[[V12]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V16:.*]] = fir.box_addr %[[V14]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V17:.*]] = fir.shape_shift %[[V15]]#0, %[[V15]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V18:.*]]:2 = hlfir.declare %[[V16]](%[[V17]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V19]] to %[[V2]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V19]] : !hlfir.expr // CHECK-NEXT: return @@ -304,22 +295,22 @@ func.func @_QPmaxloc7(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK: %[[ARG2:.*]]: !fir.box>> {fir.bindc_name = "m"} // CHECK: %[[ARG3:.*]]: !fir.ref> {fir.bindc_name = "b"} // CHECK: %[[ARG4:.*]]: !fir.box> {fir.bindc_name = "s"} -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box> +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFFtestEa"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG3]] {uniq_name = "_QFFtestEb"} : (!fir.ref>) -> (!fir.ref>, !fir.ref>) // CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFFtestEd"} : (!fir.ref) -> (!fir.ref, !fir.ref) // CHECK-NEXT: %[[V4:.*]]:2 = hlfir.declare %[[ARG2]] {uniq_name = "_QFFtestEm"} : (!fir.box>>) -> (!fir.box>>, !fir.box>>) // CHECK-NEXT: %[[V5:.*]]:2 = hlfir.declare %[[ARG4]] {uniq_name = "_QFFtestEs"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V6:.*]] = fir.load %[[V3]]#0 : !fir.ref -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V7:.*]] = fir.zero_bits !fir.heap // CHECK-NEXT: %[[V8:.*]] = fir.embox %[[V7]] : (!fir.heap) -> !fir.box> // CHECK-NEXT: fir.store %[[V8]] to %[[V0]] : !fir.ref>> // CHECK: %[[V10:.*]] = fir.convert %[[V0]] : (!fir.ref>>) -> !fir.ref> // CHECK-NEXT: %[[V11:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V14:.*]] = fir.convert %[[V4]]#1 : (!fir.box>>) -> !fir.box -// CHECK-NEXT: %[[V15:.*]] = fir.call @_FortranAMaxlocDim(%[[V10]], %[[V11]], %c4_i32, %[[V6]], {{.*}}, {{.*}}, %[[V14]], %false) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V15:.*]] = fir.call @_FortranAMaxlocDim(%[[V10]], %[[V11]], %[[C4]], %[[V6]], {{.*}}, {{.*}}, %[[V14]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V16:.*]] = fir.load %[[V0]] : !fir.ref>> // CHECK-NEXT: %[[V17:.*]] = fir.box_addr %[[V16]] : (!fir.box>) -> !fir.heap // CHECK-NEXT: %[[V18:.*]] = fir.load %[[V17]] : !fir.heap diff --git a/flang/test/HLFIR/maxval-lowering.fir b/flang/test/HLFIR/maxval-lowering.fir index 3eb36cdef2cbf..5a49ed5273ef8 100644 --- a/flang/test/HLFIR/maxval-lowering.fir +++ b/flang/test/HLFIR/maxval-lowering.fir @@ -37,6 +37,7 @@ func.func @_QPmaxval2(%arg0: !fir.box> {fir.bindc_name = "a" // CHECK: %[[ARG0:.*]]: !fir.box> // CHECK: %[[ARG1:.*]]: !fir.box> // CHECK: %[[ARG2:.*]]: !fir.ref +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] // CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]] @@ -63,7 +64,6 @@ func.func @_QPmaxval2(%arg0: !fir.box> {fir.bindc_name = "a" // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // TODO: fix alias analysis in hlfir.assign bufferization // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[ASEXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK: hlfir.assign %[[ASEXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[ASEXPR]] @@ -190,6 +190,7 @@ func.func @_QPmaxval6(%arg0: !fir.box>> {fir.bindc_n // CHECK-LABEL: func.func @_QPmaxval6( // CHECK: %[[ARG0:.*]]: !fir.box>> // CHECK: %[[ARG1:.*]]: !fir.boxchar<1> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[UNBOXED:.*]]:2 = fir.unboxchar %[[ARG1]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[UNBOXED]]#0 typeparams %[[UNBOXED]]#1 @@ -210,7 +211,6 @@ func.func @_QPmaxval6(%arg0: !fir.box>> {fir.bindc_n // CHECK: %[[BOX_ELESIZE:.*]] = fir.box_elesize %[[RET]] // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]] typeparams %[[BOX_ELESIZE]] {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[ASEXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.boxchar<1>, i1) -> !hlfir.expr> // CHECK: hlfir.assign %[[ASEXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[ASEXPR]] diff --git a/flang/test/HLFIR/minloc-lowering.fir b/flang/test/HLFIR/minloc-lowering.fir index fede0a1950121..6f3cbd171445c 100644 --- a/flang/test/HLFIR/minloc-lowering.fir +++ b/flang/test/HLFIR/minloc-lowering.fir @@ -13,29 +13,28 @@ func.func @_QPminloc1(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK-LABEL: func.func @_QPminloc1( // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFminloc1Ea"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFminloc1Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 // CHECK-NEXT: %[[V3:.*]] = fir.absent !fir.box -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V4:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V5:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V5:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V6:.*]] = fir.embox %[[V4]](%[[V5]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V6]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V8:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V9:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V12:.*]] = fir.convert %[[V3]] : (!fir.box) -> !fir.box -// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMinlocInteger4(%[[V8]], %[[V9]], %c4_i32, {{.*}}, {{.*}}, %[[V12]], %false) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMinlocInteger4(%[[V8]], %[[V9]], %[[C4]], {{.*}}, {{.*}}, %[[V12]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V16:.*]] = fir.box_addr %[[V14]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V17:.*]] = fir.shape_shift %[[V15]]#0, %[[V15]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V18:.*]]:2 = hlfir.declare %[[V16]](%[[V17]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V19]] to %[[V2]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V19]] : !hlfir.expr @@ -55,32 +54,31 @@ func.func @_QPminloc2(%arg0: !fir.box> {fir.bindc_name = "a" // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} // CHECK: %[[ARG2:.*]]: !fir.ref -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFminloc2Ea"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG2]] {uniq_name = "_QFminloc2Ed"} : (!fir.ref) -> (!fir.ref, !fir.ref) // CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFminloc2Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V4:.*]] = fir.load %[[V2]]#0 : !fir.ref -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 // CHECK-NEXT: %[[V5:.*]] = fir.convert %[[V4]] : (index) -> i32 // CHECK-NEXT: %[[V6:.*]] = fir.absent !fir.box -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V7:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V8:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V8:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V9:.*]] = fir.embox %[[V7]](%[[V8]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V9]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V11:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V12:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V15:.*]] = fir.convert %[[V6]] : (!fir.box) -> !fir.box -// CHECK-NEXT: %[[V16:.*]] = fir.call @_FortranAMinlocDim(%[[V11]], %[[V12]], %c4_i32, %[[V5]], {{.*}}, {{.*}}, %[[V15]], %false) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V16:.*]] = fir.call @_FortranAMinlocDim(%[[V11]], %[[V12]], %[[C4]], %[[V5]], {{.*}}, {{.*}}, %[[V15]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V17:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V18:.*]]:3 = fir.box_dims %[[V17]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V18:.*]]:3 = fir.box_dims %[[V17]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V19:.*]] = fir.box_addr %[[V17]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V20:.*]] = fir.shape_shift %[[V18]]#0, %[[V18]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V21:.*]]:2 = hlfir.declare %[[V19]](%[[V20]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V22:.*]] = hlfir.as_expr %[[V21]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V22:.*]] = hlfir.as_expr %[[V21]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V22]] to %[[V3]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V22]] : !hlfir.expr // CHECK-NEXT: return @@ -100,30 +98,29 @@ func.func @_QPminloc3(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} // CHECK: %[[ARG2:.*]]: !fir.ref> -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C0]] = arith.constant 0 : index +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFminloc3Ea"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG2]] {uniq_name = "_QFminloc3Em"} : (!fir.ref>) -> (!fir.ref>, !fir.ref>) // CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFminloc3Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 // CHECK-NEXT: %[[V4:.*]] = fir.embox %[[V2]]#1 : (!fir.ref>) -> !fir.box> -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V5:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V6:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V6:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V7:.*]] = fir.embox %[[V5]](%[[V6]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V7]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V9:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V10:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V13:.*]] = fir.convert %[[V4]] : (!fir.box>) -> !fir.box -// CHECK-NEXT: %[[V14:.*]] = fir.call @_FortranAMinlocInteger4(%[[V9]], %[[V10]], %c4_i32, {{.*}}, {{.*}}, %[[V13]], %false) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V14:.*]] = fir.call @_FortranAMinlocInteger4(%[[V9]], %[[V10]], %[[C4]], {{.*}}, {{.*}}, %[[V13]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V15:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V16:.*]]:3 = fir.box_dims %[[V15]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V16:.*]]:3 = fir.box_dims %[[V15]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V17:.*]] = fir.box_addr %[[V15]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V18:.*]] = fir.shape_shift %[[V16]]#0, %[[V16]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V19:.*]]:2 = hlfir.declare %[[V17]](%[[V18]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V20:.*]] = hlfir.as_expr %[[V19]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V20:.*]] = hlfir.as_expr %[[V19]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V20]] to %[[V3]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V20]] : !hlfir.expr // CHECK-NEXT: return @@ -143,29 +140,28 @@ func.func @_QPminloc4(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} // CHECK: %[[ARG2:.*]]: !fir.box>> -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFminloc4Ea"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG2]] {uniq_name = "_QFminloc4Em"} : (!fir.box>>) -> (!fir.box>>, !fir.box>>) // CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFminloc4Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V4:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V5:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V5:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V6:.*]] = fir.embox %[[V4]](%[[V5]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V6]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V8:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V9:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V12:.*]] = fir.convert %[[V2]]#1 : (!fir.box>>) -> !fir.box -// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMinlocInteger4(%[[V8]], %[[V9]], %c4_i32, {{.*}}, {{.*}}, %[[V12]], %false) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMinlocInteger4(%[[V8]], %[[V9]], %[[C4]], {{.*}}, {{.*}}, %[[V12]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V16:.*]] = fir.box_addr %[[V14]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V17:.*]] = fir.shape_shift %[[V15]]#0, %[[V15]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V18:.*]]:2 = hlfir.declare %[[V16]](%[[V17]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V19]] to %[[V3]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V19]] : !hlfir.expr // CHECK-NEXT: return @@ -205,42 +201,38 @@ func.func @_QPminloc5(%arg0: !fir.ref> {fir.bindc_name = "s"}) } // CHECK-LABEL: func.func @_QPminloc5( // CHECK: %[[ARG0:.*]]: !fir.ref> {fir.bindc_name = "s"} -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]] = fir.alloca !fir.logical<4> // CHECK-NEXT: %[[V2:.*]] = fir.address_of(@_QFminloc5Ea) : !fir.ref> -// CHECK-NEXT: %c2 = arith.constant 2 : index -// CHECK-NEXT: %c2_0 = arith.constant 2 : index -// CHECK-NEXT: %[[V3:.*]] = fir.shape %c2, %c2_0 : (index, index) -> !fir.shape<2> +// CHECK-NEXT: %[[V3:.*]] = fir.shape %[[C2]], %[[C2]] : (index, index) -> !fir.shape<2> // CHECK-NEXT: %[[V4:.*]]:2 = hlfir.declare %[[V2]](%[[V3]]) {uniq_name = "_QFminloc5Ea"} : (!fir.ref>, !fir.shape<2>) -> (!fir.ref>, !fir.ref>) -// CHECK-NEXT: %c2_1 = arith.constant 2 : index -// CHECK-NEXT: %[[V5:.*]] = fir.shape %c2_1 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V5:.*]] = fir.shape %[[C2]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V6:.*]]:2 = hlfir.declare %[[ARG0]](%[[V5]]) {uniq_name = "_QFminloc5Es"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) -// CHECK-NEXT: %c1_i32 = arith.constant 1 : i32 -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 -// CHECK-NEXT: %[[V7:.*]] = fir.shape %c2, %c2_0 : (index, index) -> !fir.shape<2> +// CHECK-NEXT: %[[V7:.*]] = fir.shape %[[C2]], %[[C2]] : (index, index) -> !fir.shape<2> // CHECK-NEXT: %[[V8:.*]] = fir.embox %[[V4]]#1(%[[V7]]) : (!fir.ref>, !fir.shape<2>) -> !fir.box> -// CHECK-NEXT: %[[V9:.*]] = fir.convert %true : (i1) -> !fir.logical<4> +// CHECK-NEXT: %[[V9:.*]] = fir.convert %[[TRUE]] : (i1) -> !fir.logical<4> // CHECK-NEXT: fir.store %[[V9]] to %[[V1]] : !fir.ref> // CHECK-NEXT: %[[V10:.*]] = fir.embox %[[V1]] : (!fir.ref>) -> !fir.box> -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V11:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V12:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V12:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V13:.*]] = fir.embox %[[V11]](%[[V12]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V13]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V15:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V16:.*]] = fir.convert %[[V8]] : (!fir.box>) -> !fir.box // CHECK: %[[V19:.*]] = fir.convert %[[V10]] : (!fir.box>) -> !fir.box -// CHECK-NEXT: %[[V20:.*]] = fir.call @_FortranAMinlocDim(%[[V15]], %[[V16]], %c4_i32, %c1_i32, {{.*}}, {{.*}}, %[[V19]], %false) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V20:.*]] = fir.call @_FortranAMinlocDim(%[[V15]], %[[V16]], %[[C4]], %[[C1]], {{.*}}, {{.*}}, %[[V19]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V21:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_2 = arith.constant 0 : index -// CHECK-NEXT: %[[V22:.*]]:3 = fir.box_dims %[[V21]], %c0_2 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V22:.*]]:3 = fir.box_dims %[[V21]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V23:.*]] = fir.box_addr %[[V21]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V24:.*]] = fir.shape_shift %[[V22]]#0, %[[V22]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V25:.*]]:2 = hlfir.declare %[[V23]](%[[V24]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true_3 = arith.constant true -// CHECK-NEXT: %[[V26:.*]] = hlfir.as_expr %[[V25]]#0 move %true_3 : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V26:.*]] = hlfir.as_expr %[[V25]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V26]] to %[[V6]]#0 : !hlfir.expr, !fir.ref> // CHECK-NEXT: hlfir.destroy %[[V26]] : !hlfir.expr // CHECK-NEXT: return @@ -258,29 +250,28 @@ func.func @_QPminloc6(%arg0: !fir.box>> {fir.bindc_n // CHECK-LABEL: func.func @_QPminloc6( // CHECK: %[[ARG0:.*]]: !fir.box>> {fir.bindc_name = "a"} // CHECK: %[[ARG1:.*]]: !fir.box> {fir.bindc_name = "s"} -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box>> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box>> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFminloc6Ea"} : (!fir.box>>) -> (!fir.box>>, !fir.box>>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFminloc4Es"} : (!fir.box>) -> (!fir.box>, !fir.box>) -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 // CHECK-NEXT: %[[V3:.*]] = fir.absent !fir.box -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V4:.*]] = fir.zero_bits !fir.heap> -// CHECK-NEXT: %c0 = arith.constant 0 : index -// CHECK-NEXT: %[[V5:.*]] = fir.shape %c0 : (index) -> !fir.shape<1> +// CHECK-NEXT: %[[V5:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V6:.*]] = fir.embox %[[V4]](%[[V5]]) : (!fir.heap>, !fir.shape<1>) -> !fir.box>> // CHECK-NEXT: fir.store %[[V6]] to %[[V0]] : !fir.ref>>> // CHECK: %[[V8:.*]] = fir.convert %[[V0]] : (!fir.ref>>>) -> !fir.ref> // CHECK-NEXT: %[[V9:.*]] = fir.convert %[[V1]]#1 : (!fir.box>>) -> !fir.box // CHECK: %[[V12:.*]] = fir.convert %[[V3]] : (!fir.box) -> !fir.box -// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMinlocCharacter(%[[V8]], %[[V9]], %c4_i32, {{.*}}, {{.*}}, %[[V12]], %false) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V13:.*]] = fir.call @_FortranAMinlocCharacter(%[[V8]], %[[V9]], %[[C4]], {{.*}}, {{.*}}, %[[V12]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V0]] : !fir.ref>>> -// CHECK-NEXT: %c0_0 = arith.constant 0 : index -// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %c0_0 : (!fir.box>>, index) -> (index, index, index) +// CHECK-NEXT: %[[V15:.*]]:3 = fir.box_dims %[[V14]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) // CHECK-NEXT: %[[V16:.*]] = fir.box_addr %[[V14]] : (!fir.box>>) -> !fir.heap> // CHECK-NEXT: %[[V17:.*]] = fir.shape_shift %[[V15]]#0, %[[V15]]#1 : (index, index) -> !fir.shapeshift<1> // CHECK-NEXT: %[[V18:.*]]:2 = hlfir.declare %[[V16]](%[[V17]]) {uniq_name = ".tmp.intrinsic_result"} : (!fir.heap>, !fir.shapeshift<1>) -> (!fir.box>, !fir.heap>) -// CHECK-NEXT: %true = arith.constant true -// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %true : (!fir.box>, i1) -> !hlfir.expr +// CHECK-NEXT: %[[V19:.*]] = hlfir.as_expr %[[V18]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK-NEXT: hlfir.assign %[[V19]] to %[[V2]]#0 : !hlfir.expr, !fir.box> // CHECK-NEXT: hlfir.destroy %[[V19]] : !hlfir.expr // CHECK-NEXT: return @@ -304,22 +295,22 @@ func.func @_QPminloc7(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK: %[[ARG2:.*]]: !fir.box>> {fir.bindc_name = "m"} // CHECK: %[[ARG3:.*]]: !fir.ref> {fir.bindc_name = "b"} // CHECK: %[[ARG4:.*]]: !fir.box> {fir.bindc_name = "s"} -// CHECK-NEXT: %[[V0:.*]] = fir.alloca !fir.box> +// CHECK-DAG: %[[FALSE:.*]] = arith.constant false +// CHECK-DAG: %[[C4:.*]] = arith.constant 4 : i32 +// CHECK: %[[V0:.*]] = fir.alloca !fir.box> // CHECK-NEXT: %[[V1:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFFtestEa"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V2:.*]]:2 = hlfir.declare %[[ARG3]] {uniq_name = "_QFFtestEb"} : (!fir.ref>) -> (!fir.ref>, !fir.ref>) // CHECK-NEXT: %[[V3:.*]]:2 = hlfir.declare %[[ARG1]] {uniq_name = "_QFFtestEd"} : (!fir.ref) -> (!fir.ref, !fir.ref) // CHECK-NEXT: %[[V4:.*]]:2 = hlfir.declare %[[ARG2]] {uniq_name = "_QFFtestEm"} : (!fir.box>>) -> (!fir.box>>, !fir.box>>) // CHECK-NEXT: %[[V5:.*]]:2 = hlfir.declare %[[ARG4]] {uniq_name = "_QFFtestEs"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK-NEXT: %[[V6:.*]] = fir.load %[[V3]]#0 : !fir.ref -// CHECK-NEXT: %c4_i32 = arith.constant 4 : i32 -// CHECK-NEXT: %false = arith.constant false // CHECK-NEXT: %[[V7:.*]] = fir.zero_bits !fir.heap // CHECK-NEXT: %[[V8:.*]] = fir.embox %[[V7]] : (!fir.heap) -> !fir.box> // CHECK-NEXT: fir.store %[[V8]] to %[[V0]] : !fir.ref>> // CHECK: %[[V10:.*]] = fir.convert %[[V0]] : (!fir.ref>>) -> !fir.ref> // CHECK-NEXT: %[[V11:.*]] = fir.convert %[[V1]]#1 : (!fir.box>) -> !fir.box // CHECK: %[[V14:.*]] = fir.convert %[[V4]]#1 : (!fir.box>>) -> !fir.box -// CHECK-NEXT: %[[V15:.*]] = fir.call @_FortranAMinlocDim(%[[V10]], %[[V11]], %c4_i32, %[[V6]], {{.*}}, {{.*}}, %[[V14]], %false) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none +// CHECK-NEXT: %[[V15:.*]] = fir.call @_FortranAMinlocDim(%[[V10]], %[[V11]], %[[C4]], %[[V6]], {{.*}}, {{.*}}, %[[V14]], %[[FALSE]]) fastmath : (!fir.ref>, !fir.box, i32, i32, !fir.ref, i32, !fir.box, i1) -> none // CHECK-NEXT: %[[V16:.*]] = fir.load %[[V0]] : !fir.ref>> // CHECK-NEXT: %[[V17:.*]] = fir.box_addr %[[V16]] : (!fir.box>) -> !fir.heap // CHECK-NEXT: %[[V18:.*]] = fir.load %[[V17]] : !fir.heap diff --git a/flang/test/HLFIR/minval-lowering.fir b/flang/test/HLFIR/minval-lowering.fir index fc8fe92dc08a2..d03dec1552309 100644 --- a/flang/test/HLFIR/minval-lowering.fir +++ b/flang/test/HLFIR/minval-lowering.fir @@ -37,6 +37,7 @@ func.func @_QPminval2(%arg0: !fir.box> {fir.bindc_name = "a" // CHECK: %[[ARG0:.*]]: !fir.box> // CHECK: %[[ARG1:.*]]: !fir.box> // CHECK: %[[ARG2:.*]]: !fir.ref +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] // CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]] @@ -63,7 +64,6 @@ func.func @_QPminval2(%arg0: !fir.box> {fir.bindc_name = "a" // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // TODO: fix alias analysis in hlfir.assign bufferization // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[ASEXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK: hlfir.assign %[[ASEXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[ASEXPR]] @@ -151,6 +151,7 @@ func.func @_QPminval5(%arg0: !fir.ref> {fir.bindc_name = "s"}) } // CHECK-LABEL: func.func @_QPminval5( // CHECK: %[[ARG0:.*]]: !fir.ref> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[RET_BOX:.*]] = fir.alloca !fir.box>> // CHECK-DAG: %[[RET_ADDR:.*]] = fir.zero_bits !fir.heap> // CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index @@ -161,7 +162,6 @@ func.func @_QPminval5(%arg0: !fir.ref> {fir.bindc_name = "s"}) // CHECK-DAG: %[[RES_VAR:.*]] = hlfir.declare %[[ARG0]](%[[RES_SHAPE:.*]]) // CHECK-DAG: %[[MASK_ALLOC:.*]] = fir.alloca !fir.logical<4> -// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[MASK_VAL:.*]] = fir.convert %[[TRUE]] : (i1) -> !fir.logical<4> // CHECK-DAG: fir.store %[[MASK_VAL]] to %[[MASK_ALLOC]] : !fir.ref> // CHECK-DAG: %[[MASK_BOX:.*]] = fir.embox %[[MASK_ALLOC]] @@ -190,6 +190,7 @@ func.func @_QPminval6(%arg0: !fir.box>> {fir.bindc_n // CHECK-LABEL: func.func @_QPminval6( // CHECK: %[[ARG0:.*]]: !fir.box>> // CHECK: %[[ARG1:.*]]: !fir.boxchar<1> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[UNBOXED:.*]]:2 = fir.unboxchar %[[ARG1]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[UNBOXED]]#0 typeparams %[[UNBOXED]]#1 @@ -210,7 +211,6 @@ func.func @_QPminval6(%arg0: !fir.box>> {fir.bindc_n // CHECK: %[[BOX_ELESIZE:.*]] = fir.box_elesize %[[RET]] // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]] typeparams %[[BOX_ELESIZE]] {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[ASEXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.boxchar<1>, i1) -> !hlfir.expr> // CHECK: hlfir.assign %[[ASEXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[ASEXPR]] diff --git a/flang/test/HLFIR/mul_transpose.f90 b/flang/test/HLFIR/mul_transpose.f90 index a4ec704547b9a..378ecfe4886aa 100644 --- a/flang/test/HLFIR/mul_transpose.f90 +++ b/flang/test/HLFIR/mul_transpose.f90 @@ -35,24 +35,22 @@ subroutine mul_transpose(a, b, res) ! CHECK-LOWERING: %[[TRANSPOSE_RES_LD:.*]] = fir.load %[[TRANSPOSE_RES_BOX:.*]] ! CHECK-LOWERING: %[[TRANSPOSE_RES_ADDR:.*]] = fir.box_addr %[[TRANSPOSE_RES_LD]] ! CHECK-LOWERING: %[[TRANSPOSE_RES_VAR:.*]]:2 = hlfir.declare %[[TRANSPOSE_RES_ADDR]]({{.*}}) {uniq_name = ".tmp.intrinsic_result"} -! CHECK-LOWERING: %[[TRUE:.*]] = arith.constant true -! CHECK-LOWERING: %[[TRANSPOSE_EXPR:.*]] = hlfir.as_expr %[[TRANSPOSE_RES_VAR]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr +! CHECK-LOWERING: %[[TRANSPOSE_EXPR:.*]] = hlfir.as_expr %[[TRANSPOSE_RES_VAR]]#0 move {{.*}} : (!fir.box>, i1) -> !hlfir.expr ! CHECK-LOWERING: %[[TRANSPOSE_ASSOC:.*]]:3 = hlfir.associate %[[TRANSPOSE_EXPR]]({{.*}}) {adapt.valuebyref} -! CHECK-LOWERING: (!hlfir.expr, !fir.shape<2>) -> (!fir.box>, !fir.ref>, i1) +! CHECK-LOWERING: (!hlfir.expr, !fir.shape<2>) -> (!fir.ref>, !fir.ref>, i1) ! CHECK-LOWERING: %[[LHS_BOX:.*]] = fir.embox %[[TRANSPOSE_ASSOC]]#1 ! CHECK-LOWERING: %[[B_BOX:.*]] = fir.embox %[[B_DECL]]#1(%{{.*}}) ! CHECK-LOWERING: %[[MUL_CONV_RES:.*]] = fir.convert %[[MUL_RES_BOX:.*]] : (!fir.ref>>>) -> !fir.ref> -! CHECK-LOWERING: %[[LHS_CONV:.*]] = fir.convert %[[LHS_BOX]] : (!fir.box>) -> !fir.box +! CHECK-LOWERING: %[[LHS_CONV:.*]] = fir.convert %[[LHS_BOX]] : (!fir.box>) -> !fir.box ! CHECK-LOWERING: %[[B_BOX_CONV:.*]] = fir.convert %[[B_BOX]] : (!fir.box>) -> !fir.box ! CHECK-LOWERING: fir.call @_FortranAMatmul(%[[MUL_CONV_RES]], %[[LHS_CONV]], %[[B_BOX_CONV]], %[[LOC_STR2:.*]], %[[LOC_N2:.*]]) ! CHECK-LOWERING: %[[MUL_RES_LD:.*]] = fir.load %[[MUL_RES_BOX:.*]] ! CHECK-LOWERING: %[[MUL_RES_ADDR:.*]] = fir.box_addr %[[MUL_RES_LD]] ! CHECK-LOWERING: %[[MUL_RES_VAR:.*]]:2 = hlfir.declare %[[MUL_RES_ADDR]]({{.*}}) {uniq_name = ".tmp.intrinsic_result"} -! CHECK-LOWERING: %[[TRUE2:.*]] = arith.constant true -! CHECK-LOWERING: %[[MUL_EXPR:.*]] = hlfir.as_expr %[[MUL_RES_VAR]]#0 move %[[TRUE2]] : (!fir.box>, i1) -> !hlfir.expr +! CHECK-LOWERING: %[[MUL_EXPR:.*]] = hlfir.as_expr %[[MUL_RES_VAR]]#0 move {{.*}} : (!fir.box>, i1) -> !hlfir.expr -! CHECK-LOWERING: hlfir.end_associate %[[TRANSPOSE_ASSOC]]#1, %[[TRANSPOSE_ASSOC]]#2 : !fir.ref>, i1 +! CHECK-LOWERING: hlfir.end_associate %[[TRANSPOSE_ASSOC]]#1, %[[TRANSPOSE_ASSOC]]#2 : !fir.ref>, i1 ! CHECK-LOWERING-NEXT: hlfir.assign %[[MUL_EXPR]] to %[[RES_DECL]]#0 : !hlfir.expr, !fir.ref> ! CHECK-LOWERING-NEXT: hlfir.destroy %[[MUL_EXPR]] ! CHECK-LOWERING-NEXT: hlfir.destroy %[[TRANSPOSE_EXPR]] @@ -66,8 +64,7 @@ subroutine mul_transpose(a, b, res) ! CHECK-LOWERING-OPT: %[[MUL_RES_LD:.*]] = fir.load %[[MUL_RES_BOX:.*]] ! CHECK-LOWERING-OPT: %[[MUL_RES_ADDR:.*]] = fir.box_addr %[[MUL_RES_LD]] ! CHECK-LOWERING-OPT: %[[MUL_RES_VAR:.*]]:2 = hlfir.declare %[[MUL_RES_ADDR]]({{.*}}) {uniq_name = ".tmp.intrinsic_result"} -! CHECK-LOWERING-OPT: %[[TRUE2:.*]] = arith.constant true -! CHECK-LOWERING-OPT: %[[MUL_EXPR:.*]] = hlfir.as_expr %[[MUL_RES_VAR]]#0 move %[[TRUE2]] : (!fir.box>, i1) -> !hlfir.expr +! CHECK-LOWERING-OPT: %[[MUL_EXPR:.*]] = hlfir.as_expr %[[MUL_RES_VAR]]#0 move {{.*}} : (!fir.box>, i1) -> !hlfir.expr ! CHECK-LOWERING-OPT: hlfir.assign %[[MUL_EXPR]] to %[[RES_DECL]]#0 : !hlfir.expr, !fir.ref> ! CHECK-LOWERING-OPT: hlfir.destroy %[[MUL_EXPR]] @@ -76,25 +73,23 @@ subroutine mul_transpose(a, b, res) ! CHECK-BUFFERING: %[[TRANSPOSE_RES_LD:.*]] = fir.load %[[TRANSPOSE_RES_BOX:.*]] ! CHECK-BUFFERING: %[[TRANSPOSE_RES_ADDR:.*]] = fir.box_addr %[[TRANSPOSE_RES_LD]] ! CHECK-BUFFERING: %[[TRANSPOSE_RES_VAR:.*]]:2 = hlfir.declare %[[TRANSPOSE_RES_ADDR]]({{.*}}) {uniq_name = ".tmp.intrinsic_result"} -! CHECK-BUFFERING: %[[TRUE:.*]] = arith.constant true ! CHECK-BUFFERING: %[[TUPLE0:.*]] = fir.undefined tuple>, i1> -! CHECK-BUFFERING: %[[TUPLE1:.*]] = fir.insert_value %[[TUPLE0]], %[[TRUE]], [1 : index] +! CHECK-BUFFERING: %[[TUPLE1:.*]] = fir.insert_value %[[TUPLE0]], {{.*}}, [1 : index] ! CHECK-BUFFERING: %[[TUPLE2:.*]] = fir.insert_value %[[TUPLE1]], %[[TRANSPOSE_RES_VAR]]#0, [0 : index] -! CHECK-BUFFERING: %[[TRANSPOSE_RES_REF:.*]] = fir.convert %[[TRANSPOSE_RES_VAR]]#1 : (!fir.heap>) -> !fir.ref> +! CHECK-BUFFERING: %[[TRANSPOSE_RES_REF:.*]] = fir.convert %[[TRANSPOSE_RES_VAR]]#1 : (!fir.heap>) -> !fir.ref> ! CHECK-BUFFERING: %[[TRANSPOSE_RES_BOX:.*]] = fir.embox %[[TRANSPOSE_RES_REF]]({{.*}}) -! CHECK-BUFFERING: %[[LHS_CONV:.*]] = fir.convert %[[TRANSPOSE_RES_BOX]] : (!fir.box>) -> !fir.box +! CHECK-BUFFERING: %[[LHS_CONV:.*]] = fir.convert %[[TRANSPOSE_RES_BOX]] : (!fir.box>) -> !fir.box ! [argument handling unchanged] ! CHECK-BUFFERING: fir.call @_FortranAMatmul( ! CHECK-BUFFERING: %[[MUL_RES_LD:.*]] = fir.load %[[MUL_RES_BOX:.*]] ! CHECK-BUFFERING: %[[MUL_RES_ADDR:.*]] = fir.box_addr %[[MUL_RES_LD]] ! CHECK-BUFFERING: %[[MUL_RES_VAR:.*]]:2 = hlfir.declare %[[MUL_RES_ADDR]]({{.*}}) {uniq_name = ".tmp.intrinsic_result"} -! CHECK-BUFFERING: %[[TRUE2:.*]] = arith.constant true ! CHECK-BUFFERING: %[[TUPLE3:.*]] = fir.undefined tuple>, i1> -! CHECK-BUFFERING: %[[TUPLE4:.*]] = fir.insert_value %[[TUPLE3]], %[[TRUE2]], [1 : index] +! CHECK-BUFFERING: %[[TUPLE4:.*]] = fir.insert_value %[[TUPLE3]], {{.*}}, [1 : index] ! CHECK-BUFFERING: %[[TUPLE5:.*]] = fir.insert_value %[[TUPLE4]], %[[MUL_RES_VAR]]#0, [0 : index] -! CHECK-BUFFERING: %[[TRANSPOSE_RES_HEAP:.*]] = fir.convert %[[TRANSPOSE_RES_REF]] : (!fir.ref>) -> !fir.heap> +! CHECK-BUFFERING: %[[TRANSPOSE_RES_HEAP:.*]] = fir.convert %[[TRANSPOSE_RES_REF]] : (!fir.ref>) -> !fir.heap> ! CHECK-BUFFERING-NEXT: fir.freemem %[[TRANSPOSE_RES_HEAP]] ! CHECK-BUFFERING-NEXT: hlfir.assign %[[MUL_RES_VAR]]#0 to %[[RES_DECL]]#0 : !fir.box>, !fir.ref> ! CHECK-BUFFERING-NEXT: %[[MUL_RES_HEAP:.*]] = fir.box_addr %[[MUL_RES_VAR]]#0 : (!fir.box>) -> !fir.heap> diff --git a/flang/test/HLFIR/product-lowering.fir b/flang/test/HLFIR/product-lowering.fir index 337b5fc3d73d3..dd3506937cacb 100644 --- a/flang/test/HLFIR/product-lowering.fir +++ b/flang/test/HLFIR/product-lowering.fir @@ -39,6 +39,7 @@ func.func @_QPproduct2(%arg0: !fir.box> {fir.bindc_name = "a // CHECK: %[[ARG0:.*]]: !fir.box> // CHECK: %[[ARG1:.*]]: !fir.box> // CHECK: %[[ARG2:.*]]: !fir.ref +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] @@ -64,7 +65,6 @@ func.func @_QPproduct2(%arg0: !fir.box> {fir.bindc_name = "a // CHECK-NEXT: %[[ADDR:.*]] = fir.box_addr %[[RET]] // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK: hlfir.assign %[[EXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[EXPR]] @@ -141,6 +141,7 @@ func.func @_QPproduct5(%arg0: !fir.ref> {fir.bindc_name = "s"} // CHECK-LABEL: func.func @_QPproduct5( // CHECK: %[[ARG0:.*]]: !fir.ref> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[RET_BOX:.*]] = fir.alloca !fir.box>> // CHECK-DAG: %[[RET_ADDR:.*]] = fir.zero_bits !fir.heap> // CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index @@ -151,7 +152,6 @@ func.func @_QPproduct5(%arg0: !fir.ref> {fir.bindc_name = "s"} // CHECK-DAG: %[[RES_VAR:.*]] = hlfir.declare %[[ARG0]](%[[RES_SHAPE:.*]]) // CHECK-DAG: %[[MASK_ALLOC:.*]] = fir.alloca !fir.logical<4> -// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[MASK_VAL:.*]] = fir.convert %[[TRUE]] : (i1) -> !fir.logical<4> // CHECK-DAG: fir.store %[[MASK_VAL]] to %[[MASK_ALLOC]] : !fir.ref> // CHECK-DAG: %[[MASK_BOX:.*]] = fir.embox %[[MASK_ALLOC]] diff --git a/flang/test/HLFIR/sum-lowering.fir b/flang/test/HLFIR/sum-lowering.fir index e33b9bc028aea..d4a79d278acc4 100644 --- a/flang/test/HLFIR/sum-lowering.fir +++ b/flang/test/HLFIR/sum-lowering.fir @@ -37,6 +37,7 @@ func.func @_QPsum2(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK: %[[ARG0:.*]]: !fir.box> // CHECK: %[[ARG1:.*]]: !fir.box> // CHECK: %[[ARG2:.*]]: !fir.ref +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[RES:.*]]:2 = hlfir.declare %[[ARG1]] // CHECK-DAG: %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]] @@ -63,7 +64,6 @@ func.func @_QPsum2(%arg0: !fir.box> {fir.bindc_name = "a"}, // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // TODO: fix alias analysis in hlfir.assign bufferization // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[ASEXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK: hlfir.assign %[[ASEXPR]] to %[[RES]]#0 // CHECK: hlfir.destroy %[[ASEXPR]] @@ -151,6 +151,7 @@ func.func @_QPsum5(%arg0: !fir.ref> {fir.bindc_name = "s"}) { } // CHECK-LABEL: func.func @_QPsum5( // CHECK: %[[ARG0:.*]]: !fir.ref> +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[RET_BOX:.*]] = fir.alloca !fir.box>> // CHECK-DAG: %[[RET_ADDR:.*]] = fir.zero_bits !fir.heap> // CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index @@ -161,7 +162,6 @@ func.func @_QPsum5(%arg0: !fir.ref> {fir.bindc_name = "s"}) { // CHECK-DAG: %[[RES_VAR:.*]] = hlfir.declare %[[ARG0]](%[[RES_SHAPE:.*]]) // CHECK-DAG: %[[MASK_ALLOC:.*]] = fir.alloca !fir.logical<4> -// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[MASK_VAL:.*]] = fir.convert %[[TRUE]] : (i1) -> !fir.logical<4> // CHECK-DAG: fir.store %[[MASK_VAL]] to %[[MASK_ALLOC]] : !fir.ref> // CHECK-DAG: %[[MASK_BOX:.*]] = fir.embox %[[MASK_ALLOC]] diff --git a/flang/test/HLFIR/transpose-lowering.fir b/flang/test/HLFIR/transpose-lowering.fir index 733e6f1a61090..9afe8a058b8b8 100644 --- a/flang/test/HLFIR/transpose-lowering.fir +++ b/flang/test/HLFIR/transpose-lowering.fir @@ -18,6 +18,7 @@ func.func @_QPtranspose1(%arg0: !fir.ref> {fir.bindc_name = // CHECK-LABEL: func.func @_QPtranspose1( // CHECK: %[[ARG0:.*]]: !fir.ref> {fir.bindc_name = "m"} // CHECK: %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "res"} +// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[M_VAR:.*]]:2 = hlfir.declare %[[ARG0]] // CHECK-DAG: %[[RES_VAR:.*]]:2 = hlfir.declare %[[ARG1]] @@ -40,7 +41,6 @@ func.func @_QPtranspose1(%arg0: !fir.ref> {fir.bindc_name = // CHECK-NEXT: %[[SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS]]#0, %[[BOX_DIMS]]#1 // TODO: fix alias analysis in hlfir.assign bufferization // CHECK-NEXT: %[[TMP:.*]]:2 = hlfir.declare %[[ADDR]](%[[SHIFT]]) {uniq_name = ".tmp.intrinsic_result"} -// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[ASEXPR:.*]] = hlfir.as_expr %[[TMP]]#0 move %[[TRUE]] : (!fir.box>, i1) -> !hlfir.expr // CHECK: hlfir.assign %[[ASEXPR]] to %[[RES_VAR]]#0 // CHECK: hlfir.destroy %[[ASEXPR]] diff --git a/flang/test/Lower/convert.f90 b/flang/test/Lower/convert.f90 index 1ab93dcc17320..b7c8b8dc20cc7 100755 --- a/flang/test/Lower/convert.f90 +++ b/flang/test/Lower/convert.f90 @@ -34,8 +34,8 @@ program test ! ALL: fir.has_value %[[VAL_0]] : !fir.char<1,[[OPT_STR_LEN]]> ! ALL: fir.global linkonce @_QQEnvironmentDefaults.list constant : tuple, !fir.ref>>>> { -! ALL: %[[VAL_0:.*]] = fir.undefined tuple, !fir.ref>>>> ! ALL: %[[VAL_1:.*]] = arith.constant 1 : i[[int_size]] +! ALL: %[[VAL_0:.*]] = fir.undefined tuple, !fir.ref>>>> ! ALL: %[[VAL_2:.*]] = fir.insert_value %[[VAL_0]], %[[VAL_1]], [0 : index] : (tuple, !fir.ref>>>>, i[[int_size]]) -> tuple, !fir.ref>>>> ! ALL: %[[VAL_3:.*]] = fir.address_of(@_QQEnvironmentDefaults.items) : !fir.ref, !fir.ref>>> ! ALL: %[[VAL_4:.*]] = fir.insert_value %[[VAL_2]], %[[VAL_3]], [1 : index] : (tuple, !fir.ref>>>>, !fir.ref, !fir.ref>>>) -> tuple, !fir.ref>>>>