[flang][fir] Updates to internal name uniquer.

[schweitz]

Summary

https://github.com/flang-compiler/f18-llvm-project/pull/474

[kiranchandramohan]

LGTM. Please address the clang-format comment before submission.

[schweitz]

run clang-format on file

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

 /// uniqued name, we can return the symbol parse name, type of the symbol, and
 /// any scope-like information for that symbol.
 struct NameUniquer {
   enum class IntrinsicType { CHARACTER, COMPLEX, INTEGER, LOGICAL, REAL };
 
   /// The sort of the unique name
   enum class NameKind {
     NOT_UNIQUED,
+    BLOCK_DATA_NAME,
     COMMON,
     CONSTANT,
     DERIVED_TYPE,
     DISPATCH_TABLE,
     GENERATED,
     INTRINSIC_TYPE_DESC,
     PROCEDURE,
     TYPE_DESC,
struct DeconstructedName {
     llvm::SmallVector<std::int64_t, 4> kinds;
   };
 
   NameUniquer() = default;
 
   /// Unique a common block name
   std::string doCommonBlock(llvm::StringRef name);
 
+  /// Unique a block data unit name
+  std::string doBlockData(llvm::StringRef name);
+
   /// Unique a (global) constant name
   std::string doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                          llvm::Optional<llvm::StringRef> host,
                          llvm::StringRef name);
 
   /// Unique a dispatch table name
   std::string doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
                               llvm::Optional<llvm::StringRef> host,

flang/lib/Optimizer/Support/InternalNames.cpp

 //===-- InternalNames.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 "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/BuiltinTypes.h"
 #include "llvm/Support/CommandLine.h"
 
 static llvm::cl::opt<std::string> mainEntryName(
     "main-entry-name",
     llvm::cl::desc("override the name of the default PROGRAM entry (may be "
                    "helpful for using other runtimes)"));
 
 constexpr std::int64_t BAD_VALUE = -1;
std::string fir::NameUniquer::doKinds(llvm::ArrayRef<std::int64_t> kinds) {
   return result;
 }
 
 std::string fir::NameUniquer::doCommonBlock(llvm::StringRef name) {
   std::string result = prefix();
   return result.append("B").append(toLower(name));
 }
 
+std::string fir::NameUniquer::doBlockData(llvm::StringRef name) {
+  std::string result = prefix();
+  return result.append("L").append(toLower(name));
+}
+
 std::string
 fir::NameUniquer::doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                              llvm::Optional<llvm::StringRef> host,
                              llvm::StringRef name) {
   std::string result = prefix();
   result.append(doModulesHost(modules, host)).append("EC");
   return result.append(toLower(name));
 }
for (std::size_t i = 2, end{uniq.size()}; i != end;) {
         if (uniq[i + 1] == 'C') {
           nk = NameKind::CONSTANT;
           name = readName(uniq, i, i + 2, end);
         } else {
           nk = NameKind::VARIABLE;
           name = readName(uniq, i, i + 1, end);
         }
         break;
+      case 'L':
+        nk = NameKind::BLOCK_DATA_NAME;
+        name = readName(uniq, i, i + 1, end);
+        break;
       case 'P':
         nk = NameKind::PROCEDURE;
         name = readName(uniq, i, i + 1, end);
         break;
       case 'Q':
         nk = NameKind::GENERATED;
         name = uniq;
         i = end;

flang/unittests/Optimizer/InternalNamesTest.cpp

void validateDeconstructedName(
     NameUniquer::NameKind &expectedNameKind,
     struct DeconstructedName &components) {
   EXPECT_EQ(actual.first, expectedNameKind)
       << "Possible error: NameKind mismatch";
   ASSERT_TRUE(components.isObjEqual(actual.second))
       << "Possible error: DeconstructedName mismatch";
 }
 
+TEST(InternalNamesTest, doBlockDataTest) {
+  NameUniquer obj;
+  std::string actual = obj.doBlockData("blockdatatest");
+  std::string actualBlank = obj.doBlockData("");
+  std::string expectedMangledName = "_QLblockdatatest";
+  std::string expectedMangledNameBlank = "_QL";
+  ASSERT_EQ(actual, expectedMangledName);
+  ASSERT_EQ(actualBlank, expectedMangledNameBlank);
+}
+
 TEST(InternalNamesTest, doCommonBlockTest) {
   NameUniquer obj;
   std::string actual = obj.doCommonBlock("hello");
   std::string actualBlank = obj.doCommonBlock("");
   std::string expectedMangledName = "_QBhello";
   std::string expectedMangledNameBlank = "_QB";
   ASSERT_EQ(actual, expectedMangledName);
   ASSERT_EQ(actualBlank, expectedMangledNameBlank);