[flang] Add getTypeAsString function to create symbols

[clementval]

Summary

This patch adds a common function to get a string representation
of a FIR type. This will be useful to generate couple of
operations like the acc.private.recipe, acc.firstprivate.recipe
and the acc.reduction.recipe

[razvanlupusoru]

This is perfect. Glad to see a single spot for canonicalizing names of types.

flang/include/flang/Optimizer/Dialect/FIRType.h

 /// Does this function type has a result that requires binding the result value
 /// with a storage in a fir.save_result operation in order to use the result?
 bool hasAbstractResult(mlir::FunctionType ty);
 
 /// Convert llvm::Type::TypeID to mlir::Type
 mlir::Type fromRealTypeID(mlir::MLIRContext *context, llvm::Type::TypeID typeID,
                           fir::KindTy kind);
 
-int getTypeCode(mlir::Type ty, KindMapping &kindMap);
+int getTypeCode(mlir::Type ty, const KindMapping &kindMap);
 
 inline bool BaseBoxType::classof(mlir::Type type) {
   return type.isa<fir::BoxType, fir::ClassType>();
 }
 
 /// Return true iff `ty` is none or fir.array<none>.
 inline bool isNoneOrSeqNone(mlir::Type type) {
   if (auto seqTy = type.dyn_cast<fir::SequenceType>())
inline bool isBoxAddress(mlir::Type t) {
   return fir::isa_ref_type(t) && fir::unwrapRefType(t).isa<fir::BaseBoxType>();
 }
 
 /// Is `t` a fir.box or class address or value type?
 inline bool isBoxAddressOrValue(mlir::Type t) {
   return fir::unwrapRefType(t).isa<fir::BaseBoxType>();
 }
 
+/// Return a string representation of `ty`. The fir.ref is omitted in the
+/// representation.
+///
+/// fir.array<10x10xf32> -> prefix_10x10xf32
+/// fir.ref<i32> -> i32
+std::string getTypeAsString(mlir::Type ty, const KindMapping &kindMap,
+                            llvm::StringRef prefix = "");
+
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_DIALECT_FIRTYPE_H

flang/lib/Optimizer/Dialect/FIRType.cpp

if (auto boxTy = ty.dyn_cast<fir::BoxType>()) {
     auto eleTy = unwrapRefType(boxTy.getEleTy());
     if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>())
       return seqTy.getEleTy();
   }
   return ty;
 }
 
 /// Return the ISO_C_BINDING intrinsic module value of type \p ty.
-int getTypeCode(mlir::Type ty, fir::KindMapping &kindMap) {
+int getTypeCode(mlir::Type ty, const fir::KindMapping &kindMap) {
   unsigned width = 0;
   if (mlir::IntegerType intTy = ty.dyn_cast<mlir::IntegerType>()) {
     switch (intTy.getWidth()) {
     case 8:
       return CFI_type_int8_t;
     case 16:
       return CFI_type_int16_t;
     case 32:
int getTypeCode(mlir::Type ty, const fir::KindMapping &kindMap) {
   }
   if (fir::isa_ref_type(ty))
     return CFI_type_cptr;
   if (ty.isa<fir::RecordType>())
     return CFI_type_struct;
   llvm_unreachable("unsupported type");
 }
 
+std::string getTypeAsString(mlir::Type ty, const fir::KindMapping &kindMap,
+                            llvm::StringRef prefix) {
+  std::stringstream name;
+  name << prefix.str();
+  if (!prefix.empty())
+    name << "_";
+  ty = fir::unwrapRefType(ty);
+  while (ty) {
+    if (fir::isa_trivial(ty)) {
+      if (ty.isIntOrIndex()) {
+        name << 'i' << ty.getIntOrFloatBitWidth();
+      } else if (ty.isa<mlir::FloatType>()) {
+        name << 'f' << ty.getIntOrFloatBitWidth();
+      } else if (fir::isa_complex(ty)) {
+        name << 'z';
+        if (auto cplxTy = mlir::dyn_cast_or_null<mlir::ComplexType>(ty)) {
+          auto floatTy = cplxTy.getElementType().cast<mlir::FloatType>();
+          name << floatTy.getWidth();
+        } else if (auto cplxTy = mlir::dyn_cast_or_null<fir::ComplexType>(ty)) {
+          name << kindMap.getRealBitsize(cplxTy.getFKind());
+        }
+      } else if (auto logTy = mlir::dyn_cast_or_null<fir::LogicalType>(ty)) {
+        name << 'l' << kindMap.getLogicalBitsize(logTy.getFKind());
+      } else {
+        llvm::report_fatal_error("unsupported type");
+      }
+      break;
+    } else if (auto charTy = mlir::dyn_cast_or_null<fir::CharacterType>(ty)) {
+      name << 'c' << kindMap.getCharacterBitsize(charTy.getFKind());
+      if (charTy.getLen() != fir::CharacterType::singleton())
+        name << "x" << charTy.getLen();
+      break;
+    } else if (auto seqTy = mlir::dyn_cast_or_null<fir::SequenceType>(ty)) {
+      for (auto extent : seqTy.getShape())
+        name << extent << 'x';
+      ty = seqTy.getEleTy();
+    } else {
+      // TODO: add support for RecordType/BaseBoxType
+      llvm::report_fatal_error("unsupported type");
+    }
+  }
+  return name.str();
+}
+
 } // namespace fir
 
 namespace {
 
 static llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4>
     recordTypeVisited;
 
 } // namespace

flang/unittests/Optimizer/FIRTypesTest.cpp

 //===- FIRTypesTest.cpp ---------------------------------------------------===//
 //
 // 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 "gtest/gtest.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
 
 struct FIRTypesTest : public testing::Test {
 public:
-  void SetUp() { fir::support::loadDialects(context); }
-
+  void SetUp() {
+    fir::support::loadDialects(context);
+    kindMap = new fir::KindMapping(&context, kindMapInit, "r42a10c14d28i40l41");
+  }
   mlir::MLIRContext context;
+  fir::KindMapping *kindMap{};
+  std::string kindMapInit =
+      "i10:80,l3:24,a1:8,r54:Double,r62:X86_FP80,r11:PPC_FP128";
 };
 
 // Test fir::isPolymorphicType from flang/Optimizer/Dialect/FIRType.h.
 TEST_F(FIRTypesTest, isPolymorphicTypeTest) {
   mlir::Type noneTy = mlir::NoneType::get(&context);
   mlir::Type seqNoneTy =
       fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, noneTy);
   mlir::Type recTy = fir::RecordType::get(&context, "dt");
for (mlir::Type ty : intrinsicTypes) {
     mlir::Type ptrTy = fir::PointerType::get(ty);
     EXPECT_EQ(ptrNone, fir::updateTypeForUnlimitedPolymorphic(ptrTy));
 
     // !fir.ptr<!fir.array<10xTY>> -> !fir.ptr<!fir.array<10xnone>>
     mlir::Type ptrArrTy = fir::PointerType::get(arrTy);
     EXPECT_EQ(ptrArrNone, fir::updateTypeForUnlimitedPolymorphic(ptrArrTy));
   }
 }
+
+TEST_F(FIRTypesTest, getTypeAsString) {
+  EXPECT_EQ("i32",
+      fir::getTypeAsString(mlir::IntegerType::get(&context, 32), *kindMap));
+  EXPECT_EQ(
+      "f64", fir::getTypeAsString(mlir::FloatType::getF64(&context), *kindMap));
+  EXPECT_EQ(
+      "l8", fir::getTypeAsString(fir::LogicalType::get(&context, 1), *kindMap));
+  EXPECT_EQ("z32",
+      fir::getTypeAsString(
+          mlir::ComplexType::get(mlir::FloatType::getF32(&context)), *kindMap));
+  EXPECT_EQ("c8",
+      fir::getTypeAsString(fir::CharacterType::get(&context, 1, 1), *kindMap));
+  EXPECT_EQ("c8x10",
+      fir::getTypeAsString(fir::CharacterType::get(&context, 1, 10), *kindMap));
+  mlir::Type ty = mlir::IntegerType::get(&context, 64);
+  mlir::Type arrTy = fir::SequenceType::get({10, 20}, ty);
+  EXPECT_EQ("10x20xi64", fir::getTypeAsString(arrTy, *kindMap));
+}