[clang] 407178b - [Flang][OpenMP] Flag for switching off implicit allocatable member mapping via default declare mapper (#228748)
via cfe-commits
cfe-commits at lists.llvm.org
Thu Nov 5 17:52:12 PST 2026
Author: agozillon
Date: 2026-11-06T02:52:05+01:00
New Revision: 407178b8e5e6f55e5f5b3f42b6a2c803b934d2c0
URL: https://github.com/llvm/llvm-project/commit/407178b8e5e6f55e5f5b3f42b6a2c803b934d2c0
DIFF: https://github.com/llvm/llvm-project/commit/407178b8e5e6f55e5f5b3f42b6a2c803b934d2c0.diff
LOG: [Flang][OpenMP] Flag for switching off implicit allocatable member mapping via default declare mapper (#228748)
Part of the OpenMP specification requires implicitly mappiing
allocatable members in derived types. However, it is quite an expensive
overhead to perform implicit allocatable member mapping as it requires a
mapper to do so due to the nature of possibly nested allocatable derived
types etc. Alongside a fairly comprehensive map of the record, this in
particular comes at a fairly substantial cost for arrays of derived
types that trigger this behaviour. Some of this may or may not be
mitigatable over time.
But for the moment this PR seeks to follow the example of other Fortran
OpenMP compilers (Cray in particular I think) and utilise a flag that
can switch this behaviour on and off, so that applications not depending
on the crutch of this implicit mapping can deactivte it and not pay the
overhead, and those that like the compiler to do this for them can
continue to do so.
Added:
flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-explicit-map.f90
flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-implicit-capture.f90
flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-nested-user-mapper.f90
flang/test/Lower/OpenMP/implicit-default-mapper-multiple-nested-default-mappers.f90
flang/test/Lower/OpenMP/implicit-default-mapper-nested-default-mapper-carrier.f90
Modified:
clang/include/clang/Options/FlangOptions.td
clang/lib/Driver/ToolChains/Flang.cpp
flang/include/flang/Frontend/CodeGenOptions.def
flang/include/flang/Support/Flags.h
flang/include/flang/Utils/OpenMP.h
flang/lib/Frontend/CompilerInvocation.cpp
flang/lib/Frontend/FrontendActions.cpp
flang/lib/Lower/OpenMP/OpenMP.cpp
flang/lib/Lower/OpenMP/Utils.cpp
flang/lib/Lower/OpenMP/Utils.h
flang/lib/Support/Flags.cpp
flang/lib/Utils/OpenMP.cpp
flang/test/Driver/omp-driver-offload.f90
Removed:
################################################################################
diff --git a/clang/include/clang/Options/FlangOptions.td b/clang/include/clang/Options/FlangOptions.td
index b07a6bdd1e606a..ad39d052bee6af 100644
--- a/clang/include/clang/Options/FlangOptions.td
+++ b/clang/include/clang/Options/FlangOptions.td
@@ -317,6 +317,12 @@ def fdo_concurrent_to_openmp_EQ : Joined<["-"], "fdo-concurrent-to-openmp=">,
HelpText<"Try to map `do concurrent` loops to OpenMP [none|host|device]">,
Values<"none, host, device">;
+def fimplicit_default_mapper_allocatable_members : Flag<["-"], "fimplicit-default-mapper-allocatable-members">,
+ Group<f_Group>, HelpText<"Enable implicit allocatable member maps in compiler-generated OpenMP default mappers">;
+def fno_implicit_default_mapper_allocatable_members : Flag<["-"], "fno-implicit-default-mapper-allocatable-members">,
+ Group<f_Group>, HelpText<"Disable implicit allocatable member maps in compiler-generated OpenMP default mappers">;
+
+
def J : JoinedOrSeparate<["-"], "J">,
Flags<[RenderJoined]>, Group<gfortran_Group>, Alias<module_dir>;
diff --git a/clang/lib/Driver/ToolChains/Flang.cpp b/clang/lib/Driver/ToolChains/Flang.cpp
index 88c3e7c020e45d..522907b58022fb 100644
--- a/clang/lib/Driver/ToolChains/Flang.cpp
+++ b/clang/lib/Driver/ToolChains/Flang.cpp
@@ -915,6 +915,16 @@ void Flang::addOffloadOptions(Compilation &C, const InputInfoList &Inputs,
/*Default=*/false))
CmdArgs.push_back("-fopenmp-assume-threads-oversubscription");
+ // This forwards the option to switch off/on mapper generation for scenarios
+ // where the compiler considers it neccessary to generate a mapper to cover
+ // implicit allocatable member mapping inside of derived types to adhere to
+ // specification compliance.
+ if (!Args.hasFlag(
+ options::OPT_fimplicit_default_mapper_allocatable_members,
+ options::OPT_fno_implicit_default_mapper_allocatable_members,
+ /*Default=*/true))
+ CmdArgs.push_back("-fno-implicit-default-mapper-allocatable-members");
+
if (IsOpenMPDevice) {
// -fopenmp-is-target-device is passed along to tell the frontend that it is
// generating code for a device, so that only the relevant code is emitted.
diff --git a/flang/include/flang/Frontend/CodeGenOptions.def b/flang/include/flang/Frontend/CodeGenOptions.def
index 4dde7077ad49a9..5043003feec1df 100644
--- a/flang/include/flang/Frontend/CodeGenOptions.def
+++ b/flang/include/flang/Frontend/CodeGenOptions.def
@@ -64,6 +64,7 @@ CODEGENOPT(DwarfVersion, 3, 0) ///< Dwarf version
CODEGENOPT(DebugInfoForProfiling, 1, 0) ///< Emit extra debug info to make sample profile more accurate.
CODEGENOPT(PseudoProbeForProfiling, 1, 0) ///< Emit pseudo probes for sample profiling.
CODEGENOPT(UniqueInternalLinkageNames, 1, 0) ///< Append MD5 hash to internal linkage symbols.
+CODEGENOPT(ImplicitDefaultMapperAllocatableMembers, 1, 1) ///< Map allocatable members in generated OpenMP default mappers.
CODEGENOPT(Underscoring, 1, 1)
ENUM_CODEGENOPT(FPMaxminBehavior, Fortran::common::FPMaxminBehavior, 2, Fortran::common::FPMaxminBehavior::Legacy)
diff --git a/flang/include/flang/Support/Flags.h b/flang/include/flang/Support/Flags.h
index bcbb72f8e50d05..1dbfa249b87bd0 100644
--- a/flang/include/flang/Support/Flags.h
+++ b/flang/include/flang/Support/Flags.h
@@ -13,5 +13,6 @@
extern llvm::cl::opt<bool> enableDelayedPrivatization;
extern llvm::cl::opt<bool> enableDelayedPrivatizationStaging;
+extern llvm::cl::opt<bool> enableImplicitDefaultMapperAllocatableMembers;
#endif // FORTRAN_SUPPORT_FLAGS_H_
diff --git a/flang/include/flang/Utils/OpenMP.h b/flang/include/flang/Utils/OpenMP.h
index 0cb77e25af9475..ee2ec231128af3 100644
--- a/flang/include/flang/Utils/OpenMP.h
+++ b/flang/include/flang/Utils/OpenMP.h
@@ -72,7 +72,8 @@ std::string getCanonicalDefaultDeclareMapperName(fir::RecordType recordType);
mlir::FlatSymbolRefAttr getOrGenImplicitDefaultDeclareMapper(
fir::FirOpBuilder &firOpBuilder, mlir::Location loc,
fir::RecordType recordType, llvm::StringRef mapperNameStr,
- RecordMemberMapperMangler mangler = {});
+ RecordMemberMapperMangler mangler = {},
+ bool emitAllocatableMemberMaps = true);
} // namespace Fortran::utils::openmp
#endif // FORTRAN_UTILS_OPENMP_H_
diff --git a/flang/lib/Frontend/CompilerInvocation.cpp b/flang/lib/Frontend/CompilerInvocation.cpp
index 64ef085761e3fb..efbb938f6b5975 100644
--- a/flang/lib/Frontend/CompilerInvocation.cpp
+++ b/flang/lib/Frontend/CompilerInvocation.cpp
@@ -586,6 +586,11 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
opts.Underscoring = 0;
}
+ opts.ImplicitDefaultMapperAllocatableMembers = args.hasFlag(
+ clang::options::OPT_fimplicit_default_mapper_allocatable_members,
+ clang::options::OPT_fno_implicit_default_mapper_allocatable_members,
+ /*Default=*/true);
+
if (const llvm::opt::Arg *arg =
args.getLastArg(clang::options::OPT_complex_range_EQ)) {
llvm::StringRef argValue = llvm::StringRef(arg->getValue());
diff --git a/flang/lib/Frontend/FrontendActions.cpp b/flang/lib/Frontend/FrontendActions.cpp
index 76c274cacb29b4..d7f6658668a40c 100644
--- a/flang/lib/Frontend/FrontendActions.cpp
+++ b/flang/lib/Frontend/FrontendActions.cpp
@@ -27,6 +27,7 @@
#include "flang/Optimizer/Transforms/Passes.h"
#include "flang/Semantics/runtime-type-info.h"
#include "flang/Semantics/unparse-with-symbols.h"
+#include "flang/Support/Flags.h"
#include "flang/Support/default-kinds.h"
#include "flang/Tools/CrossToolHelpers.h"
@@ -255,6 +256,11 @@ bool CodeGenAction::beginSourceFileAction() {
if (!res)
return res;
+ enableImplicitDefaultMapperAllocatableMembers.setValue(
+ ci.getInvocation()
+ .getCodeGenOpts()
+ .ImplicitDefaultMapperAllocatableMembers);
+
timingScopeParse.stop();
mlir::TimingScope timingScopeMLIRGen = timingScopeRoot.nest(
mlir::TimingIdentifier::get(timingIdMLIRGen, timingMgr));
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index acb05c4a3ac468..3d333e52625b56 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -4362,7 +4362,9 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
// where the record type contains an allocatable.
if (!isPointer &&
(hasDefaultMapper ||
- (requiresImplicitDefaultDeclareMapper(*typeSpec)))) {
+ (requiresImplicitDefaultDeclareMapper(
+ converter, firOpBuilder, *typeSpec,
+ enableImplicitDefaultMapperAllocatableMembers)))) {
if (!hasDefaultMapper) {
if (auto recordType = mlir::dyn_cast_or_null<fir::RecordType>(
converter.genType(*typeSpec)))
@@ -4372,7 +4374,8 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
[&](std::string &mapperIdName,
llvm::StringRef memberName) {
defaultMangler(converter, mapperIdName, memberName);
- });
+ },
+ enableImplicitDefaultMapperAllocatableMembers);
} else {
mapperId = mlir::FlatSymbolRefAttr::get(
&converter.getMLIRContext(), mapperIdName);
diff --git a/flang/lib/Lower/OpenMP/Utils.cpp b/flang/lib/Lower/OpenMP/Utils.cpp
index 0df038b4c34e88..48e352b644b545 100644
--- a/flang/lib/Lower/OpenMP/Utils.cpp
+++ b/flang/lib/Lower/OpenMP/Utils.cpp
@@ -37,6 +37,7 @@
#include <flang/Semantics/symbol.h>
#include <flang/Semantics/tools.h>
#include <flang/Semantics/type.h>
+#include <flang/Support/Flags.h>
#include <flang/Utils/OpenMP.h>
#include <llvm/ADT/STLExtras.h>
#include <llvm/ADT/SmallPtrSet.h>
@@ -75,8 +76,22 @@ llvm::cl::opt<bool> treatIndexAsSection(
namespace Fortran {
namespace lower {
namespace omp {
+
+static bool
+hasUserDefinedDefaultMapper(Fortran::lower::AbstractConverter &converter,
+ const semantics::DerivedTypeSpec &typeSpec) {
+ std::string mapperName =
+ typeSpec.name().ToString() + llvm::omp::OmpDefaultMapperName;
+ if (auto *sym = converter.getCurrentScope().FindSymbol(mapperName))
+ return sym->GetUltimate().detailsIf<semantics::MapperDetails>();
+
+ return false;
+}
+
bool requiresImplicitDefaultDeclareMapper(
- const semantics::DerivedTypeSpec &typeSpec) {
+ lower::AbstractConverter &converter, fir::FirOpBuilder &firOpBuilder,
+ const semantics::DerivedTypeSpec &typeSpec,
+ bool enableImplicitDefaultMapperAllocatableMembers) {
llvm::SmallPtrSet<const semantics::DerivedTypeSpec *, 8> visited;
std::function<bool(const semantics::DerivedTypeSpec &)> requiresMapper =
@@ -86,13 +101,21 @@ bool requiresImplicitDefaultDeclareMapper(
semantics::DirectComponentIterator directComponents{spec};
for (const semantics::Symbol &component : directComponents) {
- if (component.attrs().test(semantics::Attr::ALLOCATABLE))
+ if (enableImplicitDefaultMapperAllocatableMembers &&
+ component.attrs().test(semantics::Attr::ALLOCATABLE))
return true;
- if (const semantics::DeclTypeSpec *declType = component.GetType())
- if (const auto *nested = declType->AsDerived())
- if (requiresMapper(*nested))
- return true;
+ if (const semantics::DeclTypeSpec *declType = component.GetType()) {
+ const auto *nested = declType->AsDerived();
+ if (!nested)
+ continue;
+
+ if (hasUserDefinedDefaultMapper(converter, *nested))
+ return true;
+
+ if (requiresMapper(*nested))
+ return true;
+ }
}
return false;
};
@@ -1211,7 +1234,8 @@ findMapperIfTypeMatch(Fortran::lower::AbstractConverter &converter,
static mlir::FlatSymbolRefAttr
addImplicitMapper(Fortran::lower::AbstractConverter &converter,
mlir::Location loc, const omp::Object &object,
- std::string &mapperIdName, bool allowGenerate) {
+ std::string &mapperIdName, bool allowGenerate,
+ bool emitAllocatableMemberMaps) {
if (!allowGenerate || mapperIdName.empty())
return mlir::FlatSymbolRefAttr();
@@ -1232,7 +1256,8 @@ addImplicitMapper(Fortran::lower::AbstractConverter &converter,
converter.getFirOpBuilder(), loc, recordType, mapperIdName,
[&](std::string &mapperIdName, llvm::StringRef memberName) {
defaultMangler(converter, mapperIdName, memberName);
- });
+ },
+ emitAllocatableMemberMaps);
}
mlir::FlatSymbolRefAttr resolveMapperId(
@@ -1278,16 +1303,19 @@ mlir::FlatSymbolRefAttr resolveMapperId(
bool isImplicitMap =
(mapTypeBits & mlir::omp::ClauseMapFlags::implicit) ==
mlir::omp::ClauseMapFlags::implicit;
- bool needsDefaultMapper =
- requiresImplicitDefaultDeclareMapper(*objectTypeSpec);
+ bool needsDefaultMapper = requiresImplicitDefaultDeclareMapper(
+ converter, firOpBuilder, *objectTypeSpec,
+ enableImplicitDefaultMapperAllocatableMembers);
// For implicit captures, avoid synthesizing default mappers for
// pointer entities (which can over-map pointer payloads) and for
// plain non-allocatable/non-pointer entities. Keep implicit mapper
// support for allocatables.
if (isImplicitMap && (isPointer || !isAllocOrPointer))
needsDefaultMapper = false;
- mapperId = addImplicitMapper(converter, loc, object, mapperIdName,
- /*allowGenerate=*/needsDefaultMapper);
+ mapperId =
+ addImplicitMapper(converter, loc, object, mapperIdName,
+ /*allowGenerate=*/needsDefaultMapper,
+ enableImplicitDefaultMapperAllocatableMembers);
}
}
diff --git a/flang/lib/Lower/OpenMP/Utils.h b/flang/lib/Lower/OpenMP/Utils.h
index 6aa1d5878c5a64..ff0fcada6bc110 100644
--- a/flang/lib/Lower/OpenMP/Utils.h
+++ b/flang/lib/Lower/OpenMP/Utils.h
@@ -146,7 +146,9 @@ mlir::Value createParentSymAndGenIntermediateMaps(
mlir::omp::ClauseMapFlags mapTypeBits);
bool requiresImplicitDefaultDeclareMapper(
- const semantics::DerivedTypeSpec &typeSpec);
+ lower::AbstractConverter &converter, fir::FirOpBuilder &firOpBuilder,
+ const semantics::DerivedTypeSpec &typeSpec,
+ bool enableImplicitDefaultMapperAllocatableMembers);
omp::ObjectList gatherObjectsOf(omp::Object derivedTypeMember,
semantics::SemanticsContext &semaCtx);
diff --git a/flang/lib/Support/Flags.cpp b/flang/lib/Support/Flags.cpp
index 250232448ee94e..ea5428590e5d91 100644
--- a/flang/lib/Support/Flags.cpp
+++ b/flang/lib/Support/Flags.cpp
@@ -18,3 +18,9 @@ llvm::cl::opt<bool> enableDelayedPrivatizationStaging(
llvm::cl::desc("For partially supported constructs, emit private/local "
"variables as clauses/specifiers on MLIR ops."),
llvm::cl::init(false));
+
+llvm::cl::opt<bool> enableImplicitDefaultMapperAllocatableMembers(
+ "enable-implicit-default-mapper-allocatable-members",
+ llvm::cl::desc("Emit implicit mappers for implicit allocatable member "
+ "mapping in derived types for specification compliance"),
+ llvm::cl::init(true));
diff --git a/flang/lib/Utils/OpenMP.cpp b/flang/lib/Utils/OpenMP.cpp
index aa5ef994252f76..292d9f6ba99f99 100644
--- a/flang/lib/Utils/OpenMP.cpp
+++ b/flang/lib/Utils/OpenMP.cpp
@@ -214,7 +214,7 @@ void cloneOrMapRegionOutsiders(
mlir::FlatSymbolRefAttr getOrGenImplicitDefaultDeclareMapper(
fir::FirOpBuilder &firOpBuilder, mlir::Location loc,
fir::RecordType recordType, llvm::StringRef mapperNameStr,
- RecordMemberMapperMangler mangler) {
+ RecordMemberMapperMangler mangler, bool emitAllocatableMemberMaps) {
auto getKindlessDefaultMapperName =
[](fir::RecordType recType) -> std::string {
auto [nameKind, deconstructed] =
@@ -336,12 +336,12 @@ mlir::FlatSymbolRefAttr getOrGenImplicitDefaultDeclareMapper(
std::string mapperIdName = getCanonicalDefaultDeclareMapperName(recType);
if (mangler)
mangler(mapperIdName, memberName);
- mapperId = getOrGenImplicitDefaultDeclareMapper(
- firOpBuilder, loc, recType, mapperIdName, mangler);
+ mapperId = getOrGenImplicitDefaultDeclareMapper(firOpBuilder, loc,
+ recType, mapperIdName, mangler, emitAllocatableMemberMaps);
}
bool isAllocatable = fir::isAllocatableType(fir::unwrapRefType(memberType));
- if (isAllocatable ||
+ if ((isAllocatable && emitAllocatableMemberMaps) ||
mlir::isa<fir::RecordType>(fir::getFortranElementType(memberType))) {
auto ref =
getFieldRef(declareOp.getBase(), memberName, memberType, recordType);
diff --git a/flang/test/Driver/omp-driver-offload.f90 b/flang/test/Driver/omp-driver-offload.f90
index fccd0771d040cb..57668ec64f2696 100644
--- a/flang/test/Driver/omp-driver-offload.f90
+++ b/flang/test/Driver/omp-driver-offload.f90
@@ -230,3 +230,55 @@
! OFFLOAD-TARGETS-NOT: --offload-targets
! OFFLOAD-TARGETS: "{{[^"]*}}flang{{[^"]*}}" "-fc1" "-triple" "x86_64-unknown-linux-gnu"
! OFFLOAD-TARGETS-SAME: "--offload-targets=amdgpu-amd-amdhsa"
+
+! Verify the implicit default mapper allocatable members flags are applied to both host
+! and device phases of the offload compilation when the negative flag is used and ignored
+! in the positive case as it is the default.
+
+! RUN: %flang -### %s 2>&1 \
+! RUN: -fopenmp -fimplicit-default-mapper-allocatable-members --offload-arch=gfx90a \
+! RUN: --target=x86_64-unknown-linux-gnu -nogpulib \
+! RUN: | FileCheck %s --check-prefix=ENABLE-IMP-MAPPER
+
+! ENABLE-IMP-MAPPER: "-fc1" "-triple" "x86_64-unknown-linux-gnu"
+! ENABLE-IMP-MAPPER-SAME: "-fopenmp"
+! ENABLE-IMP-MAPPER-SAME: "--offload-targets=amdgpu-amd-amdhsa"
+! ENABLE-IMP-MAPPER-NOT: implicit-default-mapper-allocatable-members
+! ENABLE-IMP-MAPPER-NEXT: "-fc1" "-triple" "amdgpu9.0a-amd-amdhsa"
+! ENABLE-IMP-MAPPER-SAME: "-fopenmp"
+! ENABLE-IMP-MAPPER-NOT: implicit-default-mapper-allocatable-members
+
+! RUN: %flang -### %s 2>&1 \
+! RUN: -fopenmp -fno-implicit-default-mapper-allocatable-members --offload-arch=gfx90a \
+! RUN: --target=x86_64-unknown-linux-gnu -nogpulib \
+! RUN: | FileCheck %s --check-prefix=DISABLE-IMP-MAPPER
+
+! Verify when multiple flags passed the final flag wins out
+
+! RUN: %flang -### %s 2>&1 \
+! RUN: -fopenmp --offload-arch=gfx90a \
+! RUN: -fimplicit-default-mapper-allocatable-members \
+! RUN: -fimplicit-default-mapper-allocatable-members \
+! RUN: -fno-implicit-default-mapper-allocatable-members \
+! RUN: --target=x86_64-unknown-linux-gnu -nogpulib \
+! RUN: | FileCheck %s --check-prefix=DISABLE-IMP-MAPPER
+
+! DISABLE-IMP-MAPPER: "-fc1" "-triple" "x86_64-unknown-linux-gnu"
+! DISABLE-IMP-MAPPER-SAME: "-fopenmp" {{.*}} "-fno-implicit-default-mapper-allocatable-members"
+! DISABLE-IMP-MAPPER-NEXT: "-fc1" "-triple" "amdgpu9.0a-amd-amdhsa"
+! DISABLE-IMP-MAPPER-SAME: "-fopenmp" {{.*}} "-fno-implicit-default-mapper-allocatable-members"
+
+! Verify when no implicit-default-mapper flags passed we do not inadvertently add the flag
+
+! RUN: %flang -### %s 2>&1 \
+! RUN: -fopenmp --offload-arch=gfx90a \
+! RUN: --target=x86_64-unknown-linux-gnu -nogpulib \
+! RUN: | FileCheck %s --check-prefix=NO-IMP-MAPPER
+
+! NO-IMP-MAPPER: "-fc1" "-triple" "x86_64-unknown-linux-gnu"
+! NO-IMP-MAPPER-SAME: "-fopenmp"
+! NO-IMP-MAPPER-SAME: "--offload-targets=amdgpu-amd-amdhsa"
+! NO-IMP-MAPPER-NOT: "-fno-implicit-default-mapper-allocatable-members"
+! NO-IMP-MAPPER-NEXT: "-fc1" "-triple" "amdgpu9.0a-amd-amdhsa"
+! NO-IMP-MAPPER-SAME: "-fopenmp"
+! NO-IMP-MAPPER-NOT: "-fno-implicit-default-mapper-allocatable-members"
diff --git a/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-explicit-map.f90 b/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-explicit-map.f90
new file mode 100644
index 00000000000000..ad95fcfb05aa1d
--- /dev/null
+++ b/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-explicit-map.f90
@@ -0,0 +1,39 @@
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 %s -o - | FileCheck %s --check-prefix=ON
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 -fimplicit-default-mapper-allocatable-members %s -o - | FileCheck %s --check-prefix=ON
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 -fno-implicit-default-mapper-allocatable-members %s -o - | FileCheck %s --check-prefix=OFF
+
+! Check the -f[no-]implicit-default-mapper-allocatable-members switch for
+! explicit maps that synthesize an implicit default mapper for a derived
+! type containing an allocatable.
+!
+! With the default/on setting, compiler-generated implicit default mappers for
+! derived types include maps for allocatable components. With the off setting,
+! those component maps are suppressed.
+
+program explicit_map
+ implicit none
+
+ type :: t
+ integer :: scalar
+ integer, allocatable :: a(:)
+ end type
+
+ type(t) :: x
+
+ !$omp target map(tofrom: x)
+ !$omp end target
+end program
+
+! ON: omp.declare_mapper @[[MAPPER:_QQFt_omp_default_mapper]]
+! ON: %[[COORD:.*]] = fir.coordinate_of %{{.*}}#0, a
+! ON: %[[PTEE:.*]] = omp.map.info var_ptr(%[[COORD]] {{.*}}) map_clauses(implicit, tofrom, ref_ptee)
+! ON: %[[ATTACH:.*]] = omp.map.info var_ptr(%[[COORD]] {{.*}}) map_clauses(attach, ref_ptee)
+! ON: %[[PARENT:.*]] = omp.map.info {{.*}}members(%[[PTEE]] : [1]
+! ON: omp.declare_mapper.info map_entries(%[[PARENT]], %[[PTEE]], %[[ATTACH]]
+! ON: omp.map.info {{.*}}map_clauses(tofrom) capture(ByRef) mapper(@[[MAPPER]]) name("x")
+! ON: omp.target
+
+! OFF-NOT: omp.declare_mapper
+! OFF: %[[MAP:.*]] = omp.map.info var_ptr(%{{.*}}) map_clauses(tofrom) capture(ByRef) name("x")
+! OFF-NOT: mapper(
+! OFF: omp.target {{.*}}map_entries(%[[MAP]] ->
diff --git a/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-implicit-capture.f90 b/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-implicit-capture.f90
new file mode 100644
index 00000000000000..3ed87985df0f7c
--- /dev/null
+++ b/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-implicit-capture.f90
@@ -0,0 +1,40 @@
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 %s -o - | FileCheck %s --check-prefix=ON
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 -fimplicit-default-mapper-allocatable-members %s -o - | FileCheck %s --check-prefix=ON
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 -fno-implicit-default-mapper-allocatable-members %s -o - | FileCheck %s --check-prefix=OFF
+
+! Check the -f[no-]implicit-default-mapper-allocatable-members switch for
+! compiler-generated implicit target-region captures that synthesize an implicit
+! default mapper for a derived type containing an allocatable.
+!
+! With the default/on setting, compiler-generated implicit default mappers for
+! derived types include maps for allocatable components. With the off setting,
+! those component maps are suppressed.
+
+
+program implicit_capture
+ implicit none
+
+ type :: t
+ integer, allocatable :: a(:)
+ end type
+
+ type(t) :: x
+
+ !$omp target
+ x%a(1) = 1
+ !$omp end target
+end program
+
+! ON: omp.declare_mapper @[[MAPPER:_QQFt_omp_default_mapper]]
+! ON: %[[COORD:.*]] = fir.coordinate_of %{{.*}}#0, a
+! ON: %[[PTEE:.*]] = omp.map.info var_ptr(%[[COORD]] {{.*}}) map_clauses(implicit, tofrom, ref_ptee)
+! ON: %[[ATTACH:.*]] = omp.map.info var_ptr(%[[COORD]] {{.*}}) map_clauses(attach, ref_ptee)
+! ON: %[[PARENT:.*]] = omp.map.info {{.*}}members(%[[PTEE]] : [0]
+! ON: omp.declare_mapper.info map_entries(%[[PARENT]], %[[PTEE]], %[[ATTACH]]
+! ON: omp.map.info {{.*}}map_clauses(implicit, tofrom) capture(ByRef) mapper(@[[MAPPER]]) name("x")
+! ON: omp.target
+
+! OFF-NOT: omp.declare_mapper
+! OFF: %[[MAP:.*]] = omp.map.info var_ptr(%{{.*}}) map_clauses(implicit, tofrom) capture(ByRef) name("x")
+! OFF-NOT: mapper(
+! OFF: omp.target {{.*}}map_entries(%[[MAP]] ->
diff --git a/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-nested-user-mapper.f90 b/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-nested-user-mapper.f90
new file mode 100644
index 00000000000000..c038353a9f9b3d
--- /dev/null
+++ b/flang/test/Lower/OpenMP/implicit-default-mapper-allocatable-members-flag-nested-user-mapper.f90
@@ -0,0 +1,39 @@
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 -fno-implicit-default-mapper-allocatable-members %s -o - | FileCheck %s
+
+! Check that -fno-implicit-default-mapper-allocatable-members does not suppress
+! generation of an implicit default mapper when a nested record component has a
+! user-defined default mapper. The generated outer mapper is still needed as a
+! carrier for the nested component mapper, but it must not emit maps for
+! allocatable components.
+
+program main
+ implicit none
+
+ type :: inner(k)
+ integer, kind :: k
+ integer(k), pointer :: p(:)
+ end type
+
+ !$omp declare mapper(default: inner(4) :: v) map(tofrom: v%p)
+
+ type :: outer
+ integer, allocatable :: unused(:)
+ type(inner(4)) :: child
+ end type
+
+contains
+ subroutine run(x)
+ type(outer) :: x
+ !$omp target map(tofrom: x)
+ x%child%p(1) = 42
+ !$omp end target
+ end subroutine
+end program
+
+! CHECK-DAG: omp.declare_mapper @[[OUTER_MAPPER:.*outer.*_omp_default_mapper]]
+! CHECK-DAG: omp.declare_mapper @[[INNER_MAPPER:.*inner.*_omp_default_mapper]]
+! CHECK-DAG: fir.coordinate_of %{{.*}}, child
+! CHECK-DAG: omp.map.info {{.*}}mapper(@[[INNER_MAPPER]])
+! CHECK-DAG: omp.map.info {{.*}}members(%{{.*}} : [1]
+! CHECK: omp.map.info {{.*}}mapper(@[[OUTER_MAPPER]]) name("x")
+! CHECK: omp.target
diff --git a/flang/test/Lower/OpenMP/implicit-default-mapper-multiple-nested-default-mappers.f90 b/flang/test/Lower/OpenMP/implicit-default-mapper-multiple-nested-default-mappers.f90
new file mode 100644
index 00000000000000..2252462ca70852
--- /dev/null
+++ b/flang/test/Lower/OpenMP/implicit-default-mapper-multiple-nested-default-mappers.f90
@@ -0,0 +1,109 @@
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 %s -o - | FileCheck %s --check-prefixes=CHECK,ON
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 -fno-implicit-default-mapper-allocatable-members %s -o - | FileCheck %s --check-prefixes=CHECK,OFF
+
+! Check that generated default mapper carriers are emitted for multi-level
+! derived type hierarchies when nested components have user-defined default
+! mappers. This must work both with and without
+! -fno-implicit-default-mapper-allocatable-members.
+!
+! The compiler-generated top_t mapper should attach the user-defined middle_t
+! default mapper to top%mid, and the user-defined middle_t default mapper should
+! attach the user-defined leaf_t default mapper to middle%leaf.
+!
+! Also check a top-level allocatable component in a generated carrier mapper:
+! default/on emits the allocatable member map, while the -fno flag suppresses
+! only that allocatable member and still emits the nested default mapper carrier.
+
+program main
+ implicit none
+
+ type :: leaf_t(k)
+ integer, kind :: k
+ integer(k), pointer :: p(:)
+ end type
+
+ !$omp declare mapper(default: leaf_t(4) :: v) map(tofrom: v%p)
+
+ type :: middle_t
+ integer :: payload(8)
+ type(leaf_t(4)) :: leaf
+ end type
+
+ !$omp declare mapper(default: middle_t :: v) map(tofrom: v%leaf)
+
+ type :: top_t
+ integer :: scalar
+ type(middle_t) :: mid
+ end type
+
+ type(top_t) :: x
+
+ !$omp target map(tofrom: x)
+ x%mid%leaf%p(1) = 42
+ !$omp end target
+end program
+
+subroutine top_allocatable_component
+ implicit none
+
+ type :: leaf_alloc_t(k)
+ integer, kind :: k
+ integer(k), pointer :: p(:)
+ end type
+
+ !$omp declare mapper(default: leaf_alloc_t(4) :: v) map(tofrom: v%p)
+
+ type :: middle_alloc_t
+ integer :: payload(8)
+ type(leaf_alloc_t(4)) :: leaf
+ end type
+
+ !$omp declare mapper(default: middle_alloc_t :: v) map(tofrom: v%leaf)
+
+ type :: top_alloc_t
+ integer, allocatable :: alloc_field(:)
+ type(middle_alloc_t) :: mid
+ end type
+
+ type(top_alloc_t) :: x
+
+ !$omp target map(tofrom: x)
+ x%mid%leaf%p(1) = 42
+ !$omp end target
+end subroutine
+
+! The allocatable variant's generated middle mapper carries the default leaf
+! mapper, and the generated top mapper carries the default middle mapper.
+! CHECK: omp.declare_mapper @{{.*middle_alloc_t_omp_default_mapper}}
+! CHECK: omp.map.info {{.*}}mapper(@{{.*leaf_alloc_t.*_omp_default_mapper}})
+! CHECK: omp.declare_mapper @{{.*top_alloc_t_omp_default_mapper}}
+
+! Default/on maps the top-level allocatable member inside the generated mapper.
+! ON: fir.field_index alloc_field
+! ON: omp.map.info {{.*}}map_clauses(implicit, tofrom, ref_ptee)
+! ON: fir.field_index mid
+! ON: omp.map.info {{.*}}mapper(@{{.*middle_alloc_t_omp_default_mapper}})
+! ON: omp.declare_mapper.info
+
+! With -fno-implicit-default-mapper-allocatable-members, the generated carrier
+! mapper omits the allocatable member map but still attaches the nested default
+! mapper to mid.
+! OFF-NOT: fir.field_index alloc_field
+! OFF: fir.field_index mid
+! OFF: omp.map.info {{.*}}mapper(@{{.*middle_alloc_t_omp_default_mapper}})
+! OFF: omp.declare_mapper.info
+
+! The user-defined middle_alloc_t mapper also carries the leaf_alloc_t mapper.
+! CHECK: omp.declare_mapper @{{.*middle_alloc_t_omp_default_mapper}}
+! CHECK: omp.map.info {{.*}}mapper(@{{.*leaf_alloc_t.*_omp_default_mapper}})
+
+! The non-allocatable variant's generated middle mapper carries the default leaf
+! mapper, and the generated top mapper carries the default middle mapper.
+! CHECK: omp.declare_mapper @{{.*middle_t_omp_default_mapper}}
+! CHECK: omp.map.info {{.*}}mapper(@{{.*leaf_t.*_omp_default_mapper}})
+! CHECK: omp.declare_mapper @{{.*top_t_omp_default_mapper}}
+! CHECK: omp.map.info {{.*}}mapper(@{{.*middle_t_omp_default_mapper}})
+
+! The target maps use the generated top-level carrier mappers.
+! CHECK-DAG: omp.map.info {{.*}}mapper(@{{.*top_t_omp_default_mapper}}) name("x")
+! CHECK-DAG: omp.map.info {{.*}}mapper(@{{.*top_alloc_t_omp_default_mapper}}) name("x")
diff --git a/flang/test/Lower/OpenMP/implicit-default-mapper-nested-default-mapper-carrier.f90 b/flang/test/Lower/OpenMP/implicit-default-mapper-nested-default-mapper-carrier.f90
new file mode 100644
index 00000000000000..fd1c9894134fb7
--- /dev/null
+++ b/flang/test/Lower/OpenMP/implicit-default-mapper-nested-default-mapper-carrier.f90
@@ -0,0 +1,37 @@
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=50 -fno-implicit-default-mapper-allocatable-members %s -o - | FileCheck %s
+
+! Check that an implicit default mapper is generated for an outer record even
+! when it has no allocatable components, if a nested record component has a
+! user-defined default mapper. The generated outer mapper is needed as a carrier
+! to attach the nested component mapper.
+
+program main
+ implicit none
+
+ type :: inner(k)
+ integer, kind :: k
+ integer(k), pointer :: p(:)
+ end type
+
+ !$omp declare mapper(default: inner(4) :: v) map(tofrom: v%p)
+
+ type :: outer
+ integer :: some_arr(10)
+ type(inner(4)) :: child
+ end type
+
+ type(outer) :: x
+
+ !$omp target map(tofrom: x)
+ x%child%p(1) = 42
+ !$omp end target
+end program
+
+! CHECK-DAG: omp.declare_mapper @[[OUTER_MAPPER:.*outer.*_omp_default_mapper]]
+! CHECK-DAG: omp.declare_mapper @[[INNER_MAPPER:.*inner.*_omp_default_mapper]]
+! CHECK-DAG: fir.coordinate_of %{{.*}}, child
+! CHECK-DAG: omp.map.info {{.*}}mapper(@[[INNER_MAPPER]])
+! CHECK-DAG: omp.map.info {{.*}}members(%{{.*}} : [1]
+! CHECK: omp.map.info {{.*}}mapper(@[[OUTER_MAPPER]]) name("x")
+! CHECK: omp.target
More information about the cfe-commits
mailing list