[flang-commits] [flang] [llvm] [mlir] [flang][mlir][OpenMP] Report Fortran names for privatized target maps… (PR #229823)
via flang-commits
flang-commits at lists.llvm.org
Wed Oct 7 08:57:06 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir-openmp
Author: Jason Van Beusekom (Jason-Van-Beusekom)
<details>
<summary>Changes</summary>
(repush of https://github.com/llvm/llvm-project/pull/228195, added test `target-firstprivate-mapnames.f90` failed on systems that did not have the flang-rt built on the gpu, so instead split the test into two separate compile only checks `target-firstprivate-mapnames.f90` and `omptarget-map-names.mlir` actualy source / compiler changes are the same from https://github.com/llvm/llvm-project/pull/228195)
Privatized, firstprivate and implicitly captured variables offloaded to a target device were reported as "unknown" in LIBOMPTARGET_INFO debug output. This PR addresses this by adding the variable names to the offload mapping information:
- `MapsForPrivatizedSymbols` now sets the name on the omp.map.info it creates,
recovering it from the hlfir.declare uniq name or, for anonymously boxed values (e.g. a firstprivate array), from a NameLoc on the descriptor's
alloca.
- `privatizeSymbol` tags that alloca with a NameLoc carrying the symbol name
so the pass can recover it when there is no hlfir.declare.
- `createMappingInformation` gains an optional map name and prefers it over the
location-derived name; the OpenMP translation forwards each map's name
attribute for both parent and member entries.
- `genBaseAddrMap` now passes getNameAttr for the name instead of an empty string.
Repro: ``` fortran program f2_var_names implicit none integer :: factor, base, res integer :: arr(4) factor = 7 base = 5 res = 0 arr = (/1, 2, 3, 4/)
! explicit firstprivate scalar (factor) + implicit scalar capture (base)
!$omp target map(tofrom: res) firstprivate(factor)
res = factor + base
!$omp end target
print *, "res1 =", res ! expect 12
! array firstprivate is boxed for privatization; the descriptor maps must
! still report the source name.
!$omp target map(tofrom: res) firstprivate(arr)
res = arr(1) + arr(4)
!$omp end target
print *, "res2 =", res ! expect 5
end program f2_var_names
```
Output:
``` bash
# Patched Flang
omptarget device 0 info: Entering OpenMP kernel at f2_var_names.f90:22:9
with 3 arguments:
omptarget device 0 info: tofrom(res)[4]
omptarget device 0 info: firstprivate(base)[4] (implicit)
omptarget device 0 info: to(factor)[4]
omptarget device 0 info: Entering OpenMP kernel at f2_var_names.f90:29:9
with 5 arguments:
omptarget device 0 info: tofrom(res)[4]
omptarget device 0 info: to(arr)[48]
omptarget device 0 info: to(arr)[48]
omptarget device 0 info: tofrom(arr)[16]
omptarget device 0 info: attach(arr)[48]
res1 = 12
res2 = 5
# Base Flang
omptarget device 0 info: Entering OpenMP kernel at f2_var_names.f90:22:9
with 3 arguments:
omptarget device 0 info: tofrom(res)[4]
omptarget device 0 info: firstprivate(unknown)[4] (implicit)
omptarget device 0 info: to(unknown)[4]
omptarget device 0 info: Entering OpenMP kernel at f2_var_names.f90:29:9
with 5 arguments:
omptarget device 0 info: tofrom(res)[4]
omptarget device 0 info: to(unknown)[48]
omptarget device 0 info: to(unknown)[48]
omptarget device 0 info: tofrom(unknown)[16]
omptarget device 0 info: attach(unknown)[48]
res1 = 12
res2 = 5
```
Assisted-by: Opus 4.8
(cherry picked from commit cf131447a0a2f0c16afe4aeb9deecafe2b747942)
---
Patch is 156.90 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/229823.diff
36 Files Affected:
- (modified) flang/lib/Lower/Support/Utils.cpp (+5-1)
- (modified) flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp (+1-1)
- (modified) flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp (+15-3)
- (added) flang/test/Integration/OpenMP/target-firstprivate-mapnames.f90 (+31)
- (modified) flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90 (+3-3)
- (modified) flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map-2.f90 (+2-2)
- (modified) flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map.f90 (+2-2)
- (modified) flang/test/Lower/OpenMP/DelayedPrivatization/target-teams-private-implicit-scalar-map.f90 (+3-3)
- (modified) flang/test/Lower/OpenMP/allocatable-array-bounds.f90 (+3-3)
- (modified) flang/test/Lower/OpenMP/allocatable-dtype-intermediate-map-gen.f90 (+3-3)
- (modified) flang/test/Lower/OpenMP/allocatable-map.f90 (+1-1)
- (modified) flang/test/Lower/OpenMP/array-bounds.f90 (+1-1)
- (modified) flang/test/Lower/OpenMP/attach-and-ref-modifier.f90 (+6-6)
- (modified) flang/test/Lower/OpenMP/declare-mapper.f90 (+10-10)
- (modified) flang/test/Lower/OpenMP/defaultmap.f90 (+6-6)
- (modified) flang/test/Lower/OpenMP/derived-type-allocatable-map.f90 (+6-6)
- (modified) flang/test/Lower/OpenMP/derived-type-map.f90 (+1-1)
- (modified) flang/test/Lower/OpenMP/implicit-map-pointer-no-default-mapper.f90 (+2-2)
- (modified) flang/test/Lower/OpenMP/map-descriptor-deferral.f90 (+9-9)
- (modified) flang/test/Lower/OpenMP/map-descriptor-privatization.f90 (+1-1)
- (modified) flang/test/Lower/OpenMP/map-neg-alloca-derived-type-array.f90 (+1-1)
- (modified) flang/test/Lower/OpenMP/optional-argument-map-2.f90 (+3-3)
- (modified) flang/test/Lower/OpenMP/optional-argument-map-3.f90 (+2-2)
- (modified) flang/test/Lower/OpenMP/target-data-use-device-addr-common-block.f90 (+1-1)
- (modified) flang/test/Lower/OpenMP/target-enter-data-default-openmp52.f90 (+2-2)
- (modified) flang/test/Lower/OpenMP/target-update-derived-type.f90 (+1-1)
- (modified) flang/test/Lower/OpenMP/target.f90 (+4-4)
- (modified) flang/test/Lower/OpenMP/usm-descriptor-close-map.f90 (+2-2)
- (modified) flang/test/Lower/volatile-openmp.f90 (+2-2)
- (modified) flang/test/Transforms/omp-map-info-finalization.fir (+11-11)
- (modified) flang/test/Transforms/omp-maps-for-privatized-symbols.fir (+4-4)
- (modified) mlir/include/mlir/Target/LLVMIR/Dialect/OpenMPCommon.h (+2-1)
- (modified) mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp (+23-7)
- (modified) mlir/lib/Target/LLVMIR/Dialect/OpenMPCommon.cpp (+10-7)
- (added) mlir/test/Target/LLVMIR/omptarget-map-names.mlir (+28)
- (added) offload/test/offloading/fortran/target-firstprivate-info.f90 (+23)
``````````diff
diff --git a/flang/lib/Lower/Support/Utils.cpp b/flang/lib/Lower/Support/Utils.cpp
index e6b6e923308af..056e7a5af6431 100644
--- a/flang/lib/Lower/Support/Utils.cpp
+++ b/flang/lib/Lower/Support/Utils.cpp
@@ -749,8 +749,12 @@ void privatizeSymbol(
// Boxes should be passed by reference into nested regions:
auto oldIP = firOpBuilder.saveInsertionPoint();
firOpBuilder.setInsertionPointToStart(firOpBuilder.getAllocaBlock());
+ // Get name so later passes (e.g. MapsForPrivatizedSymbols) can report it in
+ // offload info.
+ mlir::Location boxLoc = mlir::NameLoc::get(
+ firOpBuilder.getStringAttr(sym->name().ToString()), symLoc);
auto alloca =
- fir::AllocaOp::create(firOpBuilder, symLoc, privVal.getType());
+ fir::AllocaOp::create(firOpBuilder, boxLoc, privVal.getType());
firOpBuilder.restoreInsertionPoint(oldIP);
fir::StoreOp::create(firOpBuilder, symLoc, privVal, alloca);
privVal = alloca;
diff --git a/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp b/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
index 8046a702f330a..6c41425db1d66 100644
--- a/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
+++ b/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
@@ -590,7 +590,7 @@ class MapInfoFinalizationPass
isRefPtee ? parentOp.getMembersIndexAttr() : mlir::ArrayAttr{},
parentOp.getBounds(),
/*mapperId=*/mapperId,
- /*name=*/builder.getStringAttr(""),
+ /*name=*/parentOp.getNameAttr(),
/*partial_map=*/builder.getBoolAttr(false));
}
diff --git a/flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp b/flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp
index de3dd8d352b3b..7ce8ee315df53 100644
--- a/flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp
+++ b/flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp
@@ -29,6 +29,7 @@
#include "flang/Optimizer/Dialect/Support/KindMapping.h"
#include "flang/Optimizer/HLFIR/HLFIROps.h"
#include "flang/Optimizer/OpenMP/Passes.h"
+#include "flang/Optimizer/Support/InternalNames.h"
#include "flang/Utils/OpenMP.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
@@ -73,6 +74,7 @@ class MapsForPrivatizedSymbolsPass
Operation *definingOp = var.getDefiningOp();
Value varPtr = var;
+ mlir::StringAttr mapName;
// We want the first result of the hlfir.declare op because our goal
// is to map the descriptor (fir.box or fir.boxchar) and the first
// result for hlfir.declare is the descriptor if a the symbol being
@@ -80,8 +82,19 @@ class MapsForPrivatizedSymbolsPass
// Some types are boxed immediately before privatization. These have other
// operations in between the privatization and the declaration. It is safe
// to use var directly here because they will be boxed anyway.
- if (auto declOp = llvm::dyn_cast_if_present<hlfir::DeclareOp>(definingOp))
+ if (auto declOp = llvm::dyn_cast_if_present<hlfir::DeclareOp>(definingOp)) {
varPtr = declOp.getBase();
+ std::string sourceName =
+ fir::NameUniquer::deconstruct(declOp.getUniqName()).second.name;
+ if (!sourceName.empty())
+ mapName = builder.getStringAttr(sourceName);
+ }
+ // Boxed values map an anonymous descriptor with no declare
+ // so recover it from the value's location.
+ if (!mapName) {
+ if (auto nameLoc = llvm::dyn_cast<mlir::NameLoc>(var.getLoc()))
+ mapName = nameLoc.getName();
+ }
// If we do not have a reference to a descriptor but the descriptor itself,
// then we need to store that on the stack so that we can map the
@@ -156,8 +169,7 @@ class MapsForPrivatizedSymbolsPass
/*members=*/SmallVector<Value>{},
/*member_index=*/mlir::ArrayAttr{},
/*bounds=*/boundsOps,
- /*mapperId=*/mapperId, /*name=*/StringAttr(),
- builder.getBoolAttr(false));
+ /*mapperId=*/mapperId, /*name=*/mapName, builder.getBoolAttr(false));
}
void addMapInfoOp(omp::TargetOp targetOp, omp::MapInfoOp mapInfoOp) {
auto argIface = llvm::cast<omp::BlockArgOpenMPOpInterface>(*targetOp);
diff --git a/flang/test/Integration/OpenMP/target-firstprivate-mapnames.f90 b/flang/test/Integration/OpenMP/target-firstprivate-mapnames.f90
new file mode 100644
index 0000000000000..088a98f1f6010
--- /dev/null
+++ b/flang/test/Integration/OpenMP/target-firstprivate-mapnames.f90
@@ -0,0 +1,31 @@
+! RUN: %flang_fc1 -emit-llvm -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa %s -o - | FileCheck %s
+
+! CHECK-DAG: c";arr;
+subroutine fp_array(res)
+ integer :: res, arr(4)
+ arr = (/1, 2, 3, 4/)
+ !$omp target map(tofrom: res) firstprivate(arr)
+ res = arr(1)
+ !$omp end target
+end subroutine
+
+! CHECK-DAG: c";cstr;
+subroutine fp_char(res)
+ integer :: res
+ character(len=4) :: cstr
+ cstr = "abcd"
+ !$omp target map(tofrom: res) firstprivate(cstr)
+ res = ichar(cstr(1:1))
+ !$omp end target
+end subroutine
+
+! CHECK-DAG: c";pa;
+subroutine priv_alloc(res)
+ integer :: res
+ integer, allocatable :: pa(:)
+ allocate(pa(4))
+ !$omp target map(tofrom: res) private(pa)
+ res = 9
+ !$omp end target
+ deallocate(pa)
+end subroutine
diff --git a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90 b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90
index 8c5ee99b26fd5..bafc2622300bb 100644
--- a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90
+++ b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-allocatable.f90
@@ -69,9 +69,9 @@ end subroutine target_allocatable
! CPU-SAME: {bindc_name = "alloc_var", {{.*}}}
! CPU: %[[VAR_DECL:.*]]:2 = hlfir.declare %[[VAR_ALLOC]]
! CPU: %[[BASE_ADDR:.*]] = fir.box_offset %[[VAR_DECL]]#0 base_addr : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> [[MEMBER_TYPE:.*]]
-! CPU: %[[MEMBER:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]], [[DESC_TYPE]]) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[BASE_ADDR]] : [[MEMBER_TYPE:.*]], i32) name("") -> {{.*}}
-! CPU: %[[MAP_VAR:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]], [[DESC_TYPE]]) map_clauses({{.*}}to{{.*}}) capture(ByRef) members(%[[MEMBER]] : [0] : [[MEMBER_TYPE]]) -> !fir.ref<!fir.box<!fir.heap<i32>>>
-! CPU: %[[ATTACH:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]], [[DESC_TYPE]]) map_clauses(attach, ref_ptr, ref_ptee) capture(ByRef) var_ptr_ptr(%[[BASE_ADDR]] : [[MEMBER_TYPE]], i32) -> !fir.ref<!fir.box<!fir.heap<i32>>>
+! CPU: %[[MEMBER:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]], [[DESC_TYPE]]) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[BASE_ADDR]] : [[MEMBER_TYPE:.*]], i32) name("alloc_var") -> {{.*}}
+! CPU: %[[MAP_VAR:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]], [[DESC_TYPE]]) map_clauses({{.*}}to{{.*}}) capture(ByRef) members(%[[MEMBER]] : [0] : [[MEMBER_TYPE]]) name("alloc_var") -> !fir.ref<!fir.box<!fir.heap<i32>>>
+! CPU: %[[ATTACH:.*]] = omp.map.info var_ptr(%[[VAR_DECL]]#0 : [[TYPE]], [[DESC_TYPE]]) map_clauses(attach, ref_ptr, ref_ptee) capture(ByRef) var_ptr_ptr(%[[BASE_ADDR]] : [[MEMBER_TYPE]], i32) name("alloc_var") -> !fir.ref<!fir.box<!fir.heap<i32>>>
! CPU: omp.target kernel_type(generic) map_entries(%[[MAP_VAR]] -> %arg0, %[[ATTACH]] -> %arg1, %[[MEMBER]] -> %arg2 : [[TYPE]], [[TYPE]], [[MEMBER_TYPE]]) private(
! CPU-SAME: @[[VAR_PRIVATIZER_SYM]] %[[VAR_DECL]]#0 -> %{{.*}} [map_idx=0] : [[TYPE]]) {
diff --git a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map-2.f90 b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map-2.f90
index dd7bd0a60f8c4..fe647147c28e1 100644
--- a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map-2.f90
+++ b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map-2.f90
@@ -35,6 +35,6 @@ end subroutine target_imp_capture
! CHECK-PROG: %[[VAL_1:.*]] = omp.map.info var_ptr({{.*}} : !fir.ref<!fir.array<10x10xf32>>, !fir.array<10x10xf32>) map_clauses(implicit, tofrom) capture(ByRef) bounds({{.*}}) name("i") -> !fir.ref<!fir.array<10x10xf32>>
! CHECK-PROG: %[[VAL_2:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ptr<!fir.array<5x5x2xf32>>, !fir.array<5x5x2xf32>) map_clauses(implicit, tofrom) capture(ByRef) bounds({{.*}}) name("j") -> !fir.ptr<!fir.array<5x5x2xf32>>
! CHECK-PROG: %[[VAL_3:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ptr<!fir.array<25x2xf32>>, !fir.array<25x2xf32>) map_clauses(implicit, tofrom) capture(ByRef) bounds({{.*}}) name("k") -> !fir.ptr<!fir.array<25x2xf32>>
-! CHECK-PROG: %[[VAL_4:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) -> !fir.ref<i32>
-! CHECK-PROG: %[[VAL_5:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) -> !fir.ref<i32>
+! CHECK-PROG: %[[VAL_4:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) name("y") -> !fir.ref<i32>
+! CHECK-PROG: %[[VAL_5:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) name("z") -> !fir.ref<i32>
! CHECK-PROG: omp.target kernel_type(generic) map_entries(%[[VAL_0]] -> %[[VAL_6:.*]], %[[VAL_1]] -> %[[VAL_7:.*]], %[[VAL_2]] -> %[[VAL_8:.*]], %[[VAL_3]] -> %[[VAL_9:.*]], %[[VAL_4]] -> %[[VAL_10:.*]], %[[VAL_5]] -> %[[VAL_11:.*]] : !fir.ref<i32>, !fir.ref<!fir.array<10x10xf32>>, !fir.ptr<!fir.array<5x5x2xf32>>, !fir.ptr<!fir.array<25x2xf32>>, !fir.ref<i32>, !fir.ref<i32>) private(@_QFtarget_imp_captureEy_firstprivate_i32 %{{.*}}#0 -> %[[VAL_12:.*]] [map_idx=4], @_QMtest_dataEz_firstprivate_i32 %{{.*}}#0 -> %[[VAL_13:.*]] [map_idx=5] : !fir.ref<i32>, !fir.ref<i32>) {
diff --git a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map.f90 b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map.f90
index 4a8d82ff765ef..5ceeb7f7a03e0 100644
--- a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map.f90
+++ b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-implicit-scalar-map.f90
@@ -22,8 +22,8 @@
! CHECK: %[[VAL_1:.*]] = fir.declare %[[VAL_0]] uniq_name("_QFExdgfx") : (!fir.ref<i32>) -> !fir.ref<i32>
! CHECK: %[[VAL_2:.*]] = fir.alloca i32 <{bindc_name = "xfpvx", uniq_name = "_QFExfpvx"}>
! CHECK: %[[VAL_3:.*]] = fir.declare %[[VAL_2]] uniq_name("_QFExfpvx") : (!fir.ref<i32>) -> !fir.ref<i32>
-! CHECK: %[[VAL_4:.*]] = omp.map.info var_ptr(%[[VAL_3]] : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) -> !fir.ref<i32>
-! CHECK: %[[VAL_5:.*]] = omp.map.info var_ptr(%[[VAL_1]] : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) -> !fir.ref<i32>
+! CHECK: %[[VAL_4:.*]] = omp.map.info var_ptr(%[[VAL_3]] : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) name("xfpvx") -> !fir.ref<i32>
+! CHECK: %[[VAL_5:.*]] = omp.map.info var_ptr(%[[VAL_1]] : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) name("xdgfx") -> !fir.ref<i32>
! CHECK: omp.target kernel_type(generic) map_entries(%[[VAL_4]] -> %{{.*}}, %[[VAL_5]] -> %{{.*}} : !fir.ref<i32>, !fir.ref<i32>) private(@_QFExfpvx_firstprivate_i32 %[[VAL_3]] -> %[[VAL_6:.*]] [map_idx=0], @_QFExdgfx_firstprivate_i32 %[[VAL_1]] -> %[[VAL_7:.*]] [map_idx=1] : !fir.ref<i32>, !fir.ref<i32>) {
! CHECK: %{{.*}} = fir.declare %[[VAL_6]] uniq_name("_QFExfpvx") : (!fir.ref<i32>) -> !fir.ref<i32>
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 aed80b558c3d1..bb22969113c2b 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
@@ -27,11 +27,11 @@ program test_default_implicit_firstprivate
!CHECK: %[[VAL_8:.*]] = omp.map.info var_ptr(%[[VAL_3]] : !fir.ref<i32>, i32) map_clauses(implicit) capture(ByCopy) name("j") -> !fir.ref<i32>
!CHECK: %[[VAL_9:.*]] = omp.map.info var_ptr(%[[VAL_4]] : !fir.ref<i32>, i32) map_clauses(implicit) capture(ByCopy) name("k") -> !fir.ref<i32>
!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>>>>, !fir.box<!fir.heap<!fir.array<?x?x?xi32>>>) map_clauses(implicit, tofrom) capture(ByRef) var_ptr_ptr(%[[VAL_10]] : !fir.llvm_ptr<!fir.ref<!fir.array<?x?x?xi32>>>, i32) bounds({{.*}}) name("") -> !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>>>>, !fir.box<!fir.heap<!fir.array<?x?x?xi32>>>) map_clauses(implicit, tofrom) capture(ByRef) var_ptr_ptr(%[[VAL_10]] : !fir.llvm_ptr<!fir.ref<!fir.array<?x?x?xi32>>>, i32) bounds({{.*}}) name("allocarr") -> !fir.llvm_ptr<!fir.ref<!fir.array<?x?x?xi32>>>
!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>>>) name("allocarr") -> !fir.ref<!fir.box<!fir.heap<!fir.array<?x?x?xi32>>>>
!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({{.*}}) name("arr") -> !fir.ref<!fir.array<10x10x10xi32>>
-!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>
+!CHECK: %[[VAL_14:.*]] = omp.map.info var_ptr(%[[VAL_6]] : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) name("xfpvx") -> !fir.ref<i32>
+!CHECK: %[[VAL_15:.*]] = omp.map.info var_ptr(%[[VAL_5]] : !fir.ref<i32>, i32) map_clauses(to) capture(ByCopy) name("xdgfx") -> !fir.ref<i32>
!CHECK: omp.target kernel_type(spmd) host_eval({{.*}}) map_entries(%[[VAL_7]] -> %{{.*}}, %[[VAL_8]] -> %{{.*}}, %[[VAL_9]] -> %{{.*}}, %[[VAL_12]] -> %{{.*}}, %[[VAL_13]] -> %{{.*}}, %[[VAL_14]] -> %{{.*}}, %[[VAL_15]] -> %{{.*}}, %[[VAL_11]] -> %{{.*}} : {{.*}}) private(@[[SYM_XFPVX]] %[[VAL_6]] -> %{{.*}} [map_idx=5], @[[SYM_XDGFX]] %[[VAL_5]] -> %{{.*}} [map_idx=6] : {{.*}}) {
!CHECK omp.parallel private(@[[SYM_XFPVX]] %{{.*}} -> %{{.*}}, @[[SYM_XDGFX]] %{{.*}} -> %{{.*}}, @[[SYM_I]] %{{.*}} -> %{{.*}}, @[[SYM_J]] %{{.*}} -> %{{.*}}, @[[SYM_K]] %{{.*}} -> %{{.*}} : {{.*}}) {
!$omp target teams distribute parallel do collapse(3) firstprivate(xfpvx)
diff --git a/flang/test/Lower/OpenMP/allocatable-array-bounds.f90 b/flang/test/Lower/OpenMP/allocatable-array-bounds.f90
index b9d2299a92c0d..7ffa92f83ac8d 100644
--- a/flang/test/Lower/OpenMP/allocatable-array-bounds.f90
+++ b/flang/test/Lower/OpenMP/allocatable-array-bounds.f90
@@ -23,7 +23,7 @@
!HOST: %[[BOX_3:.*]]:3 = fir.box_dims %[[LOAD_3]], %[[CONSTANT_3]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
!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>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, i32) bounds(%[[BOUNDS_1]]) name("") -> !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>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, i32) bounds(%[[BOUNDS_1]]) name("sp_read(2:5)") -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!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>>>) name("sp_read(2:5)") -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
!HOST: %[[LOAD_3:.*]] = fir.load %[[DECLARE_2]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
@@ -41,7 +41,7 @@
!HOST: %[[BOX_5:.*]]:3 = fir.box_dims %[[LOAD_5]], %[[CONSTANT_5]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
!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>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, i32) bounds(%[[BOUNDS_2]]) name("") -> !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>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, i32) bounds(%[[BOUNDS_2]]) name("sp_write(2:5)") -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!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>>>) name("sp_write(2:5)") -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
subroutine read_write_section()
@@ -80,7 +80,7 @@ module assumed_allocatable_array_routines
!HOST: %[[BOX_3:.*]]:3 = fir.box_dims %[[LOAD_3]], %[[CONSTANT_3]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
!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>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, i32) bounds(%[[BOUNDS]]) name("") -> !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>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[VAR_PTR_PTR]] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, i32) bounds(%[[BOUNDS]]) name("arr_read_write(2:5)") -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
!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>>>) name("arr_read_write(2:5)") -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
subroutine assumed_shape_array(arr_read_write)
integer, allocatable, in...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/229823
More information about the flang-commits
mailing list