Use lazy approach to define inherited declare mappers.

Author: TIFitis

flang/include/flang/Lower/OpenMP.h

@@ -97,12 +97,11 @@ bool markOpenMPDeferredDeclareTargetFunctions(
     AbstractConverter &);
 void genOpenMPRequires(mlir::Operation *, const Fortran::semantics::Symbol *);
 
-// Materialize omp.declare_mapper ops for mapper declarations found in
-// imported modules. If \p scope is null, materialize for the whole
-// semantics global scope; otherwise, operate recursively starting at \p scope.
-void materializeOpenMPDeclareMappers(
+// Materialize an omp.declare_mapper op for the given mapper symbol by
+// re-lowering its saved declaration from semantics.
+void materializeOpenMPDeclareMapperForSymbol(
     Fortran::lower::AbstractConverter &, Fortran::semantics::SemanticsContext &,
-    const Fortran::semantics::Scope *scope = nullptr);
+    const Fortran::semantics::Symbol &);
 
 } // namespace lower
 } // namespace Fortran

flang/lib/Lower/Bridge.cpp

@@ -447,13 +447,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
       }
     });
 
-    // Ensure imported OpenMP declare mappers are materialized at module
-    // scope before lowering any constructs that may reference them.
-    createBuilderOutsideOfFuncOpAndDo([&]() {
-      Fortran::lower::materializeOpenMPDeclareMappers(
-          *this, bridge.getSemanticsContext());
-    });
-
     // Create definitions of intrinsic module constants.
     createBuilderOutsideOfFuncOpAndDo(
         [&]() { createIntrinsicModuleDefinitions(pft); });

flang/lib/Lower/OpenMP/ClauseProcessor.cpp

@@ -15,6 +15,7 @@
 
 #include "flang/Lower/ConvertExprToHLFIR.h"
 #include "flang/Lower/OpenMP/Clauses.h"
+#include "flang/Lower/OpenMP.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Support/ReductionProcessor.h"
 #include "flang/Parser/tools.h"
@@ -1255,6 +1256,11 @@ void ClauseProcessor::processMapObjects(
     const omp::Object &object = objects.front();
     if (mapperIdNameRef == "default")
       getDefaultMapperID(object, mapperIdName);
+    // On-demand materialize named or default mappers if missing.
+    if (!converter.getModuleOp().lookupSymbol(mapperIdName))
+      if (auto *sym = converter.getCurrentScope().FindSymbol(mapperIdName))
+        Fortran::lower::materializeOpenMPDeclareMapperForSymbol(
+            converter, semaCtx, sym->GetUltimate());
     assert(converter.getModuleOp().lookupSymbol(mapperIdName) &&
            "mapper not found");
     mapperId =
@@ -1295,6 +1301,12 @@ void ClauseProcessor::processMapObjects(
     if (mapperIdNameRef == "__implicit_mapper") {
       std::string mapperIdName;
       getDefaultMapperID(object, mapperIdName);
+      // On-demand materialize default mappers if missing.
+      if (!mapperIdName.empty() &&
+          !converter.getModuleOp().lookupSymbol(mapperIdName))
+        if (auto *sym = converter.getCurrentScope().FindSymbol(mapperIdName))
+          Fortran::lower::materializeOpenMPDeclareMapperForSymbol(
+              converter, semaCtx, sym->GetUltimate());
       mapperId = converter.getModuleOp().lookupSymbol(mapperIdName)
                      ? mlir::FlatSymbolRefAttr::get(&converter.getMLIRContext(),
                                                     mapperIdName)
@@ -1410,6 +1422,10 @@ bool ClauseProcessor::processMap(
         const semantics::Symbol &ultimate = mapperSym->GetUltimate();
         mapperIdName = converter.mangleName(mapperIdName, ultimate.owner());
       }
+      // On-demand materialize if missing.
+      if (!converter.getModuleOp().lookupSymbol(mapperIdName))
+        Fortran::lower::materializeOpenMPDeclareMapperForSymbol(
+            converter, semaCtx, *mapperSym);
     }
 
     processMapObjects(stmtCtx, clauseLocation,

flang/lib/Lower/OpenMP/OpenMP.cpp

@@ -3605,6 +3605,22 @@ static void genOpenMPDeclareMapperImpl(
   mlir::omp::DeclareMapperInfoOp::create(firOpBuilder, loc, clauseOps.mapVars);
 }
 
+// Materialize omp.declare_mapper for a specific mapper symbol by lowering the
+// saved declaration from semantics.
+void Fortran::lower::materializeOpenMPDeclareMapperForSymbol(
+    Fortran::lower::AbstractConverter &converter,
+    semantics::SemanticsContext &semaCtx, const semantics::Symbol &sym) {
+  const semantics::Symbol &ultimate = sym.GetUltimate();
+  if (auto *md = ultimate.detailsIf<semantics::MapperDetails>()) {
+    for (const auto *decl : md->GetDeclList()) {
+      if (const auto *mapperDecl =
+              std::get_if<parser::OpenMPDeclareMapperConstruct>(&decl->u)) {
+        genOpenMPDeclareMapperImpl(converter, semaCtx, *mapperDecl, &ultimate);
+      }
+    }
+  }
+}
+
 static void genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
                    semantics::SemanticsContext &semaCtx,
                    lower::pft::Evaluation &eval,
@@ -4255,36 +4271,3 @@ void Fortran::lower::genOpenMPRequires(mlir::Operation *mod,
     offloadMod.setRequires(mlirFlags);
   }
 }
-
-// Walk scopes and materialize omp.declare_mapper ops for mapper declarations
-// found in imported modules. If \p scope is null, start from the global scope.
-void Fortran::lower::materializeOpenMPDeclareMappers(
-    Fortran::lower::AbstractConverter &converter,
-    semantics::SemanticsContext &semaCtx, const semantics::Scope *scope) {
-  const semantics::Scope &root = scope ? *scope : semaCtx.globalScope();
-
-  // Recurse into child scopes first (modules, submodules, etc.).
-  for (const semantics::Scope &child : root.children())
-    materializeOpenMPDeclareMappers(converter, semaCtx, &child);
-
-  // Only consider module scopes to avoid duplicating local constructs.
-  if (!root.IsModule())
-    return;
-
-  // Only materialize for modules coming from mod files to avoid duplicates.
-  if (!root.symbol() || !root.symbol()->test(semantics::Symbol::Flag::ModFile))
-    return;
-
-  // Scan symbols in this module scope for MapperDetails.
-  for (auto &it : root) {
-    const semantics::Symbol &sym = *it.second;
-    if (auto *md = sym.detailsIf<semantics::MapperDetails>()) {
-      for (const auto *decl : md->GetDeclList()) {
-        if (const auto *mapperDecl =
-                std::get_if<parser::OpenMPDeclareMapperConstruct>(&decl->u)) {
-          genOpenMPDeclareMapperImpl(converter, semaCtx, *mapperDecl, &sym);
-        }
-      }
-    }
-  }
-}