https://github.com/agozillon updated
https://github.com/llvm/llvm-project/pull/119589
>From e32330b6f5fa9d8c7f89c26e90c8d7ce34fc43bc Mon Sep 17 00:00:00 2001
From: agozillon <andrew.gozil...@amd.com>
Date: Fri, 1 Aug 2025 15:55:38 -0500
Subject: [PATCH 1/5] [Flang][OpenMP] Additional global address space
modifications for device
A prior PR added a portion of the global address space modifications required
for declare target to, this PR seeks to add a small amount more leftover from
that PR.
The intent is to allow for more correct IR that the backends (in particular
AMDGPU) can treat more aptly for optimisations and code correctness
1/3 required PRs to enable declare target to mapping, should look at PR 3/3 to
check for full green passes (this one will fail a number due to some
dependencies).
Co-authored-by: Raghu Maddhipatla raghu.maddhipa...@amd.com
---
flang/include/flang/Optimizer/Builder/FIRBuilder.h | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/flang/include/flang/Optimizer/Builder/FIRBuilder.h
b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
index e3a44f147b4cd..c19613f6fb390 100644
--- a/flang/include/flang/Optimizer/Builder/FIRBuilder.h
+++ b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
@@ -954,6 +954,10 @@ mlir::Value genLifetimeStart(mlir::OpBuilder &builder,
mlir::Location loc,
void genLifetimeEnd(mlir::OpBuilder &builder, mlir::Location loc,
mlir::Value mem);
+uint64_t getGlobalAddressSpace(mlir::DataLayout *dataLayout);
+
+uint64_t getProgramAddressSpace(mlir::DataLayout *dataLayout);
+
} // namespace fir::factory
#endif // FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
>From 0261b8bc8b8ec615e5daf9cf7d2882451faf8f9c Mon Sep 17 00:00:00 2001
From: agozillon <andrew.gozil...@amd.com>
Date: Fri, 1 Aug 2025 15:27:57 -0500
Subject: [PATCH 2/5] [MLIR][OpenMP] Introduce overlapped record type map
support
This PR introduces a new additional type of map lowering for record types that
Clang currently supports, in which a user can map a top-level record type and
then individual members with different mapping, effectively creating a sort of
"overlapping" mapping that we attempt to cut around.
This is currently most predominantly used in Fortran, when mapping descriptors
and there data, we map the descriptor and its data with separate map modifiers
and "cut around" the pointer data, so that wedo not overwrite it unless the
runtime deems it a neccesary action based on its reference counting mechanism.
However, it is a mechanism that will come in handy/trigger when a user
explitily maps a record type (derived type or structure) and then explicitly
maps a member with a different map type.
These additions were predominantly in the OpenMPToLLVMIRTranslation.cpp file
and phase, however, one Flang test that checks end-to-end IR compilation (as
far as we care for now at least) was altered.
2/3 required PRs to enable declare target to mapping, should look at PR 3/3 to
check for full green passes (this one will fail a number due to some
dependencies).
Co-authored-by: Raghu Maddhipatla raghu.maddhipa...@amd.com
---
.../Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git
a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
index 52d5c4cba3c5d..ab8bc60899385 100644
--- a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
@@ -3947,7 +3947,7 @@ static void sortMapIndices(llvm::SmallVectorImpl<size_t>
&indices,
static omp::MapInfoOp getFirstOrLastMappedMemberPtr(omp::MapInfoOp mapInfo,
bool first) {
- ArrayAttr indexAttr = mapInfo.getMembersIndexAttr();
+ mlir::ArrayAttr indexAttr = mapInfo.getMembersIndexAttr();
// Only 1 member has been mapped, we can return it.
if (indexAttr.size() == 1)
return cast<omp::MapInfoOp>(mapInfo.getMembers()[0].getDefiningOp());
>From 08d900f5bb27cbef764fbc7f2393d66590233e2a Mon Sep 17 00:00:00 2001
From: agozillon <andrew.gozil...@amd.com>
Date: Fri, 1 Aug 2025 15:27:57 -0500
Subject: [PATCH 3/5] [MLIR][OpenMP] Introduce overlapped record type map
support
This PR introduces a new additional type of map lowering for record types that
Clang currently supports, in which a user can map a top-level record type and
then individual members with different mapping, effectively creating a sort of
"overlapping" mapping that we attempt to cut around.
This is currently most predominantly used in Fortran, when mapping descriptors
and there data, we map the descriptor and its data with separate map modifiers
and "cut around" the pointer data, so that wedo not overwrite it unless the
runtime deems it a neccesary action based on its reference counting mechanism.
However, it is a mechanism that will come in handy/trigger when a user
explitily maps a record type (derived type or structure) and then explicitly
maps a member with a different map type.
These additions were predominantly in the OpenMPToLLVMIRTranslation.cpp file
and phase, however, one Flang test that checks end-to-end IR compilation (as
far as we care for now at least) was altered.
2/3 required PRs to enable declare target to mapping, should look at PR 3/3 to
check for full green passes (this one will fail a number due to some
dependencies).
Co-authored-by: Raghu Maddhipatla raghu.maddhipa...@amd.com
---
.../Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp | 3 +++
1 file changed, 3 insertions(+)
diff --git
a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
index ab8bc60899385..86b428fd4cf43 100644
--- a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
@@ -3890,6 +3890,9 @@ static void collectMapDataFromMapOperands(
}
}
+// remember to remove the movebefore that might have been added in one of the
+// PRs and is now deprecated...
+
static int getMapDataMemberIdx(MapInfoData &mapData, omp::MapInfoOp memberOp) {
auto *res = llvm::find(mapData.MapClause, memberOp);
assert(res != mapData.MapClause.end() &&
>From d6f5010d9223d6146784a40c47e632b1c2d68f75 Mon Sep 17 00:00:00 2001
From: agozillon <andrew.gozil...@amd.com>
Date: Fri, 1 Aug 2025 15:55:38 -0500
Subject: [PATCH 4/5] [Flang][OpenMP] Additional global address space
modifications for device
A prior PR added a portion of the global address space modifications required
for declare target to, this PR seeks to add a small amount more leftover from
that PR.
The intent is to allow for more correct IR that the backends (in particular
AMDGPU) can treat more aptly for optimisations and code correctness
1/3 required PRs to enable declare target to mapping, should look at PR 3/3 to
check for full green passes (this one will fail a number due to some
dependencies).
Co-authored-by: Raghu Maddhipatla raghu.maddhipa...@amd.com
---
llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
index c95446235a02a..28d5fb389233b 100644
--- a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
+++ b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
@@ -7561,8 +7561,12 @@ static Expected<Function *> createOutlinedFunction(
// preceding mapped arguments that refer to the same global that may be
// seperate segments. To prevent this, we defer global processing until all
// other processing has been performed.
+<<<<<<< HEAD
if (llvm::isa<llvm::GlobalValue, llvm::GlobalObject, llvm::GlobalVariable>(
removeASCastIfPresent(Input))) {
+=======
+ if (llvm::isa<llvm::GlobalValue, llvm::GlobalObject,
llvm::GlobalVariable>(removeASCastIfPresent(Input))) {
+>>>>>>> 1d1536f712a6 ([Flang][OpenMP] Additional global address space
modifications for device)
DeferredReplacement.push_back(std::make_pair(Input, InputCopy));
continue;
}
>From bfa228dce62ff75323aef4d6e4579d0b4d662241 Mon Sep 17 00:00:00 2001
From: agozillon <andrew.gozil...@amd.com>
Date: Fri, 1 Aug 2025 14:53:28 -0500
Subject: [PATCH 5/5] [Flang][OpenMP][MLIR] Initial declare target to for
variables implementation
While the infrastructure for declare target to/enter and link for variables
exists in the MLIR dialect and at the Flang level, the current lowering from
MLIR -> LLVM IR isn't in place, it's only in place for variables that have the
link clause applied.
This PR aims to extend that lowering to an initial implementation that
incorporates declare target to as well, which primarily requires changes in the
OpenMPToLLVMIRTranslation phase. However, a minor addition to the OpenMP
dialect was required to extend the declare target enumerator to include a
default None field as well.
This also requires a minor change to the Flang lowering's
MapInfoFinlization.cpp pass to alter the map type for descriptors to deal with
cases where a variable is marked declare to. Currently, when a descriptor
variable is mapped declare target to the descriptor component can become
attatched, and cannot be updated, this results in issues when an unusual
allocation range is specified (effectively an off-by X error). The current
solution is to map the descriptor always, as we always require an up-to-date
version of this data. However, this also requires an interlinked PR that adds a
more intricate type of mapping of structures/record types that clang currently
implements, to circumvent the overwriting of the pointer in the descriptor.
3/3 required PRs to enable declare target to mapping, this PR should pass all
tests and provide an all green CI.
Co-authored-by: Raghu Maddhipatla raghu.maddhipa...@amd.com
---
.../flang/Optimizer/Builder/FIRBuilder.h | 4 -
.../Optimizer/OpenMP/MapInfoFinalization.cpp | 18 +-
.../target-private-allocatable.f90 | 2 +-
...rget-teams-private-implicit-scalar-map.f90 | 2 +-
.../Lower/OpenMP/allocatable-array-bounds.f90 | 7 +-
flang/test/Lower/OpenMP/allocatable-map.f90 | 2 +-
flang/test/Lower/OpenMP/array-bounds.f90 | 2 +-
flang/test/Lower/OpenMP/declare-mapper.f90 | 4 +-
.../OpenMP/declare-target-link-tarop-cap.f90 | 4 +-
flang/test/Lower/OpenMP/defaultmap.f90 | 6 +-
.../OpenMP/derived-type-allocatable-map.f90 | 16 +-
.../Lower/OpenMP/optional-argument-map-3.f90 | 4 +-
.../target-enter-data-default-openmp52.f90 | 2 +-
flang/test/Lower/OpenMP/target.f90 | 4 +-
flang/test/Lower/volatile-openmp.f90 | 4 +-
.../Transforms/omp-map-info-finalization.fir | 20 +-
llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp | 4 -
.../mlir/Dialect/OpenMP/OpenMPEnums.td | 8 +-
.../OpenMP/OpenMPToLLVMIRTranslation.cpp | 200 +++++++++++-------
.../omptarget-declare-target-to-device.mlir | 35 +++
...allocatable-vars-in-target-with-update.f90 | 44 ++++
...arget-to-vars-target-region-and-update.f90 | 36 ++++
...t-to-zero-index-allocatable-target-map.f90 | 30 +++
23 files changed, 330 insertions(+), 128 deletions(-)
create mode 100644
mlir/test/Target/LLVMIR/omptarget-declare-target-to-device.mlir
create mode 100644
offload/test/offloading/fortran/declare-target-to-allocatable-vars-in-target-with-update.f90
create mode 100644
offload/test/offloading/fortran/declare-target-to-vars-target-region-and-update.f90
create mode 100644
offload/test/offloading/fortran/declare-target-to-zero-index-allocatable-target-map.f90
diff --git a/flang/include/flang/Optimizer/Builder/FIRBuilder.h
b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
index c19613f6fb390..e3a44f147b4cd 100644
--- a/flang/include/flang/Optimizer/Builder/FIRBuilder.h
+++ b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
@@ -954,10 +954,6 @@ mlir::Value genLifetimeStart(mlir::OpBuilder &builder,
mlir::Location loc,
void genLifetimeEnd(mlir::OpBuilder &builder, mlir::Location loc,
mlir::Value mem);
-uint64_t getGlobalAddressSpace(mlir::DataLayout *dataLayout);
-
-uint64_t getProgramAddressSpace(mlir::DataLayout *dataLayout);
-
} // namespace fir::factory
#endif // FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
diff --git a/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
b/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
index 57be863cfa1b8..59e4a26997c74 100644
--- a/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
+++ b/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
@@ -275,9 +275,21 @@ class MapInfoFinalizationPass
return mapTypeFlag;
mapFlags flags = mapFlags::OMP_MAP_TO |
- (mapFlags(mapTypeFlag) &
- (mapFlags::OMP_MAP_IMPLICIT | mapFlags::OMP_MAP_CLOSE |
- mapFlags::OMP_MAP_ALWAYS));
+ (mapFlags(mapTypeFlag) & mapFlags::OMP_MAP_IMPLICIT);
+
+ // Descriptors for objects will always be copied. This is because the
+ // descriptor can be rematerialized by the compiler, and so the address
+ // of the descriptor for a given object at one place in the code may
+ // differ from that address in another place. The contents of the
+ // descriptor (the base address in particular) will remain unchanged
+ // though.
+ // TODO/FIXME: We currently cannot have MAP_CLOSE and MAP_ALWAYS on
+ // the descriptor at once, these are mutually exclusive and when
+ // both are applied the runtime will fail to map.
+ flags |= ((mapFlags(mapTypeFlag) & mapFlags::OMP_MAP_CLOSE) ==
+ mapFlags::OMP_MAP_CLOSE)
+ ? mapFlags::OMP_MAP_CLOSE
+ : mapFlags::OMP_MAP_ALWAYS;
return llvm::to_underlying(flags);
}
diff --git
a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90
b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90
index 3d93fbc6e446e..e3feea85c6af0 100644
---
a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90
+++
b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90
@@ -60,7 +60,7 @@ end subroutine target_allocatable
! CHECK: %[[VAR_DECL:.*]]:2 = hlfir.declare %[[VAR_ALLOC]]
! CHECK: %[[BASE_ADDR:.*]] = fir.box_offset %[[VAR_DECL]]#0 base_addr :
(!fir.ref<!fir.box<!fir.heap<i32>>>) -> [[MEMBER_TYPE:.*]]
! CHECK: %[[MEMBER:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]],
i32) map_clauses(to) capture(ByRef) var_ptr_ptr(%[[BASE_ADDR]] :
[[MEMBER_TYPE:.*]]) -> {{.*}}
-! CHECK: %[[MAP_VAR:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]],
[[DESC_TYPE]]) map_clauses(to) capture(ByRef) members(%[[MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
+! CHECK: %[[MAP_VAR:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]],
[[DESC_TYPE]]) map_clauses(always, to) capture(ByRef) members(%[[MEMBER]] : [0]
: !fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
! CHECK: omp.target map_entries(%[[MAP_VAR]] -> %arg0, %[[MEMBER]] -> %arg1 :
[[TYPE]], [[MEMBER_TYPE]]) private(
! CHECK-SAME: @[[VAR_PRIVATIZER_SYM]] %[[VAR_DECL]]#0 -> %{{.*}} [map_idx=0] :
[[TYPE]]) {
diff --git
a/flang/test/Lower/OpenMP/DelayedPrivatization/target-teams-private-implicit-scalar-map.f90
b/flang/test/Lower/OpenMP/DelayedPrivatization/target-teams-private-implicit-scalar-map.f90
index 39f9738932d44..54dc8cc6da832 100644
---
a/flang/test/Lower/OpenMP/DelayedPrivatization/target-teams-private-implicit-scalar-map.f90
+++
b/flang/test/Lower/OpenMP/DelayedPrivatization/target-teams-private-implicit-scalar-map.f90
@@ -28,7 +28,7 @@ program test_default_implicit_firstprivate
!CHECK: %[[VAL_9:.*]] = omp.map.info var_ptr(%[[VAL_4]] :
!fir.ref<i32>, i32) map_clauses(implicit, exit_release_or_enter_alloc)
capture(ByCopy) -> !fir.ref<i32> {name = "k"}
!CHECK: %[[VAL_10:.*]] = fir.box_offset %[[VAL_0]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?x?x?xi32>>>
!CHECK: %[[VAL_11:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>>, i32)
map_clauses(implicit, tofrom) capture(ByRef) var_ptr_ptr(%[[VAL_10]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?x?x?xi32>>>) bounds({{.*}}) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?x?x?xi32>>> {name = ""}
-!CHECK: %[[VAL_12:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>) map_clauses(implicit, to)
capture(ByRef) members(%[[VAL_11]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?x?x?xi32>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>> {name = "allocarr"}
+!CHECK: %[[VAL_12:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>) map_clauses(always, implicit, to)
capture(ByRef) members(%[[VAL_11]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?x?x?xi32>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>> {name = "allocarr"}
!CHECK: %[[VAL_13:.*]] = omp.map.info var_ptr(%[[VAL_1]] :
!fir.ref<!fir.array<10x10x10xi32>>, !fir.array<10x10x10xi32>)
map_clauses(implicit, tofrom) capture(ByRef) bounds({{.*}}) ->
!fir.ref<!fir.array<10x10x10xi32>> {name = "arr"}
!CHECK: %[[VAL_14:.*]] = omp.map.info var_ptr(%[[VAL_6]] :
!fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) -> !fir.ref<i32>
!CHECK: %[[VAL_15:.*]] = omp.map.info var_ptr(%[[VAL_5]] :
!fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) -> !fir.ref<i32>
diff --git a/flang/test/Lower/OpenMP/allocatable-array-bounds.f90
b/flang/test/Lower/OpenMP/allocatable-array-bounds.f90
index 96d779c763d18..46e267572f17e 100644
--- a/flang/test/Lower/OpenMP/allocatable-array-bounds.f90
+++ b/flang/test/Lower/OpenMP/allocatable-array-bounds.f90
@@ -24,7 +24,7 @@
!HOST: %[[BOUNDS_1:.*]] = omp.map.bounds lower_bound(%[[LB_1]] : index)
upper_bound(%[[UB_1]] : index) extent(%[[BOX_3]]#1 : index) stride(%[[BOX_2]]#2
: index) start_idx(%[[BOX_1]]#0 : index) {stride_in_bytes = true}
!HOST: %[[VAR_PTR_PTR:.*]] = fir.box_offset %[[DECLARE_1]]#1 base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!HOST: %[[MAP_INFO_MEMBER:.*]] = omp.map.info var_ptr(%[[DECLARE_1]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS_1]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-!HOST: %[[MAP_INFO_1:.*]] = omp.map.info var_ptr(%[[DECLARE_1]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef)
members(%[[MAP_INFO_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "sp_read(2:5)"}
+!HOST: %[[MAP_INFO_1:.*]] = omp.map.info var_ptr(%[[DECLARE_1]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
members(%[[MAP_INFO_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "sp_read(2:5)"}
!HOST: %[[LOAD_3:.*]] = fir.load %[[DECLARE_2]]#0 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
!HOST: %[[LOAD_4:.*]] = fir.load %[[DECLARE_2]]#0 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
@@ -42,7 +42,7 @@
!HOST: %[[BOUNDS_2:.*]] = omp.map.bounds lower_bound(%[[LB_2]] : index)
upper_bound(%[[UB_2]] : index) extent(%[[BOX_5]]#1 : index) stride(%[[BOX_4]]#2
: index) start_idx(%[[BOX_3]]#0 : index) {stride_in_bytes = true}
!HOST: %[[VAR_PTR_PTR:.*]] = fir.box_offset %[[DECLARE_2]]#1 base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!HOST: %[[MAP_INFO_MEMBER:.*]] = omp.map.info var_ptr(%[[DECLARE_2]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS_2]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-!HOST: %[[MAP_INFO_2:.*]] = omp.map.info var_ptr(%[[DECLARE_2]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef)
members(%[[MAP_INFO_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "sp_write(2:5)"}
+!HOST: %[[MAP_INFO_2:.*]] = omp.map.info var_ptr(%[[DECLARE_2]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
members(%[[MAP_INFO_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "sp_write(2:5)"}
subroutine read_write_section()
integer, allocatable :: sp_read(:)
@@ -81,8 +81,7 @@ module assumed_allocatable_array_routines
!HOST: %[[BOUNDS:.*]] = omp.map.bounds lower_bound(%[[LB]] : index)
upper_bound(%[[UB]] : index) extent(%[[BOX_3]]#1 : index) stride(%[[BOX_2]]#2 :
index) start_idx(%[[BOX_1]]#0 : index) {stride_in_bytes = true}
!HOST: %[[VAR_PTR_PTR:.*]] = fir.box_offset %[[DECLARE]]#1 base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!HOST: %[[MAP_INFO_MEMBER:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-!HOST: %[[MAP_INFO:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef)
members(%[[MAP_INFO_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "arr_read_write(2:5)"}
-
+!HOST: %[[MAP_INFO:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
members(%[[MAP_INFO_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "arr_read_write(2:5)"}
subroutine assumed_shape_array(arr_read_write)
integer, allocatable, intent(inout) :: arr_read_write(:)
diff --git a/flang/test/Lower/OpenMP/allocatable-map.f90
b/flang/test/Lower/OpenMP/allocatable-map.f90
index ee1c621ad860b..114967526b8d5 100644
--- a/flang/test/Lower/OpenMP/allocatable-map.f90
+++ b/flang/test/Lower/OpenMP/allocatable-map.f90
@@ -3,7 +3,7 @@
!HLFIRDIALECT: %[[POINTER:.*]]:2 = hlfir.declare %{{.*}} {fortran_attrs =
#fir.var_attrs<pointer>, uniq_name = "_QFpointer_routineEpoint"} :
(!fir.ref<!fir.box<!fir.ptr<i32>>>) -> (!fir.ref<!fir.box<!fir.ptr<i32>>>,
!fir.ref<!fir.box<!fir.ptr<i32>>>)
!HLFIRDIALECT: %[[BOX_OFF:.*]] = fir.box_offset %[[POINTER]]#1 base_addr :
(!fir.ref<!fir.box<!fir.ptr<i32>>>) -> !fir.llvm_ptr<!fir.ref<i32>>
!HLFIRDIALECT: %[[POINTER_MAP_MEMBER:.*]] = omp.map.info
var_ptr(%[[POINTER]]#1 : !fir.ref<!fir.box<!fir.ptr<i32>>>, i32)
map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[BOX_OFF]] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.llvm_ptr<!fir.ref<i32>> {name = ""}
-!HLFIRDIALECT: %[[POINTER_MAP:.*]] = omp.map.info var_ptr(%[[POINTER]]#1 :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>) map_clauses(to)
capture(ByRef) members(%[[POINTER_MAP_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.ptr<i32>>> {name =
"point"}
+!HLFIRDIALECT: %[[POINTER_MAP:.*]] = omp.map.info var_ptr(%[[POINTER]]#1 :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>) map_clauses(always,
to) capture(ByRef) members(%[[POINTER_MAP_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.ptr<i32>>> {name =
"point"}
!HLFIRDIALECT: omp.target map_entries(%[[POINTER_MAP]] -> {{.*}},
%[[POINTER_MAP_MEMBER]] -> {{.*}} : !fir.ref<!fir.box<!fir.ptr<i32>>>,
!fir.llvm_ptr<!fir.ref<i32>>) {
subroutine pointer_routine()
integer, pointer :: point
diff --git a/flang/test/Lower/OpenMP/array-bounds.f90
b/flang/test/Lower/OpenMP/array-bounds.f90
index 8f98d671486ae..a8234bd46cf1c 100644
--- a/flang/test/Lower/OpenMP/array-bounds.f90
+++ b/flang/test/Lower/OpenMP/array-bounds.f90
@@ -52,7 +52,7 @@ module assumed_array_routines
!HOST: %[[BOUNDS:.*]] = omp.map.bounds lower_bound(%[[C3]] : index)
upper_bound(%[[C4]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 :
index) start_idx(%[[C0]] : index) {stride_in_bytes = true}
!HOST: %[[VAR_PTR_PTR:.*]] = fir.box_offset %[[INTERMEDIATE_ALLOCA]] base_addr
: (!fir.ref<!fir.box<!fir.array<?xi32>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!HOST: %[[MAP_INFO_MEMBER:.*]] = omp.map.info var_ptr(%[[INTERMEDIATE_ALLOCA]]
: !fir.ref<!fir.box<!fir.array<?xi32>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-!HOST: %[[MAP:.*]] = omp.map.info var_ptr(%[[INTERMEDIATE_ALLOCA]] :
!fir.ref<!fir.box<!fir.array<?xi32>>>, !fir.box<!fir.array<?xi32>>)
map_clauses(to) capture(ByRef) members(%[[MAP_INFO_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.array<?xi32>>
{name = "arr_read_write(2:5)"}
+!HOST: %[[MAP:.*]] = omp.map.info var_ptr(%[[INTERMEDIATE_ALLOCA]] :
!fir.ref<!fir.box<!fir.array<?xi32>>>, !fir.box<!fir.array<?xi32>>)
map_clauses(always, to) capture(ByRef) members(%[[MAP_INFO_MEMBER]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.array<?xi32>>
{name = "arr_read_write(2:5)"}
!HOST: omp.target map_entries(%[[MAP]] -> %{{.*}}, {{.*}} -> {{.*}},
%[[MAP_INFO_MEMBER]] -> %{{.*}} : !fir.ref<!fir.array<?xi32>>, !fir.ref<i32>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) {
subroutine assumed_shape_array(arr_read_write)
integer, intent(inout) :: arr_read_write(:)
diff --git a/flang/test/Lower/OpenMP/declare-mapper.f90
b/flang/test/Lower/OpenMP/declare-mapper.f90
index 8a98c68a8d582..b457ac5b70f08 100644
--- a/flang/test/Lower/OpenMP/declare-mapper.f90
+++ b/flang/test/Lower/OpenMP/declare-mapper.f90
@@ -44,7 +44,7 @@ subroutine declare_mapper_1
!CHECK: %[[VAL_18:.*]] = fir.coordinate_of %[[VAL_1]]#0, values :
(!fir.ref<[[MY_TYPE]]>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
!CHECK: %[[VAL_19:.*]] = fir.box_offset %[[VAL_18]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!CHECK: %[[VAL_20:.*]] = omp.map.info var_ptr(%[[VAL_18]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[VAL_19]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[VAL_16]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
- !CHECK: %[[VAL_21:.*]] = omp.map.info var_ptr(%[[VAL_18]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name =
"var%[[VAL_22:.*]](1:var%[[VAL_23:.*]])"}
+ !CHECK: %[[VAL_21:.*]] = omp.map.info var_ptr(%[[VAL_18]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name =
"var%[[VAL_22:.*]](1:var%[[VAL_23:.*]])"}
!CHECK: %[[VAL_24:.*]] = omp.map.info var_ptr(%[[VAL_1]]#1 :
!fir.ref<[[MY_TYPE]]>, [[MY_TYPE]]) map_clauses(tofrom) capture(ByRef)
members(%[[VAL_21]], %[[VAL_20]] : [1], [1, 0] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<[[MY_TYPE]]> {name =
"var"}
!CHECK: omp.declare_mapper.info map_entries(%[[VAL_24]],
%[[VAL_21]], %[[VAL_20]] : !fir.ref<[[MY_TYPE]]>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>)
!CHECK: }
@@ -136,7 +136,7 @@ subroutine declare_mapper_3
!CHECK: %[[VAL_18:.*]] = fir.coordinate_of %[[VAL_1]]#0, values :
(!fir.ref<[[MY_TYPE]]>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
!CHECK: %[[VAL_19:.*]] = fir.box_offset %[[VAL_18]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!CHECK: %[[VAL_20:.*]] = omp.map.info var_ptr(%[[VAL_18]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[VAL_19]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[VAL_16]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
- !CHECK: %[[VAL_21:.*]] = omp.map.info var_ptr(%[[VAL_18]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name =
"var%[[VAL_22:.*]](1:var%[[VAL_23:.*]])"}
+ !CHECK: %[[VAL_21:.*]] = omp.map.info var_ptr(%[[VAL_18]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name =
"var%[[VAL_22:.*]](1:var%[[VAL_23:.*]])"}
!CHECK: %[[VAL_24:.*]] = omp.map.info var_ptr(%[[VAL_1]]#1 :
!fir.ref<[[MY_TYPE]]>, [[MY_TYPE]]) map_clauses(tofrom) capture(ByRef)
members(%[[VAL_21]], %[[VAL_20]] : [1], [1, 0] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<[[MY_TYPE]]> {name =
"var"}
!CHECK: omp.declare_mapper.info map_entries(%[[VAL_24]], %[[VAL_21]],
%[[VAL_20]] : !fir.ref<[[MY_TYPE]]>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>)
!CHECK: }
diff --git a/flang/test/Lower/OpenMP/declare-target-link-tarop-cap.f90
b/flang/test/Lower/OpenMP/declare-target-link-tarop-cap.f90
index cfdcd9eda82d1..0fba1ee9a293d 100644
--- a/flang/test/Lower/OpenMP/declare-target-link-tarop-cap.f90
+++ b/flang/test/Lower/OpenMP/declare-target-link-tarop-cap.f90
@@ -35,7 +35,7 @@ program test_link
allocate(test_ptr1)
test_ptr1 = 1
- !CHECK-DAG: {{%.*}} = omp.map.info var_ptr({{%.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>)
map_clauses(implicit, to) capture(ByRef) members({{%.*}} :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.ptr<i32>>> {name =
"test_ptr1"}
+ !CHECK-DAG: {{%.*}} = omp.map.info var_ptr({{%.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>) map_clauses(always,
implicit, to) capture(ByRef) members({{%.*}} : !fir.llvm_ptr<!fir.ref<i32>>) ->
!fir.ref<!fir.box<!fir.ptr<i32>>> {name = "test_ptr1"}
!$omp target
test_ptr1 = test_ptr1 + 1
!$omp end target
@@ -46,7 +46,7 @@ program test_link
!$omp end target
- !CHECK-DAG: {{%.*}} = omp.map.info var_ptr({{%.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>)
map_clauses(implicit, to) capture(ByRef) members({{%.*}} :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.ptr<i32>>> {name =
"test_ptr2"}
+ !CHECK-DAG: {{%.*}} = omp.map.info var_ptr({{%.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>) map_clauses(always,
implicit, to) capture(ByRef) members({{%.*}} : !fir.llvm_ptr<!fir.ref<i32>>) ->
!fir.ref<!fir.box<!fir.ptr<i32>>> {name = "test_ptr2"}
test_ptr2 => test_target
!$omp target
test_ptr2 = test_ptr2 + 1
diff --git a/flang/test/Lower/OpenMP/defaultmap.f90
b/flang/test/Lower/OpenMP/defaultmap.f90
index 0b26f5db0feb3..1c361309423ea 100644
--- a/flang/test/Lower/OpenMP/defaultmap.f90
+++ b/flang/test/Lower/OpenMP/defaultmap.f90
@@ -6,7 +6,7 @@ subroutine defaultmap_allocatable_present()
integer, dimension(:), allocatable :: arr
! CHECK: %[[MAP_1:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(implicit,
present, exit_release_or_enter_alloc) capture(ByRef) var_ptr_ptr({{.*}})
bounds({{.*}}) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-! CHECK: %[[MAP_2:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(implicit, to)
capture(ByRef) members({{.*}}) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "arr"}
+! CHECK: %[[MAP_2:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, implicit, to)
capture(ByRef) members({{.*}}) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "arr"}
!$omp target defaultmap(present: allocatable)
arr(1) = 10
!$omp end target
@@ -34,7 +34,7 @@ subroutine defaultmap_all_default()
! CHECK: %[[MAP_1:.*]] = omp.map.info var_ptr({{.*}} : !fir.ref<i32>, i32)
map_clauses(implicit, exit_release_or_enter_alloc) capture(ByCopy) ->
!fir.ref<i32> {name = "scalar_int"}
! CHECK: %[[MAP_2:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(implicit,
tofrom) capture(ByRef) var_ptr_ptr({{.*}}) bounds({{.*}}) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-! CHECK: %[[MAP_3:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(implicit, to)
capture(ByRef) members({{.*}}) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "arr"}
+! CHECK: %[[MAP_3:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, implicit, to)
capture(ByRef) members({{.*}}) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "arr"}
! CHECK: %[[MAP_4:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.array<16xi32>>, !fir.array<16xi32>) map_clauses(implicit, tofrom)
capture(ByRef) bounds({{.*}}) -> !fir.ref<!fir.array<16xi32>> {name =
"aggregate"}
!$omp target defaultmap(default: all)
@@ -52,7 +52,7 @@ subroutine defaultmap_pointer_to()
! CHECK-NO-FPRIV: %[[MAP_1:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, i32) map_clauses(implicit, to)
capture(ByRef) var_ptr_ptr({{.*}}) bounds({{.*}}) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
! CHECK-FPRIV: %[[MAP_1:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, i32) map_clauses(implicit, to)
capture(ByRef) var_ptr_ptr({{.*}}) bounds({{.*}}) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-! CHECK: %[[MAP_2:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>,
!fir.box<!fir.ptr<!fir.array<?xi32>>>) map_clauses(implicit, to) capture(ByRef)
members({{.*}}) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> {name =
"arr_ptr"}
+! CHECK: %[[MAP_2:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>,
!fir.box<!fir.ptr<!fir.array<?xi32>>>) map_clauses(always, implicit, to)
capture(ByRef) members({{.*}}) ->
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> {name = "arr_ptr"}
! CHECK-FPRIV: %[[MAP_3:.*]] = omp.map.info var_ptr({{.*}} : !fir.ref<i32>,
i32) map_clauses(to) capture(ByCopy) -> !fir.ref<i32>
! CHECK-NO-FPRIV: %[[MAP_3:.*]] = omp.map.info var_ptr({{.*}} : !fir.ref<i32>,
i32) map_clauses(implicit, exit_release_or_enter_alloc) capture(ByCopy) ->
!fir.ref<i32> {name = "scalar_int"}
!$omp target defaultmap(to: pointer)
diff --git a/flang/test/Lower/OpenMP/derived-type-allocatable-map.f90
b/flang/test/Lower/OpenMP/derived-type-allocatable-map.f90
index d19a572c1f4fb..74aee4df1f454 100644
--- a/flang/test/Lower/OpenMP/derived-type-allocatable-map.f90
+++ b/flang/test/Lower/OpenMP/derived-type-allocatable-map.f90
@@ -6,7 +6,7 @@
!CHECK: %[[MEMBER_COORD:.*]] = fir.coordinate_of %[[DECLARE]]#0, array_j :
(!fir.ref<!fir.type<[[ONE_LAYER_TY]]>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
!CHECK: %[[MEMBER_BASE_ADDR:.*]] = fir.box_offset %[[MEMBER_COORD]] base_addr
: (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!CHECK: %[[MAP_MEMBER_BASE_ADDR:.*]] = omp.map.info var_ptr(%[[MEMBER_COORD]]
: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-!CHECK: %[[MAP_MEMBER_DESCRIPTOR:.*]] = omp.map.info var_ptr(%[[MEMBER_COORD]]
: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
+!CHECK: %[[MAP_MEMBER_DESCRIPTOR:.*]] = omp.map.info var_ptr(%[[MEMBER_COORD]]
: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
!CHECK: %[[MAP_PARENT:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.type<[[ONE_LAYER_TY]]>>, !fir.type<[[ONE_LAYER_TY]]>)
map_clauses(tofrom) capture(ByRef) members(%[[MAP_MEMBER_DESCRIPTOR]],
%[[MAP_MEMBER_BASE_ADDR]] : [4], [4, 0] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.type<[[ONE_LAYER_TY]]>> {{{.*}} partial_map = true}
!CHECK: omp.target map_entries(%[[MAP_PARENT]] -> %[[ARG0:.*]],
%[[MAP_MEMBER_DESCRIPTOR]] -> %[[ARG1:.*]], %[[MAP_MEMBER_BASE_ADDR]] ->
%[[ARG2:.*]] : !fir.ref<!fir.type<[[ONE_LAYER_TY]]>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) {
!CHECK: %{{.*}}:2 = hlfir.declare %[[ARG0]] {{{.*}}} :
(!fir.ref<!fir.type<[[ONE_LAYER_TY]]>>) ->
(!fir.ref<!fir.type<[[ONE_LAYER_TY]]>>, !fir.ref<!fir.type<[[ONE_LAYER_TY]]>>)
@@ -35,14 +35,14 @@ subroutine dtype_alloca_map_op_block()
!CHECK: %[[LOAD_DTYPE:.*]] = fir.load %[[DECLARE]]#0 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>
!CHECK: %[[MEMBER_COORD:.*]] = fir.coordinate_of %[[LOAD_DTYPE]], array_j :
(!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
!CHECK: %[[MEMBER_BASE_ADDR:.*]] = fir.box_offset %[[MEMBER_COORD]] base_addr
: (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
-!CHECK: %[[MAP_MEMBER_BASE_ADDR:.*]] = omp.map.info var_ptr(%[[MEMBER_COORD]]
: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-!CHECK: %[[MAP_MEMBER_DESC:.*]] = omp.map.info var_ptr(%[[MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
+!CHECK: %[[MAP_MEMBER_BASE_ADDR:.*]] = omp.map.info var_ptr(%[[MEMBER_COORD]]
: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
+!CHECK: %[[MAP_MEMBER_DESC:.*]] = omp.map.info var_ptr(%[[MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
!CHECK: %[[LOAD_DTYPE:.*]] = fir.load %[[DECLARE]]#0 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>
!CHECK: %[[REGULAR_MEMBER:.*]] = fir.coordinate_of %[[LOAD_DTYPE]], k :
(!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) -> !fir.ref<i32>
!CHECK: %[[MAP_REGULAR_MEMBER:.*]] = omp.map.info var_ptr(%[[REGULAR_MEMBER]]
: !fir.ref<i32>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32> {{.*}}
!CHECK: %[[DTYPE_BASE_ADDR:.*]] = fir.box_offset %[[DECLARE]]#1 base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>
-!CHECK: %[[MAP_DTYPE_BASE_ADDR:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>, !fir.type<[[REC_TY]]>)
map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[DTYPE_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>> {{.*}}
-!CHECK: %[[MAP_DTYPE_DESC:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) map_clauses(to) capture(ByRef)
members(%[[MAP_DTYPE_BASE_ADDR]], %[[MAP_MEMBER_DESC]],
%[[MAP_MEMBER_BASE_ADDR]], %[[MAP_REGULAR_MEMBER]] : [0], [0, 4], [0, 4, 0],
[0, 5] : !fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) ->
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>> {{.*}}
+!CHECK: %[[MAP_DTYPE_BASE_ADDR:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>, !fir.type<[[REC_TY]]>)
map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[DTYPE_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>> {{.*}}
+!CHECK: %[[MAP_DTYPE_DESC:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) map_clauses(always, to)
capture(ByRef) members(%[[MAP_DTYPE_BASE_ADDR]], %[[MAP_MEMBER_DESC]],
%[[MAP_MEMBER_BASE_ADDR]], %[[MAP_REGULAR_MEMBER]] : [0], [0, 4], [0, 4, 0],
[0, 5] : !fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) ->
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>> {{.*}}
!CHECK: omp.target map_entries(%[[MAP_DTYPE_DESC]] -> %[[ARG0:.*]],
%[[MAP_DTYPE_BASE_ADDR]] -> %[[ARG1:.*]], %[[MAP_MEMBER_DESC]] -> %[[ARG2:.*]],
%[[MAP_MEMBER_BASE_ADDR]] -> %[[ARG3:.*]], %[[MAP_REGULAR_MEMBER]] ->
%[[ARG4:.*]] : !fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) {
!CHECK: %{{.*}}:2 = hlfir.declare %[[ARG0]] {{{.*}}} :
(!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>) ->
(!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>)
subroutine alloca_dtype_op_block_add()
@@ -74,14 +74,14 @@ subroutine alloca_dtype_op_block_add()
!CHECK: %[[NESTED_MEMBER_COORD:.*]] = fir.coordinate_of
%[[NESTED_DTYPE_COORD]], array_k : (!fir.ref<!fir.type<[[REC_TY2]]>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
!CHECK: %[[NESTED_MEMBER_BASE_ADDR:.*]] = fir.box_offset
%[[NESTED_MEMBER_COORD]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!CHECK: %[[MAP_NESTED_MEMBER_BASE_ADDR:.*]] = omp.map.info
var_ptr(%[[NESTED_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[NESTED_MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-!CHECK: %[[MAP_NESTED_MEMBER_COORD:.*]] = omp.map.info
var_ptr(%[[NESTED_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
+!CHECK: %[[MAP_NESTED_MEMBER_COORD:.*]] = omp.map.info
var_ptr(%[[NESTED_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
!CHECK: %[[LOAD:.*]] = fir.load %[[DECLARE]]#0 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>
!CHECK: %[[NESTED_DTYPE_COORD:.*]] = fir.coordinate_of %[[LOAD]], nest :
(!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>) ->
!fir.ref<!fir.type<[[REC_TY2]]>>
!CHECK: %[[REGULAR_NESTED_MEMBER_COORD:.*]] = fir.coordinate_of
%[[NESTED_DTYPE_COORD]], k : (!fir.ref<!fir.type<[[REC_TY2]]>>) -> !fir.ref<i32>
!CHECK: %[[MAP_REGULAR_NESTED_MEMBER:.*]] = omp.map.info
var_ptr(%[[REGULAR_NESTED_MEMBER_COORD]] : !fir.ref<i32>, i32)
map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32> {{.*}}
!CHECK: %[[DTYPE_BASE_ADDR:.*]] = fir.box_offset %[[DECLARE]]#1 base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>}>>>
!CHECK: %[[MAP_DTYPE_BASE_ADDR:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>,
!fir.type<[[REC_TY]]>}>) map_clauses(tofrom) capture(ByRef)
var_ptr_ptr(%[[DTYPE_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>}>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>}>>> {{.*}}
-!CHECK: %[[MAP_DTYPE:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>,
!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>) map_clauses(to) capture(ByRef)
members(%[[MAP_DTYPE_BASE_ADDR]], %[[MAP_NESTED_MEMBER_COORD]],
%[[MAP_NESTED_MEMBER_BASE_ADDR]], %[[MAP_REGULAR_NESTED_MEMBER]] : [0], [0, 6,
2], [0, 6, 2, 0], [0, 6, 3] : !fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>}>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) ->
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>> {{.*}}
+!CHECK: %[[MAP_DTYPE:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>,
!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>) map_clauses(always, to)
capture(ByRef) members(%[[MAP_DTYPE_BASE_ADDR]], %[[MAP_NESTED_MEMBER_COORD]],
%[[MAP_NESTED_MEMBER_BASE_ADDR]], %[[MAP_REGULAR_NESTED_MEMBER]] : [0], [0, 6,
2], [0, 6, 2, 0], [0, 6, 3] : !fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>}>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) ->
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>> {{.*}}
!CHECK: omp.target map_entries(%[[MAP_DTYPE]] -> %[[ARG0:.*]],
%[[MAP_DTYPE_BASE_ADDR]] -> %[[ARG1:.*]], %[[MAP_NESTED_MEMBER_COORD]] ->
%[[ARG2:.*]], %[[MAP_NESTED_MEMBER_BASE_ADDR]] -> %[[ARG3:.*]],
%[[MAP_REGULAR_NESTED_MEMBER]] -> %[[ARG4:.*]] :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>,
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>}>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) {
!CHECK: %{{.*}}:2 = hlfir.declare %[[ARG0]] {{.*}} :
(!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>) ->
(!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>,
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>}>>>>)
subroutine alloca_nest_dype_map_op_block_add()
@@ -120,7 +120,7 @@ subroutine alloca_nest_dype_map_op_block_add()
!CHECK: %[[NESTED_MEMBER_COORD:.*]] = fir.coordinate_of
%[[NESTED_DTYPE_COORD]], array_k : (!fir.ref<!fir.type<[[REC_TY2]]>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
!CHECK: %[[NESTED_MEMBER_BASE_ADDR:.*]] = fir.box_offset
%[[NESTED_MEMBER_COORD]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!CHECK: %[[MAP_NESTED_MEMBER_BASE_ADDR:.*]] = omp.map.info
var_ptr(%[[NESTED_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[NESTED_MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-!CHECK: %[[MAP_NESTED_MEMBER_DESC:.*]] = omp.map.info
var_ptr(%[[NESTED_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
+!CHECK: %[[MAP_NESTED_MEMBER_DESC:.*]] = omp.map.info
var_ptr(%[[NESTED_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
!CHECK: %[[MAP_PARENT:.*]] = omp.map.info var_ptr(%[[DECLARE]]#1 :
!fir.ref<!fir.type<[[REC_TY]]>>, !fir.type<[[REC_TY]]>) map_clauses(tofrom)
capture(ByRef) members(%[[MAP_NESTED_MEMBER_DESC]],
%[[MAP_NESTED_MEMBER_BASE_ADDR]] : [6, 2], [6, 2, 0] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.type<[[REC_TY]]>>
{{.*}}
!CHECK: omp.target map_entries(%[[MAP_PARENT]] -> %[[ARG0:.*]],
%[[MAP_NESTED_MEMBER_DESC]] -> %[[ARG1:.*]], %[[MAP_NESTED_MEMBER_BASE_ADDR]]
-> %[[ARG2:.*]] : !fir.ref<!fir.type<[[REC_TY]]>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) {
!CHECK: %{{.*}}:2 = hlfir.declare %[[ARG0]] {{.*}} :
(!fir.ref<!fir.type<[[REC_TY]]>>) -> (!fir.ref<!fir.type<[[REC_TY]]>>,
!fir.ref<!fir.type<[[REC_TY]]>>)
diff --git a/flang/test/Lower/OpenMP/optional-argument-map-3.f90
b/flang/test/Lower/OpenMP/optional-argument-map-3.f90
index 7e2a24e31123e..4dab002ca175a 100644
--- a/flang/test/Lower/OpenMP/optional-argument-map-3.f90
+++ b/flang/test/Lower/OpenMP/optional-argument-map-3.f90
@@ -33,7 +33,7 @@ end subroutine foo
! CHECK: }
! CHECK: %[[VAL_3:.*]] = fir.box_offset %[[VAL_0]] base_addr :
(!fir.ref<!fir.box<!fir.array<?xf32>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>>
! CHECK: %[[VAL_4:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.array<?xf32>>>, f32) map_clauses(implicit, tofrom)
capture(ByRef) var_ptr_ptr(%[[VAL_3]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>>) bounds(%{{.*}}) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>> {name = ""}
-! CHECK: %[[VAL_5:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.array<?xf32>>>, !fir.box<!fir.array<?xf32>>)
map_clauses(implicit, to) capture(ByRef) members(%[[VAL_4]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>>) -> !fir.ref<!fir.array<?xf32>>
{name = "dt"}
+! CHECK: %[[VAL_5:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.array<?xf32>>>, !fir.box<!fir.array<?xf32>>)
map_clauses(always, implicit, to) capture(ByRef) members(%[[VAL_4]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>>) -> !fir.ref<!fir.array<?xf32>>
{name = "dt"}
! CHECK: omp.target host_eval({{.*}}) map_entries({{.*}}%[[VAL_5]]
-> {{.*}}, %[[VAL_4]] -> {{.*}} : {{.*}}) {
! CHECK: } else {
! CHECK: %[[VAL_6:.*]] = fir.is_present %[[VAL_1]]#1 :
(!fir.box<!fir.array<?xf32>>) -> i1
@@ -42,5 +42,5 @@ end subroutine foo
! CHECK: }
! CHECK: %[[VAL_7:.*]] = fir.box_offset %[[VAL_0]] base_addr :
(!fir.ref<!fir.box<!fir.array<?xf32>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>>
! CHECK: %[[VAL_8:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.array<?xf32>>>, f32) map_clauses(implicit, tofrom)
capture(ByRef) var_ptr_ptr(%[[VAL_7]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>>) bounds(%{{.*}}) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>> {name = ""}
-! CHECK: %[[VAL_9:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.array<?xf32>>>, !fir.box<!fir.array<?xf32>>)
map_clauses(implicit, to) capture(ByRef) members(%[[VAL_8]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>>) -> !fir.ref<!fir.array<?xf32>>
{name = "dt"}
+! CHECK: %[[VAL_9:.*]] = omp.map.info var_ptr(%[[VAL_0]] :
!fir.ref<!fir.box<!fir.array<?xf32>>>, !fir.box<!fir.array<?xf32>>)
map_clauses(always, implicit, to) capture(ByRef) members(%[[VAL_8]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xf32>>>) -> !fir.ref<!fir.array<?xf32>>
{name = "dt"}
! CHECK: omp.target host_eval({{.*}}) map_entries({{.*}},
%[[VAL_9]] ->{{.*}}, %[[VAL_8]] -> {{.*}} : {{.*}}) {
diff --git a/flang/test/Lower/OpenMP/target-enter-data-default-openmp52.f90
b/flang/test/Lower/OpenMP/target-enter-data-default-openmp52.f90
index 0d4fd964b71ec..5f7c31bb931f6 100644
--- a/flang/test/Lower/OpenMP/target-enter-data-default-openmp52.f90
+++ b/flang/test/Lower/OpenMP/target-enter-data-default-openmp52.f90
@@ -11,7 +11,7 @@ subroutine initialize()
allocate(A)
!$omp target enter data map(A)
!CHECK-52: omp.map.info var_ptr(%2 : !fir.ref<!fir.box<!fir.heap<f32>>>,
f32) map_clauses(to) capture(ByRef) var_ptr_ptr(%5 :
!fir.llvm_ptr<!fir.ref<f32>>) -> !fir.llvm_ptr<!fir.ref<f32>> {name = ""}
- !CHECK-52: omp.map.info var_ptr(%2 : !fir.ref<!fir.box<!fir.heap<f32>>>,
!fir.box<!fir.heap<f32>>) map_clauses(to) capture(ByRef) members(%6 : [0] :
!fir.llvm_ptr<!fir.ref<f32>>) -> !fir.ref<!fir.box<!fir.heap<f32>>> {name = "a"}
+ !CHECK-52: omp.map.info var_ptr(%2 : !fir.ref<!fir.box<!fir.heap<f32>>>,
!fir.box<!fir.heap<f32>>) map_clauses(always, to) capture(ByRef) members(%6 :
[0] : !fir.llvm_ptr<!fir.ref<f32>>) -> !fir.ref<!fir.box<!fir.heap<f32>>> {name
= "a"}
!CHECK-51: to and alloc map types are permitted
end subroutine initialize
diff --git a/flang/test/Lower/OpenMP/target.f90
b/flang/test/Lower/OpenMP/target.f90
index 1aef64a3b83a8..2c1bfd9bf97ec 100644
--- a/flang/test/Lower/OpenMP/target.f90
+++ b/flang/test/Lower/OpenMP/target.f90
@@ -549,9 +549,9 @@ subroutine omp_target_device_addr
!CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<i32>> {bindc_name =
"a", uniq_name = "_QFomp_target_device_addrEa"}
!CHECK: %[[VAL_0_DECL:.*]]:2 = hlfir.declare %[[VAL_0]] {fortran_attrs =
#fir.var_attrs<pointer>, uniq_name = "_QFomp_target_device_addrEa"} :
(!fir.ref<!fir.box<!fir.ptr<i32>>>) -> (!fir.ref<!fir.box<!fir.ptr<i32>>>,
!fir.ref<!fir.box<!fir.ptr<i32>>>)
!CHECK: %[[MAP_MEMBERS:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, i32) map_clauses(tofrom) capture(ByRef)
var_ptr_ptr({{.*}} : !fir.llvm_ptr<!fir.ref<i32>>) ->
!fir.llvm_ptr<!fir.ref<i32>> {name = ""}
- !CHECK: %[[MAP:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>) map_clauses(to)
capture(ByRef) members(%[[MAP_MEMBERS]] : [0] : !fir.llvm_ptr<!fir.ref<i32>>)
-> !fir.ref<!fir.box<!fir.ptr<i32>>> {name = "a"}
+ !CHECK: %[[MAP:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>) map_clauses(always,
to) capture(ByRef) members(%[[MAP_MEMBERS]] : [0] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.ptr<i32>>> {name = "a"}
!CHECK: %[[DEV_ADDR_MEMBERS:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, i32) map_clauses(return_param)
capture(ByRef) var_ptr_ptr({{.*}} : !fir.llvm_ptr<!fir.ref<i32>>) ->
!fir.llvm_ptr<!fir.ref<i32>> {name = ""}
- !CHECK: %[[DEV_ADDR:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>) map_clauses(to)
capture(ByRef) members(%[[DEV_ADDR_MEMBERS]] : [0] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.ptr<i32>>> {name = "a"}
+ !CHECK: %[[DEV_ADDR:.*]] = omp.map.info var_ptr({{.*}} :
!fir.ref<!fir.box<!fir.ptr<i32>>>, !fir.box<!fir.ptr<i32>>) map_clauses(always,
to) capture(ByRef) members(%[[DEV_ADDR_MEMBERS]] : [0] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.ptr<i32>>> {name = "a"}
!CHECK: omp.target_data map_entries(%[[MAP]], %[[MAP_MEMBERS]] : {{.*}})
use_device_addr(%[[DEV_ADDR]] -> %[[ARG_0:.*]], %[[DEV_ADDR_MEMBERS]] ->
%[[ARG_1:.*]] : !fir.ref<!fir.box<!fir.ptr<i32>>>,
!fir.llvm_ptr<!fir.ref<i32>>) {
!$omp target data map(tofrom: a) use_device_addr(a)
!CHECK: %[[VAL_1_DECL:.*]]:2 = hlfir.declare %[[ARG_0]] {fortran_attrs =
#fir.var_attrs<pointer>, uniq_name = "_QFomp_target_device_addrEa"} :
(!fir.ref<!fir.box<!fir.ptr<i32>>>) -> (!fir.ref<!fir.box<!fir.ptr<i32>>>,
!fir.ref<!fir.box<!fir.ptr<i32>>>)
diff --git a/flang/test/Lower/volatile-openmp.f90
b/flang/test/Lower/volatile-openmp.f90
index d1a844eddd106..fb6cee40c71db 100644
--- a/flang/test/Lower/volatile-openmp.f90
+++ b/flang/test/Lower/volatile-openmp.f90
@@ -36,7 +36,7 @@
! CHECK: %[[VAL_24:.*]] = fir.coordinate_of %[[VAL_13]]#0, array :
(!fir.ref<!fir.type<_QFTt{array:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>,
volatile>) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
! CHECK: %[[VAL_25:.*]] = fir.box_offset %[[VAL_24]] base_addr :
(!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
! CHECK: %[[VAL_26:.*]] = omp.map.info var_ptr(%[[VAL_24]] :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, i32) map_clauses(to)
capture(ByRef) var_ptr_ptr(%[[VAL_25]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[VAL_23]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-! CHECK: %[[VAL_27:.*]] = omp.map.info var_ptr(%[[VAL_24]] :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>,
!fir.box<!fir.ptr<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> {name =
"container%[[VAL_28:.*]]"}
+! CHECK: %[[VAL_27:.*]] = omp.map.info var_ptr(%[[VAL_24]] :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>,
!fir.box<!fir.ptr<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> {name =
"container%[[VAL_28:.*]]"}
! CHECK: %[[VAL_29:.*]] = omp.map.info var_ptr(%[[VAL_13]]#1 :
!fir.ref<!fir.type<_QFTt{array:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>,
volatile>, !fir.type<_QFTt{array:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>)
map_clauses(to) capture(ByRef) members(%[[VAL_27]], %[[VAL_26]] : [0], [0, 0] :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.type<_QFTt{array:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>,
volatile> {name = "container", partial_map = true}
! CHECK: omp.target_enter_data map_entries(%[[VAL_29]], %[[VAL_27]],
%[[VAL_26]] :
!fir.ref<!fir.type<_QFTt{array:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>,
volatile>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>)
! CHECK: %[[VAL_30:.*]] = fir.load %[[VAL_10]]#0 :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>, volatile>
@@ -47,7 +47,7 @@
! CHECK: %[[VAL_35:.*]] = omp.map.bounds lower_bound(%[[VAL_0]] :
index) upper_bound(%[[VAL_34]] : index) extent(%[[VAL_33]]#1 : index)
stride(%[[VAL_33]]#2 : index) start_idx(%[[VAL_32]]#0 : index) {stride_in_bytes
= true}
! CHECK: %[[VAL_36:.*]] = fir.box_offset %[[VAL_10]]#1 base_addr :
(!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>, volatile>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
! CHECK: %[[VAL_37:.*]] = omp.map.info var_ptr(%[[VAL_10]]#1 :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>, volatile>, i32)
map_clauses(to) capture(ByRef) var_ptr_ptr(%[[VAL_36]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[VAL_35]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-! CHECK: %[[VAL_38:.*]] = omp.map.info var_ptr(%[[VAL_10]]#1 :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>, volatile>,
!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>) map_clauses(to) capture(ByRef)
members(%[[VAL_37]] : [0] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>, volatile> {name =
"array1"}
+! CHECK: %[[VAL_38:.*]] = omp.map.info var_ptr(%[[VAL_10]]#1 :
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>, volatile>,
!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>) map_clauses(always, to)
capture(ByRef) members(%[[VAL_37]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) ->
!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>, volatile> {name =
"array1"}
! CHECK: omp.target_enter_data map_entries(%[[VAL_38]], %[[VAL_37]]
: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>, volatile>, volatile>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>)
! CHECK: return
! CHECK: }
diff --git a/flang/test/Transforms/omp-map-info-finalization.fir
b/flang/test/Transforms/omp-map-info-finalization.fir
index ed814cdcfc728..01402a51dd089 100644
--- a/flang/test/Transforms/omp-map-info-finalization.fir
+++ b/flang/test/Transforms/omp-map-info-finalization.fir
@@ -32,11 +32,11 @@ func.func @test_descriptor_expansion_pass(%arg0:
!fir.box<!fir.array<?xi32>>) {
// CHECK: %[[BOUNDS:.*]] = omp.map.bounds lower_bound(%{{.*}} : index)
upper_bound(%{{.*}} : index) extent(%{{.*}} : index) stride(%{{.*}} : index)
start_idx(%{{.*}} : index) {stride_in_bytes = true}
// CHECK: %[[BASE_ADDR_OFF:.*]] = fir.box_offset %[[DECLARE2]]#1 base_addr :
(!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.llvm_ptr<!fir.ref<i32>>
// CHECK: %[[DESC_MEMBER_MAP:.*]] = omp.map.info var_ptr(%[[DECLARE2]]#1 :
!fir.ref<!fir.box<!fir.heap<i32>>>, i32) map_clauses(tofrom) capture(ByRef)
var_ptr_ptr(%[[BASE_ADDR_OFF]] : !fir.llvm_ptr<!fir.ref<i32>>) ->
!fir.llvm_ptr<!fir.ref<i32>> {name = ""}
-// CHECK: %[[DESC_PARENT_MAP:.*]] = omp.map.info var_ptr(%[[DECLARE2]]#1 :
!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.heap<i32>>) map_clauses(to)
capture(ByRef) members(%[[DESC_MEMBER_MAP]] : [0] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
+// CHECK: %[[DESC_PARENT_MAP:.*]] = omp.map.info var_ptr(%[[DECLARE2]]#1 :
!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.heap<i32>>)
map_clauses(always, to) capture(ByRef) members(%[[DESC_MEMBER_MAP]] : [0] :
!fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
// CHECK: fir.store %[[DECLARE1]]#1 to %[[ALLOCA]] :
!fir.ref<!fir.box<!fir.array<?xi32>>>
// CHECK: %[[BASE_ADDR_OFF_2:.*]] = fir.box_offset %[[ALLOCA]] base_addr :
(!fir.ref<!fir.box<!fir.array<?xi32>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
// CHECK: %[[DESC_MEMBER_MAP_2:.*]] = omp.map.info var_ptr(%[[ALLOCA]] :
!fir.ref<!fir.box<!fir.array<?xi32>>>, i32) map_clauses(from) capture(ByRef)
var_ptr_ptr(%[[BASE_ADDR_OFF_2]] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>)
bounds(%[[BOUNDS]]) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {name = ""}
-// CHECK: %[[DESC_PARENT_MAP_2:.*]] = omp.map.info var_ptr(%[[ALLOCA]] :
!fir.ref<!fir.box<!fir.array<?xi32>>>, !fir.box<!fir.array<?xi32>>)
map_clauses(to) capture(ByRef) members(%[[DESC_MEMBER_MAP_2]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK: %[[DESC_PARENT_MAP_2:.*]] = omp.map.info var_ptr(%[[ALLOCA]] :
!fir.ref<!fir.box<!fir.array<?xi32>>>, !fir.box<!fir.array<?xi32>>)
map_clauses(always, to) capture(ByRef) members(%[[DESC_MEMBER_MAP_2]] : [0] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.array<?xi32>>
// CHECK: omp.target map_entries(%[[DESC_PARENT_MAP]] -> %[[ARG1:.*]],
%[[DESC_PARENT_MAP_2]] -> %[[ARG2:.*]], %[[DESC_MEMBER_MAP]] -> %[[ARG3:.*]],
%[[DESC_MEMBER_MAP_2]] -> %[[ARG4:.*]] : {{.*}}) {
// -----
@@ -112,7 +112,7 @@ func.func @dtype_alloca_op_block_add(%arg0:
!fir.ref<!fir.type<_QFtest_derived_t
// CHECK: %[[MEMBER_COORD:.*]] = fir.coordinate_of %[[ALLOCA]]#0, array_j :
(!fir.ref<[[REC_TY]]>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
// CHECK: %[[MEMBER_BASE_ADDR:.*]] = fir.box_offset %[[MEMBER_COORD:.*]]
base_addr : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
// CHECK: %[[MAP_MEMBER_BASE_ADDR:.*]] = omp.map.info
var_ptr(%[[MEMBER_COORD]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
i32) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-// CHECK: %[[MAP_MEMBER_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[MEMBER_COORD]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "one_l%array_j"}
+// CHECK: %[[MAP_MEMBER_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[MEMBER_COORD]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "one_l%array_j"}
// CHECK: %[[MAP_MEMBER_PARENT:.*]] = omp.map.info var_ptr(%[[ALLOCA]]#0 :
!fir.ref<[[REC_TY]]>>, [[REC_TY]]>) map_clauses(tofrom) capture(ByRef)
members(%10, %9 : [4], [4, 0] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<[[REC_TY]]>> {{.*}}
// CHECK: omp.target map_entries(%[[MAP_MEMBER_PARENT]] -> %[[ARG1:.*]],
%[[MAP_MEMBER_DESCRIPTOR]] -> %[[ARG2:.*]], %[[MAP_MEMBER_BASE_ADDR]] ->
%[[ARG3:.*]] : !fir.ref<[[REC_TY]]>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) {
@@ -152,13 +152,13 @@ func.func @alloca_dtype_map_op_block_add(%arg0 :
!fir.ref<!fir.box<!fir.heap<!fi
// CHECK: %[[ALLOCATABLE_MEMBER_COORD:.*]] = fir.coordinate_of
%[[LOAD_ALLOCA]], array_j : (!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
// CHECK: %[[ALLOCATABLE_MEMBER_BASE_ADDR:.*]] = fir.box_offset
%[[ALLOCATABLE_MEMBER_COORD]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
// CHECK: %[[MAP_ALLOCA_MEMBER_BASE_ADDR:.*]] = omp.map.info
var_ptr(%[[ALLOCATABLE_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[ALLOCATABLE_MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-// CHECK: %[[MAP_ALLOCA_MEMBER_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[ALLOCATABLE_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
+// CHECK: %[[MAP_ALLOCA_MEMBER_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[ALLOCATABLE_MEMBER_COORD]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
// CHECK: %[[LOAD_ALLOCA2:.*]] = fir.load %[[ALLOCA]]#0 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>
// CHECK: %[[REGULAR_MEMBER_COORD:.*]] = fir.coordinate_of
%[[LOAD_ALLOCA2]], k : (!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) ->
!fir.ref<i32>
// CHECK: %[[MAP_REGULAR_MEMBER:.*]] = omp.map.info
var_ptr(%[[REGULAR_MEMBER_COORD]] : !fir.ref<i32>, i32) map_clauses(tofrom)
capture(ByRef) -> !fir.ref<i32> {{.*}}
// CHECK: %[[ALLOCATABLE_PARENT_BASE_ADDR:.*]] = fir.box_offset
%[[ALLOCA]]#1 base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>
// CHECK: %[[MAP_ALLOCA_PARENT_BASE_ADDR:.*]] = omp.map.info
var_ptr(%[[ALLOCA]]#1 : !fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.type<[[REC_TY]]>) map_clauses(tofrom) capture(ByRef)
var_ptr_ptr(%[[ALLOCATABLE_PARENT_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>> {{.*}}
-// CHECK: %[[MAP_PARENT_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[ALLOCA]]#1 : !fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) map_clauses(to) capture(ByRef)
members(%18, %13, %12, %16 : [0], [0, 4], [0, 4, 0], [0, 5] :
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) ->
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>> {{.*}}
+// CHECK: %[[MAP_PARENT_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[ALLOCA]]#1 : !fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) map_clauses(always, to)
capture(ByRef) members(%18, %13, %12, %16 : [0], [0, 4], [0, 4, 0], [0, 5] :
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) ->
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>> {{.*}}
// CHECK: omp.target map_entries(%[[MAP_PARENT_DESCRIPTOR]] ->
%[[ARG1:.*]], %[[MAP_ALLOCA_PARENT_BASE_ADDR]] -> %[[ARG2:.*]],
%[[MAP_ALLOCA_MEMBER_DESCRIPTOR]] -> %[[ARG3:.*]],
%[[MAP_ALLOCA_MEMBER_BASE_ADDR]] -> %[[ARG4:.*]], %[[MAP_REGULAR_MEMBER]] ->
%[[ARG5:.*]] : !fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) {
// -----
@@ -202,14 +202,14 @@ func.func @alloca_dtype_map_op_block_add(%arg0 :
!fir.ref<!fir.box<!fir.heap<!fi
// CHECK: %[[NESTED_ALLOCA_MEMBER:.*]] = fir.coordinate_of
%[[INTERMEDIATE_DTYPE_NESTED_MEMBER]], array_k :
(!fir.ref<!fir.type<[[REC_TY2]]>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
// CHECK: %[[NESTED_ALLOCA_MEMBER_BASE_ADDR:.*]] = fir.box_offset
%[[NESTED_ALLOCA_MEMBER]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
// CHECK: %[[MAP_NESTED_ALLOCA_MEMBER_BASE_ADDR:.*]] = omp.map.info
var_ptr(%[[NESTED_ALLOCA_MEMBER]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[NESTED_ALLOCA_MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-// CHECK: %[[MAP_NESTED_ALLOCA_MEMBER:.*]] = omp.map.info
var_ptr(%[[NESTED_ALLOCA_MEMBER]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
+// CHECK: %[[MAP_NESTED_ALLOCA_MEMBER:.*]] = omp.map.info
var_ptr(%[[NESTED_ALLOCA_MEMBER]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
// CHECK: %[[ALLOCA_LOAD2:.*]] = fir.load %[[ALLOCA]]#0 :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>
// CHECK: %[[INTERMEDIATE_DTYPE_NESTED_MEMBER2:.*]] = fir.coordinate_of
%[[ALLOCA_LOAD2]], nest : (!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) ->
!fir.ref<!fir.type<[[REC_TY2]]>>
// CHECK: %[[NESTED_REGULAR_MEMBER:.*]] = fir.coordinate_of
%[[INTERMEDIATE_DTYPE_NESTED_MEMBER2]], k : (!fir.ref<!fir.type<[[REC_TY2]]>>)
-> !fir.ref<i32>
// CHECK: %[[MAP_NESTED_REGULAR_MEMBER:.*]] = omp.map.info
var_ptr(%[[NESTED_REGULAR_MEMBER:.*]] : !fir.ref<i32>, i32) map_clauses(tofrom)
capture(ByRef) -> !fir.ref<i32> {{.*}}
// CHECK: %[[ALLOCATABLE_PARENT_BASE_ADDR:.*]] = fir.box_offset
%[[ALLOCA]]#1 base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>
// CHECK: %[[MAP_ALLOCATABLE_PARENT_BASE_ADDR:.*]] = omp.map.info
var_ptr(%[[ALLOCA]]#1 : !fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.type<[[REC_TY]]>) map_clauses(tofrom) capture(ByRef)
var_ptr_ptr(%[[ALLOCATABLE_PARENT_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>> {{.*}}
-// CHECK: %[[MAP_ALLOCATABLE_PARENT_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[ALLOCA]]#1 : !fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) map_clauses(to) capture(ByRef)
members(%21, %15, %14, %19 : [0], [0, 6, 2], [0, 6, 2, 0], [0, 6, 3] :
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) ->
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>> {{.*}}
+// CHECK: %[[MAP_ALLOCATABLE_PARENT_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[ALLOCA]]#1 : !fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>) map_clauses(always, to)
capture(ByRef) members(%21, %15, %14, %19 : [0], [0, 6, 2], [0, 6, 2, 0], [0,
6, 3] : !fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) ->
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>> {{.*}}
// CHECK: omp.target map_entries(%[[MAP_ALLOCATABLE_PARENT_DESCRIPTOR]] ->
%[[ARG1:.*]], %[[MAP_ALLOCATABLE_PARENT_BASE_ADDR]] -> %[[ARG2:.*]],
%[[MAP_NESTED_ALLOCA_MEMBER]] -> %[[ARG3:.*]],
%[[MAP_NESTED_ALLOCA_MEMBER_BASE_ADDR]] -> %[[ARG4:.*]],
%[[MAP_NESTED_REGULAR_MEMBER]] -> %[[ARG5:.*]] :
!fir.ref<!fir.box<!fir.heap<!fir.type<[[REC_TY]]>>>>,
!fir.llvm_ptr<!fir.ref<!fir.type<[[REC_TY]]>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) {
// -----
@@ -245,7 +245,7 @@ func.func @alloca_dtype_map_op_block_add(%arg0 :
!fir.ref<!fir.box<!fir.heap<!fi
// CHECK: %[[ALLOCATABLE_MEMBER:.*]] = fir.coordinate_of
%[[NESTED_DTYPE_COORD]], array_k : (!fir.ref<!fir.type<[[REC_TY2]]>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
// CHECK: %[[ALLOCATABLE_MEMBER_BASE_ADDR:.*]] = fir.box_offset
%[[ALLOCATABLE_MEMBER]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
// CHECK: %[[MAP_ALLOCATABLE_MEMBER_BASE_ADDR:.*]] = omp.map.info
var_ptr(%[[ALLOCATABLE_MEMBER]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[ALLOCATABLE_MEMBER_BASE_ADDR]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%[[BOUNDS]]) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-// CHECK: %[[MAP_ALLOCATABLE_MEMBER_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[ALLOCATABLE_MEMBER]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
+// CHECK: %[[MAP_ALLOCATABLE_MEMBER_DESCRIPTOR:.*]] = omp.map.info
var_ptr(%[[ALLOCATABLE_MEMBER]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
// CHECK: %[[MAP_PARENT:.*]] = omp.map.info var_ptr(%[[ALLOCA]]#0 :
!fir.ref<!fir.type<[[REC_TY]]>>, !fir.type<[[REC_TY]]>) map_clauses(tofrom)
capture(ByRef) members(%12, %11 : [6, 2], [6, 2, 0] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.type<[[REC_TY]]>>
{{.*}}
// CHECK: omp.target map_entries(%[[MAP_PARENT]] -> %[[ARG1:.*]],
%[[MAP_ALLOCATABLE_MEMBER_DESCRIPTOR]] -> %[[ARG2:.*]],
%[[MAP_ALLOCATABLE_MEMBER_BASE_ADDR]] -> %[[ARG3:.*]] :
!fir.ref<!fir.type<[[REC_TY]]>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) {
@@ -278,13 +278,13 @@ func.func @alloca_dtype_map_op_block_add(%arg0 :
!fir.ref<!fir.box<!fir.heap<!fi
// CHECK: %[[DESC_1:.*]] = fir.coordinate_of %[[DECLARE]]#0, vertexes :
(!fir.ref<!fir.type<[[REC_TY]]>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2:_QFmaptype_nested_derived_type_member_idxTvertexes{test:i32,vertexx:!fir.box<!fir.heap<!fir.array<\?xi32>>>,vertexy:!fir.box<!fir.heap<!fir.array<\?xi32>>>}]]>>>>>
// CHECK: %[[BASE_ADDR_1:.*]] = fir.box_offset %[[DESC_1]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?x!fir.type<[[REC_TY2]]>>>>
// CHECK: %[[BASE_ADDR_MAP_1:.*]] = omp.map.info var_ptr(%[[DESC_1]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>>,
!fir.type<[[REC_TY2]]>) map_clauses(exit_release_or_enter_alloc) capture(ByRef)
var_ptr_ptr(%[[BASE_ADDR_1]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?x!fir.type<[[REC_TY2]]>>>>) bounds(%{{.*}})
-> !fir.llvm_ptr<!fir.ref<!fir.array<?x!fir.type<[[REC_TY2]]>>>> {{.*}}
-// CHECK: %[[DESC_MAP_1:.*]] = omp.map.info var_ptr(%[[DESC_1]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>>,
!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>) map_clauses(to)
capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>> {{.*}}
+// CHECK: %[[DESC_MAP_1:.*]] = omp.map.info var_ptr(%[[DESC_1]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>>,
!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>) map_clauses(always,
to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>> {{.*}}
// CHECK: %[[DESC_LD_1:.*]] = fir.load %[[DESC_1]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>>
// CHECK: %[[MEMBER_ACCESS_1:.*]] = fir.coordinate_of %[[DESC_LD_1]],
%{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>, index) ->
!fir.ref<!fir.type<[[REC_TY2]]>>
// CHECK: %[[DESC_2:.*]] = fir.coordinate_of %[[MEMBER_ACCESS_1]], vertexy
: (!fir.ref<!fir.type<[[REC_TY2]]>>) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
// CHECK: %[[BASE_ADDR_2:.*]] = fir.box_offset %[[DESC_2]] base_addr :
(!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
// CHECK: %[[BASE_ADDR_MAP_2:.*]] = omp.map.info var_ptr(%[[DESC_2]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, i32) map_clauses(tofrom)
capture(ByRef) var_ptr_ptr(%[[BASE_ADDR_2]] :
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%{{.*}}) ->
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>> {{.*}}
-// CHECK: %[[DESC_MAP_2:.*]] = omp.map.info var_ptr(%[[DESC_2]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(to) capture(ByRef) ->
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
+// CHECK: %[[DESC_MAP_2:.*]] = omp.map.info var_ptr(%[[DESC_2]] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to) capture(ByRef)
-> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {{.*}}
// CHECK: %[[TOP_PARENT_MAP:.*]] = omp.map.info var_ptr(%0#1 :
!fir.ref<!fir.type<[[REC_TY]]>>, !fir.type<[[REC_TY]]>)
map_clauses(exit_release_or_enter_alloc) capture(ByRef) members(%6, %5, %14,
%13 : [1], [1, 0], [1, 0, 2], [1, 0, 2, 0] :
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?x!fir.type<[[REC_TY2]]>>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.type<[[REC_TY]]>>
{{{.*}} partial_map = true}
// CHECK: omp.target map_entries(%[[TOP_PARENT_MAP]] -> %{{.*}},
%[[DESC_MAP_1]] -> %{{.*}}, %[[BASE_ADDR_MAP_1]] -> %{{.*}}, %[[DESC_MAP_2]] ->
%{{.*}}, %[[BASE_ADDR_MAP_2]] -> %{{.*}} : !fir.ref<!fir.type<[[REC_TY]]>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.type<[[REC_TY2]]>>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?x!fir.type<[[REC_TY2]]>>>>,
!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>,
!fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) {
diff --git a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
index 28d5fb389233b..c95446235a02a 100644
--- a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
+++ b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
@@ -7561,12 +7561,8 @@ static Expected<Function *> createOutlinedFunction(
// preceding mapped arguments that refer to the same global that may be
// seperate segments. To prevent this, we defer global processing until all
// other processing has been performed.
-<<<<<<< HEAD
if (llvm::isa<llvm::GlobalValue, llvm::GlobalObject, llvm::GlobalVariable>(
removeASCastIfPresent(Input))) {
-=======
- if (llvm::isa<llvm::GlobalValue, llvm::GlobalObject,
llvm::GlobalVariable>(removeASCastIfPresent(Input))) {
->>>>>>> 1d1536f712a6 ([Flang][OpenMP] Additional global address space
modifications for device)
DeferredReplacement.push_back(std::make_pair(Input, InputCopy));
continue;
}
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPEnums.td
b/mlir/include/mlir/Dialect/OpenMP/OpenMPEnums.td
index c080c3fac87d4..e3c2e680c2c22 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPEnums.td
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPEnums.td
@@ -40,13 +40,15 @@ class OpenMP_EnumAttr<EnumAttrInfo enumInfo, string name>
// capture_clause enum.
//===----------------------------------------------------------------------===//
-def CaptureClauseTo : I32EnumAttrCase<"to", 0>;
-def CaptureClauseLink : I32EnumAttrCase<"link", 1>;
-def CaptureClauseEnter : I32EnumAttrCase<"enter", 2>;
+def CaptureClauseNone : I32EnumAttrCase<"none", 0>;
+def CaptureClauseTo : I32EnumAttrCase<"to", 1>;
+def CaptureClauseLink : I32EnumAttrCase<"link", 2>;
+def CaptureClauseEnter : I32EnumAttrCase<"enter", 3>;
def DeclareTargetCaptureClause : OpenMP_I32EnumAttr<
"DeclareTargetCaptureClause",
"capture clause", [
+ CaptureClauseNone,
CaptureClauseTo,
CaptureClauseLink,
CaptureClauseEnter
diff --git
a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
index 86b428fd4cf43..9aa23aa4a196d 100644
--- a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
@@ -3542,10 +3542,23 @@ convertToCaptureClauseKind(
return llvm::OffloadEntriesInfoManager::OMPTargetGlobalVarEntryLink;
case mlir::omp::DeclareTargetCaptureClause::enter:
return llvm::OffloadEntriesInfoManager::OMPTargetGlobalVarEntryEnter;
+ case mlir::omp::DeclareTargetCaptureClause::none:
+ return llvm::OffloadEntriesInfoManager::OMPTargetGlobalVarEntryNone;
}
llvm_unreachable("unhandled capture clause");
}
+static Operation *getGlobalOpFromValue(Value value) {
+ Operation *op = value.getDefiningOp();
+ if (auto addrCast = dyn_cast_if_present<LLVM::AddrSpaceCastOp>(op))
+ op = addrCast->getOperand(0).getDefiningOp();
+ if (auto addressOfOp = dyn_cast_if_present<LLVM::AddressOfOp>(op)) {
+ auto modOp = addressOfOp->getParentOfType<mlir::ModuleOp>();
+ return modOp.lookupSymbol(addressOfOp.getGlobalName());
+ }
+ return nullptr;
+}
+
static llvm::SmallString<64>
getDeclareTargetRefPtrSuffix(LLVM::GlobalOp globalOp,
llvm::OpenMPIRBuilder &ompBuilder) {
@@ -3566,62 +3579,59 @@ getDeclareTargetRefPtrSuffix(LLVM::GlobalOp globalOp,
return suffix;
}
-static bool isDeclareTargetLink(mlir::Value value) {
- if (auto addressOfOp = value.getDefiningOp<LLVM::AddressOfOp>()) {
- auto modOp = addressOfOp->getParentOfType<mlir::ModuleOp>();
- Operation *gOp = modOp.lookupSymbol(addressOfOp.getGlobalName());
- if (auto declareTargetGlobal =
- llvm::dyn_cast<mlir::omp::DeclareTargetInterface>(gOp))
+static bool isDeclareTargetLink(Value value) {
+ if (Operation *gOp = getGlobalOpFromValue(value)) {
+ if (auto declareTargetGlobal = dyn_cast<omp::DeclareTargetInterface>(gOp))
+ if (declareTargetGlobal.getDeclareTargetCaptureClause() ==
+ omp::DeclareTargetCaptureClause::link)
+ return true;
+ }
+ return false;
+}
+
+static bool isDeclareTargetTo(Value value) {
+ if (Operation *gOp = getGlobalOpFromValue(value)) {
+ if (auto declareTargetGlobal = dyn_cast<omp::DeclareTargetInterface>(gOp))
{
if (declareTargetGlobal.getDeclareTargetCaptureClause() ==
- mlir::omp::DeclareTargetCaptureClause::link)
+ omp::DeclareTargetCaptureClause::to ||
+ declareTargetGlobal.getDeclareTargetCaptureClause() ==
+ omp::DeclareTargetCaptureClause::enter)
return true;
+ }
}
return false;
}
-// Returns the reference pointer generated by the lowering of the declare
target
-// operation in cases where the link clause is used or the to clause is used in
-// USM mode.
+// Returns the reference pointer generated by the lowering of the declare
+// target operation in cases where the link clause is used or the to clause is
+// used in USM mode.
static llvm::Value *
-getRefPtrIfDeclareTarget(mlir::Value value,
+getRefPtrIfDeclareTarget(Value value,
LLVM::ModuleTranslation &moduleTranslation) {
llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
- Operation *op = value.getDefiningOp();
- if (auto addrCast = llvm::dyn_cast_if_present<LLVM::AddrSpaceCastOp>(op))
- op = addrCast->getOperand(0).getDefiningOp();
-
- // An easier way to do this may just be to keep track of any pointer
- // references and their mapping to their respective operation
- if (auto addressOfOp = llvm::dyn_cast_if_present<LLVM::AddressOfOp>(op)) {
- if (auto gOp = llvm::dyn_cast_or_null<LLVM::GlobalOp>(
- addressOfOp->getParentOfType<mlir::ModuleOp>().lookupSymbol(
- addressOfOp.getGlobalName()))) {
-
- if (auto declareTargetGlobal =
- llvm::dyn_cast<mlir::omp::DeclareTargetInterface>(
- gOp.getOperation())) {
-
- // In this case, we must utilise the reference pointer generated by the
- // declare target operation, similar to Clang
- if ((declareTargetGlobal.getDeclareTargetCaptureClause() ==
- mlir::omp::DeclareTargetCaptureClause::link) ||
- (declareTargetGlobal.getDeclareTargetCaptureClause() ==
- mlir::omp::DeclareTargetCaptureClause::to &&
- ompBuilder->Config.hasRequiresUnifiedSharedMemory())) {
- llvm::SmallString<64> suffix =
- getDeclareTargetRefPtrSuffix(gOp, *ompBuilder);
-
- if (gOp.getSymName().contains(suffix))
- return moduleTranslation.getLLVMModule()->getNamedValue(
- gOp.getSymName());
+ if (auto gOp =
+ dyn_cast_or_null<LLVM::GlobalOp>(getGlobalOpFromValue(value))) {
+ if (auto declareTargetGlobal =
+ dyn_cast<omp::DeclareTargetInterface>(gOp.getOperation())) {
+ // In this case, we must utilise the reference pointer generated by
+ // the declare target operation, similar to Clang
+ if ((declareTargetGlobal.getDeclareTargetCaptureClause() ==
+ omp::DeclareTargetCaptureClause::link) ||
+ (declareTargetGlobal.getDeclareTargetCaptureClause() ==
+ omp::DeclareTargetCaptureClause::to &&
+ ompBuilder->Config.hasRequiresUnifiedSharedMemory())) {
+ llvm::SmallString<64> suffix =
+ getDeclareTargetRefPtrSuffix(gOp, *ompBuilder);
+ if (gOp.getSymName().contains(suffix))
return moduleTranslation.getLLVMModule()->getNamedValue(
- (gOp.getSymName().str() + suffix.str()).str());
- }
+ gOp.getSymName());
+
+ return moduleTranslation.getLLVMModule()->getNamedValue(
+ (gOp.getSymName().str() + suffix.str()).str());
}
}
}
-
return nullptr;
}
@@ -3664,6 +3674,30 @@ struct MapInfoData : MapInfosTy {
MapInfosTy::append(CurInfo);
}
};
+
+enum class TargetDirective : uint32_t {
+ None = 0,
+ Target = 1,
+ TargetData = 2,
+ TargetEnterData = 3,
+ TargetExitData = 4,
+ TargetUpdate = 5
+};
+
+static TargetDirective getTargetDirectiveFromOp(Operation *op) {
+ return llvm::TypeSwitch<Operation *, TargetDirective>(op)
+ .Case([](omp::TargetDataOp) { return TargetDirective::TargetData; })
+ .Case([](omp::TargetEnterDataOp) {
+ return TargetDirective::TargetEnterData;
+ })
+ .Case([&](omp::TargetExitDataOp) {
+ return TargetDirective::TargetExitData;
+ })
+ .Case([&](omp::TargetUpdateOp) { return TargetDirective::TargetUpdate; })
+ .Case([&](omp::TargetOp) { return TargetDirective::Target; })
+ .Default([&](Operation *op) { return TargetDirective::None; });
+}
+
} // namespace
uint64_t getArrayElementSizeInBits(LLVM::LLVMArrayType arrTy, DataLayout &dl) {
@@ -3692,7 +3726,7 @@ llvm::Value *getSizeInBytes(DataLayout &dl, const
mlir::Type &type,
// This calculates the size to transfer based on bounds and the underlying
// element type, provided bounds have been specified (Fortran
// pointers/allocatables/target and arrays that have sections specified
fall
- // into this as well).
+ // into this as well)
if (!memberClause.getBounds().empty()) {
llvm::Value *elementCount = builder.getInt64(1);
for (auto bounds : memberClause.getBounds()) {
@@ -3763,10 +3797,12 @@ static void collectMapDataFromMapOperands(
mapData.Pointers.push_back(mapData.OriginalValue.back());
if (llvm::Value *refPtr =
- getRefPtrIfDeclareTarget(offloadPtr,
- moduleTranslation)) { // declare target
+ getRefPtrIfDeclareTarget(offloadPtr, moduleTranslation)) {
mapData.IsDeclareTarget.push_back(true);
mapData.BasePointers.push_back(refPtr);
+ } else if (isDeclareTargetTo(offloadPtr)) {
+ mapData.IsDeclareTarget.push_back(true);
+ mapData.BasePointers.push_back(mapData.OriginalValue.back());
} else { // regular mapped variable
mapData.IsDeclareTarget.push_back(false);
mapData.BasePointers.push_back(mapData.OriginalValue.back());
@@ -3890,9 +3926,6 @@ static void collectMapDataFromMapOperands(
}
}
-// remember to remove the movebefore that might have been added in one of the
-// PRs and is now deprecated...
-
static int getMapDataMemberIdx(MapInfoData &mapData, omp::MapInfoOp memberOp) {
auto *res = llvm::find(mapData.MapClause, memberOp);
assert(res != mapData.MapClause.end() &&
@@ -3950,7 +3983,7 @@ static void sortMapIndices(llvm::SmallVectorImpl<size_t>
&indices,
static omp::MapInfoOp getFirstOrLastMappedMemberPtr(omp::MapInfoOp mapInfo,
bool first) {
- mlir::ArrayAttr indexAttr = mapInfo.getMembersIndexAttr();
+ ArrayAttr indexAttr = mapInfo.getMembersIndexAttr();
// Only 1 member has been mapped, we can return it.
if (indexAttr.size() == 1)
return cast<omp::MapInfoOp>(mapInfo.getMembers()[0].getDefiningOp());
@@ -4162,7 +4195,8 @@ mapParentWithMembers(LLVM::ModuleTranslation
&moduleTranslation,
// Map the first segment of our structure
combinedInfo.Types.emplace_back(
- isTargetParams
+ (targetDirective == TargetDirective::Target &&
+ !mapData.IsDeclareTarget[mapDataIndex])
? llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_TARGET_PARAM
: llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_NONE);
combinedInfo.DevicePointers.emplace_back(
@@ -4360,8 +4394,15 @@ static void processMapMembersWithParent(
mapFlag &= ~llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_TARGET_PARAM;
mapFlag |= llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_MEMBER_OF;
ompBuilder.setCorrectMemberOfFlag(mapFlag, memberOfFlag);
- if (checkIfPointerMap(memberClause))
+ bool isDeclTargetTo = isDeclareTargetTo(parentClause.getVarPtr()
+ ? parentClause.getVarPtr()
+ : parentClause.getVarPtrPtr());
+ if (checkIfPointerMap(memberClause) &&
+ (!isDeclTargetTo ||
+ (isDeclTargetTo && targetDirective != TargetDirective::TargetUpdate &&
+ targetDirective != TargetDirective::TargetData))) {
mapFlag |= llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_PTR_AND_OBJ;
+ }
combinedInfo.Types.emplace_back(mapFlag);
combinedInfo.DevicePointers.emplace_back(
@@ -4400,7 +4441,8 @@ static void processIndividualMap(MapInfoData &mapData,
size_t mapDataIdx,
if (isPtrTy)
mapFlag |= llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_PTR_AND_OBJ;
- if (isTargetParams && !mapData.IsDeclareTarget[mapDataIdx])
+ if (targetDirective == TargetDirective::Target &&
+ !mapData.IsDeclareTarget[mapDataIdx])
mapFlag |= llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_TARGET_PARAM;
if (mapInfoOp.getMapCaptureType() == omp::VariableCaptureKind::ByCopy &&
@@ -4453,17 +4495,18 @@ static void
processMapWithMembersOf(LLVM::ModuleTranslation &moduleTranslation,
// Clang maps array without bounds as pointers (which we do not
// currently do), whereas we treat them as arrays in all cases
// currently.
- processIndividualMap(mapData, memberDataIdx, combinedInfo, isTargetParams,
+ processIndividualMap(mapData, memberDataIdx, combinedInfo, targetDirective,
mapDataIndex);
return;
}
llvm::omp::OpenMPOffloadMappingFlags memberOfParentFlag =
mapParentWithMembers(moduleTranslation, builder, ompBuilder, dl,
- combinedInfo, mapData, mapDataIndex,
isTargetParams);
+ combinedInfo, mapData, mapDataIndex,
+ targetDirective);
processMapMembersWithParent(moduleTranslation, builder, ompBuilder, dl,
combinedInfo, mapData, mapDataIndex,
- memberOfParentFlag);
+ memberOfParentFlag, targetDirective);
}
// This is a variation on Clang's GenerateOpenMPCapturedVars, which
@@ -4544,7 +4587,6 @@ static void genMapInfos(llvm::IRBuilderBase &builder,
MapInfoData &mapData, TargetDirective targetDirective)
{
assert(!moduleTranslation.getOpenMPBuilder()->Config.isTargetDevice() &&
"function only supported for host device codegen");
-
// We wish to modify some of the methods in which arguments are
// passed based on their capture type by the target region, this can
// involve generating new loads and stores, which changes the
@@ -4574,11 +4616,11 @@ static void genMapInfos(llvm::IRBuilderBase &builder,
auto mapInfoOp = dyn_cast<omp::MapInfoOp>(mapData.MapClause[i]);
if (!mapInfoOp.getMembers().empty()) {
processMapWithMembersOf(moduleTranslation, builder, *ompBuilder, dl,
- combinedInfo, mapData, i, isTargetParams);
+ combinedInfo, mapData, i, targetDirective);
continue;
}
- processIndividualMap(mapData, i, combinedInfo, isTargetParams);
+ processIndividualMap(mapData, i, combinedInfo, targetDirective);
}
}
@@ -4641,8 +4683,8 @@ emitUserDefinedMapper(Operation *op, llvm::IRBuilderBase
&builder,
genMapInfos(builder, moduleTranslation, dl, combinedInfo, mapData,
targetDirective);
- // Drop the mapping that is no longer necessary so that the same region can
- // be processed multiple times.
+ // Drop the mapping that is no longer necessary so that the same region
+ // can be processed multiple times.
moduleTranslation.forgetMapping(declMapperOp.getRegion());
return combinedInfo;
};
@@ -4672,10 +4714,12 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase
&builder,
SmallVector<Value> useDeviceAddrVars;
llvm::omp::RuntimeFunction RTLFn;
DataLayout DL = DataLayout(op->getParentOfType<ModuleOp>());
+ TargetDirective targetDirective = getTargetDirectiveFromOp(op);
llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
- llvm::OpenMPIRBuilder::TargetDataInfo
info(/*RequiresDevicePointerInfo=*/true,
- /*SeparateBeginEndCalls=*/true);
+ llvm::OpenMPIRBuilder::TargetDataInfo info(
+ /*RequiresDevicePointerInfo=*/true,
+ /*SeparateBeginEndCalls=*/true);
bool isTargetDevice = ompBuilder->Config.isTargetDevice();
bool isOffloadEntry =
isTargetDevice || !ompBuilder->Config.TargetTriples.empty();
@@ -4777,7 +4821,8 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase
&builder,
MapInfosTy combinedInfo;
auto genMapInfoCB = [&](InsertPointTy codeGenIP) -> MapInfosTy & {
builder.restoreIP(codeGenIP);
- genMapInfos(builder, moduleTranslation, DL, combinedInfo, mapData);
+ genMapInfos(builder, moduleTranslation, DL, combinedInfo, mapData,
+ targetDirective);
return combinedInfo;
};
@@ -5154,11 +5199,16 @@ handleDeclareTargetMapVar(MapInfoData &mapData,
for (llvm::User *user : userVec) {
if (auto *insn = dyn_cast<llvm::Instruction>(user)) {
if (insn->getFunction() == func) {
- builder.SetCurrentDebugLocation(insn->getDebugLoc());
- auto *load = builder.CreateLoad(mapData.BasePointers[i]->getType(),
- mapData.BasePointers[i]);
- load->moveBefore(insn->getIterator());
- user->replaceUsesOfWith(mapData.OriginalValue[i], load);
+ auto mapOp = cast<omp::MapInfoOp>(mapData.MapClause[i]);
+ llvm::Value *substitute = mapData.BasePointers[i];
+ if (isDeclareTargetLink(mapOp.getVarPtrPtr() ? mapOp.getVarPtrPtr()
+ : mapOp.getVarPtr()))
{
+ builder.SetCurrentDebugLocation(insn->getDebugLoc());
+ substitute = builder.CreateLoad(
+ mapData.BasePointers[i]->getType(), mapData.BasePointers[i]);
+
cast<llvm::LoadInst>(substitute)->moveBefore(insn->getIterator());
+ }
+ user->replaceUsesOfWith(mapData.OriginalValue[i], substitute);
}
}
}
@@ -5452,8 +5502,8 @@ initTargetDefaultAttrs(omp::TargetOp targetOp, Operation
*capturedOp,
int32_t minTeamsVal = 1, maxTeamsVal = -1;
if (castOrGetParentOfType<omp::TeamsOp>(capturedOp)) {
- // TODO: Use `hostNumTeamsLower` to initialize `minTeamsVal`. For now,
match
- // clang and set min and max to the same value.
+ // TODO: Use `hostNumTeamsLower` to initialize `minTeamsVal`. For now,
+ // match clang and set min and max to the same value.
if (numTeamsUpper) {
if (auto val = extractConstInteger(numTeamsUpper))
minTeamsVal = maxTeamsVal = *val;
@@ -5639,9 +5689,9 @@ convertOmpTarget(Operation &opInst, llvm::IRBuilderBase
&builder,
auto parentFn = opInst.getParentOfType<LLVM::LLVMFuncOp>();
auto argIface = cast<omp::BlockArgOpenMPOpInterface>(opInst);
auto &targetRegion = targetOp.getRegion();
- // Holds the private vars that have been mapped along with the block argument
- // that corresponds to the MapInfoOp corresponding to the private var in
- // question. So, for instance:
+ // Holds the private vars that have been mapped along with the block
+ // argument that corresponds to the MapInfoOp corresponding to the private
+ // var in question. So, for instance:
//
// %10 = omp.map.info var_ptr(%6#0 : !fir.ref<!fir.box<!fir.heap<i32>>>, ..)
// omp.target map_entries(%10 -> %arg0) private(@box.privatizer %6#0-> %arg1)
@@ -5656,6 +5706,7 @@ convertOmpTarget(Operation &opInst, llvm::IRBuilderBase
&builder,
ArrayRef<BlockArgument> mapBlockArgs = argIface.getMapBlockArgs();
ArrayRef<BlockArgument> hdaBlockArgs = argIface.getHasDeviceAddrBlockArgs();
llvm::Function *llvmOutlinedFn = nullptr;
+ TargetDirective targetDirective = getTargetDirectiveFromOp(&opInst);
// TODO: It can also be false if a compile-time constant `false` IF clause is
// specified.
@@ -5817,7 +5868,8 @@ convertOmpTarget(Operation &opInst, llvm::IRBuilderBase
&builder,
auto genMapInfoCB =
[&](llvm::OpenMPIRBuilder::InsertPointTy codeGenIP) -> MapInfosTy & {
builder.restoreIP(codeGenIP);
- genMapInfos(builder, moduleTranslation, dl, combinedInfos, mapData, true);
+ genMapInfos(builder, moduleTranslation, dl, combinedInfos, mapData,
+ targetDirective);
return combinedInfos;
};
diff --git a/mlir/test/Target/LLVMIR/omptarget-declare-target-to-device.mlir
b/mlir/test/Target/LLVMIR/omptarget-declare-target-to-device.mlir
new file mode 100644
index 0000000000000..388cf77e492de
--- /dev/null
+++ b/mlir/test/Target/LLVMIR/omptarget-declare-target-to-device.mlir
@@ -0,0 +1,35 @@
+// RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
+
+// This tests the replacement of operations for `declare target to` with the
+// generated `declare target to` global variable inside of target op regions
when
+// lowering to IR for device. Unfortunately, as the host file is not passed as
a
+// module attribute, we miss out on the metadata and entry info.
+
+module attributes {llvm.target_triple = "amdgcn-amd-amdhsa", omp.is_gpu =
true, omp.is_target_device = true} {
+ // CHECK-DAG: @_QMtest_0Ezii = global [11 x float] zeroinitializer
+ llvm.mlir.global external @_QMtest_0Ezii() {addr_space = 0 : i32,
omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause =
(to)>} : !llvm.array<11 x f32> {
+ %0 = llvm.mlir.zero : !llvm.array<11 x f32>
+ llvm.return %0 : !llvm.array<11 x f32>
+ }
+
+ // CHECK-DAG: define weak_odr protected amdgpu_kernel void @{{.*}}(ptr
%{{.*}}) {{.*}} {
+ // CHECK-DAG: omp.target:
+ // CHECK-DAG: store float 1.000000e+00, ptr @_QMtest_0Ezii, align 4
+ // CHECK-DAG: br label %omp.region.cont
+ llvm.func @_QQmain() {
+ %0 = llvm.mlir.constant(1 : index) : i64
+ %1 = llvm.mlir.constant(0 : index) : i64
+ %2 = llvm.mlir.constant(11 : index) : i64
+ %3 = llvm.mlir.addressof @_QMtest_0Ezii : !llvm.ptr
+ %4 = omp.map.bounds lower_bound(%1 : i64) upper_bound(%2 : i64) extent(%2
: i64) stride(%0 : i64) start_idx(%1 : i64) {stride_in_bytes = true}
+ %5 = omp.map.info var_ptr(%3 : !llvm.ptr, !llvm.array<11 x f32>)
map_clauses(tofrom) capture(ByRef) bounds(%4) -> !llvm.ptr
+ omp.target map_entries(%5 -> %arg0 : !llvm.ptr) {
+ %6 = llvm.mlir.constant(1.0 : f32) : f32
+ %7 = llvm.mlir.constant(0 : i64) : i64
+ %8 = llvm.getelementptr %arg0[%7] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ llvm.store %6, %8 : f32, !llvm.ptr
+ omp.terminator
+ }
+ llvm.return
+ }
+}
diff --git
a/offload/test/offloading/fortran/declare-target-to-allocatable-vars-in-target-with-update.f90
b/offload/test/offloading/fortran/declare-target-to-allocatable-vars-in-target-with-update.f90
new file mode 100644
index 0000000000000..0918704fc94ab
--- /dev/null
+++
b/offload/test/offloading/fortran/declare-target-to-allocatable-vars-in-target-with-update.f90
@@ -0,0 +1,44 @@
+! Test that checks an allocatable array can be marked `declare target to` and
+! functions without issue.
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+module test
+ implicit none
+ integer, allocatable, dimension(:) :: alloca_arr
+ !$omp declare target(alloca_arr)
+ end module test
+
+ program main
+ use test
+ implicit none
+ integer :: cycle, i
+
+ allocate(alloca_arr(10))
+
+ do i = 1, 10
+ alloca_arr(i) = 0
+ end do
+
+!$omp target data map(to:alloca_arr)
+
+ do cycle = 1, 2
+
+ !$omp target
+ do i = 1, 10
+ alloca_arr(i) = alloca_arr(i) + i
+ end do
+ !$omp end target
+
+! NOTE: Technically doesn't affect the results, but there is a
+! regression case that'll cause a runtime crash if this is
+! invoked more than once, so this checks for that.
+!$omp target update from(alloca_arr)
+ end do
+
+!$omp end target data
+
+ print *, alloca_arr
+end program
+
+! CHECK: 2 4 6 8 10 12 14 16 18 20
diff --git
a/offload/test/offloading/fortran/declare-target-to-vars-target-region-and-update.f90
b/offload/test/offloading/fortran/declare-target-to-vars-target-region-and-update.f90
new file mode 100644
index 0000000000000..1d6d9fba76730
--- /dev/null
+++
b/offload/test/offloading/fortran/declare-target-to-vars-target-region-and-update.f90
@@ -0,0 +1,36 @@
+! Test `declare target to` interaction with `target update from`
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+module test
+ implicit none
+ integer :: array(10)
+ !$omp declare target(array)
+end module test
+
+PROGRAM main
+ use test
+ implicit none
+ integer :: i
+
+ !$omp target
+ do i = 1, 10
+ array(i) = i
+ end do
+ !$omp end target
+
+ !$omp target
+ do i = 1, 10
+ array(i) = array(i) + i
+ end do
+ !$omp end target
+
+ print *, array
+
+ !$omp target update from(array)
+
+ print *, array
+END PROGRAM
+
+! CHECK: 0 0 0 0 0 0 0 0 0 0
+! CHECK: 2 4 6 8 10 12 14 16 18 20
diff --git
a/offload/test/offloading/fortran/declare-target-to-zero-index-allocatable-target-map.f90
b/offload/test/offloading/fortran/declare-target-to-zero-index-allocatable-target-map.f90
new file mode 100644
index 0000000000000..0d650f6b44009
--- /dev/null
+++
b/offload/test/offloading/fortran/declare-target-to-zero-index-allocatable-target-map.f90
@@ -0,0 +1,30 @@
+! Test `declare target to` interaction with an allocatable with a non-default
+! range
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+module test_0
+ real(4), allocatable :: zero_off(:)
+ !$omp declare target(zero_off)
+end module test_0
+
+program main
+ use test_0
+ implicit none
+
+ allocate(zero_off(0:10))
+
+ zero_off(0) = 30.0
+ zero_off(1) = 40.0
+ zero_off(10) = 25.0
+
+ !$omp target map(tofrom: zero_off)
+ zero_off(0) = zero_off(1)
+ !$omp end target
+
+ print *, zero_off(0)
+ print *, zero_off(1)
+end program
+
+! CHECK: 40.
+! CHECK: 40.
_______________________________________________
llvm-branch-commits mailing list
llvm-branch-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
