[flang][fir] Add support to mangle/deconstruct namelist group name

[clementval]

Summary

Add support to create unique name for namelist group and be able to
deconstruct them.

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: jeanPerier
Co-authored-by: schweitz

[jeanPerier]

It looks like the test is failing with the windows build bot:

C:\ws\w4\llvm-project\premerge-checks\flang\unittests\Optimizer\InternalNamesTest.cpp(168): error: Expected equality of these values:
  actual.str()
    Which is: "\0QMmod1Gnlg"
  expectedMangledName
    Which is: "_QMmod1Gnlg"

[clementval]

In D110331#3018202, @jeanPerier wrote:

It looks like the test is failing with the windows build bot:

C:\ws\w4\llvm-project\premerge-checks\flang\unittests\Optimizer\InternalNamesTest.cpp(168): error: Expected equality of these values:
  actual.str()
    Which is: "\0QMmod1Gnlg"
  expectedMangledName
    Which is: "_QMmod1Gnlg"

Right ... I'll have a look at that.

[clementval]

Fix windows tests

[awarzynski]

Hi @clementval ,

Great to see that the upstreaming effort has been restarted, thanks for working on this!

Could you check https://lab.llvm.org/buildbot/#/builders/175/builds/3402? Looks related. The blame list is clearly incorrect there.

[DavidSpickett]

Could you check https://lab.llvm.org/buildbot/#/builders/175/builds/3402? Looks related. The blame list is clearly incorrect there.

Yeah I expected the other flang bots to fail too but didn't for some reason but it's the right file. Not sure why it never showed up in the changelist.

Edit: now it's showing up elsewhere https://lab.llvm.org/buildbot/#/builders/180/builds/1263 so at least you know it's not due to an "out of tree"quirk.

[clementval]

In D110331#3020924, @awarzynski wrote:

Hi @clementval ,

Great to see that the upstreaming effort has been restarted, thanks for working on this!

Could you check https://lab.llvm.org/buildbot/#/builders/175/builds/3402? Looks related. The blame list is clearly incorrect there.

Revert until I can fix the issue

[clementval]

Remove clang waring

[awarzynski]

Thanks for the quick fix!

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

enum class NameKind {
     COMMON,
     CONSTANT,
     DERIVED_TYPE,
     DISPATCH_TABLE,
     GENERATED,
     INTRINSIC_TYPE_DESC,
     PROCEDURE,
     TYPE_DESC,
-    VARIABLE
+    VARIABLE,
+    NAMELIST_GROUP
   };
 
   /// Components of an unparsed unique name
   struct DeconstructedName {
     DeconstructedName(llvm::StringRef name) : name{name} {}
     DeconstructedName(llvm::ArrayRef<std::string> modules,
                       llvm::Optional<std::string> host, llvm::StringRef name,
                       llvm::ArrayRef<std::int64_t> kinds)
static std::string doTypeDescriptor(llvm::ArrayRef<std::string> modules,
                                       llvm::ArrayRef<std::int64_t> kinds);
 
   /// Unique a (global) variable name. A variable with save attribute
   /// defined inside a subprogram also needs to be handled here
   static std::string doVariable(llvm::ArrayRef<llvm::StringRef> modules,
                                 llvm::Optional<llvm::StringRef> host,
                                 llvm::StringRef name);
 
+  /// Unique a namelist group name
+  static std::string doNamelistGroup(llvm::ArrayRef<llvm::StringRef> modules,
+                                     llvm::Optional<llvm::StringRef> host,
+                                     llvm::StringRef name);
+
   /// Entry point for the PROGRAM (called by the runtime)
   /// Can be overridden with the `--main-entry-name=<name>` option.
   static llvm::StringRef doProgramEntry();
 
   /// Decompose `uniquedName` into the parse name, symbol type, and scope info
   static std::pair<NameKind, DeconstructedName>
   deconstruct(llvm::StringRef uniquedName);
 

flang/lib/Lower/Mangler.cpp

return std::visit(
           [&](const Fortran::semantics::ObjectEntityDetails &) {
             auto modNames = moduleNames(ultimateSymbol);
             auto optHost = hostName(ultimateSymbol);
             if (Fortran::semantics::IsNamedConstant(ultimateSymbol))
               return fir::NameUniquer::doConstant(modNames, optHost,
                                                   symbolName);
             return fir::NameUniquer::doVariable(modNames, optHost, symbolName);
           },
+          [&](const Fortran::semantics::NamelistDetails &) {
+            auto modNames = moduleNames(ultimateSymbol);
+            auto optHost = hostName(ultimateSymbol);
+            return fir::NameUniquer::doNamelistGroup(modNames, optHost,
+                                                     symbolName);
+          },
           [&](const Fortran::semantics::CommonBlockDetails &) {
             return fir::NameUniquer::doCommonBlock(symbolName);
           },
           [&](const Fortran::semantics::DerivedTypeDetails &) -> std::string {
             // Derived type mangling must used mangleName(DerivedTypeSpec&) so
             // that kind type parameter values can be mangled.
             llvm::report_fatal_error(
                 "only derived type instances can be mangled");

flang/lib/Optimizer/Support/InternalNames.cpp

 fir::NameUniquer::doVariable(llvm::ArrayRef<llvm::StringRef> modules,
                              llvm::Optional<llvm::StringRef> host,
                              llvm::StringRef name) {
   std::string result = prefix();
   result.append(doModulesHost(modules, host)).append("E");
   return result.append(toLower(name));
 }
 
+std::string
+fir::NameUniquer::doNamelistGroup(llvm::ArrayRef<llvm::StringRef> modules,
+                                  llvm::Optional<llvm::StringRef> host,
+                                  llvm::StringRef name) {
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("G");
+  return result.append(toLower(name));
+}
+
 llvm::StringRef fir::NameUniquer::doProgramEntry() {
   if (mainEntryName.size())
     return mainEntryName;
   return "_QQmain";
 }
 
 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
 fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
for (std::size_t i = 2, end{uniq.size()}; i != end;) {
         host = readName(uniq, i, i + 1, end);
         break;
       case 'K':
         if (uniq[i + 1] == 'N')
           kinds.push_back(-readInt(uniq, i, i + 2, end));
         else
           kinds.push_back(readInt(uniq, i, i + 1, end));
         break;
+      case 'G':
+        nk = NameKind::NAMELIST_GROUP;
+        name = readName(uniq, i, i + 1, end);
+        break;
 
       default:
         assert(false && "unknown uniquing code");
         break;
       }
     }
     return {nk, DeconstructedName(modules, host, name, kinds)};
   }
   return {NameKind::NOT_UNIQUED, DeconstructedName(uniq)};
 }

flang/unittests/Optimizer/InternalNamesTest.cpp

 }
 
 TEST(InternalNamesTest, doProgramEntry) {
   llvm::StringRef actual = NameUniquer::doProgramEntry();
   std::string expectedMangledName = "_QQmain";
   ASSERT_EQ(actual.str(), expectedMangledName);
 }
 
+TEST(InternalNamesTest, doNamelistGroup) {
+  std::string actual = NameUniquer::doNamelistGroup({"mod1"}, {}, "nlg");
+  std::string expectedMangledName = "_QMmod1Gnlg";
+  ASSERT_EQ(actual, expectedMangledName);
+}
+
 TEST(InternalNamesTest, deconstructTest) {
   std::pair actual = NameUniquer::deconstruct("_QBhello");
   auto expectedNameKind = NameUniquer::NameKind::COMMON;
   struct DeconstructedName expectedComponents {
     {}, {}, "hello", {}
   };
   validateDeconstructedName(actual, expectedNameKind, expectedComponents);
 }
TEST(InternalNamesTest, complexdeconstructTest) {
   expectedNameKind = NameKind::DERIVED_TYPE;
   expectedComponents = {{}, {}, "yourtype", {4, -6}};
   validateDeconstructedName(actual, expectedNameKind, expectedComponents);
 
   actual = NameUniquer::deconstruct("_QDTt");
   expectedNameKind = NameKind::DISPATCH_TABLE;
   expectedComponents = {{}, {}, "t", {}};
   validateDeconstructedName(actual, expectedNameKind, expectedComponents);
+
+  actual = NameUniquer::deconstruct("_QFmstartGmpitop");
+  expectedNameKind = NameKind::NAMELIST_GROUP;
+  expectedComponents = {{}, {"mstart"}, "mpitop", {}};
+  validateDeconstructedName(actual, expectedNameKind, expectedComponents);
 }
 
 // main() from gtest_main