[clang] [llvm] [Clang][SYCL] Define Intel IGCA preprocessor macro definitions for SYCL during device compilation (PR #227877)

Ian Li via cfe-commits cfe-commits at lists.llvm.org
Thu Nov 5 00:38:58 PST 2026


https://github.com/ianayl updated https://github.com/llvm/llvm-project/pull/227877

>From 6c9b436aec42e9db1e6b60586528c308a1637d43 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Thu, 17 Sep 2026 14:03:24 -0700
Subject: [PATCH 01/14] WIP: Introduce OffloadTargetInfo

---
 clang/include/clang/Basic/OffloadArch.h |  1 +
 clang/include/clang/Basic/TargetInfo.h  |  7 ++++
 clang/lib/Basic/Targets/OffloadTarget.h | 54 +++++++++++++++++++++++++
 clang/lib/Basic/Targets/SPIR.h          |  8 +++-
 clang/lib/Frontend/InitPreprocessor.cpp |  3 ++
 5 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 clang/lib/Basic/Targets/OffloadTarget.h

diff --git a/clang/include/clang/Basic/OffloadArch.h b/clang/include/clang/Basic/OffloadArch.h
index fbf51ffab67922..26fa5eb4cf3dd7 100644
--- a/clang/include/clang/Basic/OffloadArch.h
+++ b/clang/include/clang/Basic/OffloadArch.h
@@ -96,6 +96,7 @@ class OffloadArch {
   bool isGeneric() const { return V == TargetArch::Generic; }
   bool isUnused() const { return V == TargetArch::Unused; }
   bool isUnknown() const { return V == TargetArch::Unknown; }
+  bool isUnknownOrUnused() const { return isUnknown() || isUnused(); }
 
   // Only valid when isNVPTX() / isAMDGPU() respectively.
   llvm::NVPTX::GPUKind nvptxKind() const {
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index a6523e8eaaa437..d7816685f08c61 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -21,6 +21,7 @@
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/OffloadArch.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetCXXABI.h"
 #include "clang/Basic/TargetOptions.h"
@@ -1425,6 +1426,12 @@ class TargetInfo : public TransferrableTargetInfo,
     return isValidCPUName(Name);
   }
 
+  /// Returns an OffloadArch if targeting an offload device, otherwise return
+  /// Unused.
+  virtual OffloadArch getOffloadArch() const {
+    return OffloadArch::getUnused();
+  }
+
   virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const;
 
   /// Determine whether this TargetInfo supports tune in target attribute.
diff --git a/clang/lib/Basic/Targets/OffloadTarget.h b/clang/lib/Basic/Targets/OffloadTarget.h
new file mode 100644
index 00000000000000..afcc2aa0db6e95
--- /dev/null
+++ b/clang/lib/Basic/Targets/OffloadTarget.h
@@ -0,0 +1,54 @@
+//===--- OffloadTarget.h - Declare generic offload target -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares a generic "offload" TargetInfo object.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OFFLOADTARGET_H
+#define LLVM_CLANG_LIB_BASIC_TARGETS_OFFLOADTARGET_H
+
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TargetOptions.h"
+#include "clang/Basic/OffloadArch.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/TargetParser/Triple.h"
+
+namespace clang {
+namespace targets {
+
+class LLVM_LIBRARY_VISIBILITY OffloadTargetInfo : public TargetInfo {
+protected:
+  OffloadArch DeviceArch = OffloadArch::getUnused();
+
+public:
+  OffloadTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { }
+
+  // Clang driver emits -target-cpu to indicate offload device architecture for
+  // both CUDA and SYCL. We override setCPU to capture this offload device
+  // architecture information.
+  bool setCPU(StringRef Name) override {
+    DeviceArch = StringToOffloadArch(Name);
+    return !DeviceArch.isUnknownOrUnused();
+  }
+
+  bool isValidCPUName(StringRef Name) const override {
+    return !StringToOffloadArch(Name).isUnknown();
+  }
+
+  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override {
+    fillValidOffloadArchList(Values);
+  }
+
+  OffloadArch getOffloadArch() const override { return DeviceArch; }
+};
+
+} // namespace targets
+} // namespace clang
+
+#endif // LLVM_CLANG_LIB_BASIC_TARGETS_OFFLOADTARGET_H
\ No newline at end of file
diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h
index 43a94cb9d31c89..bb2a61e1eb9f16 100644
--- a/clang/lib/Basic/Targets/SPIR.h
+++ b/clang/lib/Basic/Targets/SPIR.h
@@ -14,6 +14,7 @@
 #define LLVM_CLANG_LIB_BASIC_TARGETS_SPIR_H
 
 #include "Targets.h"
+#include "OffloadTarget.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticFrontend.h"
@@ -70,7 +71,7 @@ static constexpr LangASMap SPIRDefIsGenMap = {
 };
 
 // Base class for SPIR and SPIR-V target info.
-class LLVM_LIBRARY_VISIBILITY BaseSPIRTargetInfo : public TargetInfo {
+class LLVM_LIBRARY_VISIBILITY BaseSPIRTargetInfo : public OffloadTargetInfo {
   std::unique_ptr<TargetInfo> HostTarget;
 
 protected:
@@ -78,7 +79,7 @@ class LLVM_LIBRARY_VISIBILITY BaseSPIRTargetInfo : public TargetInfo {
   const TargetInfo *getHostTarget() const { return HostTarget.get(); }
 
   BaseSPIRTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
-      : TargetInfo(Triple) {
+      : OffloadTargetInfo(Triple) {
     assert((Triple.isSPIR() || Triple.isSPIRV()) &&
            "Invalid architecture for SPIR or SPIR-V.");
     TLSSupported = false;
@@ -520,6 +521,9 @@ class LLVM_LIBRARY_VISIBILITY SPIRV64AMDGCNTargetInfo final
   // __builtin_amdgcn_processor_is
   bool isValidCPUName(StringRef Name) const override;
   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
+  // AMD does not rely on -target-cpu to set/track CPU/GPU architecture; setCPU
+  // for AMD should not be used and thus unconditionally return false.
+  bool setCPU(StringRef Name) override { return false; }
 };
 
 class LLVM_LIBRARY_VISIBILITY SPIRV64IntelTargetInfo final
diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
index 3e22b6e64676cc..1b3af54e074cda 100644
--- a/clang/lib/Frontend/InitPreprocessor.cpp
+++ b/clang/lib/Frontend/InitPreprocessor.cpp
@@ -1510,6 +1510,9 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
   // SYCL device compiler which doesn't produce host binary.
   if (LangOpts.SYCLIsDevice) {
     Builder.defineMacro("__SYCL_DEVICE_ONLY__", "1");
+    if (OffloadArch Arch = TI.getOffloadArch(); !Arch.isUnknownOrUnused()) {
+      // TODO some sort of function to process -target-cpu
+    }
   }
 
   // OpenCL definitions.

>From 47a92f2548d867bb09e2c174db20b6a2adfc21d9 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Wed, 30 Sep 2026 13:04:21 -0700
Subject: [PATCH 02/14] Add macros indicating IGCA level

---
 clang/include/clang/Basic/TargetInfo.h  |  6 ++----
 clang/lib/Basic/TargetInfo.cpp          |  5 +++++
 clang/lib/Frontend/InitPreprocessor.cpp | 16 ++++++++++++++++
 3 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index d7816685f08c61..6a46b4bebcc25b 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -21,7 +21,6 @@
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
-#include "clang/Basic/OffloadArch.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetCXXABI.h"
 #include "clang/Basic/TargetOptions.h"
@@ -55,6 +54,7 @@ class DiagnosticsEngine;
 class LangOptions;
 class CodeGenOptions;
 class MacroBuilder;
+class OffloadArch;
 
 /// Contains information gathered from parsing the contents of TargetAttr.
 struct ParsedTargetAttr {
@@ -1428,9 +1428,7 @@ class TargetInfo : public TransferrableTargetInfo,
 
   /// Returns an OffloadArch if targeting an offload device, otherwise return
   /// Unused.
-  virtual OffloadArch getOffloadArch() const {
-    return OffloadArch::getUnused();
-  }
+  virtual OffloadArch getOffloadArch() const;
 
   virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const;
 
diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
index 6e390226d2e4b8..43ed97494a3f66 100644
--- a/clang/lib/Basic/TargetInfo.cpp
+++ b/clang/lib/Basic/TargetInfo.cpp
@@ -16,6 +16,7 @@
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/OffloadArch.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
@@ -601,6 +602,10 @@ bool TargetInfo::initFeatureMap(
   return true;
 }
 
+OffloadArch TargetInfo::getOffloadArch() const {
+  return OffloadArch::getUnused();
+}
+
 ParsedTargetAttr TargetInfo::parseTargetAttr(StringRef Features) const {
   ParsedTargetAttr Ret;
   if (Features == "default")
diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
index 1b3af54e074cda..9fe4ce3b2da7eb 100644
--- a/clang/lib/Frontend/InitPreprocessor.cpp
+++ b/clang/lib/Frontend/InitPreprocessor.cpp
@@ -14,6 +14,7 @@
 #include "clang/Basic/DiagnosticLex.h"
 #include "clang/Basic/HLSLRuntime.h"
 #include "clang/Basic/MacroBuilder.h"
+#include "clang/Basic/OffloadArch.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/SyncScope.h"
 #include "clang/Basic/TargetInfo.h"
@@ -27,6 +28,7 @@
 #include "llvm/ADT/APFloat.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/TargetParser/IntelGPUTargetParser.h"
 using namespace clang;
 
 static bool MacroBodyEndsInBackslash(StringRef MacroBody) {
@@ -1512,6 +1514,20 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
     Builder.defineMacro("__SYCL_DEVICE_ONLY__", "1");
     if (OffloadArch Arch = TI.getOffloadArch(); !Arch.isUnknownOrUnused()) {
       // TODO some sort of function to process -target-cpu
+      if (Arch.isIntelIGCA()) {
+        llvm::IntelGPU::IGCATarget IGCA = Arch.igcaTarget();
+
+        Builder.defineMacro("__OFFLOAD_ARCH_IGCA__", Twine(IGCA.getTarget()));
+        if (IGCA.isCompute())
+          Builder.defineMacro("__OFFLOAD_ARCH_IGCA_COMPUTE__");
+        else if (IGCA.isRender())
+          Builder.defineMacro("__OFFLOAD_ARCH_IGCA_RENDER__");
+
+        if (IGCA.isComputeExact())
+          Builder.defineMacro("__OFFLOAD_ARCH_IGCA_COMPUTE_EXACT__");
+        else if (IGCA.isRenderExact())
+          Builder.defineMacro("__OFFLOAD_ARCH_IGCA_RENDER_EXACT__");
+      }
     }
   }
 

>From 65e821a76255943e070b0068518dbc74f9baca79 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Wed, 30 Sep 2026 13:42:41 -0700
Subject: [PATCH 03/14] Test that macros are actually working

---
 clang/test/Preprocessor/sycl-igca-macros.cpp | 44 ++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 clang/test/Preprocessor/sycl-igca-macros.cpp

diff --git a/clang/test/Preprocessor/sycl-igca-macros.cpp b/clang/test/Preprocessor/sycl-igca-macros.cpp
new file mode 100644
index 00000000000000..72c4a5cca06fa6
--- /dev/null
+++ b/clang/test/Preprocessor/sycl-igca-macros.cpp
@@ -0,0 +1,44 @@
+/// Check that IGCA target macros are predefined correctly during SYCL device
+/// compilation if an IGCA target was provided through -target-cpu.
+
+/// Core feature set:
+// RUN: %clang_cc1 %s -fsycl-is-device -target-cpu igca_20 -E -dM \
+// RUN:   | FileCheck %s --check-prefix=CORE --implicit-check-not=__OFFLOAD_ARCH_IGCA
+// CORE: #define __OFFLOAD_ARCH_IGCA__ 20
+
+/// Compute / render feature sets:
+// RUN: %clang_cc1 %s -fsycl-is-device -target-cpu igca_20c -E -dM \
+// RUN:   | FileCheck %s --check-prefix=COMPUTE --implicit-check-not=__OFFLOAD_ARCH_IGCA
+// COMPUTE-DAG: #define __OFFLOAD_ARCH_IGCA__ 20
+// COMPUTE-DAG: #define __OFFLOAD_ARCH_IGCA_COMPUTE__ 1
+
+// RUN: %clang_cc1 %s -fsycl-is-device -target-cpu igca_15r -E -dM \
+// RUN:   | FileCheck %s --check-prefix=RENDER --implicit-check-not=__OFFLOAD_ARCH_IGCA
+// RENDER-DAG: #define __OFFLOAD_ARCH_IGCA__ 15
+// RENDER-DAG: #define __OFFLOAD_ARCH_IGCA_RENDER__ 1
+
+/// Compute-exact / render-exact:
+// RUN: %clang_cc1 %s -fsycl-is-device -target-cpu igca_20ca -E -dM \
+// RUN:   | FileCheck %s --check-prefix=COMPUTE-EXACT --implicit-check-not=__OFFLOAD_ARCH_IGCA
+// COMPUTE-EXACT-DAG: #define __OFFLOAD_ARCH_IGCA__ 20
+// COMPUTE-EXACT-DAG: #define __OFFLOAD_ARCH_IGCA_COMPUTE__ 1
+// COMPUTE-EXACT-DAG: #define __OFFLOAD_ARCH_IGCA_COMPUTE_EXACT__ 1
+
+// RUN: %clang_cc1 %s -fsycl-is-device -target-cpu igca_15ra -E -dM \
+// RUN:   | FileCheck %s --check-prefix=RENDER-EXACT --implicit-check-not=__OFFLOAD_ARCH_IGCA
+// RENDER-EXACT-DAG: #define __OFFLOAD_ARCH_IGCA__ 15
+// RENDER-EXACT-DAG: #define __OFFLOAD_ARCH_IGCA_RENDER__ 1
+// RENDER-EXACT-DAG: #define __OFFLOAD_ARCH_IGCA_RENDER_EXACT__ 1
+
+/// No IGCA macros should be defined without an IGCA target:
+// RUN: %clang_cc1 %s -fsycl-is-device -E -dM \
+// RUN:   | FileCheck %s --check-prefix=NONE --implicit-check-not=__OFFLOAD_ARCH_IGCA
+/// IGCA macros should only be defined during device compilation:
+// RUN: %clang_cc1 %s -triple spirv64-unknown-unknown -target-cpu igca_20ca -E -dM \
+// RUN:   | FileCheck %s --check-prefix=NONE --implicit-check-not=__OFFLOAD_ARCH_IGCA
+// NONE: #define __STDC__ 1
+
+/// Reject unknown IGCA targets:
+// RUN: not %clang_cc1 %s -fsycl-is-device -target-cpu igca_42 -E -dM 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=INVALID
+// INVALID: error: unknown target CPU 'igca_42'

>From 0e0769d5a7f554b8b20b7d06f6f2d1ec64204e74 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Wed, 30 Sep 2026 13:54:16 -0700
Subject: [PATCH 04/14] Remove TODO

---
 clang/lib/Frontend/InitPreprocessor.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
index 9fe4ce3b2da7eb..63a944dcdbbbe7 100644
--- a/clang/lib/Frontend/InitPreprocessor.cpp
+++ b/clang/lib/Frontend/InitPreprocessor.cpp
@@ -1513,7 +1513,6 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
   if (LangOpts.SYCLIsDevice) {
     Builder.defineMacro("__SYCL_DEVICE_ONLY__", "1");
     if (OffloadArch Arch = TI.getOffloadArch(); !Arch.isUnknownOrUnused()) {
-      // TODO some sort of function to process -target-cpu
       if (Arch.isIntelIGCA()) {
         llvm::IntelGPU::IGCATarget IGCA = Arch.igcaTarget();
 

>From 7d78584933696a82af96c407188fd20132ea4022 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Wed, 30 Sep 2026 14:40:22 -0700
Subject: [PATCH 05/14] clang-format

---
 clang/lib/Basic/Targets/OffloadTarget.h | 4 ++--
 clang/lib/Basic/Targets/SPIR.h          | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/clang/lib/Basic/Targets/OffloadTarget.h b/clang/lib/Basic/Targets/OffloadTarget.h
index afcc2aa0db6e95..a121ac699a79fa 100644
--- a/clang/lib/Basic/Targets/OffloadTarget.h
+++ b/clang/lib/Basic/Targets/OffloadTarget.h
@@ -13,9 +13,9 @@
 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OFFLOADTARGET_H
 #define LLVM_CLANG_LIB_BASIC_TARGETS_OFFLOADTARGET_H
 
+#include "clang/Basic/OffloadArch.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
-#include "clang/Basic/OffloadArch.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/TargetParser/Triple.h"
 
@@ -27,7 +27,7 @@ class LLVM_LIBRARY_VISIBILITY OffloadTargetInfo : public TargetInfo {
   OffloadArch DeviceArch = OffloadArch::getUnused();
 
 public:
-  OffloadTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { }
+  OffloadTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
 
   // Clang driver emits -target-cpu to indicate offload device architecture for
   // both CUDA and SYCL. We override setCPU to capture this offload device
diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h
index bb2a61e1eb9f16..feb7aad713fecc 100644
--- a/clang/lib/Basic/Targets/SPIR.h
+++ b/clang/lib/Basic/Targets/SPIR.h
@@ -13,8 +13,8 @@
 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_SPIR_H
 #define LLVM_CLANG_LIB_BASIC_TARGETS_SPIR_H
 
-#include "Targets.h"
 #include "OffloadTarget.h"
+#include "Targets.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticFrontend.h"

>From 2986f4ea5aec93500fda105a962498f9d715306f Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Fri, 23 Oct 2026 18:59:11 -0700
Subject: [PATCH 06/14] fix change in API from base branch

---
 clang/lib/Frontend/InitPreprocessor.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
index 63a944dcdbbbe7..2ed15dc262e281 100644
--- a/clang/lib/Frontend/InitPreprocessor.cpp
+++ b/clang/lib/Frontend/InitPreprocessor.cpp
@@ -1517,9 +1517,9 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
         llvm::IntelGPU::IGCATarget IGCA = Arch.igcaTarget();
 
         Builder.defineMacro("__OFFLOAD_ARCH_IGCA__", Twine(IGCA.getTarget()));
-        if (IGCA.isCompute())
+        if (IGCA.isAnyCompute())
           Builder.defineMacro("__OFFLOAD_ARCH_IGCA_COMPUTE__");
-        else if (IGCA.isRender())
+        else if (IGCA.isAnyRender())
           Builder.defineMacro("__OFFLOAD_ARCH_IGCA_RENDER__");
 
         if (IGCA.isComputeExact())

>From ffef864c1ac2b77e09670c641f2e6cd70b975d30 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Fri, 23 Oct 2026 21:25:56 -0700
Subject: [PATCH 07/14] delete obsolete fillValidCPUList

---
 clang/lib/Basic/Targets/OffloadTarget.h | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/clang/lib/Basic/Targets/OffloadTarget.h b/clang/lib/Basic/Targets/OffloadTarget.h
index a121ac699a79fa..c1680f4f188c80 100644
--- a/clang/lib/Basic/Targets/OffloadTarget.h
+++ b/clang/lib/Basic/Targets/OffloadTarget.h
@@ -41,10 +41,6 @@ class LLVM_LIBRARY_VISIBILITY OffloadTargetInfo : public TargetInfo {
     return !StringToOffloadArch(Name).isUnknown();
   }
 
-  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override {
-    fillValidOffloadArchList(Values);
-  }
-
   OffloadArch getOffloadArch() const override { return DeviceArch; }
 };
 

>From 1b3675dbedf91c656479158eec7da8e2933f5a18 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Sat, 24 Oct 2026 00:07:04 -0700
Subject: [PATCH 08/14] When an obviously wrong IGCA target is provided,
 provide a list of valid IGCA targets

---
 clang/test/Driver/sycl-offload-arch-igca.cpp    |  2 ++
 .../llvm/TargetParser/IntelGPUTargetParser.h    |  3 +++
 llvm/lib/TargetParser/IntelGPUTargetParser.cpp  | 17 +++++++++++++++++
 3 files changed, 22 insertions(+)

diff --git a/clang/test/Driver/sycl-offload-arch-igca.cpp b/clang/test/Driver/sycl-offload-arch-igca.cpp
index bbc44629dfb6c3..f04c81fc6adb7b 100644
--- a/clang/test/Driver/sycl-offload-arch-igca.cpp
+++ b/clang/test/Driver/sycl-offload-arch-igca.cpp
@@ -10,6 +10,7 @@
 // RUN:   --offload-targets=spirv64-unknown-unknown --offload-arch=igca_42a \
 // RUN:   -c %s 2>&1 | FileCheck -check-prefix=CHK-INVALID %s
 // CHK-INVALID: error: unsupported IGCA gpu architecture: igca_42a
+// CHK-INVALID-NEXT: note: valid target CPU values are: igca_{{.*}}
 // CHK-INVALID-NOT: llvm-offload-binary
 
 /// IGCA targets should not accept feature suffixes, so a valid target followed
@@ -18,6 +19,7 @@
 // RUN:   --offload-targets=spirv64-unknown-unknown --offload-arch=igca_20ca:foo \
 // RUN:   -c %s 2>&1 | FileCheck -check-prefix=CHK-FEATURE %s
 // CHK-FEATURE: error: unsupported IGCA gpu architecture: igca_20ca:foo
+// CHK-FEATURE-NEXT: note: valid target CPU values are: igca_{{.*}}
 // CHK-FEATURE-NOT: llvm-offload-binary
 
 /// A valid IGCA target is still rejected on NVPTX and AMDGPU device triples.
diff --git a/llvm/include/llvm/TargetParser/IntelGPUTargetParser.h b/llvm/include/llvm/TargetParser/IntelGPUTargetParser.h
index 3e9f7ef82b41d4..474293221a1b6e 100644
--- a/llvm/include/llvm/TargetParser/IntelGPUTargetParser.h
+++ b/llvm/include/llvm/TargetParser/IntelGPUTargetParser.h
@@ -176,6 +176,9 @@ LLVM_ABI IGCATarget parseIGCATarget(StringRef MaybeTarget);
 /// \p Target is invalid.
 LLVM_ABI StringRef getIGCATargetName(IGCATarget Target);
 
+/// Append every valid IGCA target spelling to \p Values.
+LLVM_ABI void fillValidIGCATargetList(SmallVectorImpl<StringRef> &Values);
+
 } // namespace IntelGPU
 } // namespace llvm
 
diff --git a/llvm/lib/TargetParser/IntelGPUTargetParser.cpp b/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
index efc171de4d8db3..a80fff796d1ae2 100644
--- a/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
+++ b/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
@@ -13,6 +13,7 @@
 #include "llvm/TargetParser/IntelGPUTargetParser.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -197,3 +198,19 @@ StringRef llvm::IntelGPU::getIGCATargetName(IGCATarget T) {
       return E.Name;
   return "";
 }
+
+void llvm::IntelGPU::fillValidIGCATargetList(
+    SmallVectorImpl<StringRef> &Values) {
+  // fillValidIGCATargetList is currently only used for diagnostics, similar to
+  // how other fillValid* functions are used. We can thus afford to generate
+  // this list when we actually need it:
+  SmallVector<IGCATarget> Targets;
+#define INTEL_IGCA_TARGET(NAME, TARGET, FEATURE_SET)                           \
+  Targets.push_back(IGCATarget(TARGET, IGCAFeatureSet::FEATURE_SET));
+#include "llvm/TargetParser/IntelGPUTargetParser.def"
+  llvm::sort(Targets,
+             [](IGCATarget A, IGCATarget B) { return A.pack() < B.pack(); });
+  Targets.erase(llvm::unique(Targets), Targets.end());
+  for (IGCATarget T : Targets)
+    Values.push_back(getIGCATargetName(T));
+}

>From bd3447e68b761610e8c19ea77de0b7733c3f3694 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Sat, 24 Oct 2026 00:31:50 -0700
Subject: [PATCH 09/14] formatting changes

---
 clang/include/clang/Basic/TargetInfo.h  | 6 ++++--
 clang/lib/Basic/Targets/OffloadTarget.h | 8 ++++----
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index 6a46b4bebcc25b..7fad8de84fc0d7 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -1426,8 +1426,10 @@ class TargetInfo : public TransferrableTargetInfo,
     return isValidCPUName(Name);
   }
 
-  /// Returns an OffloadArch if targeting an offload device, otherwise return
-  /// Unused.
+  /// Returns the OffloadArch if targeting an offload device, otherwise returns
+  /// OffloadArch::getUnused().
+  virtual OffloadArch getOffloadArch() const;
+
   virtual OffloadArch getOffloadArch() const;
 
   virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const;
diff --git a/clang/lib/Basic/Targets/OffloadTarget.h b/clang/lib/Basic/Targets/OffloadTarget.h
index c1680f4f188c80..def181b5847dd8 100644
--- a/clang/lib/Basic/Targets/OffloadTarget.h
+++ b/clang/lib/Basic/Targets/OffloadTarget.h
@@ -29,10 +29,10 @@ class LLVM_LIBRARY_VISIBILITY OffloadTargetInfo : public TargetInfo {
 public:
   OffloadTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
 
-  // Clang driver emits -target-cpu to indicate offload device architecture for
-  // both CUDA and SYCL. We override setCPU to capture this offload device
-  // architecture information.
   bool setCPU(StringRef Name) override {
+    // Clang driver emits -target-cpu to indicate offload device architecture
+    // for both CUDA and SYCL. We override setCPU to capture this offload device
+    // architecture information.
     DeviceArch = StringToOffloadArch(Name);
     return !DeviceArch.isUnknownOrUnused();
   }
@@ -47,4 +47,4 @@ class LLVM_LIBRARY_VISIBILITY OffloadTargetInfo : public TargetInfo {
 } // namespace targets
 } // namespace clang
 
-#endif // LLVM_CLANG_LIB_BASIC_TARGETS_OFFLOADTARGET_H
\ No newline at end of file
+#endif // LLVM_CLANG_LIB_BASIC_TARGETS_OFFLOADTARGET_H

>From c127b5ed588a739fccc8e70df0b34c9994d04f7e Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Sat, 24 Oct 2026 12:35:56 -0700
Subject: [PATCH 10/14] editing things in vsode's diff browser is a bad idea
 and I should've known

---
 clang/include/clang/Basic/TargetInfo.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index 7fad8de84fc0d7..7215cb8938ffc7 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -1430,8 +1430,6 @@ class TargetInfo : public TransferrableTargetInfo,
   /// OffloadArch::getUnused().
   virtual OffloadArch getOffloadArch() const;
 
-  virtual OffloadArch getOffloadArch() const;
-
   virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const;
 
   /// Determine whether this TargetInfo supports tune in target attribute.

>From b68890d8f069e0a6ccfa6f83af0eafc4134ec1bf Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Wed, 4 Nov 2026 08:02:18 -0800
Subject: [PATCH 11/14] Later changes to IGCATarget et al got rid of the
 INTEL_IGCA_TARGET table generated at compile time

---
 llvm/lib/TargetParser/IntelGPUTargetParser.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/llvm/lib/TargetParser/IntelGPUTargetParser.cpp b/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
index a80fff796d1ae2..f7fd4b356e79af 100644
--- a/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
+++ b/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
@@ -203,11 +203,11 @@ void llvm::IntelGPU::fillValidIGCATargetList(
     SmallVectorImpl<StringRef> &Values) {
   // fillValidIGCATargetList is currently only used for diagnostics, similar to
   // how other fillValid* functions are used. We can thus afford to generate
-  // this list when we actually need it:
+  // this list here:
   SmallVector<IGCATarget> Targets;
-#define INTEL_IGCA_TARGET(NAME, TARGET, FEATURE_SET)                           \
-  Targets.push_back(IGCATarget(TARGET, IGCAFeatureSet::FEATURE_SET));
-#include "llvm/TargetParser/IntelGPUTargetParser.def"
+  for (const IGCATargetNameEntry &E : IGCATargetNames)
+    if (IGCATarget T(E.Target, E.FeatureSet); T.isValid())
+      Targets.push_back(T);
   llvm::sort(Targets,
              [](IGCATarget A, IGCATarget B) { return A.pack() < B.pack(); });
   Targets.erase(llvm::unique(Targets), Targets.end());

>From 0a2e74c2df645cdacaeb0fbb1798a44f4e780be8 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Wed, 4 Nov 2026 09:05:56 -0800
Subject: [PATCH 12/14] Oops, restore this diagnostic

---
 clang/lib/Driver/Driver.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
index 9d95f69f1bbfe1..29df938800efc6 100644
--- a/clang/lib/Driver/Driver.cpp
+++ b/clang/lib/Driver/Driver.cpp
@@ -110,6 +110,7 @@
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/IntelGPUTargetParser.h"
 #include "llvm/TargetParser/RISCVISAInfo.h"
 #include <cstdlib> // ::getenv
 #include <map>
@@ -3988,6 +3989,10 @@ static StringRef getCanonicalArchString(Compilation &C,
     // SPIR-V target checks below.
     C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
         << "IGCA" << ArchStr;
+    SmallVector<StringRef, 32> ValidList;
+    llvm::IntelGPU::fillValidIGCATargetList(ValidList);
+    C.getDriver().Diag(clang::diag::note_valid_options)
+        << llvm::join(ValidList, ", ");
     return StringRef();
   } else if (Kind == Action::OFK_SYCL && isPlainSPIRV(Triple) &&
              !ArchStr.empty() && !Arch.isIntel() && !Arch.isGeneric()) {

>From a8ba00d38813f5087604425268d108b3c664d8bc Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Wed, 4 Nov 2026 09:27:00 -0800
Subject: [PATCH 13/14] clang-format

---
 llvm/lib/TargetParser/IntelGPUTargetParser.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/llvm/lib/TargetParser/IntelGPUTargetParser.cpp b/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
index f7fd4b356e79af..b0727d70c28577 100644
--- a/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
+++ b/llvm/lib/TargetParser/IntelGPUTargetParser.cpp
@@ -12,8 +12,8 @@
 
 #include "llvm/TargetParser/IntelGPUTargetParser.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/ErrorHandling.h"

>From 46fc914e395f5202a5147e4d81ba9a69b9f74abf Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Wed, 4 Nov 2026 23:37:02 -0800
Subject: [PATCH 14/14] start rejecting bad archs on setCPU

---
 clang/lib/Basic/Targets/OffloadTarget.h | 18 +++++++++---------
 clang/lib/Basic/Targets/SPIR.h          | 20 +++++++++++++++++---
 2 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/clang/lib/Basic/Targets/OffloadTarget.h b/clang/lib/Basic/Targets/OffloadTarget.h
index def181b5847dd8..dcf1b414a90800 100644
--- a/clang/lib/Basic/Targets/OffloadTarget.h
+++ b/clang/lib/Basic/Targets/OffloadTarget.h
@@ -26,19 +26,19 @@ class LLVM_LIBRARY_VISIBILITY OffloadTargetInfo : public TargetInfo {
 protected:
   OffloadArch DeviceArch = OffloadArch::getUnused();
 
+  /// \return true if \p Arch is an offload device architecture this target can
+  /// compile for.
+  virtual bool isSupportedOffloadArch(OffloadArch Arch) const { return false; }
+
 public:
   OffloadTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
 
   bool setCPU(StringRef Name) override {
-    // Clang driver emits -target-cpu to indicate offload device architecture
-    // for both CUDA and SYCL. We override setCPU to capture this offload device
-    // architecture information.
-    DeviceArch = StringToOffloadArch(Name);
-    return !DeviceArch.isUnknownOrUnused();
-  }
-
-  bool isValidCPUName(StringRef Name) const override {
-    return !StringToOffloadArch(Name).isUnknown();
+    OffloadArch Arch = StringToOffloadArch(Name);
+    if (!isSupportedOffloadArch(Arch))
+      return false;
+    DeviceArch = Arch;
+    return true;
   }
 
   OffloadArch getOffloadArch() const override { return DeviceArch; }
diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h
index feb7aad713fecc..492449963dd6b0 100644
--- a/clang/lib/Basic/Targets/SPIR.h
+++ b/clang/lib/Basic/Targets/SPIR.h
@@ -433,6 +433,23 @@ class LLVM_LIBRARY_VISIBILITY SPIRV64TargetInfo : public BaseSPIRVTargetInfo {
   std::optional<LangAS> getConstantAddressSpace() const override {
     return ConstantAS;
   }
+
+protected:
+  bool isSupportedOffloadArch(OffloadArch Arch) const override {
+    // Generic OffloadArch is used for SYCL JIT and should be accepted.
+    if (Arch.isGeneric())
+      // spirv64-*-chipstar or spirv64-*-vulkan triples shouldn't support
+      // offload arch.
+      return getTriple().getOS() == llvm::Triple::UnknownOS;
+
+    // Intel OffloadArch will be supported for SYCL and should be accepted.
+    if (Arch.isIntel())
+      return getTriple().getOS() == llvm::Triple::UnknownOS;
+
+    return false;
+  }
+
+public:
   void adjust(DiagnosticsEngine &Diags, LangOptions &Opts,
               const TargetInfo *Aux) override {
     BaseSPIRVTargetInfo::adjust(Diags, Opts, Aux);
@@ -521,9 +538,6 @@ class LLVM_LIBRARY_VISIBILITY SPIRV64AMDGCNTargetInfo final
   // __builtin_amdgcn_processor_is
   bool isValidCPUName(StringRef Name) const override;
   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
-  // AMD does not rely on -target-cpu to set/track CPU/GPU architecture; setCPU
-  // for AMD should not be used and thus unconditionally return false.
-  bool setCPU(StringRef Name) override { return false; }
 };
 
 class LLVM_LIBRARY_VISIBILITY SPIRV64IntelTargetInfo final



More information about the cfe-commits mailing list