[flang-commits] [flang] 2a1200e - [Flang][OpenMP] Fix Fortran automap handling (#162501)
via flang-commits
flang-commits at lists.llvm.org
Tue Jul 14 08:03:11 PDT 2026
Author: Akash Banerjee
Date: 2026-07-14T16:03:05+01:00
New Revision: 2a1200e08cd1cb0e6744e38a7ec4611d983fb44f
URL: https://github.com/llvm/llvm-project/commit/2a1200e08cd1cb0e6744e38a7ec4611d983fb44f
DIFF: https://github.com/llvm/llvm-project/commit/2a1200e08cd1cb0e6744e38a7ec4611d983fb44f.diff
LOG: [Flang][OpenMP] Fix Fortran automap handling (#162501)
This fixes Fortran `declare target enter(automap:...)` handling for
allocatable
descriptors.
- Replace the previous `has_device_addr` target-region rewrite with
explicit
target data operations around allocation/deallocation.
- On allocation, emit:
- descriptor `map(always,to)` to keep the Fortran descriptor present
- storage `map(storage)` for the allocated array data
- `map(attach)` to update the device descriptor base address to the
device data
- On deallocation, delete both the mapped storage and descriptor.
- Add a weak visible offload-entry alias for local/hidden `declare
target to/enter`
globals so libomptarget can associate the host descriptor with the real
device
global without changing the original symbol linkage.
This fixes `offload/test/offloading/fortran/declare-target-automap.f90`
reported broken in #161265.
Co-authored-by: Codex <codex at openai.com>
Added:
flang/test/Lower/OpenMP/declare-target-automap.f90
Modified:
flang/lib/Optimizer/OpenMP/AutomapToTargetData.cpp
flang/test/Transforms/omp-automap-to-target-data.fir
mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
mlir/test/Target/LLVMIR/omptarget-declare-target-llvm-host.mlir
offload/test/offloading/fortran/declare-target-automap.f90
Removed:
################################################################################
diff --git a/flang/lib/Optimizer/OpenMP/AutomapToTargetData.cpp b/flang/lib/Optimizer/OpenMP/AutomapToTargetData.cpp
index eeb08ebf51191..bf269b5dd3ff2 100644
--- a/flang/lib/Optimizer/OpenMP/AutomapToTargetData.cpp
+++ b/flang/lib/Optimizer/OpenMP/AutomapToTargetData.cpp
@@ -15,11 +15,12 @@
#include "flang/Optimizer/HLFIR/HLFIROps.h"
#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
-#include "mlir/Dialect/OpenMP/OpenMPInterfaces.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/Operation.h"
#include "mlir/Pass/Pass.h"
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
+
namespace flangomp {
#define GEN_PASS_DEF_AUTOMAPTOTARGETDATAPASS
#include "flang/Optimizer/OpenMP/Passes.h.inc"
@@ -86,11 +87,7 @@ class AutomapToTargetDataPass
}
void runOnOperation() override {
- ModuleOp module = getOperation()->getParentOfType<ModuleOp>();
- if (!module)
- module = dyn_cast<ModuleOp>(getOperation());
- if (!module)
- return;
+ ModuleOp module = getOperation();
// Build FIR builder for helper utilities.
fir::KindMapping kindMap = fir::getKindMapping(module);
@@ -113,16 +110,63 @@ class AutomapToTargetDataPass
if (needsBoundsOps(memOp.getMemref()))
genBoundsOps(builder, memOp.getMemref(), bounds);
+ mlir::Value boxValue;
+ if (auto storeOp = mlir::dyn_cast<fir::StoreOp>(memOp.getOperation()))
+ boxValue = storeOp.getValue();
+ else
+ boxValue = mlir::cast<fir::LoadOp>(memOp.getOperation()).getResult();
+
+ mlir::Value baseAddr =
+ fir::BoxAddrOp::create(builder, memOp.getLoc(), boxValue);
+ mlir::Value dataAddr = builder.createConvert(
+ memOp.getLoc(),
+ builder.getRefType(fir::unwrapRefType(baseAddr.getType())), baseAddr);
+ mlir::Type baseTy = fir::unwrapRefType(dataAddr.getType());
+ if (mlir::Type eleTy = fir::dyn_cast_ptrOrBoxEleTy(baseTy))
+ baseTy = eleTy;
+ if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(baseTy))
+ if (seqTy.hasDynamicExtents())
+ baseTy = seqTy.getEleTy();
+
omp::TargetEnterExitUpdateDataOperands clauses;
+ bool isAlloc = isa<fir::StoreOp>(memOp);
+
+ auto createDescriptorMap =
+ [&](mlir::omp::ClauseMapFlags mapType) -> mlir::omp::MapInfoOp {
+ mlir::Type descriptorTy =
+ fir::unwrapRefType(memOp.getMemref().getType());
+ // Keep the descriptor itself present. MapInfoFinalization expands this
+ // ref_ptr map and emits the attach map when the descriptor is created.
+ mapType |= omp::ClauseMapFlags::ref_ptr;
+ if (!isAlloc)
+ mapType |= omp::ClauseMapFlags::attach_never;
+ return mlir::omp::MapInfoOp::create(
+ builder, memOp.getLoc(), memOp.getMemref().getType(),
+ memOp.getMemref(), TypeAttr::get(descriptorTy),
+ builder.getAttr<omp::ClauseMapFlagsAttr>(mapType),
+ builder.getAttr<omp::VariableCaptureKindAttr>(
+ omp::VariableCaptureKind::ByRef),
+ /*var_ptr_ptr=*/mlir::Value{},
+ /*var_ptr_ptr_type=*/mlir::TypeAttr{},
+ /*members=*/SmallVector<Value>{},
+ /*members_index=*/ArrayAttr{},
+ /*bounds=*/SmallVector<Value>{},
+ /*mapperId=*/mlir::FlatSymbolRefAttr(), globalOp.getSymNameAttr(),
+ builder.getBoolAttr(false));
+ };
+
+ if (isAlloc)
+ clauses.mapVars.push_back(createDescriptorMap(
+ omp::ClauseMapFlags::to | omp::ClauseMapFlags::always));
+
+ mlir::omp::ClauseMapFlags mapType =
+ isAlloc ? omp::ClauseMapFlags::storage : omp::ClauseMapFlags::del;
mlir::omp::MapInfoOp mapInfo = mlir::omp::MapInfoOp::create(
- builder, memOp.getLoc(), memOp.getMemref().getType(),
- memOp.getMemref(),
- TypeAttr::get(fir::unwrapRefType(memOp.getMemref().getType())),
- builder.getAttr<omp::ClauseMapFlagsAttr>(
- isa<fir::StoreOp>(memOp) ? omp::ClauseMapFlags::to
- : omp::ClauseMapFlags::del),
+ builder, memOp.getLoc(), dataAddr.getType(), dataAddr,
+ TypeAttr::get(baseTy),
+ builder.getAttr<omp::ClauseMapFlagsAttr>(mapType),
builder.getAttr<omp::VariableCaptureKindAttr>(
- omp::VariableCaptureKind::ByCopy),
+ omp::VariableCaptureKind::ByRef),
/*var_ptr_ptr=*/mlir::Value{},
/*var_ptr_ptr_type=*/mlir::TypeAttr{},
/*members=*/SmallVector<Value>{},
@@ -130,9 +174,13 @@ class AutomapToTargetDataPass
/*mapperId=*/mlir::FlatSymbolRefAttr(), globalOp.getSymNameAttr(),
builder.getBoolAttr(false));
clauses.mapVars.push_back(mapInfo);
- isa<fir::StoreOp>(memOp)
- ? omp::TargetEnterDataOp::create(builder, memOp.getLoc(), clauses)
- : omp::TargetExitDataOp::create(builder, memOp.getLoc(), clauses);
+
+ if (!isAlloc)
+ clauses.mapVars.push_back(
+ createDescriptorMap(omp::ClauseMapFlags::del));
+
+ isAlloc ? omp::TargetEnterDataOp::create(builder, memOp.getLoc(), clauses)
+ : omp::TargetExitDataOp::create(builder, memOp.getLoc(), clauses);
};
for (fir::GlobalOp globalOp : automapGlobals) {
diff --git a/flang/test/Lower/OpenMP/declare-target-automap.f90 b/flang/test/Lower/OpenMP/declare-target-automap.f90
new file mode 100644
index 0000000000000..63014cbf36725
--- /dev/null
+++ b/flang/test/Lower/OpenMP/declare-target-automap.f90
@@ -0,0 +1,28 @@
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=60 %s -o - | FileCheck %s
+
+program automap_program
+ integer, allocatable, target :: automap_array(:)
+ !$omp declare target enter(automap:automap_array)
+
+ allocate (automap_array(10))
+
+ !$omp target
+ automap_array(1) = 1
+ !$omp end target
+
+ deallocate (automap_array)
+end program
+
+! CHECK-LABEL: func.func @_QQmain()
+! CHECK-NOT: has_device_addr
+! CHECK: %[[DESC_MAP:.*]] = omp.map.info var_ptr(%[[DESC:.*]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to, ref_ptr) capture(ByRef) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "_QFEautomap_array"}
+! CHECK: %[[DESC_BASE:.*]] = fir.box_offset %[[DESC]] base_addr : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>
+! CHECK: %[[ATTACH_MAP:.*]] = omp.map.info var_ptr(%[[DESC]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(attach, ref_ptr) capture(ByRef) var_ptr_ptr(%[[DESC_BASE]] : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, i32) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "_QFEautomap_array"}
+! CHECK: %[[STORAGE_MAP:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ref<!fir.array<?xi32>>, i32) map_clauses(storage) capture(ByRef) bounds(%{{.*}}) -> !fir.ref<!fir.array<?xi32>> {name = "_QFEautomap_array"}
+! CHECK: omp.target_enter_data map_entries(%[[DESC_MAP]], %[[STORAGE_MAP]], %[[ATTACH_MAP]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.ref<!fir.array<?xi32>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>)
+! CHECK-NOT: has_device_addr
+! CHECK: omp.target {{.*}}map_entries(
+! CHECK-NOT: has_device_addr
+! CHECK: %[[DELETE_MAP:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ref<!fir.array<?xi32>>, i32) map_clauses(delete) capture(ByRef) bounds(%{{.*}}) -> !fir.ref<!fir.array<?xi32>> {name = "_QFEautomap_array"}
+! CHECK: %[[DESC_DELETE:.*]] = omp.map.info var_ptr(%{{.*}} : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(delete, attach_never, ref_ptr) capture(ByRef) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "_QFEautomap_array"}
+! CHECK: omp.target_exit_data map_entries(%[[DELETE_MAP]], %[[DESC_DELETE]] : !fir.ref<!fir.array<?xi32>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>)
diff --git a/flang/test/Transforms/omp-automap-to-target-data.fir b/flang/test/Transforms/omp-automap-to-target-data.fir
index 7a19705a248b4..37187203369a4 100644
--- a/flang/test/Transforms/omp-automap-to-target-data.fir
+++ b/flang/test/Transforms/omp-automap-to-target-data.fir
@@ -38,21 +38,25 @@ module {
// CHECK-NEXT: fir.shape
// CHECK-NEXT: %[[ARR_BOXED:.*]] = fir.embox %[[ALLOC_MEM]]
// CHECK-NEXT: fir.store %[[ARR_BOXED]]
-// CHECK-NEXT: %[[ARR_BOXED_LOADED:.*]] = fir.load %[[AUTOMAP_DECL]]#0
-// CHECK-NEXT: %[[ARR_HEAP_PTR:.*]] = fir.box_addr %[[ARR_BOXED_LOADED]]
-// CHECK-NEXT: %[[DIM0:.*]] = arith.constant 0 : index
-// CHECK-NEXT: %[[BOX_DIMS:.*]]:3 = fir.box_dims %[[ARR_BOXED_LOADED]], %[[DIM0]]
-// CHECK-NEXT: %[[ONE:.*]] = arith.constant 1 : index
-// CHECK-NEXT: %[[ZERO:.*]] = arith.constant 0 : index
-// CHECK-NEXT: %[[BOX_DIMS2:.*]]:3 = fir.box_dims %[[ARR_BOXED_LOADED]], %[[ZERO]]
-// CHECK-NEXT: %[[LOWER_BOUND:.*]] = arith.constant 0 : index
-// CHECK-NEXT: %[[UPPER_BOUND:.*]] = arith.subi %[[BOX_DIMS2]]#1, %[[ONE]] : index
-// CHECK-NEXT: omp.map.bounds lower_bound(%[[LOWER_BOUND]] : index) upper_bound(%[[UPPER_BOUND]] : index) extent(%[[BOX_DIMS2]]#1 : index) stride(%[[BOX_DIMS2]]#2 : index) start_idx(%[[BOX_DIMS]]#0 : index) {stride_in_bytes = true}
-// CHECK-NEXT: arith.muli %[[BOX_DIMS2]]#2, %[[BOX_DIMS2]]#1 : index
-// CHECK-NEXT: %[[MAP_INFO:.*]] = omp.map.info var_ptr(%[[AUTOMAP_DECL]]#0 {{.*}} map_clauses(to) capture(ByCopy)
-// CHECK-NEXT: omp.target_enter_data map_entries(%[[MAP_INFO]]
+// CHECK: %[[ARR_BOXED_LOADED:.*]] = fir.load %[[AUTOMAP_DECL]]#0
+// CHECK: %[[DIM0:.*]] = arith.constant 0 : index
+// CHECK: %[[BOX_DIMS:.*]]:3 = fir.box_dims %[[ARR_BOXED_LOADED]], %[[DIM0]]
+// CHECK: %[[ONE:.*]] = arith.constant 1 : index
+// CHECK: %[[ZERO:.*]] = arith.constant 0 : index
+// CHECK: %[[BOX_DIMS2:.*]]:3 = fir.box_dims %[[ARR_BOXED_LOADED]], %[[ZERO]]
+// CHECK: %[[LOWER_BOUND:.*]] = arith.constant 0 : index
+// CHECK: %[[UPPER_BOUND:.*]] = arith.subi %[[BOX_DIMS2]]#1, %[[ONE]] : index
+// CHECK: %[[BOUNDS:.*]] = omp.map.bounds lower_bound(%[[LOWER_BOUND]] : index) upper_bound(%[[UPPER_BOUND]] : index) extent(%[[BOX_DIMS2]]#1 : index) stride(%[[BOX_DIMS2]]#2 : index) start_idx(%[[BOX_DIMS]]#0 : index) {stride_in_bytes = true}
+// CHECK: %[[DATA_ADDR:.*]] = fir.box_addr %[[ARR_BOXED]]
+// CHECK-NEXT: %[[DATA_REF:.*]] = fir.convert %[[DATA_ADDR]] : (!fir.heap<!fir.array<?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK-NEXT: %[[DESC_MAP:.*]] = omp.map.info var_ptr(%[[AUTOMAP_DECL]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(always, to, ref_ptr) capture(ByRef) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "_QMtestEarr"}
+// CHECK-NEXT: %[[STORAGE_MAP:.*]] = omp.map.info var_ptr(%[[DATA_REF]] : !fir.ref<!fir.array<?xi32>>, i32) map_clauses(storage) capture(ByRef) bounds(%[[BOUNDS]]) -> !fir.ref<!fir.array<?xi32>> {name = "_QMtestEarr"}
+// CHECK-NEXT: omp.target_enter_data map_entries(%[[DESC_MAP]], %[[STORAGE_MAP]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.ref<!fir.array<?xi32>>)
// CHECK: %[[LOAD:.*]] = fir.load %[[AUTOMAP_DECL]]#0
-// CHECK: %[[EXIT_MAP:.*]] = omp.map.info var_ptr(%[[AUTOMAP_DECL]]#0 {{.*}} map_clauses(delete) capture(ByCopy)
-// CHECK-NEXT: omp.target_exit_data map_entries(%[[EXIT_MAP]]
+// CHECK: %[[EXIT_ADDR:.*]] = fir.box_addr %[[LOAD]]
+// CHECK-NEXT: %[[EXIT_REF:.*]] = fir.convert %[[EXIT_ADDR]] : (!fir.heap<!fir.array<?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK-NEXT: %[[EXIT_MAP:.*]] = omp.map.info var_ptr(%[[EXIT_REF]] : !fir.ref<!fir.array<?xi32>>, i32) map_clauses(delete) capture(ByRef)
+// CHECK-NEXT: %[[DESC_DELETE:.*]] = omp.map.info var_ptr(%[[AUTOMAP_DECL]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(delete, attach_never, ref_ptr) capture(ByRef) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {name = "_QMtestEarr"}
+// CHECK-NEXT: omp.target_exit_data map_entries(%[[EXIT_MAP]], %[[DESC_DELETE]] : !fir.ref<!fir.array<?xi32>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>)
// CHECK-NEXT: %[[BOXADDR:.*]] = fir.box_addr %[[LOAD]]
// CHECK-NEXT: fir.freemem %[[BOXADDR]]
diff --git a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
index 7bb15b74aeac3..af1ec17563806 100644
--- a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
@@ -8922,6 +8922,54 @@ convertDeclareTargetAttr(Operation *op, mlir::omp::DeclareTargetAttr attribute,
auto captureClauseKind = convertToCaptureClauseKind(captureClause);
auto deviceClause =
convertToDeviceClauseKind(attribute.getDeviceType().getValue());
+ llvm::StringRef entryMangledName = mangledName;
+ llvm::Constant *entryAddr = llvm::cast<llvm::Constant>(gVal);
+ std::function<llvm::GlobalValue::LinkageTypes()> variableLinkage;
+ llvm::SmallString<128> entryNameStorage;
+ bool requiresUSM = ompBuilder->Config.hasRequiresUnifiedSharedMemory();
+ bool isToOrEnter =
+ captureClause == omp::DeclareTargetCaptureClause::to ||
+ captureClause == omp::DeclareTargetCaptureClause::enter;
+ bool isHostOnly = attribute.getDeviceType().getValue() ==
+ omp::DeclareTargetDeviceType::host;
+
+ // A to/enter declare-target variable needs a device-resident,
+ // name-resolvable copy and a host offloading entry. A local-linkage
+ // global provides neither, so we promote it to external.
+ if (isToOrEnter && !isHostOnly && !requiresUSM &&
+ gVar->hasLocalLinkage()) {
+ gVar->setLinkage(llvm::GlobalValue::ExternalLinkage);
+ isExternallyVisible = true;
+
+ // Clear the stale dso_local flag so it is referenced like a
+ // module-scope declare target global.
+ if (ompBuilder->Config.isTargetDevice())
+ gVar->setDSOLocal(false);
+ }
+
+ if (isToOrEnter &&
+ deviceClause ==
+ llvm::OffloadEntriesInfoManager::OMPTargetDeviceClauseAny &&
+ !requiresUSM && !isDeclaration &&
+ (gVal->hasLocalLinkage() || gVal->hasHiddenVisibility())) {
+ // Keep the original symbol as-is for target code, but create a visible
+ // alias for the offload entry so libomptarget can associate the host
+ // global with the actual device global.
+ entryNameStorage = (mangledName + llvm::Twine("_decl_tgt_entry")).str();
+ entryMangledName = entryNameStorage;
+ if (llvm::GlobalValue *existing =
+ llvmModule->getNamedValue(entryMangledName)) {
+ entryAddr = llvm::cast<llvm::Constant>(existing);
+ } else {
+ entryAddr = llvm::GlobalAlias::create(
+ gVal->getValueType(), gVal->getAddressSpace(),
+ llvm::GlobalValue::WeakAnyLinkage, entryMangledName, entryAddr,
+ llvmModule);
+ llvm::cast<llvm::GlobalAlias>(entryAddr)->setVisibility(
+ llvm::GlobalValue::DefaultVisibility);
+ }
+ variableLinkage = [] { return llvm::GlobalValue::WeakAnyLinkage; };
+ }
// unused for MLIR at the moment, required in Clang for book
// keeping
std::vector<llvm::GlobalVariable *> generatedRefs;
@@ -8946,34 +8994,13 @@ convertDeclareTargetAttr(Operation *op, mlir::omp::DeclareTargetAttr attribute,
lineNo);
};
- bool requiresUSM = ompBuilder->Config.hasRequiresUnifiedSharedMemory();
- bool isToOrEnter =
- captureClause == omp::DeclareTargetCaptureClause::to ||
- captureClause == omp::DeclareTargetCaptureClause::enter;
- bool isHostOnly = attribute.getDeviceType().getValue() ==
- omp::DeclareTargetDeviceType::host;
-
- // A to/enter declare-target variable needs a device-resident,
- // name-resolvable copy and a host offloading entry. A local-linkage
- // global provides neither, so we promote it to external.
- if (isToOrEnter && !isHostOnly && !requiresUSM &&
- gVar->hasLocalLinkage()) {
- gVar->setLinkage(llvm::GlobalValue::ExternalLinkage);
- isExternallyVisible = true;
-
- // Clear the stale dso_local flag so it is referenced like a
- // module-scope declare target global.
- if (ompBuilder->Config.isTargetDevice())
- gVar->setDSOLocal(false);
- }
-
llvm::vfs::FileSystem &vfs = moduleTranslation.getFileSystem();
ompBuilder->registerTargetGlobalVariable(
captureClauseKind, deviceClause, isDeclaration, isExternallyVisible,
ompBuilder->getTargetEntryUniqueInfo(fileInfoCallBack, vfs),
- mangledName, generatedRefs, /*OpenMPSimd*/ false, targetTriple,
- /*GlobalInitializer*/ nullptr, /*VariableLinkage*/ nullptr,
- gVal->getType(), gVal);
+ entryMangledName, generatedRefs, /*OpenMPSimd*/ false, targetTriple,
+ /*GlobalInitializer*/ nullptr, variableLinkage, gVal->getType(),
+ entryAddr);
if (ompBuilder->Config.isTargetDevice() &&
(captureClause == omp::DeclareTargetCaptureClause::link ||
diff --git a/mlir/test/Target/LLVMIR/omptarget-declare-target-llvm-host.mlir b/mlir/test/Target/LLVMIR/omptarget-declare-target-llvm-host.mlir
index 92c85738dbc72..0d795eefa1f9d 100644
--- a/mlir/test/Target/LLVMIR/omptarget-declare-target-llvm-host.mlir
+++ b/mlir/test/Target/LLVMIR/omptarget-declare-target-llvm-host.mlir
@@ -133,6 +133,25 @@ module attributes {llvm.target_triple = "x86_64-unknown-linux-gnu", omp.is_targe
llvm.return %0 : i32
}
+ // CHECK-DAG: @_QFEinternal_enter = dso_local global i32 7
+ // CHECK-DAG: @.offloading.entry_name{{.*}} = internal unnamed_addr constant [19 x i8] c"_QFEinternal_enter\00"
+ // CHECK-DAG: @.offloading.entry._QFEinternal_enter = weak constant %struct.__tgt_offload_entry { i64 0, i16 1, i16 1, i32 0, ptr @_QFEinternal_enter, ptr @.offloading.entry_name{{.*}}, i64 4, i64 0, ptr null }, section "llvm_offload_entries"
+ // CHECK-DAG: !{{.*}} = !{i32 {{.*}}, !"_QFEinternal_enter", i32 {{.*}}, i32 {{.*}}}
+ llvm.mlir.global internal @_QFEinternal_enter() {addr_space = 0 : i32, omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (enter)>} : i32 {
+ %0 = llvm.mlir.constant(7 : i32) : i32
+ llvm.return %0 : i32
+ }
+
+ // CHECK-DAG: @_QFEhidden_enter = hidden global i32 8
+ // CHECK-DAG: @.offloading.entry_name{{.*}} = internal unnamed_addr constant [32 x i8] c"_QFEhidden_enter_decl_tgt_entry\00"
+ // CHECK-DAG: @.offloading.entry._QFEhidden_enter_decl_tgt_entry = weak constant %struct.__tgt_offload_entry { i64 0, i16 1, i16 1, i32 0, ptr @_QFEhidden_enter_decl_tgt_entry, ptr @.offloading.entry_name{{.*}}, i64 4, i64 0, ptr null }, section "llvm_offload_entries"
+ // CHECK-DAG: @_QFEhidden_enter_decl_tgt_entry = weak alias i32, ptr @_QFEhidden_enter
+ // CHECK-DAG: !{{.*}} = !{i32 {{.*}}, !"_QFEhidden_enter_decl_tgt_entry", i32 {{.*}}, i32 {{.*}}}
+ llvm.mlir.global external hidden @_QFEhidden_enter() {addr_space = 0 : i32, omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (enter)>} : i32 {
+ %0 = llvm.mlir.constant(8 : i32) : i32
+ llvm.return %0 : i32
+ }
+
// CHECK-DAG: @_QMtest_0Ept1 = global { ptr, i64, i32, i8, i8, i8, i8 } { ptr null, i64 4, i32 20180515, i8 0, i8 9, i8 1, i8 0 }
// CHECK-DAG: @_QMtest_0Ept1_decl_tgt_ref_ptr = weak global ptr @_QMtest_0Ept1
// CHECK-DAG: @.offloading.entry_name{{.*}} = internal unnamed_addr constant [31 x i8] c"_QMtest_0Ept1_decl_tgt_ref_ptr\00"
diff --git a/offload/test/offloading/fortran/declare-target-automap.f90 b/offload/test/offloading/fortran/declare-target-automap.f90
index b44c0b2815274..b9c2d34c834fa 100644
--- a/offload/test/offloading/fortran/declare-target-automap.f90
+++ b/offload/test/offloading/fortran/declare-target-automap.f90
@@ -1,9 +1,6 @@
!Offloading test for AUTOMAP modifier in declare target enter
! REQUIRES: flang, amdgpu
-! FIXME: https://github.com/llvm/llvm-project/issues/161265
-! XFAIL: amdgpu
-
! RUN: %libomptarget-compile-fortran-run-and-check-generic
program automap_program
use iso_c_binding, only: c_loc
More information about the flang-commits
mailing list