[CUDA] Revert defining __CUDA_ARCH__ for amdgcn targets

[yaxunl]

Summary

amdgcn targets only support HIP, which does not define __CUDA_ARCH__.

__HIP_DEVICE_COMPILE__ depends on HIP language mode, therefore it needs to be added
in a different patch.

refer to discussions in https://reviews.llvm.org/D45277

[tra]

You may want to mention in the commit log that this is a partial unroll of r329232 / D45277.

[yaxunl]

In D45387#1060194, @tra wrote:

You may want to mention in the commit log that this is a partial unroll of r329232 / D45277.

Will do. Thanks.

lib/Basic/Targets.h

 // from a target triple. Typically individual targets will need to include from
 // here in order to get these functions if required.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_H
 #define LLVM_CLANG_LIB_BASIC_TARGETS_H
 
-#include "clang/Basic/Cuda.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/MacroBuilder.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace targets {
 

 
 LLVM_LIBRARY_VISIBILITY
 void addMinGWDefines(const llvm::Triple &Triple, const clang::LangOptions &Opts,
                      clang::MacroBuilder &Builder);
 
 LLVM_LIBRARY_VISIBILITY
 void addCygMingDefines(const clang::LangOptions &Opts,
                        clang::MacroBuilder &Builder);
-
-LLVM_LIBRARY_VISIBILITY
-void defineCudaArchMacro(CudaArch GPU, clang::MacroBuilder &Builder);
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_H

lib/Basic/Targets.cpp

if (Triple.isArch64Bit()) {
     DefineStd(Builder, "WIN64", Opts);
     Builder.defineMacro("__MINGW64__");
   }
   Builder.defineMacro("__MSVCRT__");
   Builder.defineMacro("__MINGW32__");
   addCygMingDefines(Opts, Builder);
 }
 
-void defineCudaArchMacro(CudaArch GPU, clang::MacroBuilder &Builder) {
-  std::string CUDAArchCode = [GPU] {
-    switch (GPU) {
-    case CudaArch::LAST:
-      break;
-    case CudaArch::SM_20:
-      return "200";
-    case CudaArch::SM_21:
-      return "210";
-    case CudaArch::SM_30:
-      return "300";
-    case CudaArch::SM_32:
-      return "320";
-    case CudaArch::SM_35:
-      return "350";
-    case CudaArch::SM_37:
-      return "370";
-    case CudaArch::SM_50:
-      return "500";
-    case CudaArch::SM_52:
-      return "520";
-    case CudaArch::SM_53:
-      return "530";
-    case CudaArch::SM_60:
-      return "600";
-    case CudaArch::SM_61:
-      return "610";
-    case CudaArch::SM_62:
-      return "620";
-    case CudaArch::SM_70:
-      return "700";
-    case CudaArch::SM_72:
-      return "720";
-    case CudaArch::GFX600:
-    case CudaArch::GFX601:
-    case CudaArch::GFX700:
-    case CudaArch::GFX701:
-    case CudaArch::GFX702:
-    case CudaArch::GFX703:
-    case CudaArch::GFX704:
-    case CudaArch::GFX801:
-    case CudaArch::GFX802:
-    case CudaArch::GFX803:
-    case CudaArch::GFX810:
-    case CudaArch::GFX900:
-    case CudaArch::GFX902:
-      return "320";
-    case CudaArch::UNKNOWN:
-      llvm_unreachable("unhandled Cuda/HIP Arch");
-    }
-    llvm_unreachable("unhandled Cuda/HIP Arch");
-  }();
-  Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode);
-}
-
 //===----------------------------------------------------------------------===//
 // Driver code
 //===----------------------------------------------------------------------===//
 
 TargetInfo *AllocateTarget(const llvm::Triple &Triple,
                            const TargetOptions &Opts) {
   llvm::Triple::OSType os = Triple.getOS();
 

lib/Basic/Targets/AMDGPU.h

 //===--- AMDGPU.h - Declare AMDGPU target feature support -------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares AMDGPU TargetInfo objects.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
 #define LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
 
-#include "clang/Basic/Cuda.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Compiler.h"
 
 namespace clang {
 namespace targets {
class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
 
   GPUInfo parseGPUName(StringRef Name) const;
 
   GPUInfo GPU;
 
   static bool isAMDGCN(const llvm::Triple &TT) {
     return TT.getArch() == llvm::Triple::amdgcn;
   }
-  CudaArch GCN_Subarch;
 
 public:
   AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
 
   void setAddressSpaceMap(bool DefaultIsPrivate);
 
   void adjust(LangOptions &Opts) override;
 
public:
   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
 
   bool setCPU(const std::string &Name) override {
     if (getTriple().getArch() == llvm::Triple::amdgcn)
       GPU = parseAMDGCNName(Name);
     else
       GPU = parseR600Name(Name);
 
-    GCN_Subarch = StringToCudaArch(Name);
     return GK_NONE != GPU.Kind;
   }
 
   void setSupportedOpenCLOpts() override {
     auto &Opts = getSupportedOpenCLOpts();
     Opts.support("cl_clang_storage_class_specifiers");
     Opts.support("cl_khr_icd");
 

lib/Basic/Targets/AMDGPU.cpp

 //===--- AMDGPU.cpp - Implement AMDGPU target feature support -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements AMDGPU TargetInfo objects.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AMDGPU.h"
-#include "Targets.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/MacroBuilder.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Frontend/CodeGenOptions.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace clang;

 
 AMDGPUTargetInfo::AMDGPUTargetInfo(const llvm::Triple &Triple,
                                    const TargetOptions &Opts)
     : TargetInfo(Triple),
       GPU(isAMDGCN(Triple) ? AMDGCNGPUs[0] : parseR600Name(Opts.CPU)) {
   resetDataLayout(isAMDGCN(getTriple()) ? DataLayoutStringAMDGCN
                                         : DataLayoutStringR600);
   assert(DataLayout->getAllocaAddrSpace() == Private);
-  GCN_Subarch = CudaArch::GFX803; // Default to fiji
 
   setAddressSpaceMap(Triple.getOS() == llvm::Triple::Mesa3D ||
                      !isAMDGCN(Triple));
   UseAddrSpaceMapMangling = true;
 
   // Set pointer width and alignment for target address space 0.
   PointerWidth = PointerAlign = DataLayout->getPointerSizeInBits();
   if (getMaxPointerWidth() == 64) {
void AMDGPUTargetInfo::getTargetDefines(const LangOptions &Opts,
   if (isAMDGCN(getTriple()))
     Builder.defineMacro("__AMDGCN__");
   else
     Builder.defineMacro("__R600__");
 
   if (GPU.Kind != GK_NONE)
     Builder.defineMacro(Twine("__") + Twine(GPU.CanonicalName) + Twine("__"));
 
-  if (Opts.CUDAIsDevice)
-    defineCudaArchMacro(GCN_Subarch, Builder);
-
   // TODO: __HAS_FMAF__, __HAS_LDEXPF__, __HAS_FP64__ are deprecated and will be
   // removed in the near future.
   if (GPU.HasFMAF)
     Builder.defineMacro("__HAS_FMAF__");
   if (GPU.HasFastFMAF)
     Builder.defineMacro("FP_FAST_FMAF");
   if (GPU.HasLDEXPF)
     Builder.defineMacro("__HAS_LDEXPF__");
   if (GPU.HasFP64)
     Builder.defineMacro("__HAS_FP64__");
   if (GPU.HasFastFMA)
     Builder.defineMacro("FP_FAST_FMA");
 }

lib/Basic/Targets/NVPTX.cpp

return llvm::StringSwitch<bool>(Feature)
       .Case("satom", GPU >= CudaArch::SM_60) // Atomics w/ scope.
       .Default(false);
 }
 
 void NVPTXTargetInfo::getTargetDefines(const LangOptions &Opts,
                                        MacroBuilder &Builder) const {
   Builder.defineMacro("__PTX__");
   Builder.defineMacro("__NVPTX__");
-  if (Opts.CUDAIsDevice)
-    defineCudaArchMacro(GPU, Builder);
+  if (Opts.CUDAIsDevice) {
+    // Set __CUDA_ARCH__ for the GPU specified.
+    std::string CUDAArchCode = [this] {
+      switch (GPU) {
+      case CudaArch::GFX600:
+      case CudaArch::GFX601:
+      case CudaArch::GFX700:
+      case CudaArch::GFX701:
+      case CudaArch::GFX702:
+      case CudaArch::GFX703:
+      case CudaArch::GFX704:
+      case CudaArch::GFX801:
+      case CudaArch::GFX802:
+      case CudaArch::GFX803:
+      case CudaArch::GFX810:
+      case CudaArch::GFX900:
+      case CudaArch::GFX902:
+      case CudaArch::LAST:
+        break;
+      case CudaArch::UNKNOWN:
+        assert(false && "No GPU arch when compiling CUDA device code.");
+        return "";
+      case CudaArch::SM_20:
+        return "200";
+      case CudaArch::SM_21:
+        return "210";
+      case CudaArch::SM_30:
+        return "300";
+      case CudaArch::SM_32:
+        return "320";
+      case CudaArch::SM_35:
+        return "350";
+      case CudaArch::SM_37:
+        return "370";
+      case CudaArch::SM_50:
+        return "500";
+      case CudaArch::SM_52:
+        return "520";
+      case CudaArch::SM_53:
+        return "530";
+      case CudaArch::SM_60:
+        return "600";
+      case CudaArch::SM_61:
+        return "610";
+      case CudaArch::SM_62:
+        return "620";
+      case CudaArch::SM_70:
+        return "700";
+      case CudaArch::SM_72:
+        return "720";
+      }
+      llvm_unreachable("unhandled CudaArch");
+    }();
+    Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode);
+  }
 }
 
 ArrayRef<Builtin::Info> NVPTXTargetInfo::getTargetBuiltins() const {
   return llvm::makeArrayRef(BuiltinInfo, clang::NVPTX::LastTSBuiltin -
                                              Builtin::FirstTSBuiltin);
 }