AMDGPU: Move target code into TargetParser

[rampitec]

LGTM

[arsenm]

r340292

lib/Basic/Targets/AMDGPU.h

 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
 #define LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_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"
+#include "llvm/Support/TargetParser.h"
 
 namespace clang {
 namespace targets {
 
 class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
 
   static const Builtin::Info BuiltinInfo[];
   static const char *const GCCRegNames[];
 
   enum AddrSpace {
     Generic = 0,
     Global = 1,
     Local = 3,
     Constant = 4,
     Private = 5
   };
   static const LangASMap AMDGPUDefIsGenMap;
   static const LangASMap AMDGPUDefIsPrivMap;
 
-  /// GPU kinds supported by the AMDGPU target.
-  enum GPUKind : uint32_t {
-    // Not specified processor.
-    GK_NONE = 0,
-
-    // R600-based processors.
-    GK_R600,
-    GK_R630,
-    GK_RS880,
-    GK_RV670,
-    GK_RV710,
-    GK_RV730,
-    GK_RV770,
-    GK_CEDAR,
-    GK_CYPRESS,
-    GK_JUNIPER,
-    GK_REDWOOD,
-    GK_SUMO,
-    GK_BARTS,
-    GK_CAICOS,
-    GK_CAYMAN,
-    GK_TURKS,
-
-    GK_R600_FIRST = GK_R600,
-    GK_R600_LAST = GK_TURKS,
-
-    // AMDGCN-based processors.
-    GK_GFX600,
-    GK_GFX601,
-    GK_GFX700,
-    GK_GFX701,
-    GK_GFX702,
-    GK_GFX703,
-    GK_GFX704,
-    GK_GFX801,
-    GK_GFX802,
-    GK_GFX803,
-    GK_GFX810,
-    GK_GFX900,
-    GK_GFX902,
-    GK_GFX904,
-    GK_GFX906,
+  llvm::AMDGPU::GPUKind GPUKind;
+  unsigned GPUFeatures;
 
-    GK_AMDGCN_FIRST = GK_GFX600,
-    GK_AMDGCN_LAST = GK_GFX906,
-  };
 
-  struct GPUInfo {
-    llvm::StringLiteral Name;
-    llvm::StringLiteral CanonicalName;
-    AMDGPUTargetInfo::GPUKind Kind;
-    bool HasFMAF;
-    bool HasFastFMAF;
-    bool HasLDEXPF;
-    bool HasFP64;
-    bool HasFastFMA;
-    bool HasFullRateF32Denorms;
-  };
+  bool hasFP64() const {
+    return getTriple().getArch() == llvm::Triple::amdgcn ||
+           !!(GPUFeatures & llvm::AMDGPU::FEATURE_FP64);
+  }
 
-  static constexpr GPUInfo InvalidGPU =
-    {{""}, {""}, GK_NONE, false, false, false, false, false, false};
-  static constexpr GPUInfo R600GPUs[26] = {
-  // Name         Canonical    Kind        Has    Has    Has    Has    Has    Has
-  //              Name                     FMAF   Fast   LDEXPF FP64   Fast   Fast
-  //                                              FMAF                 FMA    Denorm
-    {{"r600"},    {"r600"},    GK_R600,    false, false, false, false, false, false},
-    {{"rv630"},   {"r600"},    GK_R600,    false, false, false, false, false, false},
-    {{"rv635"},   {"r600"},    GK_R600,    false, false, false, false, false, false},
-    {{"r630"},    {"r630"},    GK_R630,    false, false, false, false, false, false},
-    {{"rs780"},   {"rs880"},   GK_RS880,   false, false, false, false, false, false},
-    {{"rs880"},   {"rs880"},   GK_RS880,   false, false, false, false, false, false},
-    {{"rv610"},   {"rs880"},   GK_RS880,   false, false, false, false, false, false},
-    {{"rv620"},   {"rs880"},   GK_RS880,   false, false, false, false, false, false},
-    {{"rv670"},   {"rv670"},   GK_RV670,   false, false, false, false, false, false},
-    {{"rv710"},   {"rv710"},   GK_RV710,   false, false, false, false, false, false},
-    {{"rv730"},   {"rv730"},   GK_RV730,   false, false, false, false, false, false},
-    {{"rv740"},   {"rv770"},   GK_RV770,   false, false, false, false, false, false},
-    {{"rv770"},   {"rv770"},   GK_RV770,   false, false, false, false, false, false},
-    {{"cedar"},   {"cedar"},   GK_CEDAR,   false, false, false, false, false, false},
-    {{"palm"},    {"cedar"},   GK_CEDAR,   false, false, false, false, false, false},
-    {{"cypress"}, {"cypress"}, GK_CYPRESS, true,  false, false, false, false, false},
-    {{"hemlock"}, {"cypress"}, GK_CYPRESS, true,  false, false, false, false, false},
-    {{"juniper"}, {"juniper"}, GK_JUNIPER, false, false, false, false, false, false},
-    {{"redwood"}, {"redwood"}, GK_REDWOOD, false, false, false, false, false, false},
-    {{"sumo"},    {"sumo"},    GK_SUMO,    false, false, false, false, false, false},
-    {{"sumo2"},   {"sumo"},    GK_SUMO,    false, false, false, false, false, false},
-    {{"barts"},   {"barts"},   GK_BARTS,   false, false, false, false, false, false},
-    {{"caicos"},  {"caicos"},  GK_CAICOS,  false, false, false, false, false, false},
-    {{"aruba"},   {"cayman"},  GK_CAYMAN,  true,  false, false, false, false, false},
-    {{"cayman"},  {"cayman"},  GK_CAYMAN,  true,  false, false, false, false, false},
-    {{"turks"},   {"turks"},   GK_TURKS,   false, false, false, false, false, false},
-  };
-  static constexpr GPUInfo AMDGCNGPUs[32] = {
-  // Name           Canonical    Kind        Has   Has    Has    Has   Has   Has
-  //                Name                     FMAF  Fast   LDEXPF FP64  Fast  Fast
-  //                                               FMAF                FMA   Denorm
-    {{"gfx600"},    {"gfx600"},  GK_GFX600,  true, true,  true,  true, true, false},
-    {{"tahiti"},    {"gfx600"},  GK_GFX600,  true, true,  true,  true, true, false},
-    {{"gfx601"},    {"gfx601"},  GK_GFX601,  true, false, true,  true, true, false},
-    {{"hainan"},    {"gfx601"},  GK_GFX601,  true, false, true,  true, true, false},
-    {{"oland"},     {"gfx601"},  GK_GFX601,  true, false, true,  true, true, false},
-    {{"pitcairn"},  {"gfx601"},  GK_GFX601,  true, false, true,  true, true, false},
-    {{"verde"},     {"gfx601"},  GK_GFX601,  true, false, true,  true, true, false},
-    {{"gfx700"},    {"gfx700"},  GK_GFX700,  true, false, true,  true, true, false},
-    {{"kaveri"},    {"gfx700"},  GK_GFX700,  true, false, true,  true, true, false},
-    {{"gfx701"},    {"gfx701"},  GK_GFX701,  true, true,  true,  true, true, false},
-    {{"hawaii"},    {"gfx701"},  GK_GFX701,  true, true,  true,  true, true, false},
-    {{"gfx702"},    {"gfx702"},  GK_GFX702,  true, true,  true,  true, true, false},
-    {{"gfx703"},    {"gfx703"},  GK_GFX703,  true, false, true,  true, true, false},
-    {{"kabini"},    {"gfx703"},  GK_GFX703,  true, false, true,  true, true, false},
-    {{"mullins"},   {"gfx703"},  GK_GFX703,  true, false, true,  true, true, false},
-    {{"gfx704"},    {"gfx704"},  GK_GFX704,  true, false, true,  true, true, false},
-    {{"bonaire"},   {"gfx704"},  GK_GFX704,  true, false, true,  true, true, false},
-    {{"gfx801"},    {"gfx801"},  GK_GFX801,  true, true,  true,  true, true, true},
-    {{"carrizo"},   {"gfx801"},  GK_GFX801,  true, true,  true,  true, true, true},
-    {{"gfx802"},    {"gfx802"},  GK_GFX802,  true, false, true,  true, true, true},
-    {{"iceland"},   {"gfx802"},  GK_GFX802,  true, false, true,  true, true, true},
-    {{"tonga"},     {"gfx802"},  GK_GFX802,  true, false, true,  true, true, true},
-    {{"gfx803"},    {"gfx803"},  GK_GFX803,  true, false, true,  true, true, true},
-    {{"fiji"},      {"gfx803"},  GK_GFX803,  true, false, true,  true, true, true},
-    {{"polaris10"}, {"gfx803"},  GK_GFX803,  true, false, true,  true, true, true},
-    {{"polaris11"}, {"gfx803"},  GK_GFX803,  true, false, true,  true, true, true},
-    {{"gfx810"},    {"gfx810"},  GK_GFX810,  true, false, true,  true, true, true},
-    {{"stoney"},    {"gfx810"},  GK_GFX810,  true, false, true,  true, true, true},
-    {{"gfx900"},    {"gfx900"},  GK_GFX900,  true, true,  true,  true, true, true},
-    {{"gfx902"},    {"gfx902"},  GK_GFX902,  true, true,  true,  true, true, true},
-    {{"gfx904"},    {"gfx904"},  GK_GFX904,  true, true,  true,  true, true, true},
-    {{"gfx906"},    {"gfx906"},  GK_GFX906,  true, true,  true,  true, true, true},
-  };
+  /// Has fast fma f32
+  bool hasFastFMAF() const {
+    return !!(GPUFeatures & llvm::AMDGPU::FEATURE_FAST_FMA_F32);
+  }
 
-  static GPUInfo parseR600Name(StringRef Name);
+  /// Has fast fma f64
+  bool hasFastFMA() const {
+    return getTriple().getArch() == llvm::Triple::amdgcn;
+  }
 
-  static GPUInfo parseAMDGCNName(StringRef Name);
+  bool hasFMAF() const {
+    return getTriple().getArch() == llvm::Triple::amdgcn ||
+           !!(GPUFeatures & llvm::AMDGPU::FEATURE_FMA);
+  }
 
-  GPUInfo parseGPUName(StringRef Name) const;
+  bool hasFullRateDenormalsF32() const {
+    return !!(GPUFeatures & llvm::AMDGPU::FEATURE_FAST_DENORMAL_F32);
+  }
 
-  GPUInfo GPU;
+  bool hasLDEXPF() const {
+    return getTriple().getArch() == llvm::Triple::amdgcn ||
+           !!(GPUFeatures & llvm::AMDGPU::FEATURE_LDEXP);
+  }
 
   static bool isAMDGCN(const llvm::Triple &TT) {
     return TT.getArch() == llvm::Triple::amdgcn;
   }
 
+  static bool isR600(const llvm::Triple &TT) {
+    return TT.getArch() == llvm::Triple::r600;
+  }
+
 public:
   AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
 
   void setAddressSpaceMap(bool DefaultIsPrivate);
 
   void adjust(LangOptions &Opts) override;
 
   uint64_t getPointerWidthV(unsigned AddrSpace) const override {
-    if (GPU.Kind <= GK_R600_LAST)
+    if (isR600(getTriple()))
       return 32;
+
     if (AddrSpace == Private || AddrSpace == Local)
       return 32;
+
     return 64;
   }
 
   uint64_t getPointerAlignV(unsigned AddrSpace) const override {
     return getPointerWidthV(AddrSpace);
   }
 
   uint64_t getMaxPointerWidth() const override {
void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::CharPtrBuiltinVaList;
   }
 
   bool isValidCPUName(StringRef Name) const override {
     if (getTriple().getArch() == llvm::Triple::amdgcn)
-      return GK_NONE != parseAMDGCNName(Name).Kind;
-    else
-      return GK_NONE != parseR600Name(Name).Kind;
+      return llvm::AMDGPU::parseArchAMDGCN(Name) != llvm::AMDGPU::GK_NONE;
+    return llvm::AMDGPU::parseArchR600(Name) != llvm::AMDGPU::GK_NONE;
   }
 
   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);
+    if (getTriple().getArch() == llvm::Triple::amdgcn) {
+      GPUKind = llvm::AMDGPU::parseArchAMDGCN(Name);
+      GPUFeatures = llvm::AMDGPU::getArchAttrAMDGCN(GPUKind);
+    } else {
+      GPUKind = llvm::AMDGPU::parseArchR600(Name);
+      GPUFeatures = llvm::AMDGPU::getArchAttrR600(GPUKind);
+    }
 
-    return GK_NONE != GPU.Kind;
+    return GPUKind != llvm::AMDGPU::GK_NONE;
   }
 
   void setSupportedOpenCLOpts() override {
     auto &Opts = getSupportedOpenCLOpts();
     Opts.support("cl_clang_storage_class_specifiers");
     Opts.support("cl_khr_icd");
 
-    if (GPU.HasFP64)
+    bool IsAMDGCN = isAMDGCN(getTriple());
+
+    if (hasFP64())
       Opts.support("cl_khr_fp64");
-    if (GPU.Kind >= GK_CEDAR) {
+
+    if (IsAMDGCN || GPUKind >= llvm::AMDGPU::GK_CEDAR) {
       Opts.support("cl_khr_byte_addressable_store");
       Opts.support("cl_khr_global_int32_base_atomics");
       Opts.support("cl_khr_global_int32_extended_atomics");
       Opts.support("cl_khr_local_int32_base_atomics");
       Opts.support("cl_khr_local_int32_extended_atomics");
     }
-    if (GPU.Kind >= GK_AMDGCN_FIRST) {
+
+    if (IsAMDGCN) {
       Opts.support("cl_khr_fp16");
       Opts.support("cl_khr_int64_base_atomics");
       Opts.support("cl_khr_int64_extended_atomics");
       Opts.support("cl_khr_mipmap_image");
       Opts.support("cl_khr_subgroups");
       Opts.support("cl_khr_3d_image_writes");
       Opts.support("cl_amd_media_ops");
       Opts.support("cl_amd_media_ops2");

lib/Basic/Targets/AMDGPU.cpp

 ArrayRef<const char *> AMDGPUTargetInfo::getGCCRegNames() const {
   return llvm::makeArrayRef(GCCRegNames);
 }
 
 bool AMDGPUTargetInfo::initFeatureMap(
     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
     const std::vector<std::string> &FeatureVec) const {
 
+  using namespace llvm::AMDGPU;
+
   // XXX - What does the member GPU mean if device name string passed here?
   if (isAMDGCN(getTriple())) {
     if (CPU.empty())
       CPU = "gfx600";
 
-    switch (parseAMDGCNName(CPU).Kind) {
+    switch (llvm::AMDGPU::parseArchAMDGCN(CPU)) {
     case GK_GFX906:
       Features["dl-insts"] = true;
       LLVM_FALLTHROUGH;
     case GK_GFX904:
     case GK_GFX902:
     case GK_GFX900:
       Features["gfx9-insts"] = true;
       LLVM_FALLTHROUGH;
case GK_NONE:
       return false;
     default:
       llvm_unreachable("Unhandled GPU!");
     }
   } else {
     if (CPU.empty())
       CPU = "r600";
 
-    switch (parseR600Name(CPU).Kind) {
+    switch (llvm::AMDGPU::parseArchR600(CPU)) {
     case GK_CAYMAN:
     case GK_CYPRESS:
     case GK_RV770:
     case GK_RV670:
       // TODO: Add fp64 when implemented.
       break;
     case GK_TURKS:
     case GK_CAICOS:
bool AMDGPUTargetInfo::initFeatureMap(
 
   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeatureVec);
 }
 
 void AMDGPUTargetInfo::adjustTargetOptions(const CodeGenOptions &CGOpts,
                                            TargetOptions &TargetOpts) const {
   bool hasFP32Denormals = false;
   bool hasFP64Denormals = false;
-  GPUInfo CGOptsGPU = parseGPUName(TargetOpts.CPU);
+
   for (auto &I : TargetOpts.FeaturesAsWritten) {
     if (I == "+fp32-denormals" || I == "-fp32-denormals")
       hasFP32Denormals = true;
     if (I == "+fp64-fp16-denormals" || I == "-fp64-fp16-denormals")
       hasFP64Denormals = true;
   }
   if (!hasFP32Denormals)
     TargetOpts.Features.push_back(
-        (Twine(CGOptsGPU.HasFastFMAF && CGOptsGPU.HasFullRateF32Denorms &&
-               !CGOpts.FlushDenorm
-                   ? '+'
-                   : '-') +
-         Twine("fp32-denormals"))
+      (Twine(hasFastFMAF() && hasFullRateDenormalsF32() && !CGOpts.FlushDenorm
+             ? '+' : '-') + Twine("fp32-denormals"))
             .str());
   // Always do not flush fp64 or fp16 denorms.
-  if (!hasFP64Denormals && CGOptsGPU.HasFP64)
+  if (!hasFP64Denormals && hasFP64())
     TargetOpts.Features.push_back("+fp64-fp16-denormals");
 }
 
-constexpr AMDGPUTargetInfo::GPUInfo AMDGPUTargetInfo::InvalidGPU;
-constexpr AMDGPUTargetInfo::GPUInfo AMDGPUTargetInfo::R600GPUs[];
-constexpr AMDGPUTargetInfo::GPUInfo AMDGPUTargetInfo::AMDGCNGPUs[];
-
-AMDGPUTargetInfo::GPUInfo AMDGPUTargetInfo::parseR600Name(StringRef Name) {
-  const auto *Result = llvm::find_if(
-      R600GPUs, [Name](const GPUInfo &GPU) { return GPU.Name == Name; });
-
-  if (Result == std::end(R600GPUs))
-    return InvalidGPU;
-  return *Result;
-}
-
-AMDGPUTargetInfo::GPUInfo AMDGPUTargetInfo::parseAMDGCNName(StringRef Name) {
-  const auto *Result = llvm::find_if(
-      AMDGCNGPUs, [Name](const GPUInfo &GPU) { return GPU.Name == Name; });
-
-  if (Result == std::end(AMDGCNGPUs))
-    return InvalidGPU;
-  return *Result;
-}
-
-AMDGPUTargetInfo::GPUInfo AMDGPUTargetInfo::parseGPUName(StringRef Name) const {
-  if (isAMDGCN(getTriple()))
-    return parseAMDGCNName(Name);
-  else
-    return parseR600Name(Name);
-}
-
 void AMDGPUTargetInfo::fillValidCPUList(
     SmallVectorImpl<StringRef> &Values) const {
   if (isAMDGCN(getTriple()))
-    llvm::for_each(AMDGCNGPUs, [&Values](const GPUInfo &GPU) {
-                   Values.emplace_back(GPU.Name);});
+    llvm::AMDGPU::fillValidArchListAMDGCN(Values);
   else
-    llvm::for_each(R600GPUs, [&Values](const GPUInfo &GPU) {
-                   Values.emplace_back(GPU.Name);});
+    llvm::AMDGPU::fillValidArchListR600(Values);
 }
 
 void AMDGPUTargetInfo::setAddressSpaceMap(bool DefaultIsPrivate) {
   AddrSpaceMap = DefaultIsPrivate ? &AMDGPUDefIsPrivMap : &AMDGPUDefIsGenMap;
 }
 
 AMDGPUTargetInfo::AMDGPUTargetInfo(const llvm::Triple &Triple,
                                    const TargetOptions &Opts)
     : TargetInfo(Triple),
-      GPU(isAMDGCN(Triple) ? AMDGCNGPUs[0] : parseR600Name(Opts.CPU)) {
+      GPUKind(isAMDGCN(Triple) ?
+              llvm::AMDGPU::parseArchAMDGCN(Opts.CPU) :
+              llvm::AMDGPU::parseArchR600(Opts.CPU)),
+      GPUFeatures(isAMDGCN(Triple) ?
+                  llvm::AMDGPU::getArchAttrAMDGCN(GPUKind) :
+                  llvm::AMDGPU::getArchAttrR600(GPUKind)) {
   resetDataLayout(isAMDGCN(getTriple()) ? DataLayoutStringAMDGCN
                                         : DataLayoutStringR600);
   assert(DataLayout->getAllocaAddrSpace() == Private);
 
   setAddressSpaceMap(Triple.getOS() == llvm::Triple::Mesa3D ||
                      !isAMDGCN(Triple));
   UseAddrSpaceMapMangling = true;
 
void AMDGPUTargetInfo::getTargetDefines(const LangOptions &Opts,
   Builder.defineMacro("__AMD__");
   Builder.defineMacro("__AMDGPU__");
 
   if (isAMDGCN(getTriple()))
     Builder.defineMacro("__AMDGCN__");
   else
     Builder.defineMacro("__R600__");
 
-  if (GPU.Kind != GK_NONE)
-    Builder.defineMacro(Twine("__") + Twine(GPU.CanonicalName) + Twine("__"));
+  if (GPUKind != llvm::AMDGPU::GK_NONE) {
+    StringRef CanonName = isAMDGCN(getTriple()) ?
+      getArchNameAMDGCN(GPUKind) : getArchNameR600(GPUKind);
+    Builder.defineMacro(Twine("__") + Twine(CanonName) + Twine("__"));
+  }
 
   // TODO: __HAS_FMAF__, __HAS_LDEXPF__, __HAS_FP64__ are deprecated and will be
   // removed in the near future.
-  if (GPU.HasFMAF)
+  if (hasFMAF())
     Builder.defineMacro("__HAS_FMAF__");
-  if (GPU.HasFastFMAF)
+  if (hasFastFMAF())
     Builder.defineMacro("FP_FAST_FMAF");
-  if (GPU.HasLDEXPF)
+  if (hasLDEXPF())
     Builder.defineMacro("__HAS_LDEXPF__");
-  if (GPU.HasFP64)
+  if (hasFP64())
     Builder.defineMacro("__HAS_FP64__");
-  if (GPU.HasFastFMA)
+  if (hasFastFMA())
     Builder.defineMacro("FP_FAST_FMA");
 }