Revert "[flang] Simplify hlfir.index in a few limited cases. (#157883)" #161387
+0
−553
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
flang
|
@llvm/pr-subscribers-flang-fir-hlfir Author: Valery Dmitriev (valerydmit) ChangesThis reverts commit edca510. Patch is 39.45 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/161387.diff 2 Files Affected:
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<hlfir::CmpCharOp> {
}
};
-static std::pair<mlir::Value, hlfir::AssociateOp>
-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<hlfir::ExprType>(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<hlfir::IndexOp> {
-public:
- using mlir::OpRewritePattern<hlfir::IndexOp>::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<bool> isBack;
- if (back) {
- if (auto backCst = fir::getIntIfConstant(back))
- isBack = *backCst != 0;
- } else {
- isBack = false;
- }
- auto charTy = mlir::cast<fir::CharacterType>(
- 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<mlir::Value, 1> {
- 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<mlir::Value, 1> 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 <typename Op>
class MatmulConversion : public mlir::OpRewritePattern<Op> {
public:
@@ -3162,7 +2955,6 @@ class SimplifyHLFIRIntrinsics
patterns.insert<ArrayShiftConversion<hlfir::CShiftOp>>(context);
patterns.insert<ArrayShiftConversion<hlfir::EOShiftOp>>(context);
patterns.insert<CmpCharOpConversion>(context);
- patterns.insert<IndexOpConversion>(context);
patterns.insert<MatmulConversion<hlfir::MatmulTransposeOp>>(context);
patterns.insert<ReductionConversion<hlfir::CountOp>>(context);
patterns.insert<ReductionConversion<hlfir::AnyOp>>(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<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-// 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<!fir.char<1,4>>, index) -> (!fir.ref<!fir.char<1,4>>, !fir.ref<!fir.char<1,4>>)
-// CHECK: %[[VAL_9:.*]] = fir.address_of(@_QQclX616263) : !fir.ref<!fir.char<1,3>>
-// CHECK: %[[VAL_10:.*]]:2 = hlfir.declare %[[VAL_9]] typeparams %[[VAL_2]] {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQclX616263"} : (!fir.ref<!fir.char<1,3>>, index) -> (!fir.ref<!fir.char<1,3>>, !fir.ref<!fir.char<1,3>>)
-// CHECK: hlfir.assign %[[VAL_10]]#0 to %[[VAL_8]]#0 : !fir.ref<!fir.char<1,3>>, !fir.ref<!fir.char<1,4>>
-// CHECK: %[[VAL_11:.*]] = fir.address_of(@_QQclX) : !fir.ref<!fir.char<1,0>>
-// CHECK: %[[VAL_12:.*]]:2 = hlfir.declare %[[VAL_11]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQclX"} : (!fir.ref<!fir.char<1,0>>, index) -> (!fir.ref<!fir.char<1,0>>, !fir.ref<!fir.char<1,0>>)
-// CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_0]] : (index) -> i32
-// CHECK: hlfir.assign %[[VAL_13]] to %[[VAL_6]]#0 : i32, !fir.ref<i32>
-// 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<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
- %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<!fir.char<1,4>>, index) -> (!fir.ref<!fir.char<1,4>>, !fir.ref<!fir.char<1,4>>)
- %5 = fir.address_of(@_QQclX616263) : !fir.ref<!fir.char<1,3>>
- %c3 = arith.constant 3 : index
- %6:2 = hlfir.declare %5 typeparams %c3 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQclX616263"} : (!fir.ref<!fir.char<1,3>>, index) -> (!fir.ref<!fir.char<1,3>>, !fir.ref<!fir.char<1,3>>)
- hlfir.assign %6#0 to %4#0 : !fir.ref<!fir.char<1,3>>, !fir.ref<!fir.char<1,4>>
- %7 = fir.address_of(@_QQclX) : !fir.ref<!fir.char<1,0>>
- %c0 = arith.constant 0 : index
- %8:2 = hlfir.declare %7 typeparams %c0 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQclX"} : (!fir.ref<!fir.char<1,0>>, index) -> (!fir.ref<!fir.char<1,0>>, !fir.ref<!fir.char<1,0>>)
- %true = arith.constant true
- %9 = hlfir.index %8#0 in %4#0 back %true : (!fir.ref<!fir.char<1,0>>, !fir.ref<!fir.char<1,4>>, i1) -> i32
- hlfir.assign %9 to %2#0 : i32, !fir.ref<i32>
- 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.logical<4>> {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.logical<4>> {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.logical<4>>, !fir.dscope) -> (!fir.ref<!fir.logical<4>>, !fir.ref<!fir.logical<4>>)
-// 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<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-// CHECK: %[[VAL_6:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<2>) -> (!fir.ref<!fir.char<2,?>>, index)
-// CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]]#0 typeparams %[[VAL_6]]#1 dummy_scope %[[VAL_2]] {uniq_name = "_QFt2Es"} : (!fir.ref<!fir.char<2,?>>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref<!fir.char<2,?>>)
-// CHECK: %[[VAL_8:.*]] = fir.address_of(@_QQcl2X) : !fir.ref<!fir.char<2,0>>
-// CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_8]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQcl2X"} : (!fir.ref<!fir.char<2,0>>, index) -> (!fir.ref<!fir.char<2,0>>, !fir.ref<!fir.char<2,0>>)
-// CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<!fir.logical<4>>
-// 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<i32>
-// CHECK: return
-// CHECK: }
- %0 = fir.dummy_scope : !fir.dscope
- %1:2 = hlfir.declare %arg1 dummy_scope %0 {uniq_name = "_QFt2Eb"} : (!fir.ref<!fir.logical<4>>, !fir.dscope) -> (!fir.ref<!fir.logical<4>>, !fir.ref<!fir.logical<4>>)
- %2 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFt2En"}
- %3:2 = hlfir.declare %2 {uniq_name = "_QFt2En"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
- %4:2 = fir.unboxchar %arg0 : (!fir.boxchar<2>) -> (!fir.ref<!fir.char<2,?>>, index)
- %5:2 = hlfir.declare %4#0 typeparams %4#1 dummy_scope %0 {uniq_name = "_QFt2Es"} : (!fir.ref<!fir.char<2,?>>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref<!fir.char<2,?>>)
- %6 = fir.address_of(@_QQcl2X) : !fir.ref<!fir.char<2,0>>
- %c0 = arith.constant 0 : index
- %7:2 = hlfir.declare %6 typeparams %c0 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQcl2X"} : (!fir.ref<!fir.char<2,0>>, index) -> (!fir.ref<!fir.char<2,0>>, !fir.ref<!fir.char<2,0>>)
- %8 = fir.load %1#0 : !fir.ref<!fir.logical<4>>
- %9 = hlfir.index %7#0 in %5#0 back %8 : (!fir.ref<!fir.char<2,0>>, !fir.boxchar<2>, !fir.logical<4>) -> i32
- hlfir.assign %9 to %3#0 : i32, !fir.ref<i32>
- 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<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-// CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<2>) -> (!fir.ref<!fir.char<2,?>>, index)
-// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]]#0 typeparams %[[VAL_5]]#1 dummy_scope %[[VAL_2]] {uniq_name = "_QFt3Es"} : (!fir.ref<!fir.char<2,?>>, index, !fir.dscope) -> (!fir.boxchar<2>, !fir.ref<!fir.char<2,?>>)
-// CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQcl2X6500) : !fir.ref<!fir.char<2>>
-// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_7]] typeparams %[[VAL_1]] {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQcl2X6500"} : (!fir.ref<!fir.char<2>>, index) -> (!fir.ref<!fir.char<2>>, !fir.ref<!fir.char<2>>)
-// CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_8]]#0 substr %[[VAL_1]], %[[VAL_1]] typeparams %[[VAL_1]] : (!fir.ref<!fir.char<2>>, index, index, index) -> !fir.ref<!fir.char<2>>
-// CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_9]] : !fir.ref<!fir.char<2>>
-// 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<!fir.char<2>>
-// CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_19]] : !fir.ref<!fir.char<2>>
-// 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: ...
[truncated]
|
mahesh-attarde
pushed a commit
to mahesh-attarde/llvm-project
that referenced
this pull request
Oct 3, 2025
…7883)" (llvm#161387) This reverts commit edca510 due to reported failures.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This reverts commit edca510.