Refactor sycl offload

clang/include/clang/Basic/OffloadArch.h

@@ -103,9 +103,62 @@ enum class OffloadArch {
   Generic, // A processor model named 'generic' if the target backend defines a
            // public one.
   // Intel CPUs
+  SKYLAKEAVX512,
+  COREAVX2,
+  COREI7AVX,
+  COREI7,
+  WESTMERE,
+  SANDYBRIDGE,
+  IVYBRIDGE,
+  BROADWELL,
+  COFFEELAKE,
+  ALDERLAKE,
+  SKYLAKE,
+  SKX,
+  CASCADELAKE,
+  ICELAKECLIENT,
+  ICELAKESERVER,
+  SAPPHIRERAPIDS,
   GRANITERAPIDS,
   // Intel GPUs
+  BDW,
+  SKL,
+  KBL,
+  CFL,
+  APL,
+  BXT,
+  GLK,
+  WHL,
+  AML,
+  CML,
+  ICLLP,
+  ICL,
+  EHL,
+  JSL,
+  TGLLP,
+  TGL,
+  RKL,
+  ADL_S,
+  RPL_S,
+  ADL_P,
+  ADL_N,
+  DG1,
+  ACM_G10,
+  DG2_G10,
+  ACM_G11,
+  DG2_G11,
+  ACM_G12,
+  DG2_G12,
+  PVC,
+  PVC_VG,
+  MTL_U,
+  MTL_S,
+  ARL_U,
+  ARL_S,
+  MTL_H,
+  ARL_H,
   BMG_G21,
+  LNL_M,
   LAST,
 
   CudaDefault = OffloadArch::SM_52,
@@ -122,17 +175,41 @@ static inline bool IsAMDOffloadArch(OffloadArch A) {
 }
 
 static inline bool IsIntelCPUOffloadArch(OffloadArch Arch) {
-  return Arch >= OffloadArch::GRANITERAPIDS && Arch < OffloadArch::BMG_G21;
+  return Arch >= OffloadArch::SKYLAKEAVX512 &&
+         Arch <= OffloadArch::GRANITERAPIDS;
 }
 
 static inline bool IsIntelGPUOffloadArch(OffloadArch Arch) {
-  return Arch >= OffloadArch::BMG_G21 && Arch < OffloadArch::LAST;
+  return Arch >= OffloadArch::BDW && Arch < OffloadArch::LAST;
 }
 
 static inline bool IsIntelOffloadArch(OffloadArch Arch) {
   return IsIntelCPUOffloadArch(Arch) || IsIntelGPUOffloadArch(Arch);
 }
 
+// Check if the given Arch value is a Generic AMD GPU.
+// Currently GFX*_GENERIC AMD GPUs do not support SYCL offloading.
+// This list is used to filter out GFX*_GENERIC AMD GPUs in
+// `IsSYCLSupportedAMDGPUArch`.
+static inline bool IsAMDGenericGPUArch(OffloadArch Arch) {
+  return Arch == OffloadArch::GFX9_GENERIC ||
+         Arch == OffloadArch::GFX10_1_GENERIC ||
+         Arch == OffloadArch::GFX10_3_GENERIC ||
+         Arch == OffloadArch::GFX11_GENERIC ||
+         Arch == OffloadArch::GFX12_GENERIC;
+}
+
+// Check if the given Arch value is a valid SYCL supported AMD GPU.
+static inline bool IsSYCLSupportedAMDGPUArch(OffloadArch Arch) {
+  return Arch >= OffloadArch::GFX700 && Arch < OffloadArch::AMDGCNSPIRV &&
+         !IsAMDGenericGPUArch(Arch);
+}
+
+// Check if the given Arch value is a valid SYCL supported NVidia GPU.
+static inline bool IsSYCLSupportedNVidiaGPUArch(OffloadArch Arch) {
+  return Arch >= OffloadArch::SM_50 && Arch <= OffloadArch::SM_90a;
+}
+
 const char *OffloadArchToString(OffloadArch A);
 const char *OffloadArchToVirtualArchString(OffloadArch A);
 

clang/lib/Basic/OffloadArch.cpp

@@ -89,9 +89,62 @@ static const OffloadArchToStringMap ArchNames[] = {
     GFX(1250), // gfx1250
     {OffloadArch::AMDGCNSPIRV, "amdgcnspirv", "compute_amdgcn"},
     // Intel CPUs
+    {OffloadArch::SKYLAKEAVX512, "skylakeavx512", ""},
+    {OffloadArch::COREAVX2, "coreavx2", ""},
+    {OffloadArch::COREI7AVX, "corei7avx", ""},
+    {OffloadArch::COREI7, "corei7", ""},
+    {OffloadArch::WESTMERE, "westmere", ""},
+    {OffloadArch::SANDYBRIDGE, "sandybridge", ""},
+    {OffloadArch::IVYBRIDGE, "ivybridge", ""},
+    {OffloadArch::BROADWELL, "broadwell", ""},
+    {OffloadArch::COFFEELAKE, "coffeelake", ""},
+    {OffloadArch::ALDERLAKE, "alderlake", ""},
+    {OffloadArch::SKYLAKE, "skylake", ""},
+    {OffloadArch::SKX, "skx", ""},
+    {OffloadArch::CASCADELAKE, "cascadelake", ""},
+    {OffloadArch::ICELAKECLIENT, "icelakeclient", ""},
+    {OffloadArch::ICELAKESERVER, "icelakeserver", ""},
+    {OffloadArch::SAPPHIRERAPIDS, "sapphirerapids", ""},
     {OffloadArch::GRANITERAPIDS, "graniterapids", ""},
     // Intel GPUS
+    {OffloadArch::BDW, "bdw", ""},
+    {OffloadArch::SKL, "skl", ""},
+    {OffloadArch::KBL, "kbl", ""},
+    {OffloadArch::CFL, "cfl", ""},
+    {OffloadArch::APL, "apl", ""},
+    {OffloadArch::BXT, "bxt", ""},
+    {OffloadArch::GLK, "glk", ""},
+    {OffloadArch::WHL, "whl", ""},
+    {OffloadArch::AML, "aml", ""},
+    {OffloadArch::CML, "cml", ""},
+    {OffloadArch::ICLLP, "icllp", ""},
+    {OffloadArch::ICL, "icl", ""},
+    {OffloadArch::EHL, "ehl", ""},
+    {OffloadArch::JSL, "jsl", ""},
+    {OffloadArch::TGLLP, "tgllp", ""},
+    {OffloadArch::TGL, "tgl", ""},
+    {OffloadArch::RKL, "rkl", ""},
+    {OffloadArch::ADL_S, "adl_s", ""},
+    {OffloadArch::RPL_S, "rpl_s", ""},
+    {OffloadArch::ADL_P, "adl_p", ""},
+    {OffloadArch::ADL_N, "adl_n", ""},
+    {OffloadArch::DG1, "dg1", ""},
+    {OffloadArch::ACM_G10, "acm_g10", ""},
+    {OffloadArch::DG2_G10, "dg2_g10", ""},
+    {OffloadArch::ACM_G11, "acm_g11", ""},
+    {OffloadArch::DG2_G11, "dg2_g11", ""},
+    {OffloadArch::ACM_G12, "acm_g12", ""},
+    {OffloadArch::DG2_G12, "dg2_g12", ""},
+    {OffloadArch::PVC, "pvc", ""},
+    {OffloadArch::PVC_VG, "pvc_vg", ""},
+    {OffloadArch::MTL_U, "mtl_u", ""},
+    {OffloadArch::MTL_S, "mtl_s", ""},
+    {OffloadArch::ARL_U, "arl_u", ""},
+    {OffloadArch::ARL_S, "arl_s", ""},
+    {OffloadArch::MTL_H, "mtl_h", ""},
+    {OffloadArch::ARL_H, "arl_h", ""},
     {OffloadArch::BMG_G21, "bmg_g21", ""},
+    {OffloadArch::LNL_M, "lnl_m", ""},                                                                            
     {OffloadArch::Generic, "generic", ""},
     // clang-format on
 };

clang/lib/Driver/Driver.cpp

@@ -1206,6 +1206,7 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
             StringToOffloadArch(getProcessorFromTargetID(NVPTXTriple, Arch)));
         bool IsAMDGPU = IsAMDOffloadArch(
             StringToOffloadArch(getProcessorFromTargetID(AMDTriple, Arch)));
+
         if (!IsNVPTX && !IsAMDGPU && !Arch.empty() &&
             !Arch.equals_insensitive("native")) {
           Diag(clang::diag::err_drv_failed_to_deduce_target_from_arch) << Arch;
@@ -1222,6 +1223,7 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
         llvm::SmallVector<StringRef> Archs =
             getOffloadArchs(C, C.getArgs(), Action::OFK_OpenMP, &TC,
                             /*SpecificToolchain=*/false);
+
         if (!Archs.empty()) {
           C.addOffloadDeviceToolChain(&TC, Action::OFK_OpenMP);
           OffloadArchs[&TC] = Archs;
@@ -1479,87 +1481,55 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
       Diag(clang::diag::err_drv_sycl_offload_arch_new_driver);
       return;
     }
-    const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
-    auto AMDTriple = getHIPOffloadTargetTriple(*this, C.getInputArgs());
-    auto NVPTXTriple = getNVIDIAOffloadTargetTriple(*this, C.getInputArgs(),
-                                                    HostTC->getTriple());
+    llvm::Triple AMDTriple("amdgcn-amd-amdhsa");
+    llvm::Triple NVPTXTriple("nvptx64-nvidia-cuda");
+    llvm::Triple IntelGPUTriple("spir64_gen-unknown-unknown");
+    llvm::Triple IntelCPUTriple("spir64_x86_64-unknown-unknown");
 
     // Attempt to deduce the offloading triple from the set of architectures.
     // We need to temporarily create these toolchains so that we can access
     // tools for inferring architectures.
-    llvm::DenseSet<StringRef> Archs;
-    if (NVPTXTriple) {
-      auto TempTC = std::make_unique<toolchains::CudaToolChain>(
-          *this, *NVPTXTriple, *HostTC, C.getInputArgs(), Action::OFK_None);
-      for (StringRef Arch :
-           getOffloadArchs(C, C.getArgs(), Action::OFK_SYCL, &*TempTC, true))
-        Archs.insert(Arch);
-    }
-    if (AMDTriple) {
-      auto TempTC = std::make_unique<toolchains::AMDGPUOpenMPToolChain>(
-          *this, *AMDTriple, *HostTC, C.getInputArgs());
-      for (StringRef Arch :
-           getOffloadArchs(C, C.getArgs(), Action::OFK_SYCL, &*TempTC, true))
-        Archs.insert(Arch);
-    }
-    if (!AMDTriple && !NVPTXTriple) {
-      for (StringRef Arch :
-           getOffloadArchs(C, C.getArgs(), Action::OFK_SYCL, nullptr, true))
-        Archs.insert(Arch);
-    }
-    for (StringRef Arch : Archs) {
-      if (NVPTXTriple && IsSYCLSupportedNVidiaGPUArch(StringToOffloadArch(
-                             getProcessorFromTargetID(*NVPTXTriple, Arch)))) {
-        DerivedArchs[NVPTXTriple->getTriple()].insert(Arch);
-      } else if (AMDTriple &&
-                 IsSYCLSupportedAMDGPUArch(StringToOffloadArch(
-                     getProcessorFromTargetID(*AMDTriple, Arch)))) {
-        DerivedArchs[AMDTriple->getTriple()].insert(Arch);
-      } else if (IsSYCLSupportedIntelCPUArch(StringToOffloadArchSYCL(Arch))) {
-        DerivedArchs[getSYCLDeviceTriple("spir64_x86_64").getTriple()].insert(
-            Arch);
-      } else if (IsSYCLSupportedIntelGPUArch(StringToOffloadArchSYCL(Arch))) {
-        StringRef IntelGPUArch;
-        // For Intel Graphics AOT target, valid values for '--offload-arch'
-        // are mapped to valid device names accepted by OCLOC (the Intel GPU AOT
-        // compiler) via the '-device' option. The mapIntelGPUArchName
-        // function maps the accepted values for '--offload-arch' to enable SYCL
-        // offloading to Intel GPUs and the corresponding '-device' value passed
-        // to OCLOC.
-        IntelGPUArch = mapIntelGPUArchName(Arch).data();
-        DerivedArchs[getSYCLDeviceTriple("spir64_gen").getTriple()].insert(
-            IntelGPUArch);
-      } else {
+
+    for (StringRef Arch :
+         C.getInputArgs().getAllArgValues(options::OPT_offload_arch_EQ)) {
+      bool IsNVPTX = IsSYCLSupportedNVidiaGPUArch(
+          StringToOffloadArch(getProcessorFromTargetID(NVPTXTriple, Arch)));
+      bool IsAMDGPU = IsSYCLSupportedAMDGPUArch(
+          StringToOffloadArch(getProcessorFromTargetID(AMDTriple, Arch)));
+      bool IsIntelGPU = IsIntelGPUOffloadArch(
+          StringToOffloadArch(getProcessorFromTargetID(IntelGPUTriple, Arch)));
+      bool IsIntelCPU = IsIntelCPUOffloadArch(
+          StringToOffloadArch(getProcessorFromTargetID(IntelCPUTriple, Arch)));
+
+      if (!IsNVPTX && !IsAMDGPU && !Arch.empty() && !IsIntelGPU &&
+          !IsIntelCPU && !Arch.equals_insensitive("native")) {
         Diag(clang::diag::err_drv_invalid_sycl_target) << Arch;
         return;
       }
     }
-    // Emit an error if architecture value is not provided
-    // to --offload-arch.
-    if (Archs.empty()) {
-      Diag(clang::diag::err_drv_sycl_offload_arch_missing_value);
-      return;
-    }
 
-    for (const auto &TripleAndArchs : DerivedArchs)
-      SYCLTriples.insert(TripleAndArchs.first());
+    for (const llvm::Triple &TT :
+         {AMDTriple, NVPTXTriple, IntelGPUTriple, IntelCPUTriple}) {
+      auto &TC = getOffloadToolChain(C.getInputArgs(), Action::OFK_SYCL, TT,
+                                     C.getDefaultToolChain().getTriple());
 
-    for (const auto &Val : SYCLTriples) {
-      llvm::Triple SYCLTargetTriple(getSYCLDeviceTriple(Val.getKey()));
-      std::string NormalizedName = SYCLTargetTriple.normalize();
-
-      // Make sure we don't have a duplicate triple.
-      auto Duplicate = FoundNormalizedTriples.find(NormalizedName);
-      if (Duplicate != FoundNormalizedTriples.end()) {
-        Diag(clang::diag::warn_drv_sycl_offload_target_duplicate)
-            << Val.getKey() << Duplicate->second;
-        continue;
+      llvm::SmallVector<StringRef> Archs =
+          getOffloadArchs(C, C.getArgs(), Action::OFK_SYCL, &TC,
+                          /*SpecificToolchain=*/false);
+      if (!Archs.empty()) {
+        C.addOffloadDeviceToolChain(&TC, Action::OFK_SYCL);
+        OffloadArchs[&TC] = Archs;
       }
+    }
 
-      // Store the current triple so that we can check for duplicates in the
-      // following iterations.
-      FoundNormalizedTriples[NormalizedName] = Val.getKey();
-      UniqueSYCLTriplesVec.push_back(SYCLTargetTriple);
+    auto TCRange = C.getOffloadToolChains(Action::OFK_SYCL);
+    if (TCRange.first == TCRange.second) {
+      Diag(clang::diag::err_drv_sycl_offload_arch_missing_value);
+      return;
+    }
+
+    for (const auto &ToolChainAndArchs : OffloadArchs) {
+      UniqueSYCLTriplesVec.push_back(ToolChainAndArchs.first->getTriple());
     }
 
     addSYCLDefaultTriple(C, UniqueSYCLTriplesVec);
@@ -7554,8 +7524,21 @@ static StringRef getCanonicalArchString(Compilation &C,
       C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
           << "HIP" << ArchStr;
     return StringRef();
+  } else if (Triple.isSPIRAOT() &&
+             Triple.getSubArch() == llvm::Triple::SPIRSubArch_gen &&
+             (Arch == OffloadArch::UNKNOWN || !IsIntelGPUOffloadArch(Arch))) {
+    if (SpecificToolchain)
+      C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
+          << "spir64_gen" << ArchStr;
+    return StringRef();
+  } else if (Triple.isSPIRAOT() &&
+             Triple.getSubArch() == llvm::Triple::SPIRSubArch_x86_64 &&
+             (Arch == OffloadArch::UNKNOWN || !IsIntelCPUOffloadArch(Arch))) {
+    if (SpecificToolchain)
+      C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
+          << "spir64_x86_64" << ArchStr;
+    return StringRef();
   }
-
   if (IsNVIDIAOffloadArch(Arch))
     return Args.MakeArgStringRef(OffloadArchToString(Arch));
 
@@ -7568,6 +7551,13 @@ static StringRef getCanonicalArchString(Compilation &C,
     }
     return Args.MakeArgStringRef(getCanonicalTargetID(*Arch, Features));
   }
+  if (IsIntelGPUOffloadArch(Arch)) {
+    return Args.MakeArgStringRef(ArchStr);
+  }
+
+  if (IsIntelCPUOffloadArch(Arch)) {
+    return Args.MakeArgStringRef(ArchStr);
+  }
 
   // If the input isn't CUDA or HIP just return the architecture.
   return ArchStr;