[FLANG][NFC]Use RTNAME instead of hard-coding for simplify intrinsics

[Leporacanthicus]

Summary

Use the RTNMAE macro (via stringify macros) to generate the name
strings for runtime functions, instead of using strings.
The sequence of macros generate exactly the same string as the
ones used previously, but this will support future changes in
runtime function names.

No functional change.

[vzakhari]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

32

Is this files really needed?

170–172

I am not sure RTName prefix really useful here. Maybe use something like FRT (standing for Fortran runtime) or more verbose FortranRuntime.

[Leporacanthicus]

Revew comment fixes:

• Removed unused header file
• Changed function names from RTName to Runtime to better reflect what they do.

[Leporacanthicus]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

32

Yes, we need to include entry-names.h , as that is where RTNAME is defined. Including the RTBuilder.h is not needed, and I've removed that. I originally intended to use a macro from RTBuilder.h, that did the stringify, but I decided that

Interestingly, RTBuilder.h uses RTNAME without including the header it relies on - but all the relevant flang/Runtime/*.h do include entry-names.h, so it works.

Maybe entry-names.h should be moved (or move the RTNAME macro - it's the ONLY thing in entry-names.h)?

Suggestions welcome if this should be changed.

170–172

I wasn't exactly happy with that name either, but couldn't think of something better at the time. I've gone for genRumtimeSomething as a compromise between long and cryptic variants. I don't think it's that far-fetched to understand that Runtime here means Fortran Runtime.

[vzakhari]

LGTM, except for the buildbot failures.

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

32

I guess entry-names.h was created exactly to expose RTNAME for different components in flang. Not all of them require RTBuilder functionality, so I guess it is okay as-is.

170–172

Looks good now. Thanks.

[Leporacanthicus]

Rebase to latest llvm/main

[Leporacanthicus]

In D132652#3764143, @vzakhari wrote:

LGTM, except for the buildbot failures.

Yeah, I didn't link it to the previous commit that it depends on. As that as gone in and this is now rebased, should be good to go on Monday! :)

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

 
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
+#include "flang/Runtime/entry-names.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace fir {
 #define GEN_PASS_DEF_SIMPLIFYINTRINSICS
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 } // namespace fir
 
+#define RTNAME_STRINGIFY2(x) #x
+#define RTNAME_STRINGIFY(x) RTNAME_STRINGIFY2(x)
+#define RTNAME_STRING(x) RTNAME_STRINGIFY(RTNAME(x))
+
 #define DEBUG_TYPE "flang-simplify-intrinsics"
 
 namespace {
 
 class SimplifyIntrinsicsPass
     : public fir::impl::SimplifyIntrinsicsBase<SimplifyIntrinsicsPass> {
   using FunctionTypeGeneratorTy =
       llvm::function_ref<mlir::FunctionType(fir::FirOpBuilder &)>;
private:
   /// \p kindMap is used to create FIROpBuilder
   /// \p genBodyFunc is the callback that builds the replacement function
   void simplifyReduction(fir::CallOp call, const fir::KindMapping &kindMap,
                          GenReductionBodyTy genBodyFunc);
 };
 
 } // namespace
 
-/// Generate function type for the simplified version of FortranASum and
+/// Generate function type for the simplified version of RTNAME(Sum) and
 /// similar functions with a fir.box<none> type returning \p elementType.
 static mlir::FunctionType genNoneBoxType(fir::FirOpBuilder &builder,
                                          const mlir::Type &elementType) {
   mlir::Type boxType = fir::BoxType::get(builder.getNoneType());
   return mlir::FunctionType::get(builder.getContext(), {boxType},
                                  {elementType});
 }
 
static void genReductionLoop(fir::FirOpBuilder &builder,
   builder.create<fir::ResultOp>(loc, reductionVal);
   // End of loop.
   builder.restoreInsertionPoint(loopEndPt);
 
   mlir::Value resultVal = loop.getResult(0);
   builder.create<mlir::func::ReturnOp>(loc, resultVal);
 }
 
-/// Generate function body of the simplified version of FortranASum
+/// Generate function body of the simplified version of RTNAME(Sum)
 /// with signature provided by \p funcOp. The caller is responsible
 /// for saving/restoring the original insertion point of \p builder.
 /// \p funcOp is expected to be empty on entry to this function.
-static void genFortranASumBody(fir::FirOpBuilder &builder,
-                               mlir::func::FuncOp &funcOp) {
-  // function FortranASum<T>_simplified(arr)
+static void genRuntimeSumBody(fir::FirOpBuilder &builder,
+  // function RTNAME(Sum)<T>_simplified(arr)
   //   T, dimension(:) :: arr
   //   T sum = 0
   //   integer iter
   //   do iter = 0, extent(arr)
   //     sum = sum + arr[iter]
   //   end do
-  //   FortranASum<T>_simplified = sum
-  // end function FortranASum<T>_simplified
+  //   RTNAME(Sum)<T>_simplified = sum
+  // end function RTNAME(Sum)<T>_simplified
   auto zero = [](fir::FirOpBuilder builder, mlir::Location loc,
                  mlir::Type elementType) {
     return elementType.isa<mlir::FloatType>()
                ? builder.createRealConstant(loc, elementType,
                                             llvm::APFloat(0.0))
                : builder.createIntegerConstant(loc, elementType, 0);
   };
 
   auto genBodyOp = [](fir::FirOpBuilder builder, mlir::Location loc,
                       mlir::Type elementType, mlir::Value elem1,
                       mlir::Value elem2) -> mlir::Value {
     if (elementType.isa<mlir::FloatType>())
       return builder.create<mlir::arith::AddFOp>(loc, elem1, elem2);
     if (elementType.isa<mlir::IntegerType>())
       return builder.create<mlir::arith::AddIOp>(loc, elem1, elem2);
 
     llvm_unreachable("unsupported type");
     return {};
   };
 
   genReductionLoop(builder, funcOp, zero, genBodyOp);
 }
 
-static void genFortranAMaxvalBody(fir::FirOpBuilder &builder,
-                                  mlir::func::FuncOp &funcOp) {
+static void genRuntimeMaxvalBody(fir::FirOpBuilder &builder,
   auto init = [](fir::FirOpBuilder builder, mlir::Location loc,
                  mlir::Type elementType) {
     if (auto ty = elementType.dyn_cast<mlir::FloatType>()) {
       const llvm::fltSemantics &sem = ty.getFloatSemantics();
       return builder.createRealConstant(
           loc, elementType, llvm::APFloat::getLargest(sem, /*Negative=*/true));
     }
     unsigned bits = elementType.getIntOrFloatBitWidth();
if (elementType.isa<mlir::IntegerType>())
       return builder.create<mlir::arith::MaxSIOp>(loc, elem1, elem2);
 
     llvm_unreachable("unsupported type");
     return {};
   };
   genReductionLoop(builder, funcOp, init, genBodyOp);
 }
 
-/// Generate function type for the simplified version of FortranADotProduct
+/// Generate function type for the simplified version of RTNAME(DotProduct)
 /// operating on the given \p elementType.
-static mlir::FunctionType genFortranADotType(fir::FirOpBuilder &builder,
-                                             const mlir::Type &elementType) {
+static mlir::FunctionType genRuntimeDotType(fir::FirOpBuilder &builder,
   mlir::Type boxType = fir::BoxType::get(builder.getNoneType());
   return mlir::FunctionType::get(builder.getContext(), {boxType, boxType},
                                  {elementType});
 }
 
-/// Generate function body of the simplified version of FortranADotProduct
+/// Generate function body of the simplified version of RTNAME(DotProduct)
 /// with signature provided by \p funcOp. The caller is responsible
 /// for saving/restoring the original insertion point of \p builder.
 /// \p funcOp is expected to be empty on entry to this function.
 /// \p arg1ElementTy and \p arg2ElementTy specify elements types
 /// of the underlying array objects - they are used to generate proper
 /// element accesses.
-static void genFortranADotBody(fir::FirOpBuilder &builder,
-                               mlir::func::FuncOp &funcOp,
-                               mlir::Type arg1ElementTy,
-                               mlir::Type arg2ElementTy) {
-  // function FortranADotProduct<T>_simplified(arr1, arr2)
+static void genRuntimeDotBody(fir::FirOpBuilder &builder,
+  // function RTNAME(DotProduct)<T>_simplified(arr1, arr2)
   //   T, dimension(:) :: arr1, arr2
   //   T product = 0
   //   integer iter
   //   do iter = 0, extent(arr1)
   //     product = product + arr1[iter] * arr2[iter]
   //   end do
-  //   FortranADotProduct<T>_simplified = product
-  // end function FortranADotProduct<T>_simplified
+  //   RTNAME(ADotProduct)<T>_simplified = product
+  // end function RTNAME(DotProduct)<T>_simplified
   auto loc = mlir::UnknownLoc::get(builder.getContext());
   mlir::Type resultElementType = funcOp.getResultTypes()[0];
   builder.setInsertionPointToEnd(funcOp.addEntryBlock());
 
   mlir::IndexType idxTy = builder.getIndexType();
 
   mlir::Value zero =
       resultElementType.isa<mlir::FloatType>()
if (auto call = mlir::dyn_cast<fir::CallOp>(op)) {
         // argument (no dim or mask argument) for 1D arrays with either
         // Integer4 or Real8 types. Other forms are ignored.
         // The new function is added to the module.
         //
         // Prototype for runtime call (from sum.cpp):
         // RTNAME(Sum<T>)(const Descriptor &x, const char *source, int line,
         //                int dim, const Descriptor *mask)
         //
-        if (funcName.startswith("_FortranASum")) {
-          simplifyReduction(call, kindMap, genFortranASumBody);
+        if (funcName.startswith(RTNAME_STRING(Sum))) {
+          simplifyReduction(call, kindMap, genRuntimeSumBody);
           return;
         }
-        if (funcName.startswith("_FortranADotProduct")) {
+        if (funcName.startswith(RTNAME_STRING(DotProduct))) {
           LLVM_DEBUG(llvm::dbgs() << "Handling " << funcName << "\n");
           LLVM_DEBUG(llvm::dbgs() << "Call operation:\n"; op->dump();
                      llvm::dbgs() << "\n");
           mlir::Operation::operand_range args = call.getArgs();
           const mlir::Value &v1 = args[0];
           const mlir::Value &v2 = args[1];
           mlir::Location loc = call.getLoc();
           fir::FirOpBuilder builder(op, kindMap);
if (auto call = mlir::dyn_cast<fir::CallOp>(op)) {
           if (!arg1Type->isa<mlir::FloatType>() &&
               !arg1Type->isa<mlir::IntegerType>())
             return;
           if (!arg2Type->isa<mlir::FloatType>() &&
               !arg2Type->isa<mlir::IntegerType>())
             return;
 
           auto typeGenerator = [&type](fir::FirOpBuilder &builder) {
-            return genFortranADotType(builder, type);
+            return genRuntimeDotType(builder, type);
           };
           auto bodyGenerator = [&arg1Type,
                                 &arg2Type](fir::FirOpBuilder &builder,
                                            mlir::func::FuncOp &funcOp) {
-            genFortranADotBody(builder, funcOp, *arg1Type, *arg2Type);
+            genRuntimeDotBody(builder, funcOp, *arg1Type, *arg2Type);
           };
 
           // Suffix the function name with the element types
           // of the arguments.
           std::string typedFuncName(funcName);
           llvm::raw_string_ostream nameOS(typedFuncName);
           nameOS << "_";
           arg1Type->print(nameOS);
           nameOS << "_";
           arg2Type->print(nameOS);
 
           mlir::func::FuncOp newFunc = getOrCreateFunction(
               builder, typedFuncName, typeGenerator, bodyGenerator);
           auto newCall = builder.create<fir::CallOp>(loc, newFunc,
                                                      mlir::ValueRange{v1, v2});
           call->replaceAllUsesWith(newCall.getResults());
           call->dropAllReferences();
           call->erase();
 
           LLVM_DEBUG(llvm::dbgs() << "Replaced with:\n"; newCall.dump();
                      llvm::dbgs() << "\n");
           return;
         }
-        if (funcName.startswith("_FortranAMaxval")) {
-          simplifyReduction(call, kindMap, genFortranAMaxvalBody);
+        if (funcName.startswith(RTNAME_STRING(Maxval))) {
+          simplifyReduction(call, kindMap, genRuntimeMaxvalBody);
           return;
         }
       }
     }
   });
   LLVM_DEBUG(llvm::dbgs() << "=== End " DEBUG_TYPE " ===\n");
 }
 
 void SimplifyIntrinsicsPass::getDependentDialects(
     mlir::DialectRegistry &registry) const {
   // LLVM::LinkageAttr creation requires that LLVM dialect is loaded.
   registry.insert<mlir::LLVM::LLVMDialect>();
 }
 std::unique_ptr<mlir::Pass> fir::createSimplifyIntrinsicsPass() {
   return std::make_unique<SimplifyIntrinsicsPass>();
 }