move getCharLengthIfConst to HLFIRTools as requested. NFC

Author: valerydmit

flang/include/flang/Optimizer/Builder/HLFIRTools.h

@@ -324,6 +324,10 @@ void genLengthParameters(mlir::Location loc, fir::FirOpBuilder &builder,
 mlir::Value genCharLength(mlir::Location loc, fir::FirOpBuilder &builder,
                           Entity entity);
 
+/// Return character length if known at compile time. Unlike genCharLength
+/// it does not create any new op as specifically is intended for analysis.
+std::optional<std::int64_t> getCharLengthIfConst(Entity entity);
+
 mlir::Value genRank(mlir::Location loc, fir::FirOpBuilder &builder,
                     Entity entity, mlir::Type resultType);
 

flang/lib/Optimizer/Builder/HLFIRTools.cpp

@@ -676,6 +676,34 @@ mlir::Value hlfir::genLBound(mlir::Location loc, fir::FirOpBuilder &builder,
   return dimInfo.getLowerBound();
 }
 
+static bool
+getExprLengthParameters(mlir::Value expr,
+                        llvm::SmallVectorImpl<mlir::Value> &result) {
+  if (auto concat = expr.getDefiningOp<hlfir::ConcatOp>()) {
+    result.push_back(concat.getLength());
+    return true;
+  }
+  if (auto setLen = expr.getDefiningOp<hlfir::SetLengthOp>()) {
+    result.push_back(setLen.getLength());
+    return true;
+  }
+  if (auto elemental = expr.getDefiningOp<hlfir::ElementalOp>()) {
+    result.append(elemental.getTypeparams().begin(),
+                  elemental.getTypeparams().end());
+    return true;
+  }
+  if (auto evalInMem = expr.getDefiningOp<hlfir::EvaluateInMemoryOp>()) {
+    result.append(evalInMem.getTypeparams().begin(),
+                  evalInMem.getTypeparams().end());
+    return true;
+  }
+  if (auto apply = expr.getDefiningOp<hlfir::ApplyOp>()) {
+    result.append(apply.getTypeparams().begin(), apply.getTypeparams().end());
+    return true;
+  }
+  return false;
+}
+
 void hlfir::genLengthParameters(mlir::Location loc, fir::FirOpBuilder &builder,
                                 Entity entity,
                                 llvm::SmallVectorImpl<mlir::Value> &result) {
@@ -688,29 +716,14 @@ void hlfir::genLengthParameters(mlir::Location loc, fir::FirOpBuilder &builder,
     // Going through fir::ExtendedValue would create a temp,
     // which is not desired for an inquiry.
     // TODO: make this an interface when adding further character producing ops.
-    if (auto concat = expr.getDefiningOp<hlfir::ConcatOp>()) {
-      result.push_back(concat.getLength());
-      return;
-    } else if (auto concat = expr.getDefiningOp<hlfir::SetLengthOp>()) {
-      result.push_back(concat.getLength());
-      return;
-    } else if (auto asExpr = expr.getDefiningOp<hlfir::AsExprOp>()) {
+
+    if (auto asExpr = expr.getDefiningOp<hlfir::AsExprOp>()) {
       hlfir::genLengthParameters(loc, builder, hlfir::Entity{asExpr.getVar()},
                                  result);
       return;
-    } else if (auto elemental = expr.getDefiningOp<hlfir::ElementalOp>()) {
-      result.append(elemental.getTypeparams().begin(),
-                    elemental.getTypeparams().end());
-      return;
-    } else if (auto evalInMem =
-                   expr.getDefiningOp<hlfir::EvaluateInMemoryOp>()) {
-      result.append(evalInMem.getTypeparams().begin(),
-                    evalInMem.getTypeparams().end());
-      return;
-    } else if (auto apply = expr.getDefiningOp<hlfir::ApplyOp>()) {
-      result.append(apply.getTypeparams().begin(), apply.getTypeparams().end());
-      return;
     }
+    if (getExprLengthParameters(expr, result))
+      return;
     if (entity.isCharacter()) {
       result.push_back(hlfir::GetLengthOp::create(builder, loc, expr));
       return;
@@ -733,6 +746,36 @@ mlir::Value hlfir::genCharLength(mlir::Location loc, fir::FirOpBuilder &builder,
   return lenParams[0];
 }
 
+std::optional<std::int64_t> hlfir::getCharLengthIfConst(hlfir::Entity entity) {
+  if (!entity.isCharacter()) {
+    return std::nullopt;
+  }
+  if (mlir::isa<hlfir::ExprType>(entity.getType())) {
+    mlir::Value expr = entity;
+    if (auto reassoc = expr.getDefiningOp<hlfir::NoReassocOp>())
+      expr = reassoc.getVal();
+
+    if (auto asExpr = expr.getDefiningOp<hlfir::AsExprOp>())
+      return getCharLengthIfConst(hlfir::Entity{asExpr.getVar()});
+
+    llvm::SmallVector<mlir::Value> param;
+    if (getExprLengthParameters(expr, param)) {
+      assert(param.size() == 1 && "characters must have one length parameters");
+      return fir::getIntIfConstant(param.pop_back_val());
+    }
+    return std::nullopt;
+  }
+
+  // entity is a var
+  if (mlir::Value len = tryGettingNonDeferredCharLen(entity))
+    return fir::getIntIfConstant(len);
+  auto charType =
+      mlir::cast<fir::CharacterType>(entity.getFortranElementType());
+  if (charType.hasConstantLen())
+    return charType.getLen();
+  return std::nullopt;
+}
+
 mlir::Value hlfir::genRank(mlir::Location loc, fir::FirOpBuilder &builder,
                            hlfir::Entity entity, mlir::Type resultType) {
   if (!entity.isAssumedRank())

flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp

@@ -2298,57 +2298,6 @@ getVariable(fir::FirOpBuilder &builder, mlir::Location loc, mlir::Value val) {
   return {associate.getBase(), associate};
 }
 
-// Return character length if known at compile time. Unlike genCharLength
-// it does not create any new op as specifically is intended for analysis.
-// It is inspired by genLengthParameters that does the job for genCharLength.
-static std::optional<std::int64_t> getCharLengthIfConst(hlfir::Entity entity) {
-  if (!entity.isCharacter()) {
-    return std::nullopt;
-  }
-
-  if (mlir::isa<hlfir::ExprType>(entity.getType())) {
-    mlir::Value expr = entity;
-    if (auto reassoc = expr.getDefiningOp<hlfir::NoReassocOp>())
-      expr = reassoc.getVal();
-    // Going through fir::ExtendedValue would create a temp,
-    // which is not desired for an inquiry.
-    // TODO: make this an interface when adding further character producing ops.
-    if (auto concat = expr.getDefiningOp<hlfir::ConcatOp>()) {
-      return fir::getIntIfConstant(concat.getLength());
-    } else if (auto setLength = expr.getDefiningOp<hlfir::SetLengthOp>()) {
-      return fir::getIntIfConstant(setLength.getLength());
-    } else if (auto asExpr = expr.getDefiningOp<hlfir::AsExprOp>()) {
-      return getCharLengthIfConst(hlfir::Entity{asExpr.getVar()});
-    } else {
-      llvm::SmallVector<mlir::Value> param;
-      if (auto elemental = expr.getDefiningOp<hlfir::ElementalOp>()) {
-        param.append(elemental.getTypeparams().begin(),
-                     elemental.getTypeparams().end());
-      } else if (auto evalInMem =
-                     expr.getDefiningOp<hlfir::EvaluateInMemoryOp>()) {
-        param.append(evalInMem.getTypeparams().begin(),
-                     evalInMem.getTypeparams().end());
-      } else if (auto apply = expr.getDefiningOp<hlfir::ApplyOp>()) {
-        param.append(apply.getTypeparams().begin(),
-                     apply.getTypeparams().end());
-      } else {
-        return std::nullopt;
-      }
-      assert(param.size() == 1 && "characters must have one length parameters");
-      return fir::getIntIfConstant(param.pop_back_val());
-    }
-  }
-
-  if (auto varIface = entity.getMaybeDereferencedVariableInterface())
-    if (!varIface.getExplicitTypeParams().empty())
-      return fir::getIntIfConstant(varIface.getExplicitTypeParams()[0]);
-  auto charType =
-      mlir::cast<fir::CharacterType>(entity.getFortranElementType());
-  if (charType.hasConstantLen())
-    return charType.getLen();
-  return std::nullopt;
-}
-
 class IndexOpConversion : public mlir::OpRewritePattern<hlfir::IndexOp> {
 public:
   using mlir::OpRewritePattern<hlfir::IndexOp>::OpRewritePattern;
@@ -2372,7 +2321,8 @@ class IndexOpConversion : public mlir::OpRewritePattern<hlfir::IndexOp> {
 
     auto resultTy = op.getType();
     mlir::Value back = op.getBack();
-    auto substrLenCst = getCharLengthIfConst(hlfir::Entity{op.getSubstr()});
+    auto substrLenCst =
+        hlfir::getCharLengthIfConst(hlfir::Entity{op.getSubstr()});
     if (!substrLenCst) {
       return rewriter.notifyMatchFailure(
           op, "substring length unknown at compile time");
@@ -2398,7 +2348,7 @@ class IndexOpConversion : public mlir::OpRewritePattern<hlfir::IndexOp> {
       return mlir::success();
     }
 
-    if (auto strLenCst = getCharLengthIfConst(strEntity)) {
+    if (auto strLenCst = hlfir::getCharLengthIfConst(strEntity)) {
       if (*strLenCst < *substrLenCst) {
         rewriter.replaceOp(op, builder.createIntegerConstant(loc, resultTy, 0));
         return mlir::success();