[flang][NFC] Move Procedure designator lowering in its own file

[jeanPerier]

Summary

Code move without any change, the goal is to re-use this piece of
code for procedure designator lowering in HLFIR since there is no
significant changes in the way procedure designators will be
lowered.

[clementval]

LGTM

flang/include/flang/Lower/ConvertProcedureDesignator.h

+//===- ConvertProcedureDesignator.h -- Procedure Designators ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+///
+/// Lowering of evaluate::ProcedureDesignator to FIR and HLFIR.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_LOWER_CONVERT_PROCEDURE_DESIGNATOR_H
+#define FORTRAN_LOWER_CONVERT_PROCEDURE_DESIGNATOR_H
+
+namespace mlir {
+class Location;
+}
+namespace fir {
+class ExtendedValue;
+}
+namespace Fortran::evaluate {
+struct ProcedureDesignator;
+}
+
+namespace Fortran::lower {
+class AbstractConverter;
+class StatementContext;
+class SymMap;
+
+/// Lower a procedure designator to a fir::ExtendedValue that can be a
+/// fir::CharBoxValue for character procedure designator (the CharBoxValue
+/// length carries the result length if it is known).
+fir::ExtendedValue convertProcedureDesignator(
+    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+    const Fortran::evaluate::ProcedureDesignator &proc,
+    Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx);
+
+} // namespace Fortran::lower
+#endif // FORTRAN_LOWER_CONVERT_PROCEDURE_DESIGNATOR_H

flang/lib/Lower/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FortranLower
   Allocatable.cpp
   Bridge.cpp
   CallInterface.cpp
   Coarray.cpp
   ConvertCall.cpp
   ConvertConstant.cpp
   ConvertExpr.cpp
   ConvertExprToHLFIR.cpp
+  ConvertProcedureDesignator.cpp
   ConvertType.cpp
   ConvertVariable.cpp
   ComponentPath.cpp
   CustomIntrinsicCall.cpp
   DumpEvaluateExpr.cpp
   HostAssociations.cpp
   IO.cpp
   IterationSpace.cpp

flang/lib/Lower/ConvertExpr.cpp

 #include "flang/Lower/Allocatable.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/BuiltinModules.h"
 #include "flang/Lower/CallInterface.h"
 #include "flang/Lower/Coarray.h"
 #include "flang/Lower/ComponentPath.h"
 #include "flang/Lower/ConvertCall.h"
 #include "flang/Lower/ConvertConstant.h"
+#include "flang/Lower/ConvertProcedureDesignator.h"
 #include "flang/Lower/ConvertType.h"
 #include "flang/Lower/ConvertVariable.h"
 #include "flang/Lower/CustomIntrinsicCall.h"
 #include "flang/Lower/DumpEvaluateExpr.h"
 #include "flang/Lower/Mangler.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/Support/Utils.h"
 #include "flang/Optimizer/Builder/Character.h"
if (const auto *parentheses = std::get_if<Parentheses>(&expr.u))
       return Fortran::evaluate::IsVariable(parentheses->left());
     return false;
   } else {
     return std::visit([&](const auto &x) { return isParenthesizedVariable(x); },
                       expr.u);
   }
 }
 
-/// Does \p expr only refer to symbols that are mapped to IR values in \p symMap
-/// ?
-static bool allSymbolsInExprPresentInMap(const Fortran::lower::SomeExpr &expr,
-                                         Fortran::lower::SymMap &symMap) {
-  for (const auto &sym : Fortran::evaluate::CollectSymbols(expr))
-    if (!symMap.lookupSymbol(sym))
-      return false;
-  return true;
-}
-
 /// Generate a load of a value from an address. Beware that this will lose
 /// any dynamic type information for polymorphic entities (note that unlimited
 /// polymorphic cannot be loaded and must not be provided here).
 static fir::ExtendedValue genLoad(fir::FirOpBuilder &builder,
                                   mlir::Location loc,
                                   const fir::ExtendedValue &addr) {
   return addr.match(
       [](const fir::CharBoxValue &box) -> fir::ExtendedValue { return box; },
public:
   ExtValue genval(const Fortran::evaluate::BOZLiteralConstant &) {
     TODO(getLoc(), "BOZ");
   }
 
   /// Return indirection to function designated in ProcedureDesignator.
   /// The type of the function indirection is not guaranteed to match the one
   /// of the ProcedureDesignator due to Fortran implicit typing rules.
   ExtValue genval(const Fortran::evaluate::ProcedureDesignator &proc) {
-    mlir::Location loc = getLoc();
-    if (const Fortran::evaluate::SpecificIntrinsic *intrinsic =
-            proc.GetSpecificIntrinsic()) {
-      mlir::FunctionType signature =
-          Fortran::lower::translateSignature(proc, converter);
-      // Intrinsic lowering is based on the generic name, so retrieve it here in
-      // case it is different from the specific name. The type of the specific
-      // intrinsic is retained in the signature.
-      std::string genericName =
-          converter.getFoldingContext().intrinsics().GetGenericIntrinsicName(
-              intrinsic->name);
-      mlir::SymbolRefAttr symbolRefAttr =
-          fir::getUnrestrictedIntrinsicSymbolRefAttr(builder, loc, genericName,
-                                                     signature);
-      mlir::Value funcPtr =
-          builder.create<fir::AddrOfOp>(loc, signature, symbolRefAttr);
-      return funcPtr;
-    }
-    const Fortran::semantics::Symbol *symbol = proc.GetSymbol();
-    assert(symbol && "expected symbol in ProcedureDesignator");
-    mlir::Value funcPtr;
-    mlir::Value funcPtrResultLength;
-    if (Fortran::semantics::IsDummy(*symbol)) {
-      Fortran::lower::SymbolBox val = symMap.lookupSymbol(*symbol);
-      assert(val && "Dummy procedure not in symbol map");
-      funcPtr = val.getAddr();
-      if (fir::isCharacterProcedureTuple(funcPtr.getType(),
-                                         /*acceptRawFunc=*/false))
-        std::tie(funcPtr, funcPtrResultLength) =
-            fir::factory::extractCharacterProcedureTuple(builder, loc, funcPtr);
-    } else {
-      std::string name = converter.mangleName(*symbol);
-      mlir::func::FuncOp func =
-          Fortran::lower::getOrDeclareFunction(name, proc, converter);
-      funcPtr = builder.create<fir::AddrOfOp>(loc, func.getFunctionType(),
-                                              builder.getSymbolRefAttr(name));
-    }
-    if (Fortran::lower::mustPassLengthWithDummyProcedure(proc, converter)) {
-      // The result length, if available here, must be propagated along the
-      // procedure address so that call sites where the result length is assumed
-      // can retrieve the length.
-      Fortran::evaluate::DynamicType resultType = proc.GetType().value();
-      if (const auto &lengthExpr = resultType.GetCharLength()) {
-        // The length expression may refer to dummy argument symbols that are
-        // meaningless without any actual arguments. Leave the length as
-        // unknown in that case, it be resolved on the call site
-        // with the actual arguments.
-        if (allSymbolsInExprPresentInMap(toEvExpr(*lengthExpr), symMap)) {
-          mlir::Value rawLen = fir::getBase(genval(*lengthExpr));
-          // F2018 7.4.4.2 point 5.
-          funcPtrResultLength =
-              fir::factory::genMaxWithZero(builder, getLoc(), rawLen);
-        }
-      }
-      if (!funcPtrResultLength)
-        funcPtrResultLength = builder.createIntegerConstant(
-            loc, builder.getCharacterLengthType(), -1);
-      return fir::CharBoxValue{funcPtr, funcPtrResultLength};
-    }
-    return funcPtr;
+    return Fortran::lower::convertProcedureDesignator(getLoc(), converter, proc,
+                                                      symMap, stmtCtx);
   }
   ExtValue genval(const Fortran::evaluate::NullPointer &) {
     return builder.createNullConstant(getLoc());
   }
 
   static bool
   isDerivedTypeWithLenParameters(const Fortran::semantics::Symbol &sym) {
     if (const Fortran::semantics::DeclTypeSpec *declTy = sym.GetType())

flang/lib/Lower/ConvertProcedureDesignator.cpp

+//===- ConvertProcedureDesignator.cpp -- Procedure Designator ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Lower/ConvertProcedureDesignator.h"
+#include "flang/Evaluate/intrinsics.h"
+#include "flang/Lower/AbstractConverter.h"
+#include "flang/Lower/CallInterface.h"
+#include "flang/Lower/ConvertCall.h"
+#include "flang/Lower/ConvertVariable.h"
+#include "flang/Lower/Support/Utils.h"
+#include "flang/Lower/SymbolMap.h"
+#include "flang/Optimizer/Builder/Character.h"
+#include "flang/Optimizer/Builder/IntrinsicCall.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+
+static bool areAllSymbolsInExprMapped(const Fortran::evaluate::ExtentExpr &expr,
+                                      Fortran::lower::SymMap &symMap) {
+  for (const auto &sym : Fortran::evaluate::CollectSymbols(expr))
+    if (!symMap.lookupSymbol(sym))
+      return false;
+  return true;
+}
+
+fir::ExtendedValue Fortran::lower::convertProcedureDesignator(
+    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+    const Fortran::evaluate::ProcedureDesignator &proc,
+    Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+
+  if (const Fortran::evaluate::SpecificIntrinsic *intrinsic =
+          proc.GetSpecificIntrinsic()) {
+    mlir::FunctionType signature =
+        Fortran::lower::translateSignature(proc, converter);
+    // Intrinsic lowering is based on the generic name, so retrieve it here in
+    // case it is different from the specific name. The type of the specific
+    // intrinsic is retained in the signature.
+    std::string genericName =
+        converter.getFoldingContext().intrinsics().GetGenericIntrinsicName(
+            intrinsic->name);
+    mlir::SymbolRefAttr symbolRefAttr =
+        fir::getUnrestrictedIntrinsicSymbolRefAttr(builder, loc, genericName,
+                                                   signature);
+    mlir::Value funcPtr =
+        builder.create<fir::AddrOfOp>(loc, signature, symbolRefAttr);
+    return funcPtr;
+  }
+  const Fortran::semantics::Symbol *symbol = proc.GetSymbol();
+  assert(symbol && "expected symbol in ProcedureDesignator");
+  mlir::Value funcPtr;
+  mlir::Value funcPtrResultLength;
+  if (Fortran::semantics::IsDummy(*symbol)) {
+    Fortran::lower::SymbolBox val = symMap.lookupSymbol(*symbol);
+    assert(val && "Dummy procedure not in symbol map");
+    funcPtr = val.getAddr();
+    if (fir::isCharacterProcedureTuple(funcPtr.getType(),
+                                       /*acceptRawFunc=*/false))
+      std::tie(funcPtr, funcPtrResultLength) =
+          fir::factory::extractCharacterProcedureTuple(builder, loc, funcPtr);
+  } else {
+    std::string name = converter.mangleName(*symbol);
+    mlir::func::FuncOp func =
+        Fortran::lower::getOrDeclareFunction(name, proc, converter);
+    funcPtr = builder.create<fir::AddrOfOp>(loc, func.getFunctionType(),
+                                            builder.getSymbolRefAttr(name));
+  }
+  if (Fortran::lower::mustPassLengthWithDummyProcedure(proc, converter)) {
+    // The result length, if available here, must be propagated along the
+    // procedure address so that call sites where the result length is assumed
+    // can retrieve the length.
+    Fortran::evaluate::DynamicType resultType = proc.GetType().value();
+    if (const auto &lengthExpr = resultType.GetCharLength()) {
+      // The length expression may refer to dummy argument symbols that are
+      // meaningless without any actual arguments. Leave the length as
+      // unknown in that case, it be resolved on the call site
+      // with the actual arguments.
+      if (areAllSymbolsInExprMapped(*lengthExpr, symMap)) {
+        mlir::Value rawLen = fir::getBase(
+            converter.genExprValue(toEvExpr(*lengthExpr), stmtCtx));
+        // F2018 7.4.4.2 point 5.
+        funcPtrResultLength =
+            fir::factory::genMaxWithZero(builder, loc, rawLen);
+      }
+    }
+    if (!funcPtrResultLength)
+      funcPtrResultLength = builder.createIntegerConstant(
+          loc, builder.getCharacterLengthType(), -1);
+    return fir::CharBoxValue{funcPtr, funcPtrResultLength};
+  }
+  return funcPtr;
+}