diff --git a/.github/workflows/sycl-linux-build.yml b/.github/workflows/sycl-linux-build.yml
index 54c5bcbaf9cea..19a80f14d5ecd 100644
--- a/.github/workflows/sycl-linux-build.yml
+++ b/.github/workflows/sycl-linux-build.yml
@@ -152,6 +152,9 @@ jobs:
     env:
       CCACHE_DIR: ${{ inputs.build_cache_root }}/build_cache_${{ inputs.build_cache_suffix }}
       CCACHE_MAXSIZE: 8G
+      # Intel GPU architectures of the run-only E2E runners in
+      # sycl-linux-precommit.yml. Keep in sync when adding or removing one.
+      GPU_AOT_TARGET: intel_gpu_tgllp,intel_gpu_acm_g10,intel_gpu_pvc,intel_gpu_bmg_g21,intel_gpu_mtl_u
     steps:
     - name: Deduce artifact archive params
       # To reduce number of inputs parameters that is limited for manual triggers.
@@ -330,7 +333,7 @@ jobs:
         target_devices: all
         binaries_artifact: ${{ inputs.e2e_binaries_artifact }}
         sycl_compiler: $GITHUB_WORKSPACE/toolchain/bin/dpclang++
-        extra_lit_opts: --param sycl_build_targets="spir;nvidia"
+        extra_lit_opts: --param sycl_build_targets="spir;nvidia" --param gpu_aot_target=${{ env.GPU_AOT_TARGET }}
 
     - name: Build E2E tests with NewOffloadModel
       if: |
@@ -345,7 +348,7 @@ jobs:
         target_devices: all
         binaries_artifact: ${{ inputs.e2e_binaries_new_offload_model_artifact }}
         sycl_compiler: $GITHUB_WORKSPACE/toolchain/bin/dpclang++
-        extra_lit_opts: --param sycl_build_targets="spir;nvidia" --param enable_new_offload_model=True
+        extra_lit_opts: --param sycl_build_targets="spir;nvidia" --param enable_new_offload_model=True --param gpu_aot_target=${{ env.GPU_AOT_TARGET }}
 
     - name: Build E2E tests with SPIR-V Backend
       if: ${{ inputs.e2e_binaries_spirv_backend_artifact && !cancelled() && steps.build.conclusion == 'success' }}
@@ -356,7 +359,7 @@ jobs:
         target_devices: all
         binaries_artifact: ${{ inputs.e2e_binaries_spirv_backend_artifact }}
         sycl_compiler: $GITHUB_WORKSPACE/toolchain/bin/dpclang++
-        extra_lit_opts: --param spirv-backend=True
+        extra_lit_opts: --param spirv-backend=True --param gpu_aot_target=${{ env.GPU_AOT_TARGET }}
 
     - name: Build E2E tests in Preview Mode
       if: ${{ inputs.e2e_binaries_preview_artifact && !cancelled() && steps.build.conclusion == 'success' && !startsWith(github.base_ref, 'sycl-rel-') }}
@@ -367,4 +370,4 @@ jobs:
         target_devices: all
         binaries_artifact: ${{ inputs.e2e_binaries_preview_artifact }}
         sycl_compiler: $GITHUB_WORKSPACE/toolchain/bin/dpclang++
-        extra_lit_opts: --param test-preview-mode=True
+        extra_lit_opts: --param test-preview-mode=True --param gpu_aot_target=${{ env.GPU_AOT_TARGET }}
diff --git a/.github/workflows/sycl-linux-precommit.yml b/.github/workflows/sycl-linux-precommit.yml
index 68a6ce9f939ee..c473b3830140d 100644
--- a/.github/workflows/sycl-linux-precommit.yml
+++ b/.github/workflows/sycl-linux-precommit.yml
@@ -142,6 +142,8 @@ jobs:
         echo FILTER_6_2="$(grep -v '^#\|^\W*$' devops/compat_ci_exclude.sycl-rel-6_2 | paste -sd '|')" >> $GITHUB_OUTPUT
         echo FILTER_6_3="$(grep -v '^#\|^\W*$' devops/compat_ci_exclude.sycl-rel-6_3 | paste -sd '|')" >> $GITHUB_OUTPUT
 
+  # The E2E binaries run here are built for GPU_AOT_TARGET in
+  # sycl-linux-build.yml; update it when adding or removing an Intel GPU runner.
   E2E:
     needs: [build, detect_changes, compat_read_exclude]
     if: ${{ !cancelled() && needs.build.outputs.build_conclusion == 'success' }}
diff --git a/.github/workflows/sycl-windows-build.yml b/.github/workflows/sycl-windows-build.yml
index 5d8edfde7bf45..da370d946fe8a 100644
--- a/.github/workflows/sycl-windows-build.yml
+++ b/.github/workflows/sycl-windows-build.yml
@@ -104,6 +104,11 @@ jobs:
     runs-on: [Windows, build]
     outputs:
       build_conclusion: ${{ steps.build.conclusion }}
+    env:
+      # Intel GPU architectures of the run-only E2E runners in
+      # sycl-windows-precommit.yml. Keep in sync when adding or removing one.
+      # Gen12 and older (gen12 runner) are not supported by Windows ocloc.
+      GPU_AOT_TARGET: intel_gpu_acm_g10,intel_gpu_bmg_g21
     steps:
     - name:  Detect hung tests
       if: always()
@@ -257,7 +262,7 @@ jobs:
         testing_mode: build-only
         target_devices: all
         binaries_artifact: ${{ inputs.e2e_binaries_artifact }}
-        extra_lit_opts: --param sycl_build_targets="spir"
+        extra_lit_opts: --param sycl_build_targets="spir" --param gpu_aot_target=${{ env.GPU_AOT_TARGET }}
         cxx: ${{ inputs.cxx }}
 
     - name: Build E2E tests with New Offload Model
@@ -272,7 +277,7 @@ jobs:
         testing_mode: build-only
         target_devices: all
         binaries_artifact: ${{ inputs.e2e_binaries_new_offload_model_artifact }}
-        extra_lit_opts: --param sycl_build_targets="spir" --param enable_new_offload_model=True
+        extra_lit_opts: --param sycl_build_targets="spir" --param enable_new_offload_model=True --param gpu_aot_target=${{ env.GPU_AOT_TARGET }}
         cxx: ${{ inputs.cxx }}
 
     - name:  Detect hung tests
diff --git a/.github/workflows/sycl-windows-precommit.yml b/.github/workflows/sycl-windows-precommit.yml
index 4c747545df5bf..2290861ce13eb 100644
--- a/.github/workflows/sycl-windows-precommit.yml
+++ b/.github/workflows/sycl-windows-precommit.yml
@@ -60,6 +60,8 @@ jobs:
       e2e_binaries_artifact: sycl_windows_e2ebin
       e2e_binaries_new_offload_model_artifact: sycl_windows_e2ebin_with_new_offload_model
 
+  # The E2E binaries run here are built for GPU_AOT_TARGET in
+  # sycl-windows-build.yml; update it when adding or removing an Intel GPU runner.
   run_prebuilt_e2e_tests:
     needs: build
     # Continue if build was successful.
diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td
index 940bb310858e8..6aa759e5cc49e 100644
--- a/clang/include/clang/Basic/DiagnosticDriverKinds.td
+++ b/clang/include/clang/Basic/DiagnosticDriverKinds.td
@@ -483,6 +483,8 @@ def err_drv_sycl_thinlto_split_off: Error<
   "'%0' is not supported when '%1' is set with '-fsycl'">;
 def err_drv_sycl_offload_arch_new_driver: Error<
   "'--offload-arch' is supported when '-fsycl' is set with '--offload-new-driver'">;
+def err_drv_not_supported_new_model : Error<
+  "'%0' is not supported with the new offloading model; use '%1' instead">;
 def err_drv_sycl_offload_arch_missing_value : Error<
   "must pass in an explicit cpu or gpu architecture to '--offload-arch'">;
 def warn_drv_offload_target_duplicate
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
index 17d5fb6081a9a..a93b7f4d9f1ea 100644
--- a/clang/lib/Driver/Driver.cpp
+++ b/clang/lib/Driver/Driver.cpp
@@ -1260,6 +1260,46 @@ static void diagnoseSYCLOptions(Compilation &C, bool IsSYCL) {
           << SYCLForceTarget->getAsString(C.getInputArgs());
   }
 
+  // spir64_gen is deprecated in favor of intel_gpu_<arch>, both as a
+  // -fsycl-targets value and as the triple of the -X<tool>= options. It is not
+  // supported with the new offloading model, and will be removed together with
+  // the old offloading model.
+  if (IsSYCL) {
+    const Driver &D = C.getDriver();
+    // Target is a SYCL target as given on the command line, e.g. spir64_gen,
+    // spir64_gen-unknown-unknown or intel_gpu_pvc.
+    auto IsSPIRGenTarget = [&](StringRef Target) {
+      llvm::Triple TT = D.getSYCLDeviceTriple(Target);
+      return TT.isSPIR() && TT.getSubArch() == llvm::Triple::SPIRSubArch_gen;
+    };
+    auto DiagnoseSPIRGenTarget = [&](StringRef Spelling, StringRef Target) {
+      std::string Opt = (Spelling + Target).str();
+      std::string Replacement = (Spelling + "intel_gpu_<arch>").str();
+      if (D.getUseNewOffloadingDriver())
+        D.Diag(diag::err_drv_not_supported_new_model) << Opt << Replacement;
+      else
+        D.Diag(diag::warn_drv_deprecated_option_release)
+            << Opt << /*HasReplacement=*/true << Replacement;
+    };
+
+    for (const Arg *A :
+         C.getInputArgs().filtered(options::OPT_offload_targets_EQ)) {
+      // Report the spelling the user wrote, e.g. -fsycl-targets=.
+      StringRef Spelling =
+          A->getAlias() ? A->getAlias()->getSpelling() : A->getSpelling();
+      for (StringRef Target : A->getValues())
+        if (IsSPIRGenTarget(Target))
+          DiagnoseSPIRGenTarget(Spelling, Target);
+    }
+    for (const Arg *A : C.getInputArgs().filtered(
+             options::OPT_Xsycl_backend_EQ, options::OPT_Xsycl_frontend_EQ,
+             options::OPT_Xsycl_linker_EQ, options::OPT_Xspirv_translator_EQ,
+             options::OPT_Xdevice_post_link_EQ,
+             options::OPT_Xspirv_to_ir_wrapper_EQ))
+      if (IsSPIRGenTarget(A->getValue()))
+        DiagnoseSPIRGenTarget(A->getSpelling(), A->getValue());
+  }
+
   // Check if -fsycl-host-compiler is used in conjunction with -fsycl.
   Arg *SYCLHostCompiler =
       getArgRequiringSYCLRuntime(options::OPT_fsycl_host_compiler_EQ);
diff --git a/clang/test/Driver/sycl-device-lib.cpp b/clang/test/Driver/sycl-device-lib.cpp
index 4b4f08ee96e30..c8b6f9b347950 100644
--- a/clang/test/Driver/sycl-device-lib.cpp
+++ b/clang/test/Driver/sycl-device-lib.cpp
@@ -51,21 +51,6 @@
 // RUN: -Xarch_device -fsanitize=address -### 2>&1 | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_PVC
 // RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_12_60_7 --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
 // RUN: -Xarch_device -fsanitize=address -### 2>&1 | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_PVC
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xsycl-target-backend "-device pvc" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_PVC
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xsycl-target-backend=spir64_gen "-device pvc" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_PVC
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xsycl-target-backend "-device 12.60.7" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_PVC
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xs "-device pvc" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_PVC
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xs "-device 12.60.7" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_PVC
 // SYCL_DEVICE_LIB_ASAN_PVC: clang{{.*}} "-mlink-builtin-bitcode" "{{.*}}libsycl-crt.bc"
 // SYCL_DEVICE_LIB_ASAN_PVC-SAME: {{.*}}libsycl-cmath.bc
 // SYCL_DEVICE_LIB_ASAN_PVC-SAME: {{.*}}libsycl-imf.bc
@@ -100,19 +85,12 @@
 /// test behavior of linking libsycl-asan-dg2 for DG2 target AOT compilation when asan flag is applied.
 // RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_dg2_g10 --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
 // RUN: -Xarch_device -fsanitize=address -### 2>&1 | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_DG2
+// RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_dg2 --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
+// RUN: -Xarch_device -fsanitize=address -### 2>&1 | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_DG2
 // RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_12_55_8 --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
 // RUN: -Xarch_device -fsanitize=address -### 2>&1 | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_DG2
 // RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_acm_g10 --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
 // RUN: -Xarch_device -fsanitize=address -### 2>&1 | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_DG2
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xsycl-target-backend "-device dg2" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_DG2
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xsycl-target-backend=spir64_gen "-device dg2" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_DG2
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xs "-device dg2" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_DG2
 // SYCL_DEVICE_LIB_ASAN_DG2: clang{{.*}} "-mlink-builtin-bitcode" "{{.*}}libsycl-crt.bc"
 // SYCL_DEVICE_LIB_ASAN_DG2-SAME: {{.*}}libsycl-cmath.bc
 // SYCL_DEVICE_LIB_ASAN_DG2-SAME: {{.*}}libsycl-imf.bc
@@ -121,11 +99,8 @@
 /// ###########################################################################
 /// test behavior of linking libsycl-asan for multiple targets AOT compilation
 /// when asan flag is applied.
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xsycl-target-backend "-device pvc,dg2" -### 2>&1 \
-// RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_MUL
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen --offload-new-driver %s --sysroot=%S/Inputs/SYCL \
-// RUN: -Xarch_device -fsanitize=address -Xsycl-target-backend=spir64_gen "-device pvc,dg2" -### 2>&1 \
+// RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_pvc,intel_gpu_dg2 --offload-new-driver %s \
+// RUN: --sysroot=%S/Inputs/SYCL -Xarch_device -fsanitize=address -### 2>&1 \
 // RUN: | FileCheck %s -check-prefix=SYCL_DEVICE_LIB_ASAN_MUL
 // SYCL_DEVICE_LIB_ASAN_MUL: clang{{.*}} "-mlink-builtin-bitcode" "{{.*}}libsycl-crt.bc"
 // SYCL_DEVICE_LIB_ASAN_MUL-SAME: {{.*}}libsycl-cmath.bc
diff --git a/clang/test/Driver/sycl-device-post-link-opt.cpp b/clang/test/Driver/sycl-device-post-link-opt.cpp
index cd42a8787b18b..c043f44488fa8 100644
--- a/clang/test/Driver/sycl-device-post-link-opt.cpp
+++ b/clang/test/Driver/sycl-device-post-link-opt.cpp
@@ -5,10 +5,10 @@
 // RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xdevice-post-link "foo" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-SINGLE-TARGET
 
-// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xdevice-post-link=spir64_gen "foo" -### %s 2>&1 | \
+// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xdevice-post-link=intel_gpu_pvc "foo" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-SINGLE-TARGET-UNUSED --implicit-check-not 'sycl-post-link{{.*}} "foo"'
 
-// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64,spir64_gen -Xdevice-post-link=spir64_gen "foo" -Xdevice-post-link=spir64 "bar" -### %s 2>&1 | \
+// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64,intel_gpu_pvc -Xdevice-post-link=intel_gpu_pvc "foo" -Xdevice-post-link=spir64 "bar" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-MULTIPLE-TARGET --implicit-check-not 'sycl-post-link{{.*}} "foo" "bar"'
 
 // Each token is forwarded as its own --sycl-post-link-options occurrence.
@@ -20,7 +20,7 @@
 
 // CHECK-SINGLE-TARGET: clang-linker-wrapper{{.*}} {{.*}}--sycl-post-link-options={{.*}}foo{{.*}}
 
-// CHECK-SINGLE-TARGET-UNUSED: argument unused during compilation: '-Xdevice-post-link=spir64_gen foo'
+// CHECK-SINGLE-TARGET-UNUSED: argument unused during compilation: '-Xdevice-post-link=intel_gpu_pvc foo'
 
 // CHECK-MULTIPLE-TARGET: clang-linker-wrapper{{.*}} {{.*}}"--sycl-post-link-options=sycl:spir64-unknown-unknown=bar"{{.*}}"--sycl-post-link-options=sycl:spir64_gen-unknown-unknown=foo"
 
diff --git a/clang/test/Driver/sycl-device-traits-macros.cpp b/clang/test/Driver/sycl-device-traits-macros.cpp
index 1dda50b94c383..377ded08e70fb 100644
--- a/clang/test/Driver/sycl-device-traits-macros.cpp
+++ b/clang/test/Driver/sycl-device-traits-macros.cpp
@@ -20,7 +20,7 @@
 /// definition, one for host and one for each of the two devices.
 // RUN:   %clang -fsycl --no-offload-new-driver -fsycl-targets=spir64,spir64_gen -### %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-SYCL-TARGETS %s
-// RUN:   %clang -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64,spir64_gen -### %s 2>&1 \
+// RUN:   %clang -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64,intel_gpu_pvc -### %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-SYCL-TARGETS %s
 // CHECK-SYCL-TARGETS-COUNT-3: "-D__SYCL_ANY_DEVICE_HAS_ANY_ASPECT__=1"
 
diff --git a/clang/test/Driver/sycl-foffload-fp32-prec-div.cpp b/clang/test/Driver/sycl-foffload-fp32-prec-div.cpp
index 18710fbbd2921..e91c6d31dfffa 100644
--- a/clang/test/Driver/sycl-foffload-fp32-prec-div.cpp
+++ b/clang/test/Driver/sycl-foffload-fp32-prec-div.cpp
@@ -1,13 +1,13 @@
 // Test SYCL -foffload-fp32-prec-div
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -foffload-fp32-prec-div %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -foffload-fp32-prec-div %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=AOT %s
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
 // RUN:   -foffload-fp32-prec-div %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=JIT %s
 
-// AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch={{.*}},kind=sycl,compile-opts=-options -ze-fp32-correctly-rounded-divide-sqrt{{.*}}"
+// AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch={{.*}},kind=sycl,compile-opts={{.*}}-options -ze-fp32-correctly-rounded-divide-sqrt{{.*}}"
 
 // JIT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64-unknown-unknown,arch={{.*}}compile-opts={{.*}}-foffload-fp32-prec-div"
diff --git a/clang/test/Driver/sycl-foffload-fp32-prec-sqrt.cpp b/clang/test/Driver/sycl-foffload-fp32-prec-sqrt.cpp
index e65476e049424..2d750ea875e2f 100644
--- a/clang/test/Driver/sycl-foffload-fp32-prec-sqrt.cpp
+++ b/clang/test/Driver/sycl-foffload-fp32-prec-sqrt.cpp
@@ -1,13 +1,13 @@
 // Test SYCL -foffload-fp32-prec-sqrt
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -foffload-fp32-prec-sqrt %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -foffload-fp32-prec-sqrt %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=AOT %s
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
 // RUN:   -foffload-fp32-prec-sqrt %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=JIT %s
 
-// AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch={{.*}},kind=sycl,compile-opts=-options -ze-fp32-correctly-rounded-divide-sqrt{{.*}}"
+// AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch={{.*}},kind=sycl,compile-opts={{.*}}-options -ze-fp32-correctly-rounded-divide-sqrt{{.*}}"
 
 // JIT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64-unknown-unknown,arch={{.*}}compile-opts={{.*}}-foffload-fp32-prec-sqrt"
diff --git a/clang/test/Driver/sycl-fsyclbin.cpp b/clang/test/Driver/sycl-fsyclbin.cpp
index b2f1a5e366511..6684646394eee 100644
--- a/clang/test/Driver/sycl-fsyclbin.cpp
+++ b/clang/test/Driver/sycl-fsyclbin.cpp
@@ -119,12 +119,12 @@
 /// For AOT spir64_gen, -fsyclbin=input/object additionally implies
 /// -library-compilation in the backend options so symbols stay
 /// externally visible for runtime cross-image resolution.
-// RUN: %clangxx -fsyclbin=object -fsycl-targets=spir64_gen \
+// RUN: %clangxx -fsyclbin=object -fsycl-targets=intel_gpu_pvc \
 // RUN:   --offload-new-driver --sysroot=%S/Inputs/SYCL %s -### 2>&1 \
 // RUN: | FileCheck %s --check-prefix=CHECK_LIBCOMP_IMPLIED
 // CHECK_LIBCOMP_IMPLIED: -library-compilation
 
-// RUN: %clangxx -fsyclbin=executable -fsycl-targets=spir64_gen \
+// RUN: %clangxx -fsyclbin=executable -fsycl-targets=intel_gpu_pvc \
 // RUN:   --offload-new-driver --sysroot=%S/Inputs/SYCL %s -### 2>&1 \
 // RUN: | FileCheck %s --check-prefix=CHECK_LIBCOMP_NOT_IMPLIED
 // CHECK_LIBCOMP_NOT_IMPLIED-NOT: -library-compilation
diff --git a/clang/test/Driver/sycl-ftarget-compile-fast.cpp b/clang/test/Driver/sycl-ftarget-compile-fast.cpp
index 538831de60db1..f1558cd78d990 100644
--- a/clang/test/Driver/sycl-ftarget-compile-fast.cpp
+++ b/clang/test/Driver/sycl-ftarget-compile-fast.cpp
@@ -1,10 +1,10 @@
 // Test -ftarget-compile-fast behaviors
 
 // RUN: %clang -### -target x86_64-unknown-linux-gnu -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-compile-fast %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-compile-fast %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=TARGET_COMPILE_FAST_GEN %s
 // RUN: %clang_cl -### --target=x86_64-pc-windows-msvc -fsycl --offload-new-driver /clang:--sysroot=%S/Inputs/SYCL \
-// RUN:     -fsycl-targets=spir64_gen -ftarget-compile-fast %s 2>&1 \
+// RUN:     -fsycl-targets=intel_gpu_pvc -ftarget-compile-fast %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=TARGET_COMPILE_FAST_GEN %s
 
 // TARGET_COMPILE_FAST_GEN: llvm-offload-binary
diff --git a/clang/test/Driver/sycl-ftarget-register-alloc-mode.cpp b/clang/test/Driver/sycl-ftarget-register-alloc-mode.cpp
index 7f5f7217ad9ad..af0600cc0e112 100644
--- a/clang/test/Driver/sycl-ftarget-register-alloc-mode.cpp
+++ b/clang/test/Driver/sycl-ftarget-register-alloc-mode.cpp
@@ -1,47 +1,35 @@
 // Test SYCL -ftarget-register-alloc-mode
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-register-alloc-mode=pvc:auto %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-register-alloc-mode=pvc:auto %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=AUTO_AOT %s -DDEVICE=pvc
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-register-alloc-mode=pvc:large %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-register-alloc-mode=pvc:large %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=LARGE_AOT %s
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-register-alloc-mode=pvc:small %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-register-alloc-mode=pvc:small %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=SMALL_AOT %s
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-register-alloc-mode=pvc:default %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-register-alloc-mode=pvc:default %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=DEFAULT_AOT %s
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -Xs "-device pvc" %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc %s 2>&1 \
 // RUN:   | FileCheck %if system-windows %{ -check-prefix=DEFAULT_AOT %} %else %{ -check-prefix=AUTO_AOT %} %s -DDEVICE=pvc
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -Xsycl-target-backend "-device pvc" %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_12_60_7 %s 2>&1 \
 // RUN:   | FileCheck %if system-windows %{ -check-prefix=DEFAULT_AOT %} %else %{ -check-prefix=AUTO_AOT %} %s -DDEVICE=pvc
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device pvc" %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc,intel_gpu_mtl_s %s 2>&1 \
 // RUN:   | FileCheck %if system-windows %{ -check-prefix=DEFAULT_AOT %} %else %{ -check-prefix=AUTO_AOT %} %s -DDEVICE=pvc
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -Xs "-device 0x0BD5" %s 2>&1 \
-// RUN:   | FileCheck %if system-windows %{ -check-prefix=DEFAULT_AOT %} %else %{ -check-prefix=AUTO_AOT %} %s -DDEVICE=pvc
-
-// RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -Xs "-device 12.60.7" %s 2>&1 \
-// RUN:   | FileCheck %if system-windows %{ -check-prefix=DEFAULT_AOT %} %else %{ -check-prefix=AUTO_AOT %} %s -DDEVICE=12.60.7
-
-// RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -Xs "-device pvc,mtl-s" %s 2>&1 \
-// RUN:   | FileCheck %if system-windows %{ -check-prefix=DEFAULT_AOT %} %else %{ -check-prefix=AUTO_AOT %} %s -DDEVICE=pvc
-
-// RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-register-alloc-mode=pvc:small,pvc:large %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-register-alloc-mode=pvc:small,pvc:large %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=MULTIPLE_ARGS_AOT %s
 
 // RUN: %clang -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
@@ -68,18 +56,18 @@
 // RUN:   | FileCheck -check-prefix=MULTIPLE_ARGS_JIT %s
 
 // RUN: not %clang -### -fsycl --offload-new-driver \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-register-alloc-mode=dg2:auto %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-register-alloc-mode=dg2:auto %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=BAD_DEVICE %s
 
 // RUN: not %clang -### -fsycl --offload-new-driver \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-register-alloc-mode=pvc:superlarge %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-register-alloc-mode=pvc:superlarge %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=BAD_MODE %s
 
 // RUN: not %clang -### -fsycl --offload-new-driver \
-// RUN:    -fsycl-targets=spir64_gen -ftarget-register-alloc-mode=dg2:superlarge %s 2>&1 \
+// RUN:    -fsycl-targets=intel_gpu_pvc -ftarget-register-alloc-mode=dg2:superlarge %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=BAD_BOTH %s
 
-// RUN: %clangxx -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64_gen -Xs "-device bdw" \
+// RUN: %clangxx -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=intel_gpu_bdw \
 // RUN:          %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=NO_PVC %s
 
@@ -89,22 +77,18 @@
 // RUNx:          %s 2>&1 \
 // RUNx:   | FileCheck -check-prefix=NO_PVC %s
 
-// RUN: %clangxx -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64_gen -Xs "-device pvc:mtl-s" \
-// RUN:          %s 2>&1 \
-// RUN:   | FileCheck -check-prefix=NO_PVC %s
-
 // NO_PVC-NOT: -device_options
 // NO_PVC-NOT: -ze-opt-large-register-file
 
 // AUTO_AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch={{.*}},kind=sycl,compile-opts=-device_options [[DEVICE]] -ze-intel-enable-auto-large-GRF-mode{{.*}}"
 
-// LARGE_AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=generic,kind=sycl,compile-opts=-device_options pvc -ze-opt-large-register-file"
+// LARGE_AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=pvc,kind=sycl,compile-opts=-device_options pvc -ze-opt-large-register-file"
 
-// SMALL_AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=generic,kind=sycl,compile-opts=-device_options pvc -ze-intel-128-GRF-per-thread"
+// SMALL_AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=pvc,kind=sycl,compile-opts=-device_options pvc -ze-intel-128-GRF-per-thread"
 
 // DEFAULT_AOT-NOT: -device_options
 
-// MULTIPLE_ARGS_AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=generic,kind=sycl,compile-opts=-device_options pvc -ze-intel-128-GRF-per-thread -device_options pvc -ze-opt-large-register-file"
+// MULTIPLE_ARGS_AOT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=pvc,kind=sycl,compile-opts=-device_options pvc -ze-intel-128-GRF-per-thread -device_options pvc -ze-opt-large-register-file"
 
 // AUTO_JIT: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64-unknown-unknown,arch={{.*}},kind=sycl,compile-opts=-ftarget-register-alloc-mode=pvc:-ze-intel-enable-auto-large-GRF-mode"
 
diff --git a/clang/test/Driver/sycl-no-rdc-new-driver.cpp b/clang/test/Driver/sycl-no-rdc-new-driver.cpp
index fdd8361a9f9d4..71c1da305cb3f 100644
--- a/clang/test/Driver/sycl-no-rdc-new-driver.cpp
+++ b/clang/test/Driver/sycl-no-rdc-new-driver.cpp
@@ -28,7 +28,7 @@
 
 // Test compilation step: with -c, -fno-sycl-rdc finalizes the device code of
 // the translation unit into a fat binary at compile time.
-// RUN: %clang -### --offload-new-driver -Werror --target=x86_64-unknown-linux-gnu -fsycl -fsycl-targets=spir64_gen -fno-sycl-rdc --no-offloadlib -fno-sycl-instrument-device-code %t.cpp -c -o %t.o 2>&1 \
+// RUN: %clang -### --offload-new-driver -Werror --target=x86_64-unknown-linux-gnu -fsycl -fsycl-targets=intel_gpu_pvc -fno-sycl-rdc --no-offloadlib -fno-sycl-instrument-device-code %t.cpp -c -o %t.o 2>&1 \
 // RUN:    | FileCheck -check-prefix=CHK-COMPILE-STEP %s
 
 // CHK-COMPILE-STEP-NOT: argument unused during compilation
diff --git a/clang/test/Driver/sycl-nordc-old-model-include-binary.cpp b/clang/test/Driver/sycl-nordc-old-model-include-binary.cpp
index d4c3d3ae7355c..4c8793a5d0645 100644
--- a/clang/test/Driver/sycl-nordc-old-model-include-binary.cpp
+++ b/clang/test/Driver/sycl-nordc-old-model-include-binary.cpp
@@ -10,6 +10,6 @@
 
 /// The new offloading model embeds the finalized device image.
 // RUN: %clangxx -### --target=x86_64-unknown-linux-gnu -fsycl -ccc-install-dir %S/Inputs/SYCL/bin \
-// RUN:   --offload-new-driver -fsycl-targets=spir64_gen -fno-sycl-rdc -c %s 2>&1 \
+// RUN:   --offload-new-driver -fsycl-targets=intel_gpu_pvc -fno-sycl-rdc -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHK-NEW %s
 // CHK-NEW: "-fsycl-is-host"{{.*}} "-foffload-include-binary"
diff --git a/clang/test/Driver/sycl-ocloc-path.cpp b/clang/test/Driver/sycl-ocloc-path.cpp
index c122fd0ee3612..1bc41ec9f739e 100644
--- a/clang/test/Driver/sycl-ocloc-path.cpp
+++ b/clang/test/Driver/sycl-ocloc-path.cpp
@@ -37,9 +37,6 @@
 
 /// Check that --ocloc-path= is forwarded to the clang-linker-wrapper for the
 /// new offloading model.
-// RUN:   %clang -### -fsycl --offload-new-driver -fsycl-targets=spir64_gen \
-// RUN:     --sysroot=%S/Inputs/SYCL --ocloc-path=/my/ocloc/dir %s 2>&1 \
-// RUN:   | FileCheck -check-prefix=CHK-OCLOC-PATH-NEW %s
 // RUN:   %clang -### -fsycl --offload-new-driver \
 // RUN:     -fsycl-targets=intel_gpu_pvc --sysroot=%S/Inputs/SYCL \
 // RUN:     --ocloc-path=/my/ocloc/dir %s 2>&1 \
@@ -97,7 +94,7 @@
 // RUN:     --ocloc-path="/my/ocloc dir/with spaces" %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHK-OCLOC-PATH-SPACES-OLD %s
 // CHK-OCLOC-PATH-SPACES-OLD: "/my/ocloc dir/with spaces{{[/\\]+}}ocloc{{(\.exe)?}}" "-output"
-// RUN:   %clang -### -fsycl --offload-new-driver -fsycl-targets=spir64_gen \
+// RUN:   %clang -### -fsycl --offload-new-driver -fsycl-targets=intel_gpu_pvc \
 // RUN:     --sysroot=%S/Inputs/SYCL --ocloc-path="/my/ocloc dir/with spaces" %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHK-OCLOC-PATH-SPACES-NEW %s
 // CHK-OCLOC-PATH-SPACES-NEW: clang-linker-wrapper{{.*}} "--ocloc-path=/my/ocloc dir/with spaces"
diff --git a/clang/test/Driver/sycl-offload-new-driver.cpp b/clang/test/Driver/sycl-offload-new-driver.cpp
index 363539fd4efd1..21afd2ee7f8bc 100644
--- a/clang/test/Driver/sycl-offload-new-driver.cpp
+++ b/clang/test/Driver/sycl-offload-new-driver.cpp
@@ -186,8 +186,8 @@
 
 /// Test option passing behavior for clang-offload-wrapper options for AOT.
 // RUN: %clangxx --target=x86_64-unknown-linux-gnu -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:          -fsycl-targets=spir64_gen,spir64_x86_64 \
-// RUN:          -Xsycl-target-backend=spir64_gen -backend-gen-opt \
+// RUN:          -fsycl-targets=intel_gpu_pvc,spir64_x86_64 \
+// RUN:          -Xsycl-target-backend=intel_gpu_pvc -backend-gen-opt \
 // RUN:          -Xsycl-target-backend=spir64_x86_64 -backend-cpu-opt \
 // RUN:          -### %s 2>&1 \
 // RUN:   | FileCheck -check-prefix WRAPPER_OPTIONS_BACKEND_AOT %s
@@ -208,8 +208,8 @@
 // Clang's generic LTO mode reaches the wrapper, which drops it before
 // invoking ocloc or opencl-aot.
 // RUN: %clangxx --target=x86_64-unknown-linux-gnu -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:          -fsycl-targets=spir64_gen,spir64_x86_64 -foffload-lto=full \
-// RUN:          -Xsycl-target-linker=spir64_gen -gpu-link \
+// RUN:          -fsycl-targets=intel_gpu_pvc,spir64_x86_64 -foffload-lto=full \
+// RUN:          -Xsycl-target-linker=intel_gpu_pvc -gpu-link \
 // RUN:          -Xsycl-target-linker=spir64_x86_64 -cpu-link -### %s 2>&1 \
 // RUN:   | FileCheck -check-prefix WRAPPER_AOT_LTO %s
 // WRAPPER_AOT_LTO: clang-linker-wrapper{{.*}} "--device-compiler=spir64_gen-unknown-unknown=-flto=full"
@@ -251,71 +251,37 @@
 // RUN:  | FileCheck -check-prefix CHECK_EMBED_IR %s
 // CHECK_EMBED_IR: clang-linker-wrapper{{.*}} "-sycl-embed-ir"
 
-/// Verify the filename being passed to the packager does not contain commas
-/// that are used in -device settings.
-// RUN: %clangxx -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:   -Xsycl-target-backend=spir64_gen "-device pvc,bdw" %s 2>&1 \
-// RUN:   | FileCheck -check-prefix COMMA_FILE %s
-// COMMA_FILE: llvm-offload-binary{{.*}} "--image=file={{.*}}pvc@bdw{{.*}},triple=spir64_gen-unknown-unknown,arch=pvc,arch=bdw,kind=sycl,compile-opts=-device_options pvc -ze-intel-enable-auto-large-GRF-mode -device pvc,compile-opts=bdw"
-
-/// Verify the arch value for the packager is populated with different
-/// scenarios for spir64_gen
-// RUN: %clangxx -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:   -Xsycl-target-backend=spir64_gen "-device bdw" %s 2>&1 \
-// RUN:   | FileCheck -check-prefix ARCH_CHECK %s
-// RUN: %clangxx -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:   -Xsycl-target-backend "-device bdw" %s 2>&1 \
-// RUN:   | FileCheck -check-prefix ARCH_CHECK %s
+/// Verify the arch value for the packager is populated for intel_gpu_*
 // RUN: %clangxx -fsycl -### -fsycl-targets=intel_gpu_bdw \
 // RUN: --offload-new-driver --sysroot=%S/Inputs/SYCL %s 2>&1 \
 // RUN:   | FileCheck -check-prefix ARCH_CHECK %s
-// RUN: %clang_cl -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver /clang:--sysroot=%S/Inputs/SYCL \
-// RUN:   -Xsycl-target-backend=spir64_gen "-device bdw" %s 2>&1 \
-// RUN:   | FileCheck -check-prefix ARCH_CHECK %s
-// RUN: %clang_cl -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver /clang:--sysroot=%S/Inputs/SYCL \
-// RUN:   -Xsycl-target-backend "-device bdw" %s 2>&1 \
-// RUN:   | FileCheck -check-prefix ARCH_CHECK %s
 // RUN: %clang_cl -fsycl -### -fsycl-targets=intel_gpu_bdw \
 // RUN: --offload-new-driver /clang:--sysroot=%S/Inputs/SYCL %s 2>&1 \
 // RUN:   | FileCheck -check-prefix ARCH_CHECK %s
 // ARCH_CHECK: llvm-offload-binary{{.*}} "--image=file={{.*}}triple=spir64_gen-unknown-unknown,arch=bdw,kind=sycl{{.*}}"
 
-// Verify when a comma-separated list of architectures is provided in -device, they are
-// passed to llvm-offload-binary correctly.
-// RUN: %clangxx -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:   -Xsycl-target-backend "-device pvc,bdw" %s 2>&1 \
-// RUN:   | FileCheck -check-prefix MULTI_ARCH %s
-// RUN: %clangxx -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:   -Xsycl-target-backend=spir64_gen "-device pvc,bdw" %s 2>&1 \
-// RUN:   | FileCheck -check-prefix MULTI_ARCH %s
-// RUN: %clangxx -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:   -Xs "-device pvc,bdw" %s 2>&1 \
-// RUN:   | FileCheck -check-prefix MULTI_ARCH %s
-// MULTI_ARCH: llvm-offload-binary{{.*}} "--image=file={{.*}}triple=spir64_gen-unknown-unknown,arch=pvc,arch=bdw,kind=sycl
-// MULTI_ARCH-SAME: compile-opts=-device_options pvc -ze-intel-enable-auto-large-GRF-mode -device pvc,compile-opts=bdw"
-
 // Verify for multiple targets with -Xsycl-target-backend= with commas in the values
 // are passed correctly to llvm-offload-binary.
 // RUN: %clangxx -fsycl -### --offload-new-driver --sysroot=%S/Inputs/SYCL -fno-sycl-libspirv \
-// RUN:  -fsycl-targets=nvptx64-nvidia-cuda,amdgcn-amd-amdhsa,spir64_gen \
+// RUN:  -fsycl-targets=nvptx64-nvidia-cuda,amdgcn-amd-amdhsa,intel_gpu_pvc \
 // RUN:  -Xsycl-target-backend=amdgcn-amd-amdhsa --offload-arch=gfx908,gfx1010 \
 // RUN:  -Xsycl-target-backend=nvptx64-nvidia-cuda --offload-arch=sm_86,sm_87,sm_89 \
-// RUN:  -Xsycl-target-backend=spir64_gen "-device pvc,bdw" \
-// RUN:  -Xsycl-target-linker=spir64_gen "-DFOO,BAR" \
+// RUN:  -Xsycl-target-backend=intel_gpu_pvc "-FOO a,b" \
+// RUN:  -Xsycl-target-linker=intel_gpu_pvc "-DFOO,BAR" \
 // RUN:  -nogpulib %s 2>&1 | FileCheck -check-prefix=MULTI_ARCH2 %s
 // MULTI_ARCH2: llvm-offload-binary{{.*}} "--image=file={{.*}}triple=amdgpu10.10-amd-amdhsa,arch=gfx1010,kind=sycl,compile-opts=--offload-arch=gfx908,compile-opts=gfx1010"
 // MULTI_ARCH2-SAME: "--image=file={{.*}}triple=amdgpu9.08-amd-amdhsa,arch=gfx908,kind=sycl,compile-opts=--offload-arch=gfx908,compile-opts=gfx1010"
 // MULTI_ARCH2-SAME: "--image=file={{.*}}triple=nvptx64-nvidia-cuda,arch=sm_86,kind=sycl,compile-opts=--offload-arch=sm_86,compile-opts=sm_87,compile-opts=sm_89"
 // MULTI_ARCH2-SAME: "--image=file={{.*}}triple=nvptx64-nvidia-cuda,arch=sm_87,kind=sycl,compile-opts=--offload-arch=sm_86,compile-opts=sm_87,compile-opts=sm_89"
 // MULTI_ARCH2-SAME: "--image=file={{.*}}triple=nvptx64-nvidia-cuda,arch=sm_89,kind=sycl,compile-opts=--offload-arch=sm_86,compile-opts=sm_87,compile-opts=sm_89"
-// MULTI_ARCH2-SAME: "--image=file={{.*}}triple=spir64_gen-unknown-unknown,arch=pvc,arch=bdw,kind=sycl,compile-opts=-device_options pvc -ze-intel-enable-auto-large-GRF-mode -device pvc,compile-opts=bdw,link-opts=-DFOO,link-opts=BAR"
+// MULTI_ARCH2-SAME: "--image=file={{.*}}triple=spir64_gen-unknown-unknown,arch=pvc,kind=sycl,compile-opts=-device_options pvc -ze-intel-enable-auto-large-GRF-mode -FOO a,compile-opts=b,link-opts=-DFOO,link-opts=BAR"
 
 // Verify that the driver correctly handles link-opt and compile-opt values with commas
-// RUN: %clangxx -fsycl -### -fsycl-targets=spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL \
-// RUN:   -Xsycl-target-backend "-device bdw -FOO a,b" \
+// RUN: %clangxx -fsycl -### -fsycl-targets=intel_gpu_bdw --offload-new-driver --sysroot=%S/Inputs/SYCL \
+// RUN:   -Xsycl-target-backend "-FOO a,b" \
 // RUN:   -Xsycl-target-linker "-BAR x,y" %s 2>&1 \
 // RUN:   | FileCheck -check-prefix COMMA_OPTS %s
-// COMMA_OPTS: llvm-offload-binary{{.*}} "--image=file={{.*}}triple=spir64_gen-unknown-unknown,arch=bdw,kind=sycl,compile-opts=-device bdw -FOO a,compile-opts=b,link-opts=-BAR x,link-opts=y"
+// COMMA_OPTS: llvm-offload-binary{{.*}} "--image=file={{.*}}triple=spir64_gen-unknown-unknown,arch=bdw,kind=sycl,compile-opts=-FOO a,compile-opts=b,link-opts=-BAR x,link-opts=y"
 
 /// Verify that --cuda-path is passed to clang-linker-wrapper for SYCL offload
 // RUN: %clangxx -fsycl -### -fsycl-targets=nvptx64-nvidia-cuda -fno-sycl-libspirv \
diff --git a/clang/test/Driver/sycl-offload-save-temps.cpp b/clang/test/Driver/sycl-offload-save-temps.cpp
index 38a7e985b6bfa..90f8daa4d39d6 100644
--- a/clang/test/Driver/sycl-offload-save-temps.cpp
+++ b/clang/test/Driver/sycl-offload-save-temps.cpp
@@ -36,8 +36,6 @@
 /// consumed by the host compile and passing it (an alias for --offload-targets=)
 /// triggers spurious OpenMP target triple validation on SYCL-specific names
 /// like 'intel_gpu_pvc', causing: error: OpenMP target is invalid: 'intel_gpu_pvc'
-// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64_gen-unknown-unknown -target x86_64-unknown-linux-gnu -save-temps %s -### 2>&1 \
-// RUN: | FileCheck %s --check-prefix=CHK-NO-FSYCL-TARGETS-IN-HOST-BC
 // RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=intel_gpu_pvc -target x86_64-unknown-linux-gnu -save-temps %s -### 2>&1 \
 // RUN: | FileCheck %s --check-prefix=CHK-NO-FSYCL-TARGETS-IN-HOST-BC
 /// Verify the host compile step emitting BC is present but without -fsycl-targets=.
diff --git a/clang/test/Driver/sycl-offload-with-split.cpp b/clang/test/Driver/sycl-offload-with-split.cpp
index 050500b725867..dcf4e957e1a20 100644
--- a/clang/test/Driver/sycl-offload-with-split.cpp
+++ b/clang/test/Driver/sycl-offload-with-split.cpp
@@ -7,7 +7,7 @@
 /// ###########################################################################
 
 /// Ahead of Time compilation for gen, cpu - tool invocation
-// RUN: %clang -target x86_64-unknown-linux-gnu -fsycl --offload-new-driver -fno-sycl-instrument-device-code --no-offloadlib -fsycl-device-code-split -fsycl-targets=spir64_gen-unknown-unknown %s -### 2>&1 \
+// RUN: %clang -target x86_64-unknown-linux-gnu -fsycl --offload-new-driver -fno-sycl-instrument-device-code --no-offloadlib -fsycl-device-code-split -fsycl-targets=intel_gpu_pvc %s -### 2>&1 \
 // RUN:  | FileCheck %s -check-prefix=CHK-TOOLS-AOT
 // RUN: %clang -target x86_64-unknown-linux-gnu -fsycl --offload-new-driver -fno-sycl-instrument-device-code --no-offloadlib -fsycl-device-code-split -fsycl-targets=spir64_x86_64-unknown-unknown %s -### 2>&1 \
 // RUN:  | FileCheck %s -check-prefix=CHK-TOOLS-AOT
diff --git a/clang/test/Driver/sycl-offload.cpp b/clang/test/Driver/sycl-offload.cpp
index b5b9176b917be..0400e72d67db9 100644
--- a/clang/test/Driver/sycl-offload.cpp
+++ b/clang/test/Driver/sycl-offload.cpp
@@ -419,8 +419,7 @@
 
 // RUN:  %clang -target x86_64-unknown-linux-gnu -fsycl --offload-new-driver \
 // RUN:     -fno-sycl-instrument-device-code --no-offloadlib \
-// RUN:     -fsycl-targets=nvptx64-nvidia-cuda,spir64_gen \
-// RUN:     -Xsycl-target-backend=spir64_gen "-device skl" \
+// RUN:     -fsycl-targets=nvptx64-nvidia-cuda,intel_gpu_skl \
 // RUN:     -ccc-print-phases %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHK-PHASE-MULTI-TARG-BOUND-ARCH2 %s
 // CHK-PHASE-MULTI-TARG-BOUND-ARCH2: 0: input, "[[INPUT:.+\.cpp]]", c++, (host-sycl)
@@ -650,7 +649,7 @@
 // RUN:  touch %t_empty.o
 // RUN:  %clangxx -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -target x86_64-unknown-linux-gnu -fsycl-targets=spir64_x86_64 %t_empty.o %s 2>&1 \
 // RUN:    | FileCheck -check-prefix DEFAULT_LINK %s
-// RUN:  %clangxx -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -target x86_64-unknown-linux-gnu -fsycl-targets=spir64_gen %t_empty.o %s 2>&1 \
+// RUN:  %clangxx -### -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -target x86_64-unknown-linux-gnu -fsycl-targets=intel_gpu_pvc %t_empty.o %s 2>&1 \
 // RUN:    | FileCheck -check-prefix DEFAULT_LINK %s
 // DEFAULT_LINK: clang-linker-wrapper{{.*}}
 
@@ -668,7 +667,7 @@
 
 // RUN:  %clangxx -### -target x86_64-unknown-linux-gnu -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64_x86_64 -Xsycl-target-backend -DFOO %S/Inputs/SYCL/objlin64.o 2>&1 \
 // RUN:    | FileCheck -check-prefixes=SYCL_TARGET_OPT_AOT,SYCL_TARGET_OPT_CPU %s
-// RUN:  %clangxx -### -target x86_64-unknown-linux-gnu -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64_gen -Xsycl-target-backend -DFOO %S/Inputs/SYCL/objlin64.o 2>&1 \
+// RUN:  %clangxx -### -target x86_64-unknown-linux-gnu -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=intel_gpu_pvc -Xsycl-target-backend -DFOO %S/Inputs/SYCL/objlin64.o 2>&1 \
 // RUN:    | FileCheck -check-prefixes=SYCL_TARGET_OPT_AOT,SYCL_TARGET_OPT_GPU %s
 // SYCL_TARGET_OPT_AOT-NOT: error: cannot deduce implicit triple value for '-Xsycl-target-backend'
 // SYCL_TARGET_OPT_CPU: clang-linker-wrapper{{.*}} "--device-linker=sycl:spir64_x86_64-unknown-unknown=--opencl-aot-options=-DFOO"
@@ -711,11 +710,11 @@
 // CHECK_FSYCL_FP64_CONV_EMU-NOT: clang{{.*}} "-cc1" "-triple x86_64-unknown-linux-gnu" {{.*}} "-fsycl-fp64-conv-emu"
 // CHECK_FSYCL_FP64_CONV_EMU-DAG: clang{{.*}} "-cc1" "-triple" "spir64_gen{{.*}}" "-fsycl-fp64-conv-emu"
 // CHECK_FSYCL_FP64_CONV_EMU-DAG: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=pvc,kind=sycl,compile-opts={{.*}}-options -ze-fp64-gen-conv-emu{{.*}}"
-// RUN: %clang_cl -fsycl --offload-new-driver /clang:--sysroot=%S/Inputs/SYCL -fsycl-targets=spir64_gen-unknown-unknown %s -fsycl-fp64-conv-emu -### 2>&1 \
+// RUN: %clang_cl -fsycl --offload-new-driver /clang:--sysroot=%S/Inputs/SYCL -fsycl-targets=intel_gpu_pvc %s -fsycl-fp64-conv-emu -### 2>&1 \
 // RUN:  | FileCheck %s -check-prefixes=CHECK_FSYCL_FP64_CONV_EMU_WIN
 // CHECK_FSYCL_FP64_CONV_EMU_WIN-NOT: clang{{.*}} "-cc1" "-triple x86_64-unknown-linux-gnu" {{.*}} "-fsycl-fp64-conv-emu"
 // CHECK_FSYCL_FP64_CONV_EMU_WIN-DAG: clang{{.*}} "-cc1" "-triple" "spir64_gen{{.*}}" "-fsycl-fp64-conv-emu"
-// CHECK_FSYCL_FP64_CONV_EMU_WIN-DAG: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=generic,kind=sycl,compile-opts={{.*}}-options -ze-fp64-gen-conv-emu{{.*}}"
+// CHECK_FSYCL_FP64_CONV_EMU_WIN-DAG: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spir64_gen-unknown-unknown,arch=pvc,kind=sycl,compile-opts={{.*}}-options -ze-fp64-gen-conv-emu{{.*}}"
 
 /// ###########################################################################
 
diff --git a/clang/test/Driver/sycl-option-ownership.cpp b/clang/test/Driver/sycl-option-ownership.cpp
index d822872f12532..990f7d3a5d3a8 100644
--- a/clang/test/Driver/sycl-option-ownership.cpp
+++ b/clang/test/Driver/sycl-option-ownership.cpp
@@ -39,7 +39,7 @@
 
 // Multiple SPIR targets follow the same silent-acceptance policy.
 // RUN: %clangxx --target=x86_64-unknown-linux-gnu --sysroot=%S/Inputs/SYCL \
-// RUN:   --offload-new-driver -fsycl -fsycl-targets=spir64,spir64_gen,spir64_x86_64 \
+// RUN:   --offload-new-driver -fsycl -fsycl-targets=spir64,intel_gpu_pvc,spir64_x86_64 \
 // RUN:   -Werror=unused-command-line-argument \
 // RUN:   -ftarget-register-alloc-mode=pvc:large \
 // RUN:   -### %S/Inputs/SYCL/objlin64.o 2>&1 \
@@ -94,11 +94,11 @@
 // interpretation still includes fp64 emulation, which is not in the generic
 // Clang compiler-option allowlist.
 // RUN: %clangxx --target=x86_64-unknown-linux-gnu --sysroot=%S/Inputs/SYCL \
-// RUN:   --offload-new-driver -fsycl -fsycl-targets=spir64,spir64_gen \
+// RUN:   --offload-new-driver -fsycl -fsycl-targets=spir64,intel_gpu_pvc \
 // RUN:   -g -O0 -fsycl-fp64-conv-emu \
 // RUN:   -foffload-fp32-prec-div -foffload-fp32-prec-sqrt -ftarget-compile-fast \
 // RUN:   -### %s 2>&1 | FileCheck %s --check-prefix=AOT
-// AOT: llvm-offload-binary{{.*}}triple=spir64_gen-unknown-unknown{{.*}}compile-opts=-options -ze-fp64-gen-conv-emu -g -cl-opt-disable -igc_opts{{.*}}-ze-fp32-correctly-rounded-divide-sqrt
+// AOT: llvm-offload-binary{{.*}}triple=spir64_gen-unknown-unknown{{.*}}compile-opts={{.*}}-options -ze-fp64-gen-conv-emu -g -cl-opt-disable -igc_opts{{.*}}-ze-fp32-correctly-rounded-divide-sqrt
 // AOT: clang-linker-wrapper
 // AOT-NOT: --jit-compiler-options=
 // AOT-NOT: --ocloc-options=
@@ -114,7 +114,7 @@
 
 // Exporting symbols is a linker option, not a packaging option.
 // RUN: %clangxx --target=x86_64-unknown-linux-gnu --sysroot=%S/Inputs/SYCL \
-// RUN:   --offload-new-driver -fsycl -fsycl-targets=spir64_gen \
+// RUN:   --offload-new-driver -fsycl -fsycl-targets=intel_gpu_pvc \
 // RUN:   -ftarget-export-symbols -### %s 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=EXPORT
 // EXPORT: llvm-offload-binary
@@ -125,7 +125,7 @@
 
 // Link-only SYCLBIN settings retain their full-context implications.
 // RUN: %clangxx --target=x86_64-unknown-linux-gnu --sysroot=%S/Inputs/SYCL \
-// RUN:   --offload-new-driver -fsycl -fsycl-targets=spir64_gen -fsyclbin=object \
+// RUN:   --offload-new-driver -fsycl -fsycl-targets=intel_gpu_pvc -fsyclbin=object \
 // RUN:   -### %S/Inputs/SYCL/objlin64.o 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=SYCLBIN
 // SYCLBIN: clang-linker-wrapper{{.*}}--ocloc-options=-options
@@ -133,7 +133,7 @@
 
 // An explicit opt-out wins over the SYCLBIN implication.
 // RUN: %clangxx --target=x86_64-unknown-linux-gnu --sysroot=%S/Inputs/SYCL \
-// RUN:   --offload-new-driver -fsycl -fsycl-targets=spir64_gen -fsyclbin=object \
+// RUN:   --offload-new-driver -fsycl -fsycl-targets=intel_gpu_pvc -fsyclbin=object \
 // RUN:   -fno-target-export-symbols -### %S/Inputs/SYCL/objlin64.o 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=NOEXPORT
 // NOEXPORT: clang-linker-wrapper
diff --git a/clang/test/Driver/sycl-pch-create.cpp b/clang/test/Driver/sycl-pch-create.cpp
index 36c4f199b3957..549675a18520f 100644
--- a/clang/test/Driver/sycl-pch-create.cpp
+++ b/clang/test/Driver/sycl-pch-create.cpp
@@ -41,7 +41,7 @@
 // LX_CREATE_TARGETS: clang-offload-bundler{{.*}} "-type=pch"
 // LX_CREATE_TARGETS: "-targets=sycl-spir64{{.*}},sycl-spir64_gen{{.*}},host-x86_64{{.*}}" "-output={{.*}}.pch" "-input=[[PCHFILE1]]" "-input=[[PCHFILE2]]" "-input=[[PCHFILE3]]"
 
-// RUN: %clang --offload-new-driver --no-offloadlib -fno-sycl-instrument-device-code -fsycl -x c++-header -fsycl-targets=spir64,spir64_gen -c %t.h -### 2>&1 | FileCheck -check-prefix=LX_CREATE_TARGETS_OND %s
+// RUN: %clang --offload-new-driver --no-offloadlib -fno-sycl-instrument-device-code -fsycl -x c++-header -fsycl-targets=spir64,intel_gpu_pvc -c %t.h -### 2>&1 | FileCheck -check-prefix=LX_CREATE_TARGETS_OND %s
 // LX_CREATE_TARGETS_OND: clang{{.*}} "-triple" "spir64{{.*}}"{{.*}} "-fsycl-is-device"
 // LX_CREATE_TARGETS_OND-SAME: "-fsycl-int-header=[[HEADER1:.+\.h]]"{{.*}} "-fsycl-int-footer=[[FOOTER1:.+\.h]]"{{.*}} "-sycl-std=2020"
 // LX_CREATE_TARGETS_OND-SAME: "-o" "[[PCHFILE1:.+pch]]"
@@ -114,7 +114,7 @@
 // WS_CREATE_TARGETS: clang-offload-bundler{{.*}} "-type=pch"
 // WS_CREATE_TARGETS: "-targets=sycl-spir64{{.*}},sycl-spir64_gen{{.*}},host-x86_64{{.*}}" "-output={{.*}}.pch" "-input=[[PCHFILE1]]" "-input=[[PCHFILE2]]" "-input=[[PCHFILE3]]"
 
-// RUN: %clang_cl --offload-new-driver --no-offloadlib -fno-sycl-instrument-device-code -fsycl -x c++-header -fsycl-targets=spir64,spir64_gen -c %t.h -### -- %s 2>&1 | FileCheck -check-prefix=WS_CREATE_TARGETS_OND %s
+// RUN: %clang_cl --offload-new-driver --no-offloadlib -fno-sycl-instrument-device-code -fsycl -x c++-header -fsycl-targets=spir64,intel_gpu_pvc -c %t.h -### -- %s 2>&1 | FileCheck -check-prefix=WS_CREATE_TARGETS_OND %s
 // WS_CREATE_TARGETS_OND: clang{{.*}} "-triple" "spir64{{.*}}"{{.*}} "-fsycl-is-device"
 // WS_CREATE_TARGETS_OND-SAME: "-fsycl-int-header=[[HEADER1:.+\.h]]"{{.*}} "-fsycl-int-footer=[[FOOTER1:.+\.h]]"{{.*}} "-sycl-std=2020"
 // WS_CREATE_TARGETS_OND-SAME: "-o" "[[PCHFILE1:.+pch]]"
diff --git a/clang/test/Driver/sycl-pch-use.cpp b/clang/test/Driver/sycl-pch-use.cpp
index 05a570b83c72a..6ed078a1e20fb 100644
--- a/clang/test/Driver/sycl-pch-use.cpp
+++ b/clang/test/Driver/sycl-pch-use.cpp
@@ -33,7 +33,7 @@
 // LX_USE_TARGETS: clang{{.*}} "-triple" "x86_64{{.*}}"{{.*}} "-fsycl-is-host"
 // LX_USE_TARGETS-SAME: "-include-pch" "[[PCHFILE3]]"{{.*}}
 
-// RUN: %clang --offload-new-driver --no-offloadlib -fno-sycl-instrument-device-code -fsycl -c -include-pch %t.h.pch -fsycl-targets=spir64,spir64_gen %s -### 2>&1 | FileCheck -check-prefix=LX_USE_TARGETS_OND %s
+// RUN: %clang --offload-new-driver --no-offloadlib -fno-sycl-instrument-device-code -fsycl -c -include-pch %t.h.pch -fsycl-targets=spir64,intel_gpu_pvc %s -### 2>&1 | FileCheck -check-prefix=LX_USE_TARGETS_OND %s
 // LX_USE_TARGETS_OND: llvm-offload-binary{{.*}} "[[MAINPCHFILE:.+\.pch]]"
 // LX_USE_TARGETS_OND-SAME: "--image=file=[[PCHFILE1:.+\.pch]],triple=x86_64{{.*}},arch=generic,kind=host"
 // LX_USE_TARGETS_OND: llvm-offload-binary{{.*}} "[[MAINPCHFILE:.+\.pch]]"
@@ -76,7 +76,7 @@
 // WS_USE_TARGETS: clang{{.*}} "-triple" "x86_64{{.*}}"{{.*}} "-fsycl-is-host"
 // WS_USE_TARGETS-SAME: "-include-pch" "[[PCHFILE3]]"{{.*}}
 
-// RUN: %clang_cl --offload-new-driver --no-offloadlib -fno-sycl-instrument-device-code -fsycl -fsycl-targets=spir64,spir64_gen -c /Yu%t.h -### -- %s 2>&1 | FileCheck -check-prefix=WS_USE_TARGETS_OND %s
+// RUN: %clang_cl --offload-new-driver --no-offloadlib -fno-sycl-instrument-device-code -fsycl -fsycl-targets=spir64,intel_gpu_pvc -c /Yu%t.h -### -- %s 2>&1 | FileCheck -check-prefix=WS_USE_TARGETS_OND %s
 // WS_USE_TARGETS_OND: llvm-offload-binary{{.*}} "[[MAINPCHFILE:.+\.pch]]"
 // WS_USE_TARGETS_OND-SAME: "--image=file=[[PCHFILE1:.+\.pch]],triple=x86_64{{.*}},arch=generic,kind=host"
 // WS_USE_TARGETS_OND: llvm-offload-binary{{.*}} "[[MAINPCHFILE]]"
diff --git a/clang/test/Driver/sycl-spir64-gen-deprecated.cpp b/clang/test/Driver/sycl-spir64-gen-deprecated.cpp
new file mode 100644
index 0000000000000..0f6da18c43e10
--- /dev/null
+++ b/clang/test/Driver/sycl-spir64-gen-deprecated.cpp
@@ -0,0 +1,91 @@
+/// Test the diagnostics for spir64_gen used as a SYCL target, which is
+/// deprecated in favor of intel_gpu_<arch>.
+
+/// Old offloading model: deprecation warning.
+// RUN: %clangxx -### -fsycl --no-offload-new-driver -fsycl-targets=spir64_gen \
+// RUN:   -Xsycl-target-backend "-device pvc" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=WARN -DOPT=-fsycl-targets=
+// RUN: %clangxx -### -fsycl --no-offload-new-driver \
+// RUN:   -fsycl-targets=spir64_gen-unknown-unknown \
+// RUN:   -Xsycl-target-backend "-device pvc" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=WARN-TRIPLE
+// RUN: %clangxx -### -fsycl --no-offload-new-driver \
+// RUN:   --offload-targets=spir64_gen -Xsycl-target-backend "-device pvc" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=WARN -DOPT=--offload-targets=
+// RUN: %clangxx -### -fsycl --no-offload-new-driver \
+// RUN:   -fsycl-targets=intel_gpu_pvc,spir64_gen \
+// RUN:   -Xsycl-target-backend=spir64_gen "-device dg2" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefixes=WARN,WARN-XS -DOPT=-fsycl-targets=
+// Diagnosed also without a -device option, e.g. at a compile-only (-c) step.
+// RUN: %clangxx -### -fsycl --no-offload-new-driver -fsycl-targets=spir64_gen \
+// RUN:   -c %s 2>&1 | FileCheck %s --check-prefix=WARN -DOPT=-fsycl-targets=
+// WARN: warning: option '[[OPT]]spir64_gen' is deprecated and will be removed in a future release, use '[[OPT]]intel_gpu_<arch>' instead [-Wdeprecated]
+// WARN-TRIPLE: warning: option '-fsycl-targets=spir64_gen-unknown-unknown' is deprecated and will be removed in a future release, use '-fsycl-targets=intel_gpu_<arch>' instead [-Wdeprecated]
+// WARN-XS: warning: option '-Xsycl-target-backend=spir64_gen' is deprecated and will be removed in a future release, use '-Xsycl-target-backend=intel_gpu_<arch>' instead [-Wdeprecated]
+
+/// -Xsycl-target-* with a spir64_gen triple is diagnosed even when the target
+/// is spelled intel_gpu_<arch>.
+// RUN: %clangxx -### -fsycl --no-offload-new-driver -fsycl-targets=intel_gpu_pvc \
+// RUN:   -Xsycl-target-backend=spir64_gen "-options -extra" \
+// RUN:   -Xsycl-target-frontend=spir64_gen -DFOO \
+// RUN:   -Xsycl-target-linker=spir64_gen "-foo" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=WARN-X
+// WARN-X-DAG: warning: option '-Xsycl-target-backend=spir64_gen' is deprecated and will be removed in a future release, use '-Xsycl-target-backend=intel_gpu_<arch>' instead [-Wdeprecated]
+// WARN-X-DAG: warning: option '-Xsycl-target-frontend=spir64_gen' is deprecated and will be removed in a future release, use '-Xsycl-target-frontend=intel_gpu_<arch>' instead [-Wdeprecated]
+// WARN-X-DAG: warning: option '-Xsycl-target-linker=spir64_gen' is deprecated and will be removed in a future release, use '-Xsycl-target-linker=intel_gpu_<arch>' instead [-Wdeprecated]
+
+/// The deprecation warning is controlled by -Wdeprecated.
+// RUN: %clangxx -### -fsycl --no-offload-new-driver -fsycl-targets=spir64_gen \
+// RUN:   -Xsycl-target-backend "-device pvc" -Wno-deprecated %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=NO-DIAG
+// RUN: not %clangxx -### -fsycl --no-offload-new-driver -fsycl-targets=spir64_gen \
+// RUN:   -Xsycl-target-backend "-device pvc" -Werror=deprecated %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=WERROR
+// WERROR: error: option '-fsycl-targets=spir64_gen' is deprecated
+
+/// New offloading model: error.
+// RUN: not %clangxx -### -fsycl --offload-new-driver -fsycl-targets=spir64_gen \
+// RUN:   -Xsycl-target-backend "-device pvc" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=ERR
+// RUN: not %clangxx -### -fsycl --offload-new-driver \
+// RUN:   -fsycl-targets=spir64_gen-unknown-unknown \
+// RUN:   -Xsycl-target-backend "-device pvc" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=ERR-TRIPLE
+// RUN: not %clangxx -### -fsycl --offload-new-driver -fsycl-targets=intel_gpu_pvc \
+// RUN:   -Xsycl-target-backend=spir64_gen "-options -extra" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=ERR-XS
+// RUN: not %clangxx -### -fsycl --offload-new-driver -fsycl-targets=spir64_gen \
+// RUN:   -c %s 2>&1 | FileCheck %s --check-prefix=ERR
+// ERR: error: '-fsycl-targets=spir64_gen' is not supported with the new offloading model; use '-fsycl-targets=intel_gpu_<arch>' instead
+// ERR-TRIPLE: error: '-fsycl-targets=spir64_gen-unknown-unknown' is not supported with the new offloading model; use '-fsycl-targets=intel_gpu_<arch>' instead
+// ERR-XS: error: '-Xsycl-target-backend=spir64_gen' is not supported with the new offloading model; use '-Xsycl-target-backend=intel_gpu_<arch>' instead
+
+/// The other triple-scoped tool options are diagnosed the same way.
+// RUN: not %clangxx -### -fsycl --offload-new-driver -fsycl-targets=intel_gpu_pvc \
+// RUN:   -Xspirv-translator=spir64_gen "-foo" -Xdevice-post-link=spir64_gen "-foo" \
+// RUN:   -Xspirv-to-ir-wrapper=spir64_gen "-foo" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=ERR-XTOOL
+// RUN: %clangxx -### -fsycl --no-offload-new-driver -fsycl-targets=intel_gpu_pvc \
+// RUN:   -Xspirv-translator=spir64_gen "-foo" -Xdevice-post-link=spir64_gen "-foo" \
+// RUN:   -Xspirv-to-ir-wrapper=spir64_gen "-foo" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=WARN-XTOOL
+// ERR-XTOOL-DAG: error: '-Xspirv-translator=spir64_gen' is not supported with the new offloading model; use '-Xspirv-translator=intel_gpu_<arch>' instead
+// ERR-XTOOL-DAG: error: '-Xdevice-post-link=spir64_gen' is not supported with the new offloading model; use '-Xdevice-post-link=intel_gpu_<arch>' instead
+// ERR-XTOOL-DAG: error: '-Xspirv-to-ir-wrapper=spir64_gen' is not supported with the new offloading model; use '-Xspirv-to-ir-wrapper=intel_gpu_<arch>' instead
+// WARN-XTOOL-DAG: warning: option '-Xspirv-translator=spir64_gen' is deprecated and will be removed in a future release, use '-Xspirv-translator=intel_gpu_<arch>' instead [-Wdeprecated]
+// WARN-XTOOL-DAG: warning: option '-Xdevice-post-link=spir64_gen' is deprecated and will be removed in a future release, use '-Xdevice-post-link=intel_gpu_<arch>' instead [-Wdeprecated]
+// WARN-XTOOL-DAG: warning: option '-Xspirv-to-ir-wrapper=spir64_gen' is deprecated and will be removed in a future release, use '-Xspirv-to-ir-wrapper=intel_gpu_<arch>' instead [-Wdeprecated]
+
+/// The error cannot be downgraded with -Wno-deprecated.
+// RUN: not %clangxx -### -fsycl --offload-new-driver -fsycl-targets=spir64_gen \
+// RUN:   -Xsycl-target-backend "-device pvc" -Wno-deprecated %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=ERR
+
+/// intel_gpu_<arch> is not diagnosed in either model.
+// RUN: %clangxx -### -fsycl --no-offload-new-driver -fsycl-targets=intel_gpu_pvc \
+// RUN:   -Xsycl-target-backend=intel_gpu_pvc "-options -extra" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=NO-DIAG
+// RUN: %clangxx -### -fsycl --offload-new-driver -fsycl-targets=intel_gpu_pvc \
+// RUN:   -Xsycl-target-backend=intel_gpu_pvc "-options -extra" %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=NO-DIAG
+// NO-DIAG-NOT: spir64_gen' is
diff --git a/clang/test/Driver/sycl-spirv-opt.cpp b/clang/test/Driver/sycl-spirv-opt.cpp
index 7d89f9c9fa829..7ab9869acdde6 100644
--- a/clang/test/Driver/sycl-spirv-opt.cpp
+++ b/clang/test/Driver/sycl-spirv-opt.cpp
@@ -5,10 +5,10 @@
 // RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-translator "foo" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-SINGLE-TARGET
 
-// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-translator=spir64_gen "foo" -### %s 2>&1 | \
+// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-translator=intel_gpu_pvc "foo" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-SINGLE-TARGET-UNUSED --implicit-check-not 'llvm-spirv{{.*}} "foo"'
 
-// RUN: %clangxx -fsycl -fsycl-targets=spir64,spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-translator=spir64_gen "foo" -Xspirv-translator=spir64 "bar" -### %s 2>&1 | \
+// RUN: %clangxx -fsycl -fsycl-targets=spir64,intel_gpu_pvc --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-translator=intel_gpu_pvc "foo" -Xspirv-translator=spir64 "bar" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-MULTIPLE-TARGET
 
 // Each token is forwarded as its own --llvm-spirv-options occurrence.
@@ -19,7 +19,7 @@
 // RUN:  FileCheck %s -check-prefix CHECK-SPACE
 
 // CHECK-SINGLE-TARGET: clang-linker-wrapper{{.*}} "--llvm-spirv-options=sycl:spir64-unknown-unknown=foo{{.*}}
-// CHECK-SINGLE-TARGET-UNUSED: argument unused during compilation: '-Xspirv-translator=spir64_gen foo'
+// CHECK-SINGLE-TARGET-UNUSED: argument unused during compilation: '-Xspirv-translator=intel_gpu_pvc foo'
 // CHECK-MULTIPLE-TARGET: clang-linker-wrapper{{.*}} "--llvm-spirv-options=sycl:spir64-unknown-unknown=bar"{{.*}}"--llvm-spirv-options=sycl:spir64_gen-unknown-unknown=foo"
 // CHECK-MULTIPLE-TOKENS: clang-linker-wrapper{{.*}} "--llvm-spirv-options=sycl:spir64-unknown-unknown=foo"{{.*}}"--llvm-spirv-options=sycl:spir64-unknown-unknown=bar"
 // CHECK-SPACE: clang-linker-wrapper{{.*}} "--llvm-spirv-options=sycl:spir64-unknown-unknown=foo bar"
diff --git a/clang/test/Driver/sycl-spirv-to-ir-opt.cpp b/clang/test/Driver/sycl-spirv-to-ir-opt.cpp
index f476d14f9ad22..a5a6b4bfea2ab 100644
--- a/clang/test/Driver/sycl-spirv-to-ir-opt.cpp
+++ b/clang/test/Driver/sycl-spirv-to-ir-opt.cpp
@@ -5,10 +5,10 @@
 // RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-to-ir-wrapper "foo" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-SINGLE-TARGET
 
-// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-to-ir-wrapper=spir64_gen "foo" -### %s 2>&1 | \
+// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-to-ir-wrapper=intel_gpu_pvc "foo" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-SINGLE-TARGET-UNUSED --implicit-check-not 'spirv-to-ir-wrapper-options{{.*}}=foo'
 
-// RUN: %clangxx -fsycl -fsycl-targets=spir64,spir64_gen --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-to-ir-wrapper=spir64_gen "foo" -Xspirv-to-ir-wrapper=spir64 "bar" -### %s 2>&1 | \
+// RUN: %clangxx -fsycl -fsycl-targets=spir64,intel_gpu_pvc --offload-new-driver --sysroot=%S/Inputs/SYCL -Xspirv-to-ir-wrapper=intel_gpu_pvc "foo" -Xspirv-to-ir-wrapper=spir64 "bar" -### %s 2>&1 | \
 // RUN:  FileCheck %s -check-prefix CHECK-MULTIPLE-TARGET
 
 // Each token is forwarded as its own --spirv-to-ir-wrapper-options occurrence.
@@ -19,7 +19,7 @@
 // RUN:  FileCheck %s -check-prefix CHECK-SPACE
 
 // CHECK-SINGLE-TARGET: clang-linker-wrapper{{.*}} "--spirv-to-ir-wrapper-options=sycl:spir64-unknown-unknown=foo{{.*}}
-// CHECK-SINGLE-TARGET-UNUSED: argument unused during compilation: '-Xspirv-to-ir-wrapper=spir64_gen foo'
+// CHECK-SINGLE-TARGET-UNUSED: argument unused during compilation: '-Xspirv-to-ir-wrapper=intel_gpu_pvc foo'
 // CHECK-MULTIPLE-TARGET: clang-linker-wrapper{{.*}} "--spirv-to-ir-wrapper-options=sycl:spir64-unknown-unknown=bar"{{.*}}"--spirv-to-ir-wrapper-options=sycl:spir64_gen-unknown-unknown=foo"
 // CHECK-MULTIPLE-TOKENS: clang-linker-wrapper{{.*}} "--spirv-to-ir-wrapper-options=sycl:spir64-unknown-unknown=foo"{{.*}}"--spirv-to-ir-wrapper-options=sycl:spir64-unknown-unknown=bar"
 // CHECK-SPACE: clang-linker-wrapper{{.*}} "--spirv-to-ir-wrapper-options=sycl:spir64-unknown-unknown=foo bar"
diff --git a/clang/test/Driver/sycl-suppress-undefined-func-warnings.cpp b/clang/test/Driver/sycl-suppress-undefined-func-warnings.cpp
index 2a85d3b4f95da..f59e3eb772e6f 100644
--- a/clang/test/Driver/sycl-suppress-undefined-func-warnings.cpp
+++ b/clang/test/Driver/sycl-suppress-undefined-func-warnings.cpp
@@ -64,7 +64,7 @@
 // AOT target (spir64_gen): forwarding is target-independent.
 // RUN: %clangxx -### -fsycl -fsycl-targets=spir64_gen -Wno-sycl-undefined-func-in-image %s 2>&1 \
 // RUN:   | FileCheck --check-prefix=WNO %s
-// RUN: %clangxx -### -fsycl --offload-new-driver -fsycl-targets=spir64_gen \
+// RUN: %clangxx -### -fsycl --offload-new-driver -fsycl-targets=intel_gpu_pvc \
 // RUN:   -fno-sycl-instrument-device-code --no-offloadlib \
 // RUN:   -Wno-sycl-undefined-func-in-image %s 2>&1 \
 // RUN:   | FileCheck --check-prefix=WNO-NEW %s
diff --git a/clang/test/Driver/sycl-unique-prefix.cpp b/clang/test/Driver/sycl-unique-prefix.cpp
index 8ec1e0c19429f..57416f5ed7b02 100644
--- a/clang/test/Driver/sycl-unique-prefix.cpp
+++ b/clang/test/Driver/sycl-unique-prefix.cpp
@@ -1,7 +1,7 @@
 /// Test for Unique prefix setting for SYCL compilations
 // RUN: touch %t_file1.cpp
 // RUN: touch %t_file2.cpp
-// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64-unknown-unknown,spir64_gen-unknown-unknown -c %t_file1.cpp %t_file2.cpp -### 2>&1 \
+// RUN: %clangxx -fsycl --offload-new-driver --sysroot=%S/Inputs/SYCL -fsycl-targets=spir64-unknown-unknown,intel_gpu_pvc -c %t_file1.cpp %t_file2.cpp -### 2>&1 \
 // RUN:  | FileCheck -check-prefix=CHECK_PREFIX %s
 // CHECK_PREFIX: clang{{.*}} "-triple" "spir64-unknown-unknown"{{.*}} "-fsycl-is-device"{{.*}} "-fsycl-unique-prefix=[[PREFIX1:uid([A-z0-9]){16}]]"{{.*}} "{{.*}}_file1.cpp"
 // CHECK_PREFIX: clang{{.*}} "-triple" "spir64_gen-unknown-unknown"{{.*}} "-fsycl-is-device"{{.*}} "-fsycl-unique-prefix=[[PREFIX1]]"{{.*}} "{{.*}}_file1.cpp"
diff --git a/clang/test/Driver/sycl-windows-device-filename.cpp b/clang/test/Driver/sycl-windows-device-filename.cpp
index af6550bf1a547..f54c043b88463 100644
--- a/clang/test/Driver/sycl-windows-device-filename.cpp
+++ b/clang/test/Driver/sycl-windows-device-filename.cpp
@@ -2,7 +2,7 @@
 // REQUIRES: system-windows
 
 // RUN: %clang -### --target=x86_64-pc-windows-msvc -fsycl \
-// RUN:   -fsycl-targets=spir64_gen --offload-new-driver \
+// RUN:   -fsycl-targets=intel_gpu_pvc --offload-new-driver \
 // RUN:   --sysroot=%S/Inputs/SYCL \
 // RUN:   -Xsycl-target-backend "-device arch1:arch2" %s 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK_COLON
@@ -12,7 +12,7 @@
 // CHECK_COLON-NOT: sycl-windows-device-filename-arch1:arch2
 
 // RUN: %clang -### --target=x86_64-pc-windows-msvc -fsycl \
-// RUN:   -fsycl-targets=spir64_gen --offload-new-driver \
+// RUN:   -fsycl-targets=intel_gpu_pvc --offload-new-driver \
 // RUN:   --sysroot=%S/Inputs/SYCL \
 // RUN:   -Xsycl-target-backend "-device *" %s 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK_STAR
diff --git a/sycl/doc/GetStartedGuide.md b/sycl/doc/GetStartedGuide.md
index 9c66d7981f5a6..baed5a54b4c79 100644
--- a/sycl/doc/GetStartedGuide.md
+++ b/sycl/doc/GetStartedGuide.md
@@ -730,7 +730,7 @@ specify the target architecture.  The examples provided use a supported
 alias for the target, representing a full triple.  Additional details can
 be found in the [Users Manual](UsersManual.md#generic-options).
 
-```-fsycl-targets=spir64_gen``` for GPU,
+```-fsycl-targets=intel_gpu_<arch>``` (e.g. ```intel_gpu_pvc```) for GPU,
 ```-fsycl-targets=spir64_x86_64``` for CPU.
 
 Multiple target architectures are supported.
@@ -739,7 +739,7 @@ E.g., this command builds simple-sycl-app for GPU and CPU devices in
 ahead of time mode:
 
 ```bash
-clang++ -fsycl -fsycl-targets=spir64_gen,spir64_x86_64 simple-sycl-app.cpp -o simple-sycl-app-aot.exe
+clang++ -fsycl -fsycl-targets=intel_gpu_pvc,spir64_x86_64 simple-sycl-app.cpp -o simple-sycl-app-aot.exe
 ```
 
 Additionally, user can pass specific options of AOT compiler to
diff --git a/sycl/doc/UsersManual.md b/sycl/doc/UsersManual.md
index f6035f35b67d6..965fb2f1e4590 100644
--- a/sycl/doc/UsersManual.md
+++ b/sycl/doc/UsersManual.md
@@ -33,10 +33,10 @@ and not recommended to use in production environment.
     The following triples are supported by default:
     * spir64 - this is the default generic SPIR-V target;
     * spir64_x86_64 - generate code ahead of time for x86_64 CPUs;
-    * spir64_gen - generate code ahead of time for Intel Processor Graphics;
+    * intel_gpu_<arch> - generate code ahead of time for Intel Processor
+      Graphics; see the list of intel_gpu_* values below;
     Full target triples can also be used:
-    * spir64-unknown-unknown, spir64_x86_64-unknown-unknown,
-      spir64_gen-unknown-unknown
+    * spir64-unknown-unknown, spir64_x86_64-unknown-unknown
     Available in special build configuration:
     * nvptx64-nvidia-cuda - generate code ahead of time for CUDA target;
     * amdgcn-amd-amdhsa - generate code ahead of time for HIP target;
@@ -146,6 +146,19 @@ and not recommended to use in production environment.
     * amd_gpu_gfx1200 - GCN GFX12 (RDNA 4) architecture
     * amd_gpu_gfx1201 - GCN GFX12 (RDNA 4) architecture
 
+    Deprecated: spir64_gen (spir64_gen-unknown-unknown) is deprecated in favor
+    of the intel_gpu_* values above. It emits a deprecation warning by default,
+    and is an error with --offload-new-driver. To migrate
+    '-fsycl-targets=spir64_gen -Xsycl-target-backend "-device <value>"':
+    * a device name, e.g. "-device pvc": use -fsycl-targets=intel_gpu_pvc;
+    * a full IP version, e.g. "-device 12.60.7": use
+      -fsycl-targets=intel_gpu_12_60_7;
+    * a list, e.g. "-device pvc,dg2": use
+      -fsycl-targets=intel_gpu_pvc,intel_gpu_dg2;
+    * "-device *", hex device IDs (e.g. 0x0BD5), partial versions (e.g.
+      12.60) and devices without an intel_gpu_* value (e.g. pvc-sdv) have
+      no equivalent; list the intel_gpu_* values of the devices to target.
+
 ## Language options
 
 **`-sycl-std=<value>`** [EXPERIMENTAL]
@@ -478,7 +491,8 @@ and not recommended to use in production environment.
     Exposes exported symbols in a generated target library to allow for
     visibility to other modules.
 
-    NOTE: This flag is only supported for spir64_gen AOT targets.
+    NOTE: This flag is only supported for Intel GPU AOT targets
+    (intel_gpu_*).
 
 **`-ftarget-register-alloc-mode=<arg>`**
 
diff --git a/sycl/test-e2e/AOT/multiple-devices.cpp b/sycl/test-e2e/AOT/multiple-devices.cpp
index 61de08b4041cc..af44e27d8c2a5 100644
--- a/sycl/test-e2e/AOT/multiple-devices.cpp
+++ b/sycl/test-e2e/AOT/multiple-devices.cpp
@@ -28,17 +28,17 @@
 // REQUIRES: opencl-aot, ocloc, any-device-is-cpu, any-device-is-gpu, target-spir, opencl-cpu-rt
 
 // Produce a fat object for all targets (generic SPIR-V, CPU, GPU)
-// RUN: %clangxx -fsycl -fsycl-targets=spir64,spir64_x86_64,spir64_gen %S/Inputs/aot.cpp -c -o %t.o
+// RUN: %clangxx -fsycl -fsycl-targets=spir64,spir64_x86_64,%{gpu_aot_target} %S/Inputs/aot.cpp -c -o %t.o
 
 // Verify that AOT compilation occurs for the targets (GPU, CPU)
 // specified in the link command line. Note that generic SPIR-V compilation
 // is enabled by default even when AOT GPU or CPU targets are specified.
-// RUN: %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64,spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts -v %t.o -o %t_cpu_gpu.out -Wno-unused-command-line-argument 2>&1 | FileCheck %s --check-prefix=CHECK-AOT-CPU --check-prefix=CHECK-AOT-GPU --check-prefix=CHECK-GENERIC
+// RUN: %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64,%{gpu_aot_target} -v %t.o -o %t_cpu_gpu.out -Wno-unused-command-line-argument 2>&1 | FileCheck %s --check-prefix=CHECK-AOT-CPU --check-prefix=CHECK-AOT-GPU --check-prefix=CHECK-GENERIC
 // RUN: %{run} %t_cpu_gpu.out
 
 // Verify that AOT compilation occurs for the targets (GPU) specified in
 // the link command line.
-// RUN: %clangxx -fsycl -fsycl-targets=spir64,spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts -v %t.o -o %t_spv_gpu.out -Wno-unused-command-line-argument 2>&1 | FileCheck %s --check-prefix=CHECK-GENERIC --check-prefix=CHECK-AOT-GPU --check-prefix=CHECK-NO-AOT-CPU
+// RUN: %clangxx -fsycl -fsycl-targets=spir64,%{gpu_aot_target} -v %t.o -o %t_spv_gpu.out -Wno-unused-command-line-argument 2>&1 | FileCheck %s --check-prefix=CHECK-GENERIC --check-prefix=CHECK-AOT-GPU --check-prefix=CHECK-NO-AOT-CPU
 // Check that execution on AOT-compatible devices is unaffected
 // RUN: env ONEAPI_DEVICE_SELECTOR="*:gpu" %{run-unfiltered-devices} %t_spv_gpu.out
 
diff --git a/sycl/test-e2e/AddressSanitizer/aot/gpu.cpp b/sycl/test-e2e/AddressSanitizer/aot/gpu.cpp
index 4f302070e9113..f2dfab2a5a8ef 100644
--- a/sycl/test-e2e/AddressSanitizer/aot/gpu.cpp
+++ b/sycl/test-e2e/AddressSanitizer/aot/gpu.cpp
@@ -1,9 +1,6 @@
 // REQUIRES: linux, gpu && level_zero
 // REQUIRES: (arch-intel_gpu_pvc || gpu-intel-dg2)
 
-// XFAIL: arch-intel_gpu_pvc && new-offload-model
-// XFAIL-TRACKER: https://github.com/intel/llvm/issues/23265
-
 // RUN: %{run-aux} %{build} %device_asan_aot_gpu_flags -O0 -g %S/Inputs/host-usm-oob.cpp -o %t.out
 // RUN: %{run} not --crash %t.out 2>&1 | FileCheck %S/Inputs/host-usm-oob.cpp
 
diff --git a/sycl/test-e2e/AddressSanitizer/common/kernel-filter-aot-gpu.cpp b/sycl/test-e2e/AddressSanitizer/common/kernel-filter-aot-gpu.cpp
index 9e9cb59c46581..c3bb6d6f8b9bb 100644
--- a/sycl/test-e2e/AddressSanitizer/common/kernel-filter-aot-gpu.cpp
+++ b/sycl/test-e2e/AddressSanitizer/common/kernel-filter-aot-gpu.cpp
@@ -1,9 +1,6 @@
 // REQUIRES: linux, gpu && level_zero
 // REQUIRES: (arch-intel_gpu_pvc || gpu-intel-dg2)
 
-// XFAIL: arch-intel_gpu_pvc && new-offload-model
-// XFAIL-TRACKER: https://github.com/intel/llvm/issues/23265
-
 // RUN: %{run-aux} %{build} %device_asan_aot_gpu_flags %S/kernel-filter.cpp -g -O2 -fsanitize-ignorelist=%p/ignorelist.txt -o %t1
 // RUN: %{run} %t1 2>&1 | FileCheck %S/kernel-filter.cpp --check-prefixes CHECK-IGNORE
 // RUN: %{run-aux} %{build} %device_asan_aot_gpu_flags %S/kernel-filter.cpp -g -O2 -o %t2
diff --git a/sycl/test-e2e/AddressSanitizer/lit.local.cfg b/sycl/test-e2e/AddressSanitizer/lit.local.cfg
index a9a68083cd3c3..d1e227f89ce90 100644
--- a/sycl/test-e2e/AddressSanitizer/lit.local.cfg
+++ b/sycl/test-e2e/AddressSanitizer/lit.local.cfg
@@ -16,8 +16,7 @@ config.substitutions.append(
 config.substitutions.append(
     (
         "%device_asan_aot_gpu_flags",
-        "-Xarch_device -fsanitize=address -fsycl-targets=spir64_gen "
-        "-Xsycl-target-backend=spir64_gen '-device pvc,dg2'",
+        "-Xarch_device -fsanitize=address -fsycl-targets=intel_gpu_pvc,intel_gpu_dg2",
     )
 )
 config.substitutions.append(
diff --git a/sycl/test-e2e/BFloat16/bfloat16_example_aot.cpp b/sycl/test-e2e/BFloat16/bfloat16_example_aot.cpp
index 6d1e1e217bbbd..c63841b4a9a72 100644
--- a/sycl/test-e2e/BFloat16/bfloat16_example_aot.cpp
+++ b/sycl/test-e2e/BFloat16/bfloat16_example_aot.cpp
@@ -8,11 +8,11 @@
 // RUN: %clangxx -fsycl -fsycl-targets=spir64 %s -o %t.out
 // RUN: %{run} %t.out
 
-// RUN: %clangxx -fsycl -fsycl-targets=spir64,spir64_gen -Xsycl-target-backend=spir64_gen "-device dg2" %s -o %t.out
+// RUN: %clangxx -fsycl -fsycl-targets=spir64,%{gpu_aot_target} %s -o %t.out
 // RUN: %{run} %t.out
 
 // CPU AOT targets host isa, so we compile on the run system instead.
-// RUN: %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64,spir64_gen -Xsycl-target-backend=spir64_gen "-device dg2" %s -o %t.out
+// RUN: %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64,%{gpu_aot_target} %s -o %t.out
 // RUN: %{run} %t.out
 
 #include "bfloat16_example.hpp"
diff --git a/sycl/test-e2e/BFloat16/bfloat16_example_aot_cpu.cpp b/sycl/test-e2e/BFloat16/bfloat16_example_aot_cpu.cpp
index edf317f5b57e9..f110d125703ef 100644
--- a/sycl/test-e2e/BFloat16/bfloat16_example_aot_cpu.cpp
+++ b/sycl/test-e2e/BFloat16/bfloat16_example_aot_cpu.cpp
@@ -5,11 +5,11 @@
 
 // REQUIRES: opencl-aot, ocloc, gpu-intel-dg2, any-device-is-cpu, target-spir
 
-// RUN: %clangxx -fsycl -fsycl-targets=spir64,spir64_gen -Xsycl-target-backend=spir64_gen "-device dg2" %s -o %t.out
+// RUN: %clangxx -fsycl -fsycl-targets=spir64,intel_gpu_dg2 %s -o %t.out
 // RUN: %if cpu %{ %{run} %t.out %}
 
 // CPU AOT targets host isa, so we compile on the run system instead.
-// RUN: %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64,spir64_gen -Xsycl-target-backend=spir64_gen "-device dg2" %s -o %t.out
+// RUN: %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64,intel_gpu_dg2 %s -o %t.out
 // RUN: %if cpu %{ %{run} %t.out %}
 
 #include "bfloat16_example.hpp"
diff --git a/sycl/test-e2e/BFloat16/bfloat16_example_aot_gpu.cpp b/sycl/test-e2e/BFloat16/bfloat16_example_aot_gpu.cpp
index 6b1dfe8f64631..846b9b4cc99ba 100644
--- a/sycl/test-e2e/BFloat16/bfloat16_example_aot_gpu.cpp
+++ b/sycl/test-e2e/BFloat16/bfloat16_example_aot_gpu.cpp
@@ -5,10 +5,10 @@
 
 // REQUIRES: opencl-aot, ocloc, gpu-intel-dg2, any-device-is-gpu, target-spir
 
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend "-device dg2" %s -o %t.out
+// RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_dg2 %s -o %t.out
 // RUN: %if gpu %{%{run} %t.out %}
 
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend "-device *" %s -o %t.out
+// RUN: %clangxx -fsycl -fsycl-targets=%{gpu_aot_target} %s -o %t.out
 // RUN: %if gpu %{%{run} %t.out %}
 
 #include "bfloat16_example.hpp"
diff --git a/sycl/test-e2e/Basic/build_log.cpp b/sycl/test-e2e/Basic/build_log.cpp
index 0dc3f4fb8019c..060f0ac125323 100644
--- a/sycl/test-e2e/Basic/build_log.cpp
+++ b/sycl/test-e2e/Basic/build_log.cpp
@@ -1,8 +1,12 @@
 // REQUIRES: opencl || level_zero, gpu, ocloc, target-spir
 // UNSUPPORTED: arch-intel_gpu_dg2
 // UNSUPPORTED-INTENDED: see https://github.com/intel/llvm/pull/20643
+// UNSUPPORTED: new-offload-model
+// UNSUPPORTED-INTENDED: runs a kernel built for DG2 on another GPU to get a
+// build log. intel_gpu_dg2 images are only used on DG2, and spir64_gen is an
+// error with --offload-new-driver.
 
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device dg2" %s -o %t.out
+// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device dg2" -Wno-deprecated %s -o %t.out
 // RUN: env SYCL_RT_WARNING_LEVEL=2 %{run} %t.out 2>&1 | FileCheck %s
 
 #include <sycl/detail/core.hpp>
diff --git a/sycl/test-e2e/DeviceImageDependencies/objects_aot.cpp b/sycl/test-e2e/DeviceImageDependencies/objects_aot.cpp
index cc2ee41c8f9e5..aec81f397bc98 100644
--- a/sycl/test-e2e/DeviceImageDependencies/objects_aot.cpp
+++ b/sycl/test-e2e/DeviceImageDependencies/objects_aot.cpp
@@ -8,12 +8,11 @@
 // UNSUPPORTED: new-offload-model
 // UNSUPPORTED-TRACKER: https://github.com/intel/llvm/issues/23302
 
-// DEFINE: %{aot_options} = -fsycl -fsycl-targets=spir64_gen -DUSE_AOT
-// DEFINE: %{aot_backend_options} = -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts
+// DEFINE: %{aot_options} = -fsycl -fsycl-targets=%{gpu_aot_target} -DUSE_AOT
 
 // RUN: %clangxx %{aot_options} %S/Inputs/a.cpp -I %S/Inputs -c -o %t_a.o
 // RUN: %clangxx %{aot_options} %S/Inputs/b.cpp -I %S/Inputs -c -o %t_b.o
 // RUN: %clangxx %{aot_options} %S/Inputs/c.cpp -I %S/Inputs -c -o %t_c.o
 // RUN: %clangxx %{aot_options} %S/Inputs/d.cpp -I %S/Inputs -c -o %t_d.o
-// RUN: %clangxx %{aot_options} %{aot_backend_options} -fsycl-device-code-split=per_kernel -fsycl-allow-device-image-dependencies -ftarget-export-symbols %t_a.o %t_b.o %t_c.o %t_d.o %S/Inputs/basic.cpp -o %t.out
+// RUN: %clangxx %{aot_options} -fsycl-device-code-split=per_kernel -fsycl-allow-device-image-dependencies -ftarget-export-symbols %t_a.o %t_b.o %t_c.o %t_d.o %S/Inputs/basic.cpp -o %t.out
 // RUN: %{run} %t.out
diff --git a/sycl/test-e2e/ESIMD/aot_mixed.cpp b/sycl/test-e2e/ESIMD/aot_mixed.cpp
index 0b678400af5cd..07ea7677f18f6 100644
--- a/sycl/test-e2e/ESIMD/aot_mixed.cpp
+++ b/sycl/test-e2e/ESIMD/aot_mixed.cpp
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 // TODO: Enable on other GPUs once internal ticket is fixed
 // REQUIRES: ocloc && gpu-intel-dg2
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device dg2" -o %t.sycl.out -DENABLE_SYCL=0 %s
+// RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_dg2 -o %t.sycl.out -DENABLE_SYCL=0 %s
 // RUN: %{run} %t.sycl.out
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device dg2" -o %t.out %s
+// RUN: %clangxx -fsycl -fsycl-targets=intel_gpu_dg2 -o %t.out %s
 // RUN: %{run} %t.out
 
 // This test checks the following ESIMD ahead-of-time compilation scenarios:
diff --git a/sycl/test-e2e/KernelAndProgram/test_cache_jit_aot.cpp b/sycl/test-e2e/KernelAndProgram/test_cache_jit_aot.cpp
index bece8886570c6..2ac63b10c467c 100644
--- a/sycl/test-e2e/KernelAndProgram/test_cache_jit_aot.cpp
+++ b/sycl/test-e2e/KernelAndProgram/test_cache_jit_aot.cpp
@@ -27,7 +27,7 @@
 // RUN: %{cache_vars} %{run-unfiltered-devices} %t.out 2>&1 | FileCheck %s --check-prefixes RESULT1
 // ******************************
 //
-// REDEFINE: %{build_cmd} = %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device acm-g10" %s
+// REDEFINE: %{build_cmd} = %clangxx -fsycl -fsycl-targets=%{gpu_aot_target},spir64 %s
 // ******************************
 // Check the logs first.
 // RUN: %{run-aux} %{build_cmd} -DVALUE=1 -o %t.out
@@ -36,25 +36,6 @@
 // RUN: %{cache_vars} %{run-unfiltered-devices} %t.out 2>&1 | FileCheck %s  --check-prefixes=CHECK-CACHE-READ
 // RUN: %{cache_vars} %{run-unfiltered-devices} %t.out 2>&1 | FileCheck %s  --check-prefixes=CHECK-CACHE-READ
 
-//
-// Now try to substitute the cached image and verify it is actually taken and
-// the code/binary there is executed.
-// RUN: %{run-aux} mv %t/cache_dir/*/*/*/*/*.bin %t.value1.bin
-// RUN: %{run-aux} rm -rf %t/cache_dir/*
-// RUN: %{run-aux} %{build_cmd} -DVALUE=2 -o %t.out
-// RUN: %{cache_vars} %{run-unfiltered-devices} %t.out 2>&1 | FileCheck %s --check-prefixes RESULT2
-// RUN: %{run-aux} mv %t.value1.bin %t/cache_dir/*/*/*/*/*.bin
-// RUN: %{cache_vars} %{run-unfiltered-devices} %t.out 2>&1 | FileCheck %s --check-prefixes RESULT1
-// ******************************
-//
-// REDEFINE: %{build_cmd} = %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device acm-g10,acm-g11" %s
-// ******************************
-// Check the logs first.
-// RUN: %{run-aux} %{build_cmd} -DVALUE=1 -o %t.out
-// RUN: %{run-aux} rm -rf %t/cache_dir/*
-// RUN: %{cache_vars} %{run-unfiltered-devices} %t.out 2>&1 | FileCheck %s  --check-prefixes=CHECK-CACHE-WRITE
-// RUN: %{cache_vars} %{run-unfiltered-devices} %t.out 2>&1 | FileCheck %s  --check-prefixes=CHECK-CACHE-READ
-// RUN: %{cache_vars} %{run-unfiltered-devices} %t.out 2>&1 | FileCheck %s  --check-prefixes=CHECK-CACHE-READ
 //
 // Now try to substitute the cached image and verify it is actually taken and
 // the code/binary there is executed.
diff --git a/sycl/test-e2e/MemorySanitizer/lit.local.cfg b/sycl/test-e2e/MemorySanitizer/lit.local.cfg
index b27814baeea78..48d52b892a4b9 100644
--- a/sycl/test-e2e/MemorySanitizer/lit.local.cfg
+++ b/sycl/test-e2e/MemorySanitizer/lit.local.cfg
@@ -11,8 +11,7 @@ config.substitutions.append(
 config.substitutions.append(
     (
         "%device_msan_aot_gpu_flags",
-        "-Xarch_device -fsanitize=memory -fsycl-targets=spir64_gen "
-        "-Xsycl-target-backend=spir64_gen '-device pvc'",
+        "-Xarch_device -fsanitize=memory -fsycl-targets=intel_gpu_pvc",
     )
 )
 
diff --git a/sycl/test-e2e/NewOffloadDriver/aot-multiple-devices.cpp b/sycl/test-e2e/NewOffloadDriver/aot-multiple-devices.cpp
index cbee51ad49877..5639ff8711d31 100644
--- a/sycl/test-e2e/NewOffloadDriver/aot-multiple-devices.cpp
+++ b/sycl/test-e2e/NewOffloadDriver/aot-multiple-devices.cpp
@@ -17,16 +17,16 @@
 
 // Produce a fat object for all targets (generic SPIR-V, CPU, GPU).
 // It is required to specify the device name when compiling AOT for GPU.
-// RUN: %{run-aux} %clangxx --offload-new-driver -fsycl -fsycl-targets=spir64,spir64_x86_64,spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %S/Inputs/aot.cpp -c -o %t.o
+// RUN: %{run-aux} %clangxx --offload-new-driver -fsycl -fsycl-targets=spir64,spir64_x86_64,%{gpu_aot_target} %S/Inputs/aot.cpp -c -o %t.o
 
 // Check that all targets compiled in the fat binary are selected during
 // linking.
-// RUN: %{run-aux} %clangxx --offload-new-driver -fsycl -fsycl-targets=spir64_x86_64,spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts -v %t.o -o %t_cpu_gpu.out 2>&1 | FileCheck %s --check-prefix=CHECK-DEVICE
+// RUN: %{run-aux} %clangxx --offload-new-driver -fsycl -fsycl-targets=spir64_x86_64,%{gpu_aot_target} -v %t.o -o %t_cpu_gpu.out 2>&1 | FileCheck %s --check-prefix=CHECK-DEVICE
 // RUN: %{run} %t_cpu_gpu.out
 
 // Check that all targets compiled in the fat binary are selected during
 // linking (including CPU even though it is not specified during linking).
-// RUN: %{run-aux} %clangxx --offload-new-driver -fsycl -fsycl-targets=spir64,spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts -v %t.o -o %t_spv_gpu.out 2>&1 | FileCheck %s --check-prefix=CHECK-DEVICE
+// RUN: %{run-aux} %clangxx --offload-new-driver -fsycl -fsycl-targets=spir64,%{gpu_aot_target} -v %t.o -o %t_spv_gpu.out 2>&1 | FileCheck %s --check-prefix=CHECK-DEVICE
 // Check that execution on AOT-compatible devices is unaffected
 // RUN: env ONEAPI_DEVICE_SELECTOR="*:gpu" %{run-unfiltered-devices} %t_spv_gpu.out
 
diff --git a/sycl/test-e2e/OptionalKernelFeatures/is_compatible/is_compatible_several_targets.cpp b/sycl/test-e2e/OptionalKernelFeatures/is_compatible/is_compatible_several_targets.cpp
index 51cfe332d1234..ee4bd416f4e65 100644
--- a/sycl/test-e2e/OptionalKernelFeatures/is_compatible/is_compatible_several_targets.cpp
+++ b/sycl/test-e2e/OptionalKernelFeatures/is_compatible/is_compatible_several_targets.cpp
@@ -1,5 +1,5 @@
 // REQUIRES: opencl-aot, ocloc, opencl-cpu-rt
 
-// RUN: %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64,spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %S/Inputs/is_compatible_with_env.cpp -o %t.out
+// RUN: %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64,%{gpu_aot_target} %S/Inputs/is_compatible_with_env.cpp -o %t.out
 
 // RUN: %if !(level_zero || opencl) %{ not %} %{run} %t.out
diff --git a/sycl/test-e2e/OptionalKernelFeatures/is_compatible/is_compatible_spir64_gen.cpp b/sycl/test-e2e/OptionalKernelFeatures/is_compatible/is_compatible_spir64_gen.cpp
index 4e836a3bb6d4f..0f942089c8a80 100644
--- a/sycl/test-e2e/OptionalKernelFeatures/is_compatible/is_compatible_spir64_gen.cpp
+++ b/sycl/test-e2e/OptionalKernelFeatures/is_compatible/is_compatible_spir64_gen.cpp
@@ -1,5 +1,5 @@
 // REQUIRES: ocloc, target-spir
 
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device *" %S/Inputs/is_compatible_with_env.cpp -o %t.out
+// RUN: %clangxx -fsycl -fsycl-targets=%{gpu_aot_target} %S/Inputs/is_compatible_with_env.cpp -o %t.out
 
 // RUN: %if !(level_zero || opencl && gpu) %{ not %} %{run} %t.out
diff --git a/sycl/test-e2e/ProgramManager/uneven_kernel_split.cpp b/sycl/test-e2e/ProgramManager/uneven_kernel_split.cpp
index 414fd33565d47..45f627e0939f6 100644
--- a/sycl/test-e2e/ProgramManager/uneven_kernel_split.cpp
+++ b/sycl/test-e2e/ProgramManager/uneven_kernel_split.cpp
@@ -5,9 +5,9 @@
 // DEFINE: %{gpu_compile_flags} = %if !new-offload-model %{-Wno-unused-command-line-argument%}
 
 // RUN: %clangxx -fsycl -fsycl-targets=spir64_x86_64 -I %S/Inputs/ %S/uneven_kernel_split.cpp -c -o %t.o
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts -I %S/Inputs/ %S/Inputs/gpu_kernel1.cpp %{gpu_compile_flags} -c -o %t1.o
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts -I %S/Inputs/ %S/Inputs/gpu_kernel2.cpp %{gpu_compile_flags} -c -o %t2.o
-// RUN: %clangxx -fsycl -fsycl-targets=spir64_x86_64,spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts -Wno-unused-command-line-argument %t.o %t1.o %t2.o -o %t.out
+// RUN: %clangxx -fsycl -fsycl-targets=%{gpu_aot_target} -I %S/Inputs/ %S/Inputs/gpu_kernel1.cpp %{gpu_compile_flags} -c -o %t1.o
+// RUN: %clangxx -fsycl -fsycl-targets=%{gpu_aot_target} -I %S/Inputs/ %S/Inputs/gpu_kernel2.cpp %{gpu_compile_flags} -c -o %t2.o
+// RUN: %clangxx -fsycl -fsycl-targets=spir64_x86_64,%{gpu_aot_target} -Wno-unused-command-line-argument %t.o %t1.o %t2.o -o %t.out
 // RUN: %{run} %t.out
 
 // Test require the following device image structure: cpu target device image
diff --git a/sycl/test-e2e/README.md b/sycl/test-e2e/README.md
index 61c6370719c51..4a9b532bf322b 100644
--- a/sycl/test-e2e/README.md
+++ b/sycl/test-e2e/README.md
@@ -207,9 +207,14 @@ may be set to "gfx906". Otherwise must be provided via the ***amd_arch*** LIT
 parameter (e.g., ***--param amd_arch=gfx906***) at runtime via the command line
 or via the ***LIT_OPTS*** environment variable.
 
-***GPU_AOT_TARGET_OPTS*** - defines additional options which are passed to AOT
-compilation command line for GPU device. If not specified "-device *" value is
-used.
+***GPU_AOT_TARGET_OPTS*** - defines additional options passed to the AOT
+compilation of each Intel GPU target in GPU_AOT_TARGET (e.g. "-cl-opt-disable").
+It must not contain "-device"; use GPU_AOT_TARGET to select the targets.
+
+***GPU_AOT_TARGET*** - defines the Intel GPU target(s) used for AOT compilation,
+as a `-fsycl-targets` value (e.g. "intel_gpu_pvc" or
+"intel_gpu_pvc,intel_gpu_bmg_g21"). If not specified, the architectures of the
+detected Intel GPU devices are used, or "intel_gpu_dg2" if none are detected.
 
 ***OFFLOAD_BUILD_TARGET*** - when testing the Offload backend, this must be set
 to specify the correct build target type for the available Offload device.
@@ -292,9 +297,17 @@ configure specific single test execution in the command line:
 * **compatibility_testing** - forces LIT infra to skip the tests compilation to
   support compatibility testing (a SYCL application is built with one version of
   SYCL compiler and then run with different SYCL RT version);
-* **gpu_aot_target_opts** - defines additional options which are passed to AOT
-  compilation command line for GPU device. It can be also set by CMake variable
-  GPU_AOT_TARGET_OPTS. If not specified "-device *" value is used.
+* **gpu_aot_target_opts** - defines additional options passed to the AOT
+  compilation of each target in `gpu_aot_target`, for tests built with the
+  `spir_gen` build target or `%aot_options`. It can be also set by CMake
+  variable GPU_AOT_TARGET_OPTS. It must not contain "-device".
+* **gpu_aot_target** - defines the Intel GPU target(s) used for AOT
+  compilation, as a `-fsycl-targets` value. Tests use it via the
+  `%{gpu_aot_target}` substitution. It can be also set by CMake variable
+  GPU_AOT_TARGET. If not specified, the architectures of the detected Intel GPU
+  devices are used, or "intel_gpu_dg2" if none are detected (e.g. in
+  `build-only` mode). Binaries built in `build-only` mode only run on the
+  devices they are built for, so set it to cover the devices they run on.
 * **gpu-intel-dg2** - tells LIT infra that Intel GPU DG2 is present in the
   system. It is developer / CI infra responsibility to make sure that the device
   is available in the system.
@@ -474,12 +487,11 @@ to only run the compilation stage, or the execution stage respectively.
   The triples to compile in this mode are set via the `sycl_build_targets` lit
   parameter. Valid build targets are: `spir`, `nvidia`, `amd`, `native_cpu`,
   `spir_gen`, `spir_x86_64`. These correspond to `spir64`,
-  `nvptx64-nvidia-cuda`, `amdgcn-amd-amdhsa`, `native_cpu`, `spir64_gen`, and
-  `spir64_x86_64` triples respectively. `spir_gen` and `spir_x86_64` select the
-  AOT-only GPU and CPU triples respectively, rather than the JIT `spir64`
-  triple; `spir_gen` compilation also passes the `GPU_AOT_TARGET_OPTS`/
-  `gpu_aot_target_opts` options (see above) to
-  `-Xsycl-target-backend=spir64_gen`. Each build target should be separated
+  `nvptx64-nvidia-cuda`, `amdgcn-amd-amdhsa`, `native_cpu`, Intel GPU AOT and
+  `spir64_x86_64` targets respectively. `spir_gen` and `spir_x86_64` select the
+  AOT-only GPU and CPU targets respectively, rather than the JIT `spir64`
+  triple; `spir_gen` compiles for the `GPU_AOT_TARGET`/`gpu_aot_target` Intel
+  GPU target(s) (see above). Each build target should be separated
   with a semicolon. This parameter is set to `all` by default, which enables
   autodetection for the available build targets. A test can be marked as
   requiring, or not supporting a particular triple via the `target-*` features.
diff --git a/sycl/test-e2e/SYCLBIN/aot_object_load.cpp b/sycl/test-e2e/SYCLBIN/aot_object_load.cpp
index 494e4b1de20ab..1b61dae4378f0 100644
--- a/sycl/test-e2e/SYCLBIN/aot_object_load.cpp
+++ b/sycl/test-e2e/SYCLBIN/aot_object_load.cpp
@@ -16,9 +16,8 @@
 // -- is in object state and was previously dropped by
 // -- SYCLBINBinaries::getBestCompatibleImages.
 //
-// -- The test targets spir64_gen via ocloc with -device *
-// (%gpu_aot_target_opts)
-// -- so it is not locked to a single Intel GPU architecture. spir64_x86_64
+// -- The test targets the configured Intel GPU architecture(s)
+// -- (%{gpu_aot_target}) so it is not locked to a single one. spir64_x86_64
 // -- is intentionally not exercised here: the Intel OpenCL CPU runtime's
 // -- clBuildProgram does not accept unresolved imported symbols (no
 // -- equivalent of IGC's -library-compilation), and the -cmd=compile path
@@ -30,8 +29,7 @@
 
 // RUN: %clangxx --offload-new-driver -fsyclbin=object \
 // RUN:   -fsycl-allow-device-image-dependencies \
-// RUN:   -fsycl-targets=spir64_gen \
-// RUN:   -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts \
+// RUN:   -fsycl-targets=%{gpu_aot_target} \
 // RUN:   %S/Inputs/aot_object_with_imports.cpp -o %t.syclbin
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out %t.syclbin
diff --git a/sycl/test-e2e/SYCLBIN/aot_object_no_symbols.cpp b/sycl/test-e2e/SYCLBIN/aot_object_no_symbols.cpp
index 238cc3c20b47f..224df2e222ed9 100644
--- a/sycl/test-e2e/SYCLBIN/aot_object_no_symbols.cpp
+++ b/sycl/test-e2e/SYCLBIN/aot_object_no_symbols.cpp
@@ -30,14 +30,14 @@
 // -- the native-AOT partition (build with ALLOW_UNRESOLVED_SYMBOLS +
 // -- dynamicLink) to reach executable state.
 //
-// -- The -device * wildcard (%gpu_aot_target_opts) keeps this off a single
-// -- Intel GPU architecture. Complements the hardware-independent unit test
+// -- Targeting the configured Intel GPU architecture(s) (%{gpu_aot_target})
+// -- keeps this off a single hard-coded one. Complements the
+// -- hardware-independent unit test
 // -- SYCLBINSelector.NativeWithoutSymbolsSurfacedForObject, which covers the
 // -- selector in isolation but neither the producer nor the link-and-run path.
 
 // RUN: %clangxx --offload-new-driver -fsyclbin=object \
-// RUN:   -fsycl-targets=spir64_gen \
-// RUN:   -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts \
+// RUN:   -fsycl-targets=%{gpu_aot_target} \
 // RUN:   %S/Inputs/aot_object_no_symbols.cpp -o %t.syclbin
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out %t.syclbin
diff --git a/sycl/test-e2e/SYCLBIN/basic_executable_bmg_aot.cpp b/sycl/test-e2e/SYCLBIN/basic_executable_bmg_aot.cpp
index ffc7c392f0ee5..4ca4a807154f2 100644
--- a/sycl/test-e2e/SYCLBIN/basic_executable_bmg_aot.cpp
+++ b/sycl/test-e2e/SYCLBIN/basic_executable_bmg_aot.cpp
@@ -3,7 +3,7 @@
 // -- Basic test for compiling and loading a SYCLBIN kernel_bundle in executable
 // -- state using only AOT target for BMG G21.
 
-// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device bmg-g21" %S/Inputs/basic_kernel.cpp -o %t.syclbin
+// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=intel_gpu_bmg_g21 %S/Inputs/basic_kernel.cpp -o %t.syclbin
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out %t.syclbin
 
diff --git a/sycl/test-e2e/SYCLBIN/dae_executable_bmg_aot.cpp b/sycl/test-e2e/SYCLBIN/dae_executable_bmg_aot.cpp
index 5d43b4db128ec..c56eae62c1bfb 100644
--- a/sycl/test-e2e/SYCLBIN/dae_executable_bmg_aot.cpp
+++ b/sycl/test-e2e/SYCLBIN/dae_executable_bmg_aot.cpp
@@ -3,7 +3,7 @@
 // -- Test for using a kernel from a SYCLBIN with a dead argument using only AOT
 // target for BMG G21.
 
-// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device bmg-g21" %S/Inputs/dae_kernel.cpp -o %t.syclbin
+// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=intel_gpu_bmg_g21 %S/Inputs/dae_kernel.cpp -o %t.syclbin
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out %t.syclbin
 
diff --git a/sycl/test-e2e/SYCLBIN/dg_executable_bmg_aot.cpp b/sycl/test-e2e/SYCLBIN/dg_executable_bmg_aot.cpp
index d9c5c16fbe5b8..9cfcc453aa7a3 100644
--- a/sycl/test-e2e/SYCLBIN/dg_executable_bmg_aot.cpp
+++ b/sycl/test-e2e/SYCLBIN/dg_executable_bmg_aot.cpp
@@ -9,7 +9,7 @@
 // UNSUPPORTED: cuda
 // UNSUPPORTED-TRACKER: https://github.com/intel/llvm/issues/19533
 
-// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device bmg-g21" %S/Inputs/dg_kernel.cpp -o %t.syclbin
+// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=intel_gpu_bmg_g21 %S/Inputs/dg_kernel.cpp -o %t.syclbin
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out %t.syclbin
 
diff --git a/sycl/test-e2e/SYCLBIN/link_object_aot.cpp b/sycl/test-e2e/SYCLBIN/link_object_aot.cpp
index 1242b8d1bd5a1..c33539b4f97f2 100644
--- a/sycl/test-e2e/SYCLBIN/link_object_aot.cpp
+++ b/sycl/test-e2e/SYCLBIN/link_object_aot.cpp
@@ -26,12 +26,10 @@
 // -- exercises the full AOT object-state link-and-run path.
 
 // RUN: %clangxx --offload-new-driver -fsyclbin=object \
-// RUN:   -fsycl-targets=spir64_gen \
-// RUN:   -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts \
+// RUN:   -fsycl-targets=%{gpu_aot_target} \
 // RUN:   %S/Inputs/exporting_function.cpp -o %t.export.syclbin
 // RUN: %clangxx --offload-new-driver -fsyclbin=object \
-// RUN:   -fsycl-targets=spir64_gen \
-// RUN:   -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts \
+// RUN:   -fsycl-targets=%{gpu_aot_target} \
 // RUN:   %S/Inputs/importing_kernel.cpp -o %t.import.syclbin
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out %t.export.syclbin %t.import.syclbin
diff --git a/sycl/test-e2e/SYCLBIN/lit.local.cfg b/sycl/test-e2e/SYCLBIN/lit.local.cfg
index 5467332c99af5..44ca4075e1312 100644
--- a/sycl/test-e2e/SYCLBIN/lit.local.cfg
+++ b/sycl/test-e2e/SYCLBIN/lit.local.cfg
@@ -2,10 +2,8 @@ syclbin_exec_opts = ""
 if 'target-spir' in config.available_features:
   syclbin_exec_opts = '-fsycl-targets=spir64,spir64_x86_64'
   if 'ocloc' in config.available_features:
-    # Due to a bug in clang-linker-wrapper we cannot use -device * on Windows, so
-    # we pick specific targets for now. Once that is fixed we can switch to the
-    # wildcard. See https://github.com/intel/llvm/issues/19373.
-    syclbin_exec_opts = syclbin_exec_opts + ',spir64_gen -Xsycl-target-backend=spir64_gen "-device pvc,dg2,bmg-g21"'
+    # Build for a fixed set of Intel GPU architectures.
+    syclbin_exec_opts = syclbin_exec_opts + ',intel_gpu_pvc,intel_gpu_dg2,intel_gpu_bmg_g21'
 config.substitutions.append(('%{syclbin_exec_opts}', format(syclbin_exec_opts)))
 
 # https://github.com/intel/llvm/issues/20142
diff --git a/sycl/test-e2e/SYCLBIN/optional_kernel_features_executable_bmg_aot.cpp b/sycl/test-e2e/SYCLBIN/optional_kernel_features_executable_bmg_aot.cpp
index f9d377975d741..ef585d7de8bf5 100644
--- a/sycl/test-e2e/SYCLBIN/optional_kernel_features_executable_bmg_aot.cpp
+++ b/sycl/test-e2e/SYCLBIN/optional_kernel_features_executable_bmg_aot.cpp
@@ -3,7 +3,7 @@
 // -- Test for compiling and loading a kernel bundle with a SYCLBIN containing
 //    the use of optional kernel features using only AOT target for BMG G21.
 
-// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device bmg-g21" %S/Inputs/optional_kernel_features.cpp -o %t.syclbin
+// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=intel_gpu_bmg_g21 %S/Inputs/optional_kernel_features.cpp -o %t.syclbin
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out %t.syclbin
 
diff --git a/sycl/test-e2e/SYCLBIN/simple_kernel_aot.cpp b/sycl/test-e2e/SYCLBIN/simple_kernel_aot.cpp
index 9c2bdc2ffbc43..10a2b632dd7cc 100644
--- a/sycl/test-e2e/SYCLBIN/simple_kernel_aot.cpp
+++ b/sycl/test-e2e/SYCLBIN/simple_kernel_aot.cpp
@@ -3,11 +3,11 @@
 
 // REQUIRES: ocloc
 
-// RUN: %clangxx --offload-new-driver -fsyclbin=input -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device bmg-g21" -o %t.input_bmg_g21_gpu_device_arch.syclbin %s
-// RUN: %clangxx --offload-new-driver -fsyclbin=input -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device *" -o %t.input_all_gpu_device_archs.syclbin %s
-// RUN: %clangxx --offload-new-driver -fsyclbin=object -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device bmg-g21" -o %t.object_bmg_g21_gpu_device_arch.syclbin %s
-// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device bmg-g21" -o %t.executable_bmg_g21_gpu_device_arch.syclbin %s
-// RUN: %clangxx --offload-new-driver -fsyclbin -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "-device bmg-g21" -o %t.default_bmg_g21_gpu_device_arch.syclbin %s
+// RUN: %clangxx --offload-new-driver -fsyclbin=input -fsycl-targets=intel_gpu_bmg_g21 -o %t.input_bmg_g21_gpu_device_arch.syclbin %s
+// RUN: %clangxx --offload-new-driver -fsyclbin=input -fsycl-targets=%{gpu_aot_target} -o %t.input_all_gpu_device_archs.syclbin %s
+// RUN: %clangxx --offload-new-driver -fsyclbin=object -fsycl-targets=intel_gpu_bmg_g21 -o %t.object_bmg_g21_gpu_device_arch.syclbin %s
+// RUN: %clangxx --offload-new-driver -fsyclbin=executable -fsycl-targets=intel_gpu_bmg_g21 -o %t.executable_bmg_g21_gpu_device_arch.syclbin %s
+// RUN: %clangxx --offload-new-driver -fsyclbin -fsycl-targets=intel_gpu_bmg_g21 -o %t.default_bmg_g21_gpu_device_arch.syclbin %s
 
 // RUN: syclbin-dump %t.input_bmg_g21_gpu_device_arch.syclbin | FileCheck %s --check-prefix CHECK-INPUT-BMG-G21-GPU-DEVICE-ARCH
 // RUN: syclbin-dump %t.input_all_gpu_device_archs.syclbin | FileCheck %s --check-prefix CHECK-INPUT-ALL-GPU-DEVICE-ARCHS
@@ -48,7 +48,7 @@ void TestKernel(int *Ptr, int Size) {
 // CHECK-INPUT-ALL-GPU-DEVICE-ARCHS-NEXT: Global metadata:
 // CHECK-INPUT-ALL-GPU-DEVICE-ARCHS-NEXT:   SYCLBIN/global metadata:
 // CHECK-INPUT-ALL-GPU-DEVICE-ARCHS-NEXT:     state: 0
-// CHECK-INPUT-ALL-GPU-DEVICE-ARCHS-NEXT: Number of Abstract Modules: 1
+// CHECK-INPUT-ALL-GPU-DEVICE-ARCHS-NEXT: Number of Abstract Modules: {{[1-9][0-9]*}}
 // CHECK-INPUT-ALL-GPU-DEVICE-ARCHS-NEXT: Abstract Module 0:
 // CHECK-INPUT-ALL-GPU-DEVICE-ARCHS-NEXT:   Metadata:
 // CHECK-INPUT-ALL-GPU-DEVICE-ARCHS:      Number of IR Modules: 0
diff --git a/sycl/test-e2e/SpecConstants/2020/image_selection.cpp b/sycl/test-e2e/SpecConstants/2020/image_selection.cpp
index 89c32efe4a214..0f5a4634c6481 100644
--- a/sycl/test-e2e/SpecConstants/2020/image_selection.cpp
+++ b/sycl/test-e2e/SpecConstants/2020/image_selection.cpp
@@ -5,21 +5,21 @@
 // are replaced with defaults and original images.
 
 // clang-format off
-// RUN: %clangxx -fsycl-add-default-spec-consts-image -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t1.out
+// RUN: %clangxx -fsycl-add-default-spec-consts-image -fsycl -fsycl-targets=%{gpu_aot_target} %s -o %t1.out
 // RUN: env SYCL_UR_TRACE=2 %{run} %t1.out | FileCheck --match-full-lines --check-prefix=CHECK-ENABLED %s
 // clang-format on
 
 // Check the behaviour when -fsycl-add-default-spec-consts-image option is not
 // used.
 
-// RUN: %clangxx  -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t2.out
+// RUN: %clangxx  -fsycl -fsycl-targets=%{gpu_aot_target} %s -o %t2.out
 // RUN: env SYCL_UR_TRACE=2 %{run} %t2.out | FileCheck --match-full-lines --check-prefix=CHECK-DEFAULT %s
 
 // Check the behaviour when -fsycl-add-default-spec-consts-image option is used
 // and we have spirv image in addition to AOT.
 
 // clang-format off
-// RUN: %clangxx  -fsycl -fsycl-targets=spir64,spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t3.out
+// RUN: %clangxx  -fsycl -fsycl-targets=spir64,%{gpu_aot_target} %s -o %t3.out
 // RUN: env SYCL_UR_TRACE=2 %{run} %t3.out | FileCheck --match-full-lines --check-prefix=CHECK-MIX %s
 // clang-format on
 
@@ -28,7 +28,7 @@
 // choose images with inlined values in this case.
 
 // clang-format off
-// RUN: %clangxx  -fsycl-add-default-spec-consts-image -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t3.out
+// RUN: %clangxx  -fsycl-add-default-spec-consts-image -fsycl -fsycl-targets=%{gpu_aot_target} %s -o %t3.out
 // RUN: env SYCL_UR_TRACE=2 %{run} %t3.out | FileCheck --match-full-lines --check-prefix=CHECK-DEFAULT-EXPLICIT-SET %s
 // clang-format on
 
@@ -38,7 +38,7 @@
 // this case.
 
 // clang-format off
-// RUN: %clangxx  -fsycl-add-default-spec-consts-image -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t3.out
+// RUN: %clangxx  -fsycl-add-default-spec-consts-image -fsycl -fsycl-targets=%{gpu_aot_target} %s -o %t3.out
 // RUN: env SYCL_UR_TRACE=2 %{run} %t3.out | FileCheck --match-full-lines --check-prefix=CHECK-DEFAULT-BACK-TO-DEFAULT %s
 // clang-format on
 #include <iostream>
diff --git a/sycl/test-e2e/SpecConstants/2020/native_specialization_constant.cpp b/sycl/test-e2e/SpecConstants/2020/native_specialization_constant.cpp
index d6bf10c393419..bb7f0085ee221 100644
--- a/sycl/test-e2e/SpecConstants/2020/native_specialization_constant.cpp
+++ b/sycl/test-e2e/SpecConstants/2020/native_specialization_constant.cpp
@@ -7,7 +7,7 @@
 // RUN: %{build} -DJIT -o %t1.out
 // RUN: %{run} %t1.out
 
-// RUN: %if any-device-is-gpu %{ %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t2.out %}
+// RUN: %if any-device-is-gpu %{ %{run-aux} %clangxx -fsycl -fsycl-targets=%{gpu_aot_target} %s -o %t2.out %}
 // RUN: %if gpu %{ %{run} %t2.out %}
 
 // RUN: %if any-device-is-cpu %{ %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64 %s -o %t3.out %}
diff --git a/sycl/test-e2e/SpecConstants/2020/non_native/spec_const_alignment_test.cpp b/sycl/test-e2e/SpecConstants/2020/non_native/spec_const_alignment_test.cpp
index 6d007586498f7..cd23123eb90eb 100644
--- a/sycl/test-e2e/SpecConstants/2020/non_native/spec_const_alignment_test.cpp
+++ b/sycl/test-e2e/SpecConstants/2020/non_native/spec_const_alignment_test.cpp
@@ -1,6 +1,6 @@
 // REQUIRES: opencl-aot, ocloc, target-spir
 
-// RUN: %if any-device-is-gpu %{ %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t1.out %}
+// RUN: %if any-device-is-gpu %{ %{run-aux} %clangxx -fsycl -fsycl-targets=%{gpu_aot_target} %s -o %t1.out %}
 // RUN: %if gpu %{ %{run} %t1.out %}
 
 // RUN: %if any-device-is-cpu %{ %{run-aux} %clangxx -fsycl -fsycl-targets=spir64_x86_64 %s -o %t2.out %}
diff --git a/sycl/test-e2e/ThreadSanitizer/lit.local.cfg b/sycl/test-e2e/ThreadSanitizer/lit.local.cfg
index 1d75725c0e5c6..b8bef8e9b8474 100644
--- a/sycl/test-e2e/ThreadSanitizer/lit.local.cfg
+++ b/sycl/test-e2e/ThreadSanitizer/lit.local.cfg
@@ -30,8 +30,7 @@ config.substitutions.append(
 config.substitutions.append(
     (
         "%device_tsan_aot_gpu_flags",
-        "-Xarch_device -fsanitize=thread -fsycl-targets=spir64_gen "
-        "-Xsycl-target-backend=spir64_gen '-device pvc'",
+        "-Xarch_device -fsanitize=thread -fsycl-targets=intel_gpu_pvc",
     )
 )
 
diff --git a/sycl/test-e2e/format.py b/sycl/test-e2e/format.py
index 43469917c3931..1f02e7d64f079 100644
--- a/sycl/test-e2e/format.py
+++ b/sycl/test-e2e/format.py
@@ -304,7 +304,15 @@ def execute(self, test, litConfig):
                 (backend, _) = sycl_device.split(":")
                 build_targets.add(test.config.backend_to_target[backend])
 
-        triples = set(test.config.target_to_triple[t] for t in build_targets)
+        # spir_gen builds for the configured Intel GPU architecture(s).
+        triples = set(
+            (
+                test.config.gpu_aot_target
+                if t == "target-spir_gen"
+                else test.config.target_to_triple[t]
+            )
+            for t in build_targets
+        )
         features_for_test = test.config.available_features.union(build_targets)
 
         substitutions = lit.TestRunner.getDefaultSubstitutions(test, tmpDir, tmpBase)
@@ -320,10 +328,11 @@ def execute(self, test, litConfig):
         # CPU vs GPU AOT comes from test.requires, not the matched triple:
         # target_to_triple has no spir64_x86_64, and build-only mode has no
         # selected device to query a cpu/gpu role from either.
-        matched_spir_triple = next(
-            (t for t in triples if t in ("spir64", "spir64_gen")), None
-        )
-        if matched_spir_triple in ("spir64", "spir64_gen"):
+        # Match on build targets: triples has spir_gen mapped to gpu_aot_target.
+        if any(
+            test.config.target_to_triple[t] in ("spir64", "spir64_gen")
+            for t in build_targets
+        ):
             requires_cpu = any(r in test.requires for r in ("cpu", "any-device-is-cpu"))
             requires_gpu = any(r in test.requires for r in ("gpu", "any-device-is-gpu"))
             if requires_cpu and requires_gpu:
@@ -337,8 +346,10 @@ def execute(self, test, litConfig):
                 aot_options = "-fsycl-targets=spir64_x86_64"
             else:
                 aot_options = (
-                    "-fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen "
-                    + test.config.gpu_aot_target_opts
+                    "-fsycl-targets="
+                    + test.config.gpu_aot_target
+                    + " "
+                    + test.config.gpu_aot_backend_opts
                 )
         else:
             aot_options = ""
@@ -346,9 +357,7 @@ def execute(self, test, litConfig):
 
         sycl_target_opts = "-fsycl-targets=%{sycl_triple}"
         if "target-spir_gen" in build_targets:
-            sycl_target_opts += " -Xsycl-target-backend=spir64_gen {}".format(
-                test.config.gpu_aot_target_opts
-            )
+            sycl_target_opts += " " + test.config.gpu_aot_backend_opts
         if "target-amd" in build_targets:
             hip_arch_opts = (
                 " -Xsycl-target-backend=amdgcn-amd-amdhsa --offload-arch={}".format(
diff --git a/sycl/test-e2e/lit.cfg.py b/sycl/test-e2e/lit.cfg.py
index 8cdf938269081..55aaa7d3c644c 100644
--- a/sycl/test-e2e/lit.cfg.py
+++ b/sycl/test-e2e/lit.cfg.py
@@ -697,11 +697,6 @@ def open_check_file(file_name):
         directx_libs = ["/clang:" + l for l in directx_libs]
     config.substitutions.append(("%link-directx", " ".join(directx_libs)))
 
-if not config.gpu_aot_target_opts:
-    config.gpu_aot_target_opts = '"-device *"'
-
-config.substitutions.append(("%gpu_aot_target_opts", config.gpu_aot_target_opts))
-
 if config.dump_ir_supported:
     config.available_features.add("dump_ir")
 
@@ -1306,6 +1301,38 @@ def get_sycl_ls_verbose(sycl_device, env):
     )
 config.substitutions.append(("%amd_arch_options", amd_arch_flags))
 
+# Intel GPU AOT target(s), as a -fsycl-targets value. Uses the detected Intel
+# GPU architectures, or intel_gpu_dg2 if none are detected (e.g. build-only
+# mode). CI passes the architectures of its run-only runners.
+if not config.gpu_aot_target:
+    intel_gpu_archs = sorted(
+        feature[len("arch-") :]
+        for feature in set().union(*config.sycl_dev_features.values())
+        if feature.startswith("arch-intel_gpu_")
+    )
+    config.gpu_aot_target = ",".join(intel_gpu_archs)
+    if not config.gpu_aot_target:
+        config.gpu_aot_target = "intel_gpu_dg2"
+        lit_config.note(
+            "No Intel GPU detected, defaulting the AOT target to intel_gpu_dg2"
+        )
+lit_config.note("Intel GPU AOT target: {}".format(config.gpu_aot_target))
+config.substitutions.append(("%{gpu_aot_target}", config.gpu_aot_target))
+
+# Extra backend options for Intel GPU AOT compilation, passed for each target in
+# gpu_aot_target. The device is selected by gpu_aot_target instead.
+if "-device" in config.gpu_aot_target_opts.split():
+    lit_config.error(
+        "gpu_aot_target_opts must not contain -device; use gpu_aot_target to "
+        "select the Intel GPU AOT target(s)"
+    )
+config.gpu_aot_backend_opts = ""
+if config.gpu_aot_target_opts:
+    config.gpu_aot_backend_opts = " ".join(
+        "-Xsycl-target-backend={} '{}'".format(target, config.gpu_aot_target_opts)
+        for target in config.gpu_aot_target.split(",")
+    )
+
 if lit_config.params.get("compatibility_testing", "False") != "False":
     config.substitutions.append(("%clangxx", " true "))
     config.substitutions.append(("%clang", " true "))
diff --git a/sycl/test-e2e/lit.site.cfg.py.in b/sycl/test-e2e/lit.site.cfg.py.in
index 5ae02752917b1..f4636bb323f30 100644
--- a/sycl/test-e2e/lit.site.cfg.py.in
+++ b/sycl/test-e2e/lit.site.cfg.py.in
@@ -54,6 +54,7 @@ config.cxx_flags = lit_config.params.get("cxx_flags", "@SYCL_E2E_CLANG_CXX_FLAGS
 config.c_flags = "@CMAKE_C_FLAGS@"
 config.external_tests = "@SYCL_EXTERNAL_TESTS@"
 config.extra_include = "@CMAKE_CURRENT_SOURCE_DIR@/include"
+config.gpu_aot_target = lit_config.params.get("gpu_aot_target", "@GPU_AOT_TARGET@")
 config.gpu_aot_target_opts = lit_config.params.get("gpu_aot_target_opts", "@GPU_AOT_TARGET_OPTS@")
 
 config.vulkan_include_dir = "@Vulkan_INCLUDE_DIRS@"
diff --git a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-convert.cpp b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-convert.cpp
index 5aeb711a8445f..bd28b6b155daa 100644
--- a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-convert.cpp
+++ b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-convert.cpp
@@ -1,6 +1,6 @@
 // UNSUPPORTED: cuda, hip
 
-// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=spir64_gen -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
+// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=intel_gpu_dg2 -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
 
 // CHECK-NOT: define {{.*}} spir_kernel void @_ZTSZZ4mainENKUlRN4sycl3_V17handlerEE_clES2_EUlvE_(){{.*}} !sycl_used_aspects
 
diff --git a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-test-call-convert.cpp b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-test-call-convert.cpp
index 8043dce78328e..fb17af53d343a 100644
--- a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-test-call-convert.cpp
+++ b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-test-call-convert.cpp
@@ -1,6 +1,6 @@
 // UNSUPPORTED: cuda, hip
 
-// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=spir64_gen -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
+// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=intel_gpu_dg2 -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
 
 // CHECK-NOT: define {{.*}} spir_kernel void @_ZTSZZ4mainENKUlRN4sycl3_V17handlerEE_clES2_EUlvE_(){{.*}} !sycl_used_aspects
 
diff --git a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-test-call.cpp b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-test-call.cpp
index ecdb761c17ec2..4f15b705897c4 100644
--- a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-test-call.cpp
+++ b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-test-call.cpp
@@ -1,6 +1,6 @@
 // UNSUPPORTED: cuda, hip
 
-// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=spir64_gen -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
+// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=intel_gpu_dg2 -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
 
 // CHECK: define {{.*}} spir_kernel void @_ZTSZZ4mainENKUlRN4sycl3_V17handlerEE_clES2_EUlvE_(){{.*}} !sycl_used_aspects ![[ASPECTFP64:[0-9]+]]
 // CHECK-DAG: define {{.*}} spir_kernel void @_ZTSZZ4mainENKUlRN4sycl3_V17handlerEE0_clES2_EUlvE_(){{.*}} !sycl_used_aspects ![[ASPECTFP64]]
diff --git a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-with-recursive-type-decls.cpp b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-with-recursive-type-decls.cpp
index faa695d460e93..3f836b2911523 100644
--- a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-with-recursive-type-decls.cpp
+++ b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu-with-recursive-type-decls.cpp
@@ -1,6 +1,6 @@
 // UNSUPPORTED: cuda, hip
 
-// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=spir64_gen -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
+// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=intel_gpu_dg2 -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
 
 // CHECK-NOT: define {{.*}} spir_kernel void @_ZTSZZ4mainENKUlRN4sycl3_V17handlerEE_clES2_EUlvE_(){{.*}} !sycl_used_aspects
 
diff --git a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu.cpp b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu.cpp
index 82a65559f4172..d681cba122319 100644
--- a/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu.cpp
+++ b/sycl/test/check_device_code/optional_kernel_features/fp64-conv-emu.cpp
@@ -1,6 +1,6 @@
 // UNSUPPORTED: cuda, hip
 
-// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=spir64_gen -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
+// RUN: %clangxx -O0 -fsycl -fsycl-device-only -fsycl-targets=intel_gpu_dg2 -fsycl-fp64-conv-emu %s -c -S -emit-llvm -o- | FileCheck %s
 // CHECK: define {{.*}} spir_kernel void @_ZTSZZ4mainENKUlRN4sycl3_V17handlerEE_clES2_EUlvE_(){{.*}} !sycl_used_aspects ![[ASPECTFP64:[0-9]+]]
 // CHECK-DAG: ![[ASPECTFP64]] = !{![[TMP:[0-9]+]]}
 // CHECK-DAG: ![[TMP]] = !{!"fp64", i32 6}