contrib/llvm/tools/clang/lib/Basic/Targets/AMDGPU.h

   1 //===--- AMDGPU.h - Declare AMDGPU target feature support -------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares AMDGPU TargetInfo objects.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
  15 #define LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
  16
  17 #include "clang/Basic/TargetInfo.h"
  18 #include "clang/Basic/TargetOptions.h"
  19 #include "llvm/ADT/StringSet.h"
  20 #include "llvm/ADT/Triple.h"
  21 #include "llvm/Support/Compiler.h"
  22
  23 namespace clang {
  24 namespace targets {
  25
  26 class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
  27
  28   static const Builtin::Info BuiltinInfo[];
  29   static const char *const GCCRegNames[];
  30
  31   enum AddrSpace {
  32     Generic = 0,
  33     Global = 1,
  34     Local = 3,
  35     Constant = 4,
  36     Private = 5
  37   };
  38   static const LangASMap AMDGPUDefIsGenMap;
  39   static const LangASMap AMDGPUDefIsPrivMap;
  40
  41   /// GPU kinds supported by the AMDGPU target.
  42   enum GPUKind : uint32_t {
  43     // Not specified processor.
  44     GK_NONE = 0,
  45
  46     // R600-based processors.
  47     GK_R600,
  48     GK_R630,
  49     GK_RS880,
  50     GK_RV670,
  51     GK_RV710,
  52     GK_RV730,
  53     GK_RV770,
  54     GK_CEDAR,
  55     GK_CYPRESS,
  56     GK_JUNIPER,
  57     GK_REDWOOD,
  58     GK_SUMO,
  59     GK_BARTS,
  60     GK_CAICOS,
  61     GK_CAYMAN,
  62     GK_TURKS,
  63
  64     GK_R600_FIRST = GK_R600,
  65     GK_R600_LAST = GK_TURKS,
  66
  67     // AMDGCN-based processors.
  68     GK_GFX600,
  69     GK_GFX601,
  70     GK_GFX700,
  71     GK_GFX701,
  72     GK_GFX702,
  73     GK_GFX703,
  74     GK_GFX704,
  75     GK_GFX801,
  76     GK_GFX802,
  77     GK_GFX803,
  78     GK_GFX810,
  79     GK_GFX900,
  80     GK_GFX902,
  81     GK_GFX904,
  82     GK_GFX906,
  83
  84     GK_AMDGCN_FIRST = GK_GFX600,
  85     GK_AMDGCN_LAST = GK_GFX906,
  86   };
  87
  88   struct GPUInfo {
  89     llvm::StringLiteral Name;
  90     llvm::StringLiteral CanonicalName;
  91     AMDGPUTargetInfo::GPUKind Kind;
  92     bool HasFMAF;
  93     bool HasFastFMAF;
  94     bool HasLDEXPF;
  95     bool HasFP64;
  96     bool HasFastFMA;
  97   };
  98
  99   static constexpr GPUInfo InvalidGPU =
 100     {{""}, {""}, GK_NONE, false, false, false, false, false};
 101   static constexpr GPUInfo R600GPUs[26] = {
 102   // Name         Canonical    Kind        Has    Has    Has    Has    Has
 103   //              Name                     FMAF   Fast   LDEXPF FP64   Fast
 104   //                                              FMAF                 FMA
 105     {{"r600"},    {"r600"},    GK_R600,    false, false, false, false, false},
 106     {{"rv630"},   {"r600"},    GK_R600,    false, false, false, false, false},
 107     {{"rv635"},   {"r600"},    GK_R600,    false, false, false, false, false},
 108     {{"r630"},    {"r630"},    GK_R630,    false, false, false, false, false},
 109     {{"rs780"},   {"rs880"},   GK_RS880,   false, false, false, false, false},
 110     {{"rs880"},   {"rs880"},   GK_RS880,   false, false, false, false, false},
 111     {{"rv610"},   {"rs880"},   GK_RS880,   false, false, false, false, false},
 112     {{"rv620"},   {"rs880"},   GK_RS880,   false, false, false, false, false},
 113     {{"rv670"},   {"rv670"},   GK_RV670,   false, false, false, false, false},
 114     {{"rv710"},   {"rv710"},   GK_RV710,   false, false, false, false, false},
 115     {{"rv730"},   {"rv730"},   GK_RV730,   false, false, false, false, false},
 116     {{"rv740"},   {"rv770"},   GK_RV770,   false, false, false, false, false},
 117     {{"rv770"},   {"rv770"},   GK_RV770,   false, false, false, false, false},
 118     {{"cedar"},   {"cedar"},   GK_CEDAR,   false, false, false, false, false},
 119     {{"palm"},    {"cedar"},   GK_CEDAR,   false, false, false, false, false},
 120     {{"cypress"}, {"cypress"}, GK_CYPRESS, true,  false, false, false, false},
 121     {{"hemlock"}, {"cypress"}, GK_CYPRESS, true,  false, false, false, false},
 122     {{"juniper"}, {"juniper"}, GK_JUNIPER, false, false, false, false, false},
 123     {{"redwood"}, {"redwood"}, GK_REDWOOD, false, false, false, false, false},
 124     {{"sumo"},    {"sumo"},    GK_SUMO,    false, false, false, false, false},
 125     {{"sumo2"},   {"sumo"},    GK_SUMO,    false, false, false, false, false},
 126     {{"barts"},   {"barts"},   GK_BARTS,   false, false, false, false, false},
 127     {{"caicos"},  {"caicos"},  GK_BARTS,   false, false, false, false, false},
 128     {{"aruba"},   {"cayman"},  GK_CAYMAN,  true,  false, false, false, false},
 129     {{"cayman"},  {"cayman"},  GK_CAYMAN,  true,  false, false, false, false},
 130     {{"turks"},   {"turks"},   GK_TURKS,   false, false, false, false, false},
 131   };
 132   static constexpr GPUInfo AMDGCNGPUs[32] = {
 133   // Name           Canonical    Kind        Has   Has    Has    Has   Has
 134   //                Name                     FMAF  Fast   LDEXPF FP64  Fast
 135   //                                               FMAF                FMA
 136     {{"gfx600"},    {"gfx600"},  GK_GFX600,  true, true,  true,  true, true},
 137     {{"tahiti"},    {"gfx600"},  GK_GFX600,  true, true,  true,  true, true},
 138     {{"gfx601"},    {"gfx601"},  GK_GFX601,  true, false, true,  true, true},
 139     {{"hainan"},    {"gfx601"},  GK_GFX601,  true, false, true,  true, true},
 140     {{"oland"},     {"gfx601"},  GK_GFX601,  true, false, true,  true, true},
 141     {{"pitcairn"},  {"gfx601"},  GK_GFX601,  true, false, true,  true, true},
 142     {{"verde"},     {"gfx601"},  GK_GFX601,  true, false, true,  true, true},
 143     {{"gfx700"},    {"gfx700"},  GK_GFX700,  true, false, true,  true, true},
 144     {{"kaveri"},    {"gfx700"},  GK_GFX700,  true, false, true,  true, true},
 145     {{"gfx701"},    {"gfx701"},  GK_GFX701,  true, true,  true,  true, true},
 146     {{"hawaii"},    {"gfx701"},  GK_GFX701,  true, true,  true,  true, true},
 147     {{"gfx702"},    {"gfx702"},  GK_GFX702,  true, true,  true,  true, true},
 148     {{"gfx703"},    {"gfx703"},  GK_GFX703,  true, false, true,  true, true},
 149     {{"kabini"},    {"gfx703"},  GK_GFX703,  true, false, true,  true, true},
 150     {{"mullins"},   {"gfx703"},  GK_GFX703,  true, false, true,  true, true},
 151     {{"gfx704"},    {"gfx704"},  GK_GFX704,  true, false, true,  true, true},
 152     {{"bonaire"},   {"gfx704"},  GK_GFX704,  true, false, true,  true, true},
 153     {{"gfx801"},    {"gfx801"},  GK_GFX801,  true, true,  true,  true, true},
 154     {{"carrizo"},   {"gfx801"},  GK_GFX801,  true, true,  true,  true, true},
 155     {{"gfx802"},    {"gfx802"},  GK_GFX802,  true, false, true,  true, true},
 156     {{"iceland"},   {"gfx802"},  GK_GFX802,  true, false, true,  true, true},
 157     {{"tonga"},     {"gfx802"},  GK_GFX802,  true, false, true,  true, true},
 158     {{"gfx803"},    {"gfx803"},  GK_GFX803,  true, false, true,  true, true},
 159     {{"fiji"},      {"gfx803"},  GK_GFX803,  true, false, true,  true, true},
 160     {{"polaris10"}, {"gfx803"},  GK_GFX803,  true, false, true,  true, true},
 161     {{"polaris11"}, {"gfx803"},  GK_GFX803,  true, false, true,  true, true},
 162     {{"gfx810"},    {"gfx810"},  GK_GFX810,  true, false, true,  true, true},
 163     {{"stoney"},    {"gfx810"},  GK_GFX810,  true, false, true,  true, true},
 164     {{"gfx900"},    {"gfx900"},  GK_GFX900,  true, true,  true,  true, true},
 165     {{"gfx902"},    {"gfx902"},  GK_GFX900,  true, true,  true,  true, true},
 166     {{"gfx904"},    {"gfx904"},  GK_GFX904,  true, true,  true,  true, true},
 167     {{"gfx906"},    {"gfx906"},  GK_GFX906,  true, true,  true,  true, true},
 168   };
 169
 170   static GPUInfo parseR600Name(StringRef Name);
 171
 172   static GPUInfo parseAMDGCNName(StringRef Name);
 173
 174   GPUInfo parseGPUName(StringRef Name) const;
 175
 176   GPUInfo GPU;
 177
 178   static bool isAMDGCN(const llvm::Triple &TT) {
 179     return TT.getArch() == llvm::Triple::amdgcn;
 180   }
 181
 182 public:
 183   AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
 184
 185   void setAddressSpaceMap(bool DefaultIsPrivate);
 186
 187   void adjust(LangOptions &Opts) override;
 188
 189   uint64_t getPointerWidthV(unsigned AddrSpace) const override {
 190     if (GPU.Kind <= GK_R600_LAST)
 191       return 32;
 192     if (AddrSpace == Private || AddrSpace == Local)
 193       return 32;
 194     return 64;
 195   }
 196
 197   uint64_t getPointerAlignV(unsigned AddrSpace) const override {
 198     return getPointerWidthV(AddrSpace);
 199   }
 200
 201   uint64_t getMaxPointerWidth() const override {
 202     return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 32;
 203   }
 204
 205   const char *getClobbers() const override { return ""; }
 206
 207   ArrayRef<const char *> getGCCRegNames() const override;
 208
 209   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
 210     return None;
 211   }
 212
 213   /// Accepted register names: (n, m is unsigned integer, n < m)
 214   /// v
 215   /// s
 216   /// {vn}, {v[n]}
 217   /// {sn}, {s[n]}
 218   /// {S} , where S is a special register name
 219   ////{v[n:m]}
 220   /// {s[n:m]}
 221   bool validateAsmConstraint(const char *&Name,
 222                              TargetInfo::ConstraintInfo &Info) const override {
 223     static const ::llvm::StringSet<> SpecialRegs({
 224         "exec", "vcc", "flat_scratch", "m0", "scc", "tba", "tma",
 225         "flat_scratch_lo", "flat_scratch_hi", "vcc_lo", "vcc_hi", "exec_lo",
 226         "exec_hi", "tma_lo", "tma_hi", "tba_lo", "tba_hi",
 227     });
 228
 229     StringRef S(Name);
 230     bool HasLeftParen = false;
 231     if (S.front() == '{') {
 232       HasLeftParen = true;
 233       S = S.drop_front();
 234     }
 235     if (S.empty())
 236       return false;
 237     if (S.front() != 'v' && S.front() != 's') {
 238       if (!HasLeftParen)
 239         return false;
 240       auto E = S.find('}');
 241       if (!SpecialRegs.count(S.substr(0, E)))
 242         return false;
 243       S = S.drop_front(E + 1);
 244       if (!S.empty())
 245         return false;
 246       // Found {S} where S is a special register.
 247       Info.setAllowsRegister();
 248       Name = S.data() - 1;
 249       return true;
 250     }
 251     S = S.drop_front();
 252     if (!HasLeftParen) {
 253       if (!S.empty())
 254         return false;
 255       // Found s or v.
 256       Info.setAllowsRegister();
 257       Name = S.data() - 1;
 258       return true;
 259     }
 260     bool HasLeftBracket = false;
 261     if (!S.empty() && S.front() == '[') {
 262       HasLeftBracket = true;
 263       S = S.drop_front();
 264     }
 265     unsigned long long N;
 266     if (S.empty() || consumeUnsignedInteger(S, 10, N))
 267       return false;
 268     if (!S.empty() && S.front() == ':') {
 269       if (!HasLeftBracket)
 270         return false;
 271       S = S.drop_front();
 272       unsigned long long M;
 273       if (consumeUnsignedInteger(S, 10, M) || N >= M)
 274         return false;
 275     }
 276     if (HasLeftBracket) {
 277       if (S.empty() || S.front() != ']')
 278         return false;
 279       S = S.drop_front();
 280     }
 281     if (S.empty() || S.front() != '}')
 282       return false;
 283     S = S.drop_front();
 284     if (!S.empty())
 285       return false;
 286     // Found {vn}, {sn}, {v[n]}, {s[n]}, {v[n:m]}, or {s[n:m]}.
 287     Info.setAllowsRegister();
 288     Name = S.data() - 1;
 289     return true;
 290   }
 291
 292   // \p Constraint will be left pointing at the last character of
 293   // the constraint.  In practice, it won't be changed unless the
 294   // constraint is longer than one character.
 295   std::string convertConstraint(const char *&Constraint) const override {
 296     const char *Begin = Constraint;
 297     TargetInfo::ConstraintInfo Info("", "");
 298     if (validateAsmConstraint(Constraint, Info))
 299       return std::string(Begin).substr(0, Constraint - Begin + 1);
 300
 301     Constraint = Begin;
 302     return std::string(1, *Constraint);
 303   }
 304
 305   bool
 306   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
 307                  StringRef CPU,
 308                  const std::vector<std::string> &FeatureVec) const override;
 309
 310   void adjustTargetOptions(const CodeGenOptions &CGOpts,
 311                            TargetOptions &TargetOpts) const override;
 312
 313   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 314
 315   void getTargetDefines(const LangOptions &Opts,
 316                         MacroBuilder &Builder) const override;
 317
 318   BuiltinVaListKind getBuiltinVaListKind() const override {
 319     return TargetInfo::CharPtrBuiltinVaList;
 320   }
 321
 322   bool isValidCPUName(StringRef Name) const override {
 323     if (getTriple().getArch() == llvm::Triple::amdgcn)
 324       return GK_NONE != parseAMDGCNName(Name).Kind;
 325     else
 326       return GK_NONE != parseR600Name(Name).Kind;
 327   }
 328
 329   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
 330
 331   bool setCPU(const std::string &Name) override {
 332     if (getTriple().getArch() == llvm::Triple::amdgcn)
 333       GPU = parseAMDGCNName(Name);
 334     else
 335       GPU = parseR600Name(Name);
 336
 337     return GK_NONE != GPU.Kind;
 338   }
 339
 340   void setSupportedOpenCLOpts() override {
 341     auto &Opts = getSupportedOpenCLOpts();
 342     Opts.support("cl_clang_storage_class_specifiers");
 343     Opts.support("cl_khr_icd");
 344
 345     if (GPU.HasFP64)
 346       Opts.support("cl_khr_fp64");
 347     if (GPU.Kind >= GK_CEDAR) {
 348       Opts.support("cl_khr_byte_addressable_store");
 349       Opts.support("cl_khr_global_int32_base_atomics");
 350       Opts.support("cl_khr_global_int32_extended_atomics");
 351       Opts.support("cl_khr_local_int32_base_atomics");
 352       Opts.support("cl_khr_local_int32_extended_atomics");
 353     }
 354     if (GPU.Kind >= GK_AMDGCN_FIRST) {
 355       Opts.support("cl_khr_fp16");
 356       Opts.support("cl_khr_int64_base_atomics");
 357       Opts.support("cl_khr_int64_extended_atomics");
 358       Opts.support("cl_khr_mipmap_image");
 359       Opts.support("cl_khr_subgroups");
 360       Opts.support("cl_khr_3d_image_writes");
 361       Opts.support("cl_amd_media_ops");
 362       Opts.support("cl_amd_media_ops2");
 363     }
 364   }
 365
 366   LangAS getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const override {
 367     switch (TK) {
 368     case OCLTK_Image:
 369       return LangAS::opencl_constant;
 370
 371     case OCLTK_ClkEvent:
 372     case OCLTK_Queue:
 373     case OCLTK_ReserveID:
 374       return LangAS::opencl_global;
 375
 376     default:
 377       return TargetInfo::getOpenCLTypeAddrSpace(TK);
 378     }
 379   }
 380
 381   llvm::Optional<LangAS> getConstantAddressSpace() const override {
 382     return getLangASFromTargetAS(Constant);
 383   }
 384
 385   /// \returns Target specific vtbl ptr address space.
 386   unsigned getVtblPtrAddressSpace() const override {
 387     return static_cast<unsigned>(Constant);
 388   }
 389
 390   /// \returns If a target requires an address within a target specific address
 391   /// space \p AddressSpace to be converted in order to be used, then return the
 392   /// corresponding target specific DWARF address space.
 393   ///
 394   /// \returns Otherwise return None and no conversion will be emitted in the
 395   /// DWARF.
 396   Optional<unsigned>
 397   getDWARFAddressSpace(unsigned AddressSpace) const override {
 398     const unsigned DWARF_Private = 1;
 399     const unsigned DWARF_Local = 2;
 400     if (AddressSpace == Private) {
 401       return DWARF_Private;
 402     } else if (AddressSpace == Local) {
 403       return DWARF_Local;
 404     } else {
 405       return None;
 406     }
 407   }
 408
 409   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
 410     switch (CC) {
 411     default:
 412       return CCCR_Warning;
 413     case CC_C:
 414     case CC_OpenCLKernel:
 415       return CCCR_OK;
 416     }
 417   }
 418
 419   // In amdgcn target the null pointer in global, constant, and generic
 420   // address space has value 0 but in private and local address space has
 421   // value ~0.
 422   uint64_t getNullPointerValue(LangAS AS) const override {
 423     return AS == LangAS::opencl_local ? ~0 : 0;
 424   }
 425 };
 426
 427 } // namespace targets
 428 } // namespace clang
 429
 430 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H