diff --git a/flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp b/flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp index 9969ee474ff98..d8e36ea294cdb 100644 --- a/flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp +++ b/flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp @@ -2284,213 +2284,6 @@ class CmpCharOpConversion : public mlir::OpRewritePattern { } }; -static std::pair -getVariable(fir::FirOpBuilder &builder, mlir::Location loc, mlir::Value val) { - // If it is an expression - create a variable from it, or forward - // the value otherwise. - hlfir::AssociateOp associate; - if (!mlir::isa(val.getType())) - return {val, associate}; - hlfir::Entity entity{val}; - mlir::NamedAttribute byRefAttr = fir::getAdaptToByRefAttr(builder); - associate = hlfir::genAssociateExpr(loc, builder, entity, entity.getType(), - "", byRefAttr); - return {associate.getBase(), associate}; -} - -class IndexOpConversion : public mlir::OpRewritePattern { -public: - using mlir::OpRewritePattern::OpRewritePattern; - - llvm::LogicalResult - matchAndRewrite(hlfir::IndexOp op, - mlir::PatternRewriter &rewriter) const override { - // We simplify only limited cases: - // 1) a substring length shall be known at compile time - // 2) if a substring length is 0 then replace with 1 for forward search, - // or otherwise with the string length + 1 (builder shall const-fold if - // lookup direction is known at compile time). - // 3) for known string length at compile time, if it is - // shorter than substring => replace with zero. - // 4) if a substring length is one => inline as simple search loop - // 5) for forward search with input strings of kind=1 runtime is faster. - // Do not simplify in all the other cases relying on a runtime call. - - fir::FirOpBuilder builder{rewriter, op.getOperation()}; - const mlir::Location &loc = op->getLoc(); - - auto resultTy = op.getType(); - mlir::Value back = op.getBack(); - mlir::Value substrLen = - hlfir::genCharLength(loc, builder, hlfir::Entity{op.getSubstr()}); - - auto substrLenCst = fir::getIntIfConstant(substrLen); - if (!substrLenCst) { - return rewriter.notifyMatchFailure( - op, "substring length unknown at compile time"); - } - mlir::Value strLen = - hlfir::genCharLength(loc, builder, hlfir::Entity{op.getStr()}); - auto i1Ty = builder.getI1Type(); - auto idxTy = builder.getIndexType(); - if (*substrLenCst == 0) { - mlir::Value oneIdx = builder.createIntegerConstant(loc, idxTy, 1); - // zero length substring. For back search replace with - // strLen+1, or otherwise with 1. - mlir::Value strEnd = mlir::arith::AddIOp::create( - builder, loc, builder.createConvert(loc, idxTy, strLen), oneIdx); - if (back) - back = builder.createConvert(loc, i1Ty, back); - else - back = builder.createIntegerConstant(loc, i1Ty, 0); - mlir::Value result = - mlir::arith::SelectOp::create(builder, loc, back, strEnd, oneIdx); - - rewriter.replaceOp(op, builder.createConvert(loc, resultTy, result)); - return mlir::success(); - } - - if (auto strLenCst = fir::getIntIfConstant(strLen)) { - if (*strLenCst < *substrLenCst) { - rewriter.replaceOp(op, builder.createIntegerConstant(loc, resultTy, 0)); - return mlir::success(); - } - if (*strLenCst == 0) { - // both strings have zero length - rewriter.replaceOp(op, builder.createIntegerConstant(loc, resultTy, 1)); - return mlir::success(); - } - } - if (*substrLenCst != 1) { - return rewriter.notifyMatchFailure( - op, "rely on runtime implementation if substring length > 1"); - } - // For forward search and character kind=1 the runtime uses memchr - // which well optimized. But it looks like memchr idiom is not recognized - // in LLVM yet. On a micro-kernel test with strings of length 40 runtime - // had ~2x less execution time vs inlined code. For unknown search direction - // at compile time pessimistically assume "forward". - std::optional isBack; - if (back) { - if (auto backCst = fir::getIntIfConstant(back)) - isBack = *backCst != 0; - } else { - isBack = false; - } - auto charTy = mlir::cast( - hlfir::getFortranElementType(op.getSubstr().getType())); - unsigned kind = charTy.getFKind(); - if (kind == 1 && (!isBack || !*isBack)) { - return rewriter.notifyMatchFailure( - op, "rely on runtime implementation for character kind 1"); - } - - // All checks are passed here. Generate single character search loop. - auto [strV, strAssociate] = getVariable(builder, loc, op.getStr()); - auto [substrV, substrAssociate] = getVariable(builder, loc, op.getSubstr()); - hlfir::Entity str{strV}; - hlfir::Entity substr{substrV}; - mlir::Value oneIdx = builder.createIntegerConstant(loc, idxTy, 1); - - auto genExtractAndConvertToInt = [&charTy, &idxTy, &oneIdx, - kind](mlir::Location loc, - fir::FirOpBuilder &builder, - hlfir::Entity &charStr, - mlir::Value index) { - auto bits = builder.getKindMap().getCharacterBitsize(kind); - auto intTy = builder.getIntegerType(bits); - auto charLen1Ty = - fir::CharacterType::getSingleton(builder.getContext(), kind); - mlir::Type designatorTy = - fir::ReferenceType::get(charLen1Ty, fir::isa_volatile_type(charTy)); - auto idxAttr = builder.getIntegerAttr(idxTy, 0); - - auto singleChr = hlfir::DesignateOp::create( - builder, loc, designatorTy, charStr, /*component=*/{}, - /*compShape=*/mlir::Value{}, hlfir::DesignateOp::Subscripts{}, - /*substring=*/mlir::ValueRange{index, index}, - /*complexPart=*/std::nullopt, - /*shape=*/mlir::Value{}, /*typeParams=*/mlir::ValueRange{oneIdx}, - fir::FortranVariableFlagsAttr{}); - auto chrVal = fir::LoadOp::create(builder, loc, singleChr); - mlir::Value intVal = fir::ExtractValueOp::create( - builder, loc, intTy, chrVal, builder.getArrayAttr(idxAttr)); - return intVal; - }; - - auto wantChar = genExtractAndConvertToInt(loc, builder, substr, oneIdx); - - // Generate search loop body with the following C equivalent: - // idx_t result = 0; - // idx_t end = strlen + 1; - // char want = substr[0]; - // for (idx_t idx = 1; idx < end; ++idx) { - // if (result == 0) { - // idx_t at = back ? end - idx: idx; - // result = str[at-1] == want ? at : result; - // } - // } - if (!back) - back = builder.createIntegerConstant(loc, i1Ty, 0); - else - back = builder.createConvert(loc, i1Ty, back); - mlir::Value strEnd = mlir::arith::AddIOp::create( - builder, loc, builder.createConvert(loc, idxTy, strLen), oneIdx); - mlir::Value zeroIdx = builder.createIntegerConstant(loc, idxTy, 0); - auto genSearchBody = [&](mlir::Location loc, fir::FirOpBuilder &builder, - mlir::ValueRange index, - mlir::ValueRange reductionArgs) - -> llvm::SmallVector { - assert(index.size() == 1 && "expected single loop"); - assert(reductionArgs.size() == 1 && "expected single reduction value"); - mlir::Value inRes = reductionArgs[0]; - auto resEQzero = mlir::arith::CmpIOp::create( - builder, loc, mlir::arith::CmpIPredicate::eq, inRes, zeroIdx); - - mlir::Value res = - builder - .genIfOp(loc, {idxTy}, resEQzero, - /*withElseRegion=*/true) - .genThen([&]() { - mlir::Value idx = builder.createConvert(loc, idxTy, index[0]); - // offset = back ? end - idx : idx; - mlir::Value offset = mlir::arith::SelectOp::create( - builder, loc, back, - mlir::arith::SubIOp::create(builder, loc, strEnd, idx), - idx); - - auto haveChar = - genExtractAndConvertToInt(loc, builder, str, offset); - auto charsEQ = mlir::arith::CmpIOp::create( - builder, loc, mlir::arith::CmpIPredicate::eq, haveChar, - wantChar); - mlir::Value newVal = mlir::arith::SelectOp::create( - builder, loc, charsEQ, offset, inRes); - - fir::ResultOp::create(builder, loc, newVal); - }) - .genElse([&]() { fir::ResultOp::create(builder, loc, inRes); }) - .getResults()[0]; - return {res}; - }; - - llvm::SmallVector loopOut = - hlfir::genLoopNestWithReductions(loc, builder, {strLen}, - /*reductionInits=*/{zeroIdx}, - genSearchBody, - /*isUnordered=*/false); - mlir::Value result = builder.createConvert(loc, resultTy, loopOut[0]); - - if (strAssociate) - hlfir::EndAssociateOp::create(builder, loc, strAssociate); - if (substrAssociate) - hlfir::EndAssociateOp::create(builder, loc, substrAssociate); - - rewriter.replaceOp(op, result); - return mlir::success(); - } -}; - template class MatmulConversion : public mlir::OpRewritePattern { public: @@ -3162,7 +2955,6 @@ class SimplifyHLFIRIntrinsics patterns.insert>(context); patterns.insert>(context); patterns.insert(context); - patterns.insert(context); patterns.insert>(context); patterns.insert>(context); patterns.insert>(context); diff --git a/flang/test/HLFIR/simplify-hlfir-intrinsics-index.fir b/flang/test/HLFIR/simplify-hlfir-intrinsics-index.fir deleted file mode 100644 index 258a1d899a40d..0000000000000 --- a/flang/test/HLFIR/simplify-hlfir-intrinsics-index.fir +++ /dev/null @@ -1,345 +0,0 @@ -// RUN: fir-opt %s --simplify-hlfir-intrinsics | FileCheck %s - -// Simplify should reduce hlfir.index to constant (5) -func.func @_QPt1() { -// CHECK-LABEL: func.func @_QPt1() { -// CHECK: %[[VAL_0:.*]] = arith.constant 5 : index -// CHECK: %[[VAL_1:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_2:.*]] = arith.constant 3 : index -// CHECK: %[[VAL_3:.*]] = arith.constant 4 : index -// CHECK: %[[VAL_4:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_5:.*]] = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt1En"} -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]] {uniq_name = "_QFt1En"} : (!fir.ref) -> (!fir.ref, !fir.ref) -// CHECK: %[[VAL_7:.*]] = fir.alloca !fir.char<1,4> {bindc_name = "s", uniq_name = "_QFt1Es"} -// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_7]] typeparams %[[VAL_3]] {uniq_name = "_QFt1Es"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_9:.*]] = fir.address_of(@_QQclX616263) : !fir.ref> -// CHECK: %[[VAL_10:.*]]:2 = hlfir.declare %[[VAL_9]] typeparams %[[VAL_2]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX616263"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: hlfir.assign %[[VAL_10]]#0 to %[[VAL_8]]#0 : !fir.ref>, !fir.ref> -// CHECK: %[[VAL_11:.*]] = fir.address_of(@_QQclX) : !fir.ref> -// CHECK: %[[VAL_12:.*]]:2 = hlfir.declare %[[VAL_11]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_0]] : (index) -> i32 -// CHECK: hlfir.assign %[[VAL_13]] to %[[VAL_6]]#0 : i32, !fir.ref -// CHECK: return -// CHECK: } - %0 = fir.dummy_scope : !fir.dscope - %1 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt1En"} - %2:2 = hlfir.declare %1 {uniq_name = "_QFt1En"} : (!fir.ref) -> (!fir.ref, !fir.ref) - %c4 = arith.constant 4 : index - %3 = fir.alloca !fir.char<1,4> {bindc_name = "s", uniq_name = "_QFt1Es"} - %4:2 = hlfir.declare %3 typeparams %c4 {uniq_name = "_QFt1Es"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %5 = fir.address_of(@_QQclX616263) : !fir.ref> - %c3 = arith.constant 3 : index - %6:2 = hlfir.declare %5 typeparams %c3 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX616263"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - hlfir.assign %6#0 to %4#0 : !fir.ref>, !fir.ref> - %7 = fir.address_of(@_QQclX) : !fir.ref> - %c0 = arith.constant 0 : index - %8:2 = hlfir.declare %7 typeparams %c0 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %true = arith.constant true - %9 = hlfir.index %8#0 in %4#0 back %true : (!fir.ref>, !fir.ref>, i1) -> i32 - hlfir.assign %9 to %2#0 : i32, !fir.ref - return -} - -// ! 'back' is unknown at compile time, substring is zero length - generate select (back ? strlen+1 : 1) -func.func @_QPt2(%arg0: !fir.boxchar<2> {fir.bindc_name = "s"}, %arg1: !fir.ref> {fir.bindc_name = "b"}) { -// CHECK-LABEL: func.func @_QPt2( -// CHECK-SAME: %[[ARG0:.*]]: !fir.boxchar<2> {fir.bindc_name = "s"}, -// CHECK-SAME: %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) { -// CHECK: %[[VAL_0:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_1:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %[[VAL_2]] {uniq_name = "_QFt2Eb"} : (!fir.ref>, !fir.dscope) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_4:.*]] = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt2En"} -// CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_4]] {uniq_name = "_QFt2En"} : (!fir.ref) -> (!fir.ref, !fir.ref) -// CHECK: %[[VAL_6:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<2>) -> (!fir.ref>, index) -// CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]]#0 typeparams %[[VAL_6]]#1 dummy_scope %[[VAL_2]] {uniq_name = "_QFt2Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref>) -// CHECK: %[[VAL_8:.*]] = fir.address_of(@_QQcl2X) : !fir.ref> -// CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_8]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQcl2X"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref> -// CHECK: %[[VAL_11:.*]] = arith.addi %[[VAL_6]]#1, %[[VAL_0]] : index -// CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_10]] : (!fir.logical<4>) -> i1 -// CHECK: %[[VAL_13:.*]] = arith.select %[[VAL_12]], %[[VAL_11]], %[[VAL_0]] : index -// CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (index) -> i32 -// CHECK: hlfir.assign %[[VAL_14]] to %[[VAL_5]]#0 : i32, !fir.ref -// CHECK: return -// CHECK: } - %0 = fir.dummy_scope : !fir.dscope - %1:2 = hlfir.declare %arg1 dummy_scope %0 {uniq_name = "_QFt2Eb"} : (!fir.ref>, !fir.dscope) -> (!fir.ref>, !fir.ref>) - %2 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt2En"} - %3:2 = hlfir.declare %2 {uniq_name = "_QFt2En"} : (!fir.ref) -> (!fir.ref, !fir.ref) - %4:2 = fir.unboxchar %arg0 : (!fir.boxchar<2>) -> (!fir.ref>, index) - %5:2 = hlfir.declare %4#0 typeparams %4#1 dummy_scope %0 {uniq_name = "_QFt2Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref>) - %6 = fir.address_of(@_QQcl2X) : !fir.ref> - %c0 = arith.constant 0 : index - %7:2 = hlfir.declare %6 typeparams %c0 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQcl2X"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %8 = fir.load %1#0 : !fir.ref> - %9 = hlfir.index %7#0 in %5#0 back %8 : (!fir.ref>, !fir.boxchar<2>, !fir.logical<4>) -> i32 - hlfir.assign %9 to %3#0 : i32, !fir.ref - return -} - -// inline as search loop (backward) -func.func @_QPt3(%arg0: !fir.boxchar<2> {fir.bindc_name = "s"}) { -// CHECK-LABEL: func.func @_QPt3( -// CHECK-SAME: %[[ARG0:.*]]: !fir.boxchar<2> {fir.bindc_name = "s"}) { -// CHECK: %[[VAL_0:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_1:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt3En"} -// CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QFt3En"} : (!fir.ref) -> (!fir.ref, !fir.ref) -// CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<2>) -> (!fir.ref>, index) -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]]#0 typeparams %[[VAL_5]]#1 dummy_scope %[[VAL_2]] {uniq_name = "_QFt3Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref>) -// CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQcl2X6500) : !fir.ref> -// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_7]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQcl2X6500"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_8]]#0 substr %[[VAL_1]], %[[VAL_1]] typeparams %[[VAL_1]] : (!fir.ref>, index, index, index) -> !fir.ref> -// CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_9]] : !fir.ref> -// CHECK: %[[VAL_11:.*]] = fir.extract_value %[[VAL_10]], [0 : index] : (!fir.char<2>) -> i16 -// CHECK: %[[VAL_12:.*]] = arith.addi %[[VAL_5]]#1, %[[VAL_1]] : index -// CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_1]] to %[[VAL_5]]#1 step %[[VAL_1]] iter_args(%[[VAL_15:.*]] = %[[VAL_0]]) -> (index) { -// CHECK: %[[VAL_16:.*]] = arith.cmpi eq, %[[VAL_15]], %[[VAL_0]] : index -// CHECK: %[[VAL_17:.*]] = fir.if %[[VAL_16]] -> (index) { -// CHECK: %[[VAL_18:.*]] = arith.subi %[[VAL_12]], %[[VAL_14]] : index -// CHECK: %[[VAL_19:.*]] = hlfir.designate %[[VAL_6]]#0 substr %[[VAL_18]], %[[VAL_18]] typeparams %[[VAL_1]] : (!fir.boxchar<2>, index, index, index) -> !fir.ref> -// CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_19]] : !fir.ref> -// CHECK: %[[VAL_21:.*]] = fir.extract_value %[[VAL_20]], [0 : index] : (!fir.char<2>) -> i16 -// CHECK: %[[VAL_22:.*]] = arith.cmpi eq, %[[VAL_21]], %[[VAL_11]] : i16 -// CHECK: %[[VAL_23:.*]] = arith.select %[[VAL_22]], %[[VAL_18]], %[[VAL_15]] : index -// CHECK: fir.result %[[VAL_23]] : index -// CHECK: } else { -// CHECK: fir.result %[[VAL_15]] : index -// CHECK: } -// CHECK: fir.result %[[VAL_17]] : index -// CHECK: } -// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_13]] : (index) -> i32 -// CHECK: hlfir.assign %[[VAL_24]] to %[[VAL_4]]#0 : i32, !fir.ref -// CHECK: return -// CHECK: } - %0 = fir.dummy_scope : !fir.dscope - %1 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt3En"} - %2:2 = hlfir.declare %1 {uniq_name = "_QFt3En"} : (!fir.ref) -> (!fir.ref, !fir.ref) - %3:2 = fir.unboxchar %arg0 : (!fir.boxchar<2>) -> (!fir.ref>, index) - %4:2 = hlfir.declare %3#0 typeparams %3#1 dummy_scope %0 {uniq_name = "_QFt3Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref>) - %5 = fir.address_of(@_QQcl2X6500) : !fir.ref> - %c1 = arith.constant 1 : index - %6:2 = hlfir.declare %5 typeparams %c1 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQcl2X6500"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %true = arith.constant true - %7 = hlfir.index %6#0 in %4#0 back %true : (!fir.ref>, !fir.boxchar<2>, i1) -> i32 - hlfir.assign %7 to %2#0 : i32, !fir.ref - return -} - -//inline as search loop (forward) -func.func @_QPt4(%arg0: !fir.boxchar<2> {fir.bindc_name = "s"}) { -// CHECK-LABEL: func.func @_QPt4( -// CHECK-SAME: %[[ARG0:.*]]: !fir.boxchar<2> {fir.bindc_name = "s"}) { -// CHECK: %[[VAL_0:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_1:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt4En"} -// CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QFt4En"} : (!fir.ref) -> (!fir.ref, !fir.ref) -// CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<2>) -> (!fir.ref>, index) -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]]#0 typeparams %[[VAL_5]]#1 dummy_scope %[[VAL_2]] {uniq_name = "_QFt4Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref>) -// CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQcl2X6500) : !fir.ref> -// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_7]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQcl2X6500"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_8]]#0 substr %[[VAL_1]], %[[VAL_1]] typeparams %[[VAL_1]] : (!fir.ref>, index, index, index) -> !fir.ref> -// CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_9]] : !fir.ref> -// CHECK: %[[VAL_11:.*]] = fir.extract_value %[[VAL_10]], [0 : index] : (!fir.char<2>) -> i16 -// CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_1]] to %[[VAL_5]]#1 step %[[VAL_1]] iter_args(%[[VAL_14:.*]] = %[[VAL_0]]) -> (index) { -// CHECK: %[[VAL_15:.*]] = arith.cmpi eq, %[[VAL_14]], %[[VAL_0]] : index -// CHECK: %[[VAL_16:.*]] = fir.if %[[VAL_15]] -> (index) { -// CHECK: %[[VAL_17:.*]] = hlfir.designate %[[VAL_6]]#0 substr %[[VAL_13]], %[[VAL_13]] typeparams %[[VAL_1]] : (!fir.boxchar<2>, index, index, index) -> !fir.ref> -// CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_17]] : !fir.ref> -// CHECK: %[[VAL_19:.*]] = fir.extract_value %[[VAL_18]], [0 : index] : (!fir.char<2>) -> i16 -// CHECK: %[[VAL_20:.*]] = arith.cmpi eq, %[[VAL_19]], %[[VAL_11]] : i16 -// CHECK: %[[VAL_21:.*]] = arith.select %[[VAL_20]], %[[VAL_13]], %[[VAL_14]] : index -// CHECK: fir.result %[[VAL_21]] : index -// CHECK: } else { -// CHECK: fir.result %[[VAL_14]] : index -// CHECK: } -// CHECK: fir.result %[[VAL_16]] : index -// CHECK: } -// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_12]] : (index) -> i32 -// CHECK: hlfir.assign %[[VAL_22]] to %[[VAL_4]]#0 : i32, !fir.ref -// CHECK: return -// CHECK: } - %0 = fir.dummy_scope : !fir.dscope - %1 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt4En"} - %2:2 = hlfir.declare %1 {uniq_name = "_QFt4En"} : (!fir.ref) -> (!fir.ref, !fir.ref) - %3:2 = fir.unboxchar %arg0 : (!fir.boxchar<2>) -> (!fir.ref>, index) - %4:2 = hlfir.declare %3#0 typeparams %3#1 dummy_scope %0 {uniq_name = "_QFt4Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref>) - %5 = fir.address_of(@_QQcl2X6500) : !fir.ref> - %c1 = arith.constant 1 : index - %6:2 = hlfir.declare %5 typeparams %c1 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQcl2X6500"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %false = arith.constant false - %7 = hlfir.index %6#0 in %4#0 back %false : (!fir.ref>, !fir.boxchar<2>, i1) -> i32 - hlfir.assign %7 to %2#0 : i32, !fir.ref - return -} - -// Same as t4 above but result kind=1 -func.func @_QPt5(%arg0: !fir.boxchar<2> {fir.bindc_name = "s"}) { -// CHECK-LABEL: func.func @_QPt5( -// CHECK-SAME: %[[ARG0:.*]]: !fir.boxchar<2> {fir.bindc_name = "s"}) { -// CHECK: %[[VAL_0:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_1:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt5En"} -// CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QFt5En"} : (!fir.ref) -> (!fir.ref, !fir.ref) -// CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<2>) -> (!fir.ref>, index) -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]]#0 typeparams %[[VAL_5]]#1 dummy_scope %[[VAL_2]] {uniq_name = "_QFt5Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref>) -// CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQcl2X6500) : !fir.ref> -// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_7]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQcl2X6500"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_8]]#0 substr %[[VAL_1]], %[[VAL_1]] typeparams %[[VAL_1]] : (!fir.ref>, index, index, index) -> !fir.ref> -// CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_9]] : !fir.ref> -// CHECK: %[[VAL_11:.*]] = fir.extract_value %[[VAL_10]], [0 : index] : (!fir.char<2>) -> i16 -// CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_1]] to %[[VAL_5]]#1 step %[[VAL_1]] iter_args(%[[VAL_14:.*]] = %[[VAL_0]]) -> (index) { -// CHECK: %[[VAL_15:.*]] = arith.cmpi eq, %[[VAL_14]], %[[VAL_0]] : index -// CHECK: %[[VAL_16:.*]] = fir.if %[[VAL_15]] -> (index) { -// CHECK: %[[VAL_17:.*]] = hlfir.designate %[[VAL_6]]#0 substr %[[VAL_13]], %[[VAL_13]] typeparams %[[VAL_1]] : (!fir.boxchar<2>, index, index, index) -> !fir.ref> -// CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_17]] : !fir.ref> -// CHECK: %[[VAL_19:.*]] = fir.extract_value %[[VAL_18]], [0 : index] : (!fir.char<2>) -> i16 -// CHECK: %[[VAL_20:.*]] = arith.cmpi eq, %[[VAL_19]], %[[VAL_11]] : i16 -// CHECK: %[[VAL_21:.*]] = arith.select %[[VAL_20]], %[[VAL_13]], %[[VAL_14]] : index -// CHECK: fir.result %[[VAL_21]] : index -// CHECK: } else { -// CHECK: fir.result %[[VAL_14]] : index -// CHECK: } -// CHECK: fir.result %[[VAL_16]] : index -// CHECK: } -// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_12]] : (index) -> i8 -// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (i8) -> i32 -// CHECK: hlfir.assign %[[VAL_23]] to %[[VAL_4]]#0 : i32, !fir.ref -// CHECK: return -// CHECK: } - %0 = fir.dummy_scope : !fir.dscope - %1 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt5En"} - %2:2 = hlfir.declare %1 {uniq_name = "_QFt5En"} : (!fir.ref) -> (!fir.ref, !fir.ref) - %3:2 = fir.unboxchar %arg0 : (!fir.boxchar<2>) -> (!fir.ref>, index) - %4:2 = hlfir.declare %3#0 typeparams %3#1 dummy_scope %0 {uniq_name = "_QFt5Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref>) - %5 = fir.address_of(@_QQcl2X6500) : !fir.ref> - %c1 = arith.constant 1 : index - %6:2 = hlfir.declare %5 typeparams %c1 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQcl2X6500"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %false = arith.constant false - %7 = hlfir.index %6#0 in %4#0 back %false : (!fir.ref>, !fir.boxchar<2>, i1) -> i8 - %8 = fir.convert %7 : (i8) -> i32 - hlfir.assign %8 to %2#0 : i32, !fir.ref - return - } - -// Do no simplify - runtime call for forward search with character kind=1 is faster -func.func @_QPt6(%arg0: !fir.boxchar<1> {fir.bindc_name = "s"}) { -// CHECK-LABEL: func.func @_QPt6( -// CHECK-SAME: %[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "s"}) { -// CHECK: %[[VAL_0:.*]] = arith.constant false -// CHECK: %[[VAL_1:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt6En"} -// CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QFt6En"} : (!fir.ref) -> (!fir.ref, !fir.ref) -// CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref>, index) -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]]#0 typeparams %[[VAL_5]]#1 dummy_scope %[[VAL_2]] {uniq_name = "_QFt6Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<1>, !fir.ref>) -// CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQclX65) : !fir.ref> -// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_7]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX65"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_9:.*]] = hlfir.index %[[VAL_8]]#0 in %[[VAL_6]]#0 back %[[VAL_0]] : (!fir.ref>, !fir.boxchar<1>, i1) -> i32 -// CHECK: hlfir.assign %[[VAL_9]] to %[[VAL_4]]#0 : i32, !fir.ref -// CHECK: return -// CHECK: } - %0 = fir.dummy_scope : !fir.dscope - %1 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt6En"} - %2:2 = hlfir.declare %1 {uniq_name = "_QFt6En"} : (!fir.ref) -> (!fir.ref, !fir.ref) - %3:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref>, index) - %4:2 = hlfir.declare %3#0 typeparams %3#1 dummy_scope %0 {uniq_name = "_QFt6Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<1>, !fir.ref>) - %5 = fir.address_of(@_QQclX65) : !fir.ref> - %c1 = arith.constant 1 : index - %6:2 = hlfir.declare %5 typeparams %c1 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX65"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %false = arith.constant false - %7 = hlfir.index %6#0 in %4#0 back %false : (!fir.ref>, !fir.boxchar<1>, i1) -> i32 - hlfir.assign %7 to %2#0 : i32, !fir.ref - return -} - -// Do not simplify - runtime call for forward search with character kind=1 is faster -// Lookup direction is unknown at compile time, hence forward is pessimistically assumed -func.func @_QPt7(%arg0: !fir.boxchar<1> {fir.bindc_name = "s"}, %arg1: !fir.ref> {fir.bindc_name = "b"}) { -// CHECK-LABEL: func.func @_QPt7( -// CHECK-SAME: %[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "s"}, -// CHECK-SAME: %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) { -// CHECK: %[[VAL_0:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_1:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_2:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %[[VAL_1]] {uniq_name = "_QFt7Eb"} : (!fir.ref>, !fir.dscope) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt7En"} -// CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QFt7En"} : (!fir.ref) -> (!fir.ref, !fir.ref) -// CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref>, index) -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]]#0 typeparams %[[VAL_5]]#1 dummy_scope %[[VAL_1]] {uniq_name = "_QFt7Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<1>, !fir.ref>) -// CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQclX65) : !fir.ref> -// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_7]] typeparams %[[VAL_0]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX65"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_2]]#0 : !fir.ref> -// CHECK: %[[VAL_10:.*]] = hlfir.index %[[VAL_8]]#0 in %[[VAL_6]]#0 back %[[VAL_9]] : (!fir.ref>, !fir.boxchar<1>, !fir.logical<4>) -> i32 -// CHECK: hlfir.assign %[[VAL_10]] to %[[VAL_4]]#0 : i32, !fir.ref -// CHECK: return -// CHECK: } - %0 = fir.dummy_scope : !fir.dscope - %1:2 = hlfir.declare %arg1 dummy_scope %0 {uniq_name = "_QFt7Eb"} : (!fir.ref>, !fir.dscope) -> (!fir.ref>, !fir.ref>) - %2 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt7En"} - %3:2 = hlfir.declare %2 {uniq_name = "_QFt7En"} : (!fir.ref) -> (!fir.ref, !fir.ref) - %4:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref>, index) - %5:2 = hlfir.declare %4#0 typeparams %4#1 dummy_scope %0 {uniq_name = "_QFt7Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<1>, !fir.ref>) - %6 = fir.address_of(@_QQclX65) : !fir.ref> - %c1 = arith.constant 1 : index - %7:2 = hlfir.declare %6 typeparams %c1 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX65"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %8 = fir.load %1#0 : !fir.ref> - %9 = hlfir.index %7#0 in %5#0 back %8 : (!fir.ref>, !fir.boxchar<1>, !fir.logical<4>) -> i32 - hlfir.assign %9 to %3#0 : i32, !fir.ref - return -} - -// Inline as backward search loop for character kind=1. -// The case similar to t7 but direction is known, so it is faster than runtime call. -func.func @_QPt8(%arg0: !fir.boxchar<1> {fir.bindc_name = "s"}) { -// CHECK-LABEL: func.func @_QPt8( -// CHECK-SAME: %[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "s"}) { -// CHECK: %[[VAL_0:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_1:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt8En"} -// CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QFt8En"} : (!fir.ref) -> (!fir.ref, !fir.ref) -// CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref>, index) -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]]#0 typeparams %[[VAL_5]]#1 dummy_scope %[[VAL_2]] {uniq_name = "_QFt8Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<1>, !fir.ref>) -// CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQclX65) : !fir.ref> -// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_7]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX65"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_8]]#0 substr %[[VAL_1]], %[[VAL_1]] typeparams %[[VAL_1]] : (!fir.ref>, index, index, index) -> !fir.ref> -// CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_9]] : !fir.ref> -// CHECK: %[[VAL_11:.*]] = fir.extract_value %[[VAL_10]], [0 : index] : (!fir.char<1>) -> i8 -// CHECK: %[[VAL_12:.*]] = arith.addi %[[VAL_5]]#1, %[[VAL_1]] : index -// CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_1]] to %[[VAL_5]]#1 step %[[VAL_1]] iter_args(%[[VAL_15:.*]] = %[[VAL_0]]) -> (index) { -// CHECK: %[[VAL_16:.*]] = arith.cmpi eq, %[[VAL_15]], %[[VAL_0]] : index -// CHECK: %[[VAL_17:.*]] = fir.if %[[VAL_16]] -> (index) { -// CHECK: %[[VAL_18:.*]] = arith.subi %[[VAL_12]], %[[VAL_14]] : index -// CHECK: %[[VAL_19:.*]] = hlfir.designate %[[VAL_6]]#0 substr %[[VAL_18]], %[[VAL_18]] typeparams %[[VAL_1]] : (!fir.boxchar<1>, index, index, index) -> !fir.ref> -// CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_19]] : !fir.ref> -// CHECK: %[[VAL_21:.*]] = fir.extract_value %[[VAL_20]], [0 : index] : (!fir.char<1>) -> i8 -// CHECK: %[[VAL_22:.*]] = arith.cmpi eq, %[[VAL_21]], %[[VAL_11]] : i8 -// CHECK: %[[VAL_23:.*]] = arith.select %[[VAL_22]], %[[VAL_18]], %[[VAL_15]] : index -// CHECK: fir.result %[[VAL_23]] : index -// CHECK: } else { -// CHECK: fir.result %[[VAL_15]] : index -// CHECK: } -// CHECK: fir.result %[[VAL_17]] : index -// CHECK: } -// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_13]] : (index) -> i32 -// CHECK: hlfir.assign %[[VAL_24]] to %[[VAL_4]]#0 : i32, !fir.ref -// CHECK: return -// CHECK: } - %0 = fir.dummy_scope : !fir.dscope - %1 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt8En"} - %2:2 = hlfir.declare %1 {uniq_name = "_QFt8En"} : (!fir.ref) -> (!fir.ref, !fir.ref) - %3:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref>, index) - %4:2 = hlfir.declare %3#0 typeparams %3#1 dummy_scope %0 {uniq_name = "_QFt8Es"} : (!fir.ref>, index, !fir.dscope) -> (!fir.boxchar<1>, !fir.ref>) - %5 = fir.address_of(@_QQclX65) : !fir.ref> - %c1 = arith.constant 1 : index - %6:2 = hlfir.declare %5 typeparams %c1 {fortran_attrs = #fir.var_attrs, uniq_name = "_QQclX65"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) - %true = arith.constant true - %7 = hlfir.index %6#0 in %4#0 back %true : (!fir.ref>, !fir.boxchar<1>, i1) -> i32 - hlfir.assign %7 to %2#0 : i32, !fir.ref - return -} -