[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 12:00:19 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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

>From 3367095eb008d805e088c31888d3ecf309873a63 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Thu, 5 Nov 2026 01:50:03 -0800
Subject: [PATCH 15/19] Add ability to override what backend CPU string is used
 for TargetMachine creation

---
 clang/include/clang/Basic/TargetInfo.h | 3 +++
 clang/lib/Basic/Targets/SPIR.h         | 6 ++++++
 clang/lib/CodeGen/BackendUtil.cpp      | 7 ++++---
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index 7215cb8938ffc7..f525c78275e858 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -1392,6 +1392,9 @@ class TargetInfo : public TransferrableTargetInfo,
   /// Get the ABI currently in use.
   virtual StringRef getABI() const { return StringRef(); }
 
+  /// Get the CPU name to pass to the LLVM backend.
+  virtual StringRef getBackendCPU() const { return getTargetOpts().CPU; }
+
   /// Get the C++ ABI currently in use.
   TargetCXXABI getCXXABI() const {
     return TheCXXABI;
diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h
index 492449963dd6b0..babffe33c8b91c 100644
--- a/clang/lib/Basic/Targets/SPIR.h
+++ b/clang/lib/Basic/Targets/SPIR.h
@@ -314,6 +314,12 @@ class LLVM_LIBRARY_VISIBILITY BaseSPIRVTargetInfo : public BaseSPIRTargetInfo {
     return Feature == "spirv";
   }
 
+  // The LLVM SPIR-V backend defines no processors and accepts only "generic";
+  // The -target-cpu value used in BaseSPIRTargetInfo is only used by the
+  // frontend, and the backend / createTargetMachine should not use this 
+  // -target-cpu value to (attempt to) construct an LLVM TargetMachine.
+  StringRef getBackendCPU() const override { return StringRef(); }
+
   virtual bool isAddressSpaceSupersetOf(LangAS A, LangAS B) const override {
     // The generic space AS(4) is a superset of all the other address
     // spaces used by the backend target except constant address space.
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
index f226878f64f6f8..26d573e7b032fb 100644
--- a/clang/lib/CodeGen/BackendUtil.cpp
+++ b/clang/lib/CodeGen/BackendUtil.cpp
@@ -603,8 +603,9 @@ void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
     return;
   Options.MCOptions.LibraryOptions =
       &TheModule->getContext().getLibraryOptions();
-  TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
-                                          Options, RM, CM, OptLevel));
+  TM.reset(
+      TheTarget->createTargetMachine(Triple, CI.getTarget().getBackendCPU(),
+                                     FeaturesStr, Options, RM, CM, OptLevel));
   if (TM)
     TM->setLargeDataThreshold(CodeGenOpts.LargeDataThreshold);
 }
@@ -1374,7 +1375,7 @@ runThinLTOBackend(CompilerInstance &CI, ModuleSummaryIndex *CombinedIndex,
       });
     }
   }
-  Conf.CPU = TOpts.CPU;
+  Conf.CPU = CI.getTarget().getBackendCPU().str();
   Conf.CodeModel = getCodeModel(CGOpts);
   Conf.MAttrs = TOpts.Features;
   Conf.RelocModel = CGOpts.RelocationModel;

>From 3c0fd20f6ee97addb659c7d65e864f9fdc1c0fbd Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Thu, 5 Nov 2026 10:17:25 -0800
Subject: [PATCH 16/19] clang-format

---
 clang/lib/Basic/Targets/SPIR.h           |  2 +-
 clang/test/CodeGen/spirv-backend-cpu.cpp | 24 ++++++++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 clang/test/CodeGen/spirv-backend-cpu.cpp

diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h
index babffe33c8b91c..9fad891c6220d9 100644
--- a/clang/lib/Basic/Targets/SPIR.h
+++ b/clang/lib/Basic/Targets/SPIR.h
@@ -316,7 +316,7 @@ class LLVM_LIBRARY_VISIBILITY BaseSPIRVTargetInfo : public BaseSPIRTargetInfo {
 
   // The LLVM SPIR-V backend defines no processors and accepts only "generic";
   // The -target-cpu value used in BaseSPIRTargetInfo is only used by the
-  // frontend, and the backend / createTargetMachine should not use this 
+  // frontend, and the backend / createTargetMachine should not use this
   // -target-cpu value to (attempt to) construct an LLVM TargetMachine.
   StringRef getBackendCPU() const override { return StringRef(); }
 
diff --git a/clang/test/CodeGen/spirv-backend-cpu.cpp b/clang/test/CodeGen/spirv-backend-cpu.cpp
new file mode 100644
index 00000000000000..e16c155cb0bc67
--- /dev/null
+++ b/clang/test/CodeGen/spirv-backend-cpu.cpp
@@ -0,0 +1,24 @@
+// Offload arch names accepted as -target-cpu on SPIR-V must not be forwarded to
+// the LLVM backend, which defines no processors and would print a
+// non-diagnostic "not a recognized processor" message to stderr. The
+// "target-cpu" IR attribute is still emitted.
+//
+// RUN: %clang_cc1 -triple spirv64-unknown-unknown -target-cpu igca_20ca -emit-llvm -o - %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=IGCA
+// RUN: %clang_cc1 -triple spirv64-unknown-unknown -target-cpu xe-pvc -emit-llvm -o - %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=XE
+// RUN: %clang_cc1 -triple spirv64-unknown-unknown -emit-llvm -o - %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=NONE
+
+int f(int x) { return x + 1; }
+
+// IGCA-NOT: not a recognized processor
+// IGCA: "target-cpu"="igca_20ca"
+// IGCA-NOT: not a recognized processor
+
+// XE-NOT: not a recognized processor
+// XE: "target-cpu"="xe-pvc"
+// XE-NOT: not a recognized processor
+
+// NONE-NOT: not a recognized processor
+// NONE-NOT: "target-cpu"

>From e71c0957b49b212e249cafac2ad5e8d0a6069a89 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Thu, 5 Nov 2026 10:49:16 -0800
Subject: [PATCH 17/19] Fix test comment

---
 ...backend-cpu.cpp => spirv-target-cpu-not-forwarded.cpp} | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
 rename clang/test/CodeGen/{spirv-backend-cpu.cpp => spirv-target-cpu-not-forwarded.cpp} (70%)

diff --git a/clang/test/CodeGen/spirv-backend-cpu.cpp b/clang/test/CodeGen/spirv-target-cpu-not-forwarded.cpp
similarity index 70%
rename from clang/test/CodeGen/spirv-backend-cpu.cpp
rename to clang/test/CodeGen/spirv-target-cpu-not-forwarded.cpp
index e16c155cb0bc67..3c83a23d5b799b 100644
--- a/clang/test/CodeGen/spirv-backend-cpu.cpp
+++ b/clang/test/CodeGen/spirv-target-cpu-not-forwarded.cpp
@@ -1,7 +1,7 @@
-// Offload arch names accepted as -target-cpu on SPIR-V must not be forwarded to
-// the LLVM backend, which defines no processors and would print a
-// non-diagnostic "not a recognized processor" message to stderr. The
-// "target-cpu" IR attribute is still emitted.
+// SPIRV offload arch names accepted via -target-cpu should not be forwarded
+// to LLVM backend: The SPIRV backend only defines a "generic" processor, and
+// any other name forwarded results in a "not a recognized processor"
+// diagnostic. -target-cpu values are only used in the frontend for SPIRV.
 //
 // RUN: %clang_cc1 -triple spirv64-unknown-unknown -target-cpu igca_20ca -emit-llvm -o - %s 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=IGCA

>From c5f960e6c3e9f553fb0bf2384b181d96ef82206d Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Thu, 5 Nov 2026 10:57:02 -0800
Subject: [PATCH 18/19] get rid of isunknownorunused

---
 clang/include/clang/Basic/OffloadArch.h |  1 -
 clang/lib/Basic/Targets/OffloadTarget.h |  4 ++--
 clang/lib/Frontend/InitPreprocessor.cpp | 28 ++++++++++++-------------
 3 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/clang/include/clang/Basic/OffloadArch.h b/clang/include/clang/Basic/OffloadArch.h
index 26fa5eb4cf3dd7..fbf51ffab67922 100644
--- a/clang/include/clang/Basic/OffloadArch.h
+++ b/clang/include/clang/Basic/OffloadArch.h
@@ -96,7 +96,6 @@ 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/lib/Basic/Targets/OffloadTarget.h b/clang/lib/Basic/Targets/OffloadTarget.h
index dcf1b414a90800..313603b6d20623 100644
--- a/clang/lib/Basic/Targets/OffloadTarget.h
+++ b/clang/lib/Basic/Targets/OffloadTarget.h
@@ -26,8 +26,8 @@ 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.
+  /// \return true if \p Arch is an offload device architecture this target
+  /// should accept.
   virtual bool isSupportedOffloadArch(OffloadArch Arch) const { return false; }
 
 public:
diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
index 2ed15dc262e281..76366f826f00d3 100644
--- a/clang/lib/Frontend/InitPreprocessor.cpp
+++ b/clang/lib/Frontend/InitPreprocessor.cpp
@@ -1512,21 +1512,19 @@ 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()) {
-      if (Arch.isIntelIGCA()) {
-        llvm::IntelGPU::IGCATarget IGCA = Arch.igcaTarget();
-
-        Builder.defineMacro("__OFFLOAD_ARCH_IGCA__", Twine(IGCA.getTarget()));
-        if (IGCA.isAnyCompute())
-          Builder.defineMacro("__OFFLOAD_ARCH_IGCA_COMPUTE__");
-        else if (IGCA.isAnyRender())
-          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__");
-      }
+    if (OffloadArch Arch = TI.getOffloadArch(); Arch.isIntelIGCA()) {
+      llvm::IntelGPU::IGCATarget IGCA = Arch.igcaTarget();
+
+      Builder.defineMacro("__OFFLOAD_ARCH_IGCA__", Twine(IGCA.getTarget()));
+      if (IGCA.isAnyCompute())
+        Builder.defineMacro("__OFFLOAD_ARCH_IGCA_COMPUTE__");
+      else if (IGCA.isAnyRender())
+        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 204da00d17c9723598b82e9fcdf6da562ee0825e Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li at intel.com>
Date: Thu, 5 Nov 2026 11:37:28 -0800
Subject: [PATCH 19/19] make supportedoffloadarch apply to spirv32 too

---
 clang/lib/Basic/Targets/SPIR.h                | 26 +++++++------------
 .../spirv-target-cpu-not-forwarded.cpp        |  6 +++++
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h
index 9fad891c6220d9..0b0cf7e70cb03c 100644
--- a/clang/lib/Basic/Targets/SPIR.h
+++ b/clang/lib/Basic/Targets/SPIR.h
@@ -333,6 +333,16 @@ class LLVM_LIBRARY_VISIBILITY BaseSPIRVTargetInfo : public BaseSPIRTargetInfo {
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
+
+protected:
+  bool isSupportedOffloadArch(OffloadArch Arch) const override {
+    // Chipstar, vulkan, and amdhsa triples shouldn't accept a -target-cpu.
+    if (getTriple().getOS() != llvm::Triple::UnknownOS)
+      return false;
+
+    // Valid offload archs for SPIRV:
+    return Arch.isGeneric() || Arch.isIntel();
+  }
 };
 
 class LLVM_LIBRARY_VISIBILITY SPIRVTargetInfo : public BaseSPIRVTargetInfo {
@@ -440,22 +450,6 @@ class LLVM_LIBRARY_VISIBILITY SPIRV64TargetInfo : public BaseSPIRVTargetInfo {
     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);
diff --git a/clang/test/CodeGen/spirv-target-cpu-not-forwarded.cpp b/clang/test/CodeGen/spirv-target-cpu-not-forwarded.cpp
index 3c83a23d5b799b..58fb4c165a285e 100644
--- a/clang/test/CodeGen/spirv-target-cpu-not-forwarded.cpp
+++ b/clang/test/CodeGen/spirv-target-cpu-not-forwarded.cpp
@@ -9,6 +9,12 @@
 // RUN:   | FileCheck %s --check-prefix=XE
 // RUN: %clang_cc1 -triple spirv64-unknown-unknown -emit-llvm -o - %s 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=NONE
+// RUN: %clang_cc1 -triple spirv32-unknown-unknown -target-cpu igca_20ca -emit-llvm -o - %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=IGCA
+// RUN: %clang_cc1 -triple spirv32-unknown-unknown -target-cpu xe-pvc -emit-llvm -o - %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=XE
+// RUN: %clang_cc1 -triple spirv32-unknown-unknown -emit-llvm -o - %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=NONE
 
 int f(int x) { return x + 1; }
 



More information about the cfe-commits mailing list