[clang] [llvm] [offload] Add OpenACC Offload Kind (PR #239432)

Ivan R. Ivanov via cfe-commits cfe-commits at lists.llvm.org
Fri Nov 6 11:58:10 PST 2026


https://github.com/ivanradanov updated https://github.com/llvm/llvm-project/pull/239432

>From 5dec55857418f06e7a51b72a8db1bf6293c2d09a Mon Sep 17 00:00:00 2001
From: Ivan Radanov Ivanov <iivanov at nvidia.com>
Date: Mon, 12 Oct 2026 09:01:34 -0700
Subject: [PATCH 1/2] [offload] Add OpenACC Offload Kind

Add the new OFK_OpenACC to the OffloadKind enum to represent device code
generated by OpenACC. The __tgt_acc_register_lib will be implemented by
the offload/libacctarget runtime, and this separate runtime call is
necessary to distinguish them from kernels compiled for OpenMP, as
calling conventions and kernel launch procedure will differ.
---
 .../ClangLinkerWrapper.cpp                    | 16 ++---
 .../llvm/Frontend/Offloading/OffloadWrapper.h | 10 ++--
 llvm/include/llvm/Object/OffloadBinary.h      |  4 +-
 .../Frontend/Offloading/OffloadWrapper.cpp    | 58 ++++++++++++++-----
 llvm/lib/Object/OffloadBinary.cpp             |  3 +
 llvm/lib/ObjectYAML/OffloadYAML.cpp           |  1 +
 .../ObjectYAML/Offload/enumeration_kinds.yaml |  5 ++
 .../llvm-offload-binary.ll                    | 10 ++++
 .../llvm-offload-wrapper/offload-wrapper.ll   | 17 ++++++
 .../llvm-offload-wrapper.cpp                  |  9 ++-
 10 files changed, 103 insertions(+), 30 deletions(-)

diff --git a/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp b/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
index 9f3976949d3f6b..575c6df7b004d2 100644
--- a/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
+++ b/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
@@ -803,9 +803,10 @@ wrapDeviceImages(ArrayRef<std::unique_ptr<MemoryBuffer>> Buffers,
 
   switch (Kind) {
   case OFK_OpenMP:
-    if (Error Err = offloading::wrapOpenMPBinaries(
+  case OFK_OpenACC:
+    if (Error Err = offloading::wrapOmpAccBinaries(
             M, BuffersToWrap, offloading::getOffloadEntryArray(M),
-            /*Suffix=*/"", /*Relocatable=*/Args.hasArg(OPT_relocatable)))
+            /*Suffix=*/"", /*Relocatable=*/Args.hasArg(OPT_relocatable), Kind))
       return std::move(Err);
     break;
   case OFK_Cuda:
@@ -855,7 +856,7 @@ wrapDeviceImages(ArrayRef<std::unique_ptr<MemoryBuffer>> Buffers,
 
 /// Perform the OpenMP bundling with 'llvm-offload-binary' in verbose mode.
 Expected<SmallVector<std::unique_ptr<MemoryBuffer>>>
-bundleOpenMPVerbose(ArrayRef<OffloadingImage> Images) {
+bundleOmpAccVerbose(ArrayRef<OffloadingImage> Images) {
   Expected<std::string> OffloadBinaryPath = findProgram(
       "llvm-offload-binary", {getExecutableDir("llvm-offload-binary")});
   if (!OffloadBinaryPath)
@@ -898,7 +899,7 @@ bundleOpenMPVerbose(ArrayRef<OffloadingImage> Images) {
 }
 
 Expected<SmallVector<std::unique_ptr<MemoryBuffer>>>
-bundleOpenMP(ArrayRef<OffloadingImage> Images) {
+bundleOmpAcc(ArrayRef<OffloadingImage> Images) {
   SmallVector<std::unique_ptr<MemoryBuffer>> Buffers;
   for (const OffloadingImage &Image : Images)
     Buffers.emplace_back(
@@ -982,8 +983,9 @@ bundleLinkedOutput(ArrayRef<OffloadingImage> Images, const ArgList &Args,
   llvm::TimeTraceScope TimeScope("Bundle linked output");
   switch (Kind) {
   case OFK_OpenMP:
-    return (Verbose && SaveTemps) ? bundleOpenMPVerbose(Images)
-                                  : bundleOpenMP(Images);
+  case OFK_OpenACC:
+    return (Verbose && SaveTemps) ? bundleOmpAccVerbose(Images)
+                                  : bundleOmpAcc(Images);
   case OFK_SYCL:
     return bundleSYCL(Images);
   case OFK_Cuda:
@@ -1149,7 +1151,7 @@ linkAndWrapDeviceFiles(ArrayRef<SmallVector<OffloadFile>> LinkerInputFiles,
       return OutputOrErr.takeError();
 
     // Store the offloading image for each linked output file.
-    for (OffloadKind Kind = OFK_OpenMP; Kind != OFK_LAST;
+    for (OffloadKind Kind = OFK_FIRST; Kind != OFK_LAST;
          Kind = static_cast<OffloadKind>((uint16_t)(Kind) << 1)) {
       if ((ActiveOffloadKindMask & Kind) == 0)
         continue;
diff --git a/llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h b/llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h
index 8d0c98f12b24de..99594ca379d3d7 100644
--- a/llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h
+++ b/llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h
@@ -11,6 +11,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Object/OffloadBinary.h"
 #include "llvm/Support/Compiler.h"
 
 #include <string>
@@ -19,16 +20,17 @@ namespace llvm {
 namespace offloading {
 using EntryArrayTy = std::pair<Constant *, Constant *>;
 /// Wraps the input device images into the module \p M as global symbols and
-/// registers the images with the OpenMP Offloading runtime libomptarget.
+/// registers the images with the OpenMP or OpenACC Offloading runtime
+/// libomptarget or libacctarget.
 /// \param EntryArray Optional pair pointing to the begin and end of the
 /// `__tgt_offload_entry` array.
 /// \param Suffix An optional suffix appended to the emitted symbols.
 /// \param Relocatable Indicate if we need to change the offloading section to
 /// create a relocatable object.
 LLVM_ABI llvm::Error
-wrapOpenMPBinaries(llvm::Module &M, llvm::ArrayRef<llvm::ArrayRef<char>> Images,
-                   EntryArrayTy EntryArray, llvm::StringRef Suffix = "",
-                   bool Relocatable = false);
+wrapOmpAccBinaries(llvm::Module &M, llvm::ArrayRef<llvm::ArrayRef<char>> Images,
+                   EntryArrayTy EntryArray, llvm::StringRef Suffix,
+                   bool Relocatable, object::OffloadKind Kind);
 
 /// Wraps the input fatbinary image into the module \p M as global symbols and
 /// registers the images with the CUDA runtime.
diff --git a/llvm/include/llvm/Object/OffloadBinary.h b/llvm/include/llvm/Object/OffloadBinary.h
index 6bffeb9d9ac1b3..79ed747ba4c2d6 100644
--- a/llvm/include/llvm/Object/OffloadBinary.h
+++ b/llvm/include/llvm/Object/OffloadBinary.h
@@ -35,11 +35,13 @@ namespace object {
 /// The producer of the associated offloading image.
 enum OffloadKind : uint16_t {
   OFK_None = 0,
+  OFK_FIRST = (1 << 0),
   OFK_OpenMP = (1 << 0),
   OFK_Cuda = (1 << 1),
   OFK_HIP = (1 << 2),
   OFK_SYCL = (1 << 3),
-  OFK_LAST = (1 << 4),
+  OFK_OpenACC = (1 << 4),
+  OFK_LAST = (1 << 5),
 };
 
 /// The type of contents the offloading image contains.
diff --git a/llvm/lib/Frontend/Offloading/OffloadWrapper.cpp b/llvm/lib/Frontend/Offloading/OffloadWrapper.cpp
index bcd65513bc8428..3da8fe57948475 100644
--- a/llvm/lib/Frontend/Offloading/OffloadWrapper.cpp
+++ b/llvm/lib/Frontend/Offloading/OffloadWrapper.cpp
@@ -196,20 +196,47 @@ GlobalVariable *createBinDesc(Module &M, ArrayRef<ArrayRef<char>> Bufs,
                             ".omp_offloading.descriptor" + Suffix);
 }
 
+namespace {
+/// Names of the runtime entry points and of the generated static constructor
+/// and destructor for OpenMP and OpenACC.
+struct OmpAccFuncNames {
+  StringRef CtorName;
+  StringRef DtorName;
+  StringRef RegFuncName;
+  StringRef UnregFuncName;
+
+  explicit OmpAccFuncNames(OffloadKind Kind) {
+    if (Kind == OFK_OpenMP) {
+      CtorName = ".omp_offloading.descriptor_reg";
+      DtorName = ".omp_offloading.descriptor_unreg";
+      RegFuncName = "__tgt_register_lib";
+      UnregFuncName = "__tgt_unregister_lib";
+    } else if (Kind == OFK_OpenACC) {
+      CtorName = ".acc.descriptor_reg";
+      DtorName = ".acc.descriptor_unreg";
+      RegFuncName = "__tgt_acc_register_lib";
+      UnregFuncName = "__tgt_acc_unregister_lib";
+    } else {
+      llvm_unreachable("Unexpected Kind - only OpenMP or OpenACC allowed");
+    }
+  }
+};
+} // namespace
+
 Function *createUnregisterFunction(Module &M, GlobalVariable *BinDesc,
-                                   StringRef Suffix) {
+                                   StringRef Suffix, OffloadKind Kind) {
+  OmpAccFuncNames Names(Kind);
   LLVMContext &C = M.getContext();
   auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
-  auto *Func =
-      Function::Create(FuncTy, GlobalValue::InternalLinkage,
-                       ".omp_offloading.descriptor_unreg" + Suffix, &M);
+  auto *Func = Function::Create(FuncTy, GlobalValue::InternalLinkage,
+                                Names.DtorName + Suffix, &M);
   Func->setSection(getStartupSection(M.getTargetTriple()));
 
-  // Get __tgt_unregister_lib function declaration.
+  // Get the unreg function declaration.
   auto *UnRegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(M),
                                         /*isVarArg*/ false);
   FunctionCallee UnRegFuncC =
-      M.getOrInsertFunction("__tgt_unregister_lib", UnRegFuncTy);
+      M.getOrInsertFunction(Names.UnregFuncName, UnRegFuncTy);
 
   // Construct function body
   IRBuilder<> Builder(BasicBlock::Create(C, "entry", Func));
@@ -220,24 +247,24 @@ Function *createUnregisterFunction(Module &M, GlobalVariable *BinDesc,
 }
 
 void createRegisterFunction(Module &M, GlobalVariable *BinDesc,
-                            StringRef Suffix) {
+                            StringRef Suffix, OffloadKind Kind) {
+  OmpAccFuncNames Names(Kind);
   LLVMContext &C = M.getContext();
   auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
   auto *Func = Function::Create(FuncTy, GlobalValue::InternalLinkage,
-                                ".omp_offloading.descriptor_reg" + Suffix, &M);
+                                Names.CtorName + Suffix, &M);
   Func->setSection(getStartupSection(M.getTargetTriple()));
 
-  // Get __tgt_register_lib function declaration.
+  // Get the reg function declaration.
   auto *RegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(M),
                                       /*isVarArg*/ false);
-  FunctionCallee RegFuncC =
-      M.getOrInsertFunction("__tgt_register_lib", RegFuncTy);
+  FunctionCallee RegFuncC = M.getOrInsertFunction(Names.RegFuncName, RegFuncTy);
 
   auto *AtExitTy = FunctionType::get(
       Type::getInt32Ty(C), PointerType::getUnqual(C), /*isVarArg=*/false);
   FunctionCallee AtExit = M.getOrInsertFunction("atexit", AtExitTy);
 
-  Function *UnregFunc = createUnregisterFunction(M, BinDesc, Suffix);
+  Function *UnregFunc = createUnregisterFunction(M, BinDesc, Suffix, Kind);
 
   // Construct function body
   IRBuilder<> Builder(BasicBlock::Create(C, "entry", Func));
@@ -712,15 +739,16 @@ class SYCLWrapper {
 
 } // namespace
 
-Error offloading::wrapOpenMPBinaries(Module &M, ArrayRef<ArrayRef<char>> Images,
+Error offloading::wrapOmpAccBinaries(Module &M, ArrayRef<ArrayRef<char>> Images,
                                      EntryArrayTy EntryArray,
-                                     llvm::StringRef Suffix, bool Relocatable) {
+                                     llvm::StringRef Suffix, bool Relocatable,
+                                     OffloadKind Kind) {
   GlobalVariable *Desc =
       createBinDesc(M, Images, EntryArray, Suffix, Relocatable);
   if (!Desc)
     return createStringError(inconvertibleErrorCode(),
                              "No binary descriptors created.");
-  createRegisterFunction(M, Desc, Suffix);
+  createRegisterFunction(M, Desc, Suffix, Kind);
   return Error::success();
 }
 
diff --git a/llvm/lib/Object/OffloadBinary.cpp b/llvm/lib/Object/OffloadBinary.cpp
index 2cb24eb5b5d669..67d1ba8e3387aa 100644
--- a/llvm/lib/Object/OffloadBinary.cpp
+++ b/llvm/lib/Object/OffloadBinary.cpp
@@ -487,6 +487,7 @@ OffloadKind object::getOffloadKind(StringRef Name) {
       .Case("cuda", OFK_Cuda)
       .Case("hip", OFK_HIP)
       .Case("sycl", OFK_SYCL)
+      .Case("openacc", OFK_OpenACC)
       .Default(OFK_None);
 }
 
@@ -500,6 +501,8 @@ StringRef object::getOffloadKindName(OffloadKind Kind) {
     return "hip";
   case OFK_SYCL:
     return "sycl";
+  case OFK_OpenACC:
+    return "openacc";
   default:
     return "none";
   }
diff --git a/llvm/lib/ObjectYAML/OffloadYAML.cpp b/llvm/lib/ObjectYAML/OffloadYAML.cpp
index f61a2052073aac..c8094da7c3a726 100644
--- a/llvm/lib/ObjectYAML/OffloadYAML.cpp
+++ b/llvm/lib/ObjectYAML/OffloadYAML.cpp
@@ -39,6 +39,7 @@ void ScalarEnumerationTraits<object::OffloadKind>::enumeration(
   ECase(OFK_Cuda);
   ECase(OFK_HIP);
   ECase(OFK_SYCL);
+  ECase(OFK_OpenACC);
   ECase(OFK_LAST);
 #undef ECase
   IO.enumFallback<Hex16>(Value);
diff --git a/llvm/test/ObjectYAML/Offload/enumeration_kinds.yaml b/llvm/test/ObjectYAML/Offload/enumeration_kinds.yaml
index 3e4e68e46c4fb8..0520633ec123a0 100644
--- a/llvm/test/ObjectYAML/Offload/enumeration_kinds.yaml
+++ b/llvm/test/ObjectYAML/Offload/enumeration_kinds.yaml
@@ -9,6 +9,8 @@ Members:
     OffloadKind:      OFK_Cuda
   - ImageKind:        IMG_Cubin
     OffloadKind:      OFK_HIP
+  - ImageKind:        IMG_Object
+    OffloadKind:      OFK_OpenACC
   - ImageKind:        IMG_Fatbinary
   - ImageKind:        IMG_PTX
   - ImageKind:        999
@@ -28,6 +30,9 @@ Members:
 # CHECK-NEXT:   - ImageKind:       IMG_Cubin
 # CHECK-NEXT:     OffloadKind:     OFK_HIP
 # CHECK-NEXT:     Flags:           0
+# CHECK-NEXT:   - ImageKind:       IMG_Object
+# CHECK-NEXT:     OffloadKind:     OFK_OpenACC
+# CHECK-NEXT:     Flags:           0
 # CHECK-NEXT:   - ImageKind:       IMG_Fatbinary
 # CHECK-NEXT:     OffloadKind:     OFK_None
 # CHECK-NEXT:     Flags:           0
diff --git a/llvm/test/tools/llvm-offload-binary/llvm-offload-binary.ll b/llvm/test/tools/llvm-offload-binary/llvm-offload-binary.ll
index 4a4538ea780aa2..541832e8085854 100644
--- a/llvm/test/tools/llvm-offload-binary/llvm-offload-binary.ll
+++ b/llvm/test/tools/llvm-offload-binary/llvm-offload-binary.ll
@@ -136,3 +136,13 @@
 ; Test extracting inner OffloadBinary with --image filter.
 ; RUN: llvm-offload-binary %t7 --image=file=%t8,arch=nested,triple=x-y-z
 ; RUN: diff %t5 %t8
+
+; Test the OpenACC offload kind name round-trips through the binary format.
+; RUN: llvm-offload-binary -o %t.acc --image=file=%s,arch=abc,triple=x-y-z,kind=openacc
+; RUN: llvm-objdump --offloading %t.acc | FileCheck %s --check-prefix=ACC
+
+; ACC:      OFFLOADING IMAGE [0]:
+; ACC-NEXT: kind            <none>
+; ACC-NEXT: arch            abc
+; ACC-NEXT: triple          x-y-z
+; ACC-NEXT: producer        openacc
diff --git a/llvm/test/tools/llvm-offload-wrapper/offload-wrapper.ll b/llvm/test/tools/llvm-offload-wrapper/offload-wrapper.ll
index 9d8abaca5924cb..a85daebd41b415 100644
--- a/llvm/test/tools/llvm-offload-wrapper/offload-wrapper.ll
+++ b/llvm/test/tools/llvm-offload-wrapper/offload-wrapper.ll
@@ -144,3 +144,20 @@
 ; RUN: llvm-dis %t.bc -o - | FileCheck %s --check-prefix=OMP-RELOCATABLE
 
 ; OMP-RELOCATABLE: @.omp_offloading.device_image = internal unnamed_addr constant [{{[0-9]+}} x i8] c"{{.*}}", section ".llvm.offloading.relocatable", align 8
+
+; RUN: llvm-offload-wrapper --triple=x86_64-unknown-linux-gnu -kind=openacc %s -o %t.bc
+; RUN: llvm-dis %t.bc -o - | FileCheck %s --check-prefix=ACC
+
+;      ACC: @.omp_offloading.descriptor = internal constant %__tgt_bin_desc { i32 1, ptr @.omp_offloading.device_images, ptr @__start_llvm_offload_entries, ptr @__stop_llvm_offload_entries }
+;      ACC: define internal void @.acc.descriptor_reg() section ".text.startup" {
+; ACC-NEXT: entry:
+; ACC-NEXT:   call void @__tgt_acc_register_lib(ptr @.omp_offloading.descriptor)
+; ACC-NEXT:   %0 = call i32 @atexit(ptr @.acc.descriptor_unreg)
+; ACC-NEXT:   ret void
+; ACC-NEXT: }
+
+;      ACC: define internal void @.acc.descriptor_unreg() section ".text.startup" {
+; ACC-NEXT: entry:
+; ACC-NEXT:   call void @__tgt_acc_unregister_lib(ptr @.omp_offloading.descriptor)
+; ACC-NEXT:   ret void
+; ACC-NEXT: }
diff --git a/llvm/tools/llvm-offload-wrapper/llvm-offload-wrapper.cpp b/llvm/tools/llvm-offload-wrapper/llvm-offload-wrapper.cpp
index ff5332ada15b4c..4f94109cc42a81 100644
--- a/llvm/tools/llvm-offload-wrapper/llvm-offload-wrapper.cpp
+++ b/llvm/tools/llvm-offload-wrapper/llvm-offload-wrapper.cpp
@@ -39,7 +39,9 @@ static cl::opt<object::OffloadKind> Kind(
     cl::values(clEnumValN(object::OFK_OpenMP, "openmp", "Wrap OpenMP binaries"),
                clEnumValN(object::OFK_Cuda, "cuda", "Wrap CUDA binaries"),
                clEnumValN(object::OFK_HIP, "hip", "Wrap HIP binaries"),
-               clEnumValN(object::OFK_SYCL, "sycl", "Wrap SYCL binaries")));
+               clEnumValN(object::OFK_SYCL, "sycl", "Wrap SYCL binaries"),
+               clEnumValN(object::OFK_OpenACC, "openacc",
+                          "Wrap OpenACC binaries")));
 
 static cl::opt<bool> Relocatable(
     "relocatable",
@@ -72,9 +74,10 @@ static Error wrapImages(ArrayRef<ArrayRef<char>> BuffersToWrap) {
 
   switch (Kind) {
   case llvm::object::OFK_OpenMP:
-    if (Error Err = offloading::wrapOpenMPBinaries(
+  case llvm::object::OFK_OpenACC:
+    if (Error Err = offloading::wrapOmpAccBinaries(
             M, BuffersToWrap, offloading::getOffloadEntryArray(M),
-            /*Suffix=*/"", /*Relocatable=*/Relocatable))
+            /*Suffix=*/"", /*Relocatable=*/Relocatable, Kind))
       return Err;
     break;
   case llvm::object::OFK_Cuda:

>From 9b5c3f25968b00f4b97c6484b96f1f83282e43ba Mon Sep 17 00:00:00 2001
From: "Ivan R. Ivanov" <ivanov.i.aa at m.titech.ac.jp>
Date: Fri, 6 Nov 2026 20:57:59 +0100
Subject: [PATCH 2/2] Update
 llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h

Co-authored-by: Yury Plyakhin <yury.plyakhin at intel.com>
---
 llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h b/llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h
index 99594ca379d3d7..44cb3c501efc35 100644
--- a/llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h
+++ b/llvm/include/llvm/Frontend/Offloading/OffloadWrapper.h
@@ -20,8 +20,8 @@ namespace llvm {
 namespace offloading {
 using EntryArrayTy = std::pair<Constant *, Constant *>;
 /// Wraps the input device images into the module \p M as global symbols and
-/// registers the images with the OpenMP or OpenACC Offloading runtime
-/// libomptarget or libacctarget.
+/// registers the images with the OpenMP (libomptarget) or OpenACC (libacctarget) offloading runtime,
+/// depending on \p Kind.
 /// \param EntryArray Optional pair pointing to the begin and end of the
 /// `__tgt_offload_entry` array.
 /// \param Suffix An optional suffix appended to the emitted symbols.



More information about the cfe-commits mailing list