[flang] Add getTypeDescriptorBindingTableName function

[clementval]

Summary

Type descriptor and its binding table are defined as fir.global in FIR.
Their names are derived from the derived-type name. This patch adds a new
function getTypeDescriptorBindingTableName in the NameUniquer and
refactor the GetTypeDescriptorName function to reuse the same code.
This will be used in the fir.dispatch code generation.

[clementval]

clang-format

[PeteSteinfeld]

Aside from a couple of nits, all builds and tests correctly and looks good.

flang/include/flang/Optimizer/Support/InternalNames.h

148

Should read "Given a" rather than "Given an".

149

Should read "is not a valid".

[clementval]

Fix typos

[jeanPerier]

Nothing to add to Pete's comment.

flang/include/flang/Optimizer/Support/InternalNames.h

 //===-- Optimizer/Support/InternalNames.h -----------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_SUPPORT_INTERNALNAMES_H
 #define FORTRAN_OPTIMIZER_SUPPORT_INTERNALNAMES_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 
+static constexpr llvm::StringRef typeDescriptorSeparator = ".dt.";
+static constexpr llvm::StringRef bindingTableSeparator = ".v.";
+
 namespace fir {
 
 /// Internal name mangling of identifiers
 ///
 /// In order to generate symbolically referencable artifacts in a ModuleOp,
 /// it is required that those symbols be uniqued.  This is a simple interface
 /// for converting Fortran symbols into unique names.
 ///
struct NameUniquer {
   static bool belongsToModule(llvm::StringRef uniquedName,
                               llvm::StringRef moduleName);
 
   /// Given a mangled derived type name, get the name of the related derived
   /// type descriptor object. Returns an empty string if \p mangledTypeName is
   /// not a valid mangled derived type name.
   static std::string getTypeDescriptorName(llvm::StringRef mangledTypeName);
 
+  /// Given a mangled derived type name, get the name of the related binding
+  /// table object. Returns an empty string if \p mangledTypeName is not a valid
+  /// mangled derived type name.
+  static std::string
+  getTypeDescriptorBindingTableName(llvm::StringRef mangledTypeName);
+
 private:
   static std::string intAsString(std::int64_t i);
   static std::string doKind(std::int64_t kind);
   static std::string doKinds(llvm::ArrayRef<std::int64_t> kinds);
   static std::string toLower(llvm::StringRef name);
 
   NameUniquer() = delete;
   NameUniquer(const NameUniquer &) = delete;
   NameUniquer(NameUniquer &&) = delete;
   NameUniquer &operator=(const NameUniquer &) = delete;
 };
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_SUPPORT_INTERNALNAMES_H

flang/lib/Optimizer/Support/InternalNames.cpp

mangleTypeDescriptorKinds(llvm::ArrayRef<std::int64_t> kinds) {
   if (kinds.empty())
     return "";
   std::string result;
   for (std::int64_t kind : kinds)
     result += "." + std::to_string(kind);
   return result;
 }
 
-std::string
-fir::NameUniquer::getTypeDescriptorName(llvm::StringRef mangledTypeName) {
-  auto result = deconstruct(mangledTypeName);
-  if (result.first != NameKind::DERIVED_TYPE)
+static std::string getDerivedTypeObjectName(llvm::StringRef mangledTypeName,
+                                            const llvm::StringRef separator) {
+  auto result = fir::NameUniquer::deconstruct(mangledTypeName);
+  if (result.first != fir::NameUniquer::NameKind::DERIVED_TYPE)
     return "";
-  std::string varName = ".dt." + result.second.name +
+  std::string varName = separator.str() + result.second.name +
                         mangleTypeDescriptorKinds(result.second.kinds);
   llvm::SmallVector<llvm::StringRef> modules;
   for (const std::string &mod : result.second.modules)
     modules.push_back(mod);
   llvm::Optional<llvm::StringRef> host;
   if (result.second.host)
     host = *result.second.host;
-  return doVariable(modules, host, varName);
+  return fir::NameUniquer::doVariable(modules, host, varName);
+}
+
+std::string
+fir::NameUniquer::getTypeDescriptorName(llvm::StringRef mangledTypeName) {
+  return getDerivedTypeObjectName(mangledTypeName, typeDescriptorSeparator);
+}
+
+std::string fir::NameUniquer::getTypeDescriptorBindingTableName(
+    llvm::StringRef mangledTypeName) {
+  return getDerivedTypeObjectName(mangledTypeName, bindingTableSeparator);
 }

flang/unittests/Optimizer/InternalNamesTest.cpp

TEST(InternalNamesTest, isExternalFacingUniquedName) {
   result = NameUniquer::deconstruct("_QPfoo");
   ASSERT_TRUE(NameUniquer::isExternalFacingUniquedName(result));
   result = NameUniquer::deconstruct("_QPbar");
   ASSERT_TRUE(NameUniquer::isExternalFacingUniquedName(result));
   result = NameUniquer::deconstruct("_QBa");
   ASSERT_TRUE(NameUniquer::isExternalFacingUniquedName(result));
 }
 
+TEST(InternalNamesTest, getTypeDescriptorName) {
+  std::string derivedTypeName = "_QMdispatch1Tp1";
+  std::string expectedBindingTableName = "_QMdispatch1E.dt.p1";
+  ASSERT_EQ(expectedBindingTableName,
+      fir::NameUniquer::getTypeDescriptorName(derivedTypeName));
+  ASSERT_EQ("", fir::NameUniquer::getTypeDescriptorName("_QMdispatch1Pp1"));
+}
+
+TEST(InternalNamesTest, getTypeDescriptorBindingTableName) {
+  std::string derivedTypeName = "_QMdispatch1Tp1";
+  std::string expectedBindingTableName = "_QMdispatch1E.v.p1";
+  ASSERT_EQ(expectedBindingTableName,
+      fir::NameUniquer::getTypeDescriptorBindingTableName(derivedTypeName));
+  ASSERT_EQ("",
+      fir::NameUniquer::getTypeDescriptorBindingTableName("_QMdispatch1Pp1"));
+}
+
 // main() from gtest_main