[flang-commits] [flang] c19b9cf - [flang][CUDA] Only apply implicit managed attribute when CUDA Fortran is enabled (#195353)

[via flang-commits]

Author: Zhen Wang
Date: 2026-05-04T10:09:10-07:00
New Revision: c19b9cf35a0fbcc97f57d4f0e61756388ee79c96

URL: https://github.com/llvm/llvm-project/commit/c19b9cf35a0fbcc97f57d4f0e61756388ee79c96
DIFF: https://github.com/llvm/llvm-project/commit/c19b9cf35a0fbcc97f57d4f0e61756388ee79c96.diff

LOG: [flang][CUDA] Only apply implicit managed attribute when CUDA Fortran is enabled (#195353)

The implicit-managed tagging added in #175648 was intended for CUDA
Fortran allocatables. However, the gate was just
LanguageFeature::CudaManaged, so the tagging also fires on
non-CUDA-Fortran translation units when -gpu=mem:managed is in effect.

This patch adds a LanguageFeature::CUDA check so the implicit tagging
only fires for CUDA Fortran TUs (driver-set -fcuda or .cuf/.CUF source).
Adds a regression test that bbc -gpu=managed without -fcuda on a .f90
source must not produce any cuf.* ops or #cuf.cuda<managed> attributes.

Added: 
    flang/test/Lower/CUDA/cuda-gpu-managed-without-fcuda.f90

Modified: 
    flang/lib/Semantics/resolve-names.cpp

Removed: 
    


################################################################################
diff  --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp
index 822fc8b593fae..839f8edeceb97 100644
--- a/flang/lib/Semantics/resolve-names.cpp
+++ b/flang/lib/Semantics/resolve-names.cpp
@@ -10175,8 +10175,13 @@ void ResolveNamesVisitor::FinishSpecificationPart(
     }
     // Implicitly treat allocatable arrays as managed when feature is enabled.
     // This is done after all explicit CUDA attributes have been processed.
+    // Only applies when CUDA Fortran is enabled; otherwise -gpu=mem:managed
+    // on a non-CUDA-Fortran translation unit (e.g. pure OpenACC) would
+    // incorrectly route every allocatable through the CUDA Fortran managed
+    // descriptor pipeline.
     if (context().languageFeatures().IsEnabled(
-            common::LanguageFeature::CudaManaged))
+            common::LanguageFeature::CudaManaged) &&
+        context().languageFeatures().IsEnabled(common::LanguageFeature::CUDA))
       if (auto *object{symbol.detailsIf<ObjectEntityDetails>()})
         if (IsAllocatable(symbol) && !object->cudaDataAttr())
           object->set_cudaDataAttr(common::CUDADataAttr::Managed);

diff  --git a/flang/test/Lower/CUDA/cuda-gpu-managed-without-fcuda.f90 b/flang/test/Lower/CUDA/cuda-gpu-managed-without-fcuda.f90
new file mode 100644
index 0000000000000..eb767bdfcad3d
--- /dev/null
+++ b/flang/test/Lower/CUDA/cuda-gpu-managed-without-fcuda.f90
@@ -0,0 +1,59 @@
+! RUN: bbc -emit-hlfir -gpu=managed %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir -gpu=mem:managed %s -o - | FileCheck %s
+
+! Test that -gpu=managed (a.k.a. -gpu=mem:managed) does NOT implicitly tag
+! plain Fortran allocatables as CUDA managed when CUDA Fortran is not
+! enabled. The implicit-managed tagging is a CUDA Fortran convenience and
+! should only fire when -fcuda is also in effect (or the source is .cuf).
+! Otherwise, a non-CUDA-Fortran translation unit (e.g. pure OpenACC code
+! compiled with -gpu=mem:managed by the driver) would route every
+! allocatable through the CUDA Fortran managed descriptor pipeline and
+! crash at runtime in cudaGetSymbolAddress.
+
+subroutine test_no_implicit_managed()
+  real, allocatable :: a(:)
+  allocate(a(100))
+  a = 1.0
+  deallocate(a)
+end subroutine
+
+subroutine test_no_implicit_managed_multidim()
+  real, allocatable :: arr(:,:,:)
+  allocate(arr(10,20,30))
+  arr = 0.0
+  deallocate(arr)
+end subroutine
+
+module mod_no_managed
+  real, allocatable :: g(:)
+end module
+
+subroutine test_no_implicit_managed_module()
+  use mod_no_managed
+  allocate(g(50))
+  deallocate(g)
+end subroutine
+
+! CHECK-LABEL: func.func @_QPtest_no_implicit_managed()
+! CHECK-NOT:     cuf.alloc
+! CHECK-NOT:     data_attr = #cuf.cuda<managed>
+! CHECK-NOT:     allocator_idx = 3
+! CHECK-NOT:     cuf.allocate
+! CHECK-NOT:     cuf.deallocate
+! CHECK-NOT:     cuf.free
+
+! CHECK-LABEL: func.func @_QPtest_no_implicit_managed_multidim()
+! CHECK-NOT:     cuf.alloc
+! CHECK-NOT:     data_attr = #cuf.cuda<managed>
+! CHECK-NOT:     allocator_idx = 3
+
+! CHECK-LABEL: func.func @_QPtest_no_implicit_managed_module()
+! CHECK-NOT:     cuf.allocate
+! CHECK-NOT:     cuf.deallocate
+! CHECK-NOT:     data_attr = #cuf.cuda<managed>
+! CHECK-NOT:     allocator_idx = 3
+
+! Module global must not be tagged as managed either.
+! CHECK:     fir.global @_QMmod_no_managedEg
+! CHECK-NOT: data_attr = #cuf.cuda<managed>
+! CHECK-NOT: allocator_idx = 3