[flang][NFC] move getIntIfConstant into FIROpsSupport.h

[jeanPerier]

Summary

The motivation is to have it accessible in HLFIROps.cpp to
use it in hlfir.set_length builder to build the result length
type as best as possible.

[clementval]

LGTM

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/include/flang/Optimizer/Builder/FIRBuilder.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
 #define FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
 
 #include "flang/Common/MathOptionsBase.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 
 namespace fir {
mlir::Value genLenOfCharacter(fir::FirOpBuilder &builder, mlir::Location loc,
                               llvm::ArrayRef<mlir::Value> path,
                               llvm::ArrayRef<mlir::Value> substring);
 
 /// Create the zero value of a given the numerical or logical \p type (`false`
 /// for logical types).
 mlir::Value createZeroValue(fir::FirOpBuilder &builder, mlir::Location loc,
                             mlir::Type type);
 
-/// Unwrap integer constant from an mlir::Value.
-llvm::Optional<std::int64_t> getIntIfConstant(mlir::Value value);
-
 /// Get the integer constants of triplet and compute the extent.
 llvm::Optional<std::int64_t>
 getExtentFromTriplet(mlir::Value lb, mlir::Value ub, mlir::Value stride);
 
 /// Generate max(\p value, 0) where \p value is a scalar integer.
 mlir::Value genMaxWithZero(fir::FirOpBuilder &builder, mlir::Location loc,
                            mlir::Value value);
 

flang/include/flang/Optimizer/Dialect/FIROpsSupport.h

 ///     previous cases.
 bool valueHasFirAttribute(mlir::Value value, llvm::StringRef attributeName);
 
 /// Scan the arguments of a FuncOp to determine if any arguments have the
 /// attribute `attr` placed on them. This can be used to determine if the
 /// function has any host associations, for example.
 bool anyFuncArgsHaveAttr(mlir::func::FuncOp func, llvm::StringRef attr);
 
+/// Unwrap integer constant from an mlir::Value.
+inline std::optional<std::int64_t> getIntIfConstant(mlir::Value value) {
+  if (auto *definingOp = value.getDefiningOp())
+    if (auto cst = mlir::dyn_cast<mlir::arith::ConstantOp>(definingOp))
+      if (auto intAttr = cst.getValue().dyn_cast<mlir::IntegerAttr>())
+        return intAttr.getInt();
+  return {};
+}
+
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_DIALECT_FIROPSSUPPORT_H

flang/lib/Lower/ConvertExprToHLFIR.cpp

if (!loweredExpr.isArray()) {
     fir::FirOpBuilder &builder = getBuilder();
     if (loweredExpr.isVariable())
       return hlfir::EntityWithAttributes{
           hlfir::loadTrivialScalar(loc, builder, loweredExpr).getBase()};
     // Skip constant conversions that litters designators and makes generated
     // IR harder to read: directly use index constants for constant subscripts.
     mlir::Type idxTy = builder.getIndexType();
     if (loweredExpr.getType() != idxTy)
-      if (auto cstIndex = fir::factory::getIntIfConstant(loweredExpr))
+      if (auto cstIndex = fir::getIntIfConstant(loweredExpr))
         return hlfir::EntityWithAttributes{
             builder.createIntegerConstant(getLoc(), idxTy, *cstIndex)};
   }
   return loweredExpr;
 }
 
 } // namespace
 
 hlfir::EntityWithAttributes Fortran::lower::convertExprToHLFIR(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
     const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &symMap,
     Fortran::lower::StatementContext &stmtCtx) {
   return HlfirBuilder(loc, converter, symMap, stmtCtx).gen(expr);
 }

flang/lib/Lower/IntrinsicCall.cpp

mlir::Value lbArrayExtent =
         builder.createIntegerConstant(loc, indexType, rank);
     llvm::SmallVector<mlir::Value> extents{lbArrayExtent};
     return fir::ArrayBoxValue{lbArray, extents};
   }
   // DIM is present.
   mlir::Value dim = fir::getBase(args[1]);
 
   // If it is a compile time constant, skip the runtime call.
-  if (llvm::Optional<std::int64_t> cstDim =
-          fir::factory::getIntIfConstant(dim)) {
+  if (std::optional<std::int64_t> cstDim = fir::getIntIfConstant(dim)) {
     mlir::Value one = builder.createIntegerConstant(loc, resultType, 1);
     mlir::Value zero = builder.createIntegerConstant(loc, indexType, 0);
     mlir::Value lb = computeLBOUND(builder, loc, array, *cstDim - 1, zero, one);
     return builder.createConvert(loc, resultType, lb);
   }
 
   fir::ExtendedValue box = createBoxForRuntimeBoundInquiry(loc, builder, array);
   return builder.createConvert(

flang/lib/Optimizer/Builder/FIRBuilder.cpp

if (fir::isa_complex(type)) {
     mlir::Type partType = complexHelper.getComplexPartType(type);
     mlir::Value zeroPart = builder.createRealZeroConstant(loc, partType);
     return complexHelper.createComplex(type, zeroPart, zeroPart);
   }
   fir::emitFatalError(loc, "internal: trying to generate zero value of non "
                            "numeric or logical type");
 }
 
-llvm::Optional<std::int64_t> fir::factory::getIntIfConstant(mlir::Value value) {
-  if (auto *definingOp = value.getDefiningOp())
-    if (auto cst = mlir::dyn_cast<mlir::arith::ConstantOp>(definingOp))
-      if (auto intAttr = cst.getValue().dyn_cast<mlir::IntegerAttr>())
-        return intAttr.getInt();
-  return {};
-}
-
 llvm::Optional<std::int64_t>
 fir::factory::getExtentFromTriplet(mlir::Value lb, mlir::Value ub,
                                    mlir::Value stride) {
   std::function<llvm::Optional<std::int64_t>(mlir::Value)> getConstantValue =
       [&](mlir::Value value) -> llvm::Optional<std::int64_t> {
-    if (auto valInt = fir::factory::getIntIfConstant(value))
-      return valInt;
+    if (auto valInt = fir::getIntIfConstant(value))
+      return *valInt;
     auto *definingOp = value.getDefiningOp();
     if (mlir::isa_and_nonnull<fir::ConvertOp>(definingOp)) {
       auto valOp = mlir::dyn_cast<fir::ConvertOp>(definingOp);
       return getConstantValue(valOp.getValue());
     }
     return {};
   };
   if (auto lbInt = getConstantValue(lb)) {

flang/lib/Optimizer/Builder/HLFIRTools.cpp

designate = builder.create<hlfir::DesignateOp>(loc, resultType, entity,
                                                    oneBasedIndices, lenParams);
   }
   return mlir::cast<fir::FortranVariableOpInterface>(designate.getOperation());
 }
 
 static mlir::Value genUBound(mlir::Location loc, fir::FirOpBuilder &builder,
                              mlir::Value lb, mlir::Value extent,
                              mlir::Value one) {
-  if (auto constantLb = fir::factory::getIntIfConstant(lb))
+  if (auto constantLb = fir::getIntIfConstant(lb))
     if (*constantLb == 1)
       return extent;
   extent = builder.createConvert(loc, one.getType(), extent);
   lb = builder.createConvert(loc, one.getType(), lb);
   auto add = builder.create<mlir::arith::AddIOp>(loc, lb, extent);
   return builder.create<mlir::arith::SubIOp>(loc, add, one);
 }
 

 }
 
 static hlfir::ExprType getArrayExprType(mlir::Type elementType,
                                         mlir::Value shape, bool isPolymorphic) {
   unsigned rank = shape.getType().cast<fir::ShapeType>().getRank();
   hlfir::ExprType::Shape typeShape(rank, hlfir::ExprType::getUnknownExtent());
   if (auto shapeOp = shape.getDefiningOp<fir::ShapeOp>())
     for (auto extent : llvm::enumerate(shapeOp.getExtents()))
-      if (auto cstExtent = fir::factory::getIntIfConstant(extent.value()))
+      if (auto cstExtent = fir::getIntIfConstant(extent.value()))
         typeShape[extent.index()] = *cstExtent;
   return hlfir::ExprType::get(elementType.getContext(), typeShape, elementType,
                               isPolymorphic);
 }
 
 hlfir::ElementalOp
 hlfir::genElementalOp(mlir::Location loc, fir::FirOpBuilder &builder,
                       mlir::Type elementType, mlir::Value shape,

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

matchAndRewrite(hlfir::EndAssociateOp endAssociate, OpAdaptor adaptor,
     mlir::Location loc = endAssociate->getLoc();
     rewriter.eraseOp(endAssociate);
     auto genFree = [&]() {
       mlir::Value var = adaptor.getVar();
       if (var.getType().isa<fir::BaseBoxType>())
         TODO(loc, "unbox");
       rewriter.create<fir::FreeMemOp>(loc, var);
     };
-    if (auto cstMustFree = fir::factory::getIntIfConstant(mustFree)) {
+    if (auto cstMustFree = fir::getIntIfConstant(mustFree)) {
       if (*cstMustFree != 0)
         genFree();
       // else, nothing to do.
       return mlir::success();
     }
     TODO(endAssociate.getLoc(), "conditional free");
   }
 };