lib/Target/PTX/PTXSubtarget.h

   1 //====-- PTXSubtarget.h - Define Subtarget for the PTX ---------*- 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 the PTX specific subclass of TargetSubtargetInfo.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef PTX_SUBTARGET_H
  15 #define PTX_SUBTARGET_H
  16
  17 #include "llvm/Target/TargetSubtargetInfo.h"
  18
  19 #define GET_SUBTARGETINFO_HEADER
  20 #include "PTXGenSubtargetInfo.inc"
  21
  22 namespace llvm {
  23 class StringRef;
  24
  25   class PTXSubtarget : public PTXGenSubtargetInfo {
  26       virtual void anchor();
  27     public:
  28
  29       /**
  30        * Enumeration of Shader Models supported by the back-end.
  31        */
  32       enum PTXTargetEnum {
  33         PTX_COMPUTE_1_0, /*< Compute Compatibility 1.0 */
  34         PTX_COMPUTE_1_1, /*< Compute Compatibility 1.1 */
  35         PTX_COMPUTE_1_2, /*< Compute Compatibility 1.2 */
  36         PTX_COMPUTE_1_3, /*< Compute Compatibility 1.3 */
  37         PTX_COMPUTE_2_0, /*< Compute Compatibility 2.0 */
  38         PTX_LAST_COMPUTE,
  39
  40         PTX_SM_1_0, /*< Shader Model 1.0 */
  41         PTX_SM_1_1, /*< Shader Model 1.1 */
  42         PTX_SM_1_2, /*< Shader Model 1.2 */
  43         PTX_SM_1_3, /*< Shader Model 1.3 */
  44         PTX_SM_2_0, /*< Shader Model 2.0 */
  45         PTX_SM_2_1, /*< Shader Model 2.1 */
  46         PTX_SM_2_2, /*< Shader Model 2.2 */
  47         PTX_SM_2_3, /*< Shader Model 2.3 */
  48         PTX_LAST_SM
  49       };
  50
  51       /**
  52        * Enumeration of PTX versions supported by the back-end.
  53        *
  54        * Currently, PTX 2.0 is the minimum supported version.
  55        */
  56       enum PTXVersionEnum {
  57         PTX_VERSION_2_0,  /*< PTX Version 2.0 */
  58         PTX_VERSION_2_1,  /*< PTX Version 2.1 */
  59         PTX_VERSION_2_2,  /*< PTX Version 2.2 */
  60         PTX_VERSION_2_3   /*< PTX Version 2.3 */
  61       };
  62
  63   private:
  64
  65       /// Shader Model supported on the target GPU.
  66       PTXTargetEnum PTXTarget;
  67
  68       /// PTX Language Version.
  69       PTXVersionEnum PTXVersion;
  70
  71       // The native .f64 type is supported on the hardware.
  72       bool SupportsDouble;
  73
  74       // Support the fused-multiply add (FMA) and multiply-add (MAD)
  75       // instructions
  76       bool SupportsFMA;
  77
  78       // Use .u64 instead of .u32 for addresses.
  79       bool Is64Bit;
  80
  81     public:
  82
  83       PTXSubtarget(const std::string &TT, const std::string &CPU,
  84                    const std::string &FS, bool is64Bit);
  85
  86       // Target architecture accessors
  87       std::string getTargetString() const;
  88
  89       std::string getPTXVersionString() const;
  90
  91       bool supportsDouble() const { return SupportsDouble; }
  92
  93       bool is64Bit() const { return Is64Bit; }
  94
  95       bool supportsFMA() const { return SupportsFMA; }
  96
  97       bool supportsPTX21() const { return PTXVersion >= PTX_VERSION_2_1; }
  98
  99       bool supportsPTX22() const { return PTXVersion >= PTX_VERSION_2_2; }
 100
 101       bool supportsPTX23() const { return PTXVersion >= PTX_VERSION_2_3; }
 102
 103       bool fdivNeedsRoundingMode() const {
 104         return (PTXTarget >= PTX_SM_1_3 && PTXTarget < PTX_LAST_SM) ||
 105                (PTXTarget >= PTX_COMPUTE_1_3 && PTXTarget < PTX_LAST_COMPUTE);
 106       }
 107
 108       bool fmadNeedsRoundingMode() const {
 109         return (PTXTarget >= PTX_SM_1_3 && PTXTarget < PTX_LAST_SM) ||
 110                (PTXTarget >= PTX_COMPUTE_1_3 && PTXTarget < PTX_LAST_COMPUTE);
 111       }
 112
 113       bool useParamSpaceForDeviceArgs() const {
 114         return (PTXTarget >= PTX_SM_2_0 && PTXTarget < PTX_LAST_SM) ||
 115                (PTXTarget >= PTX_COMPUTE_2_0 && PTXTarget < PTX_LAST_COMPUTE);
 116       }
 117
 118       bool callsAreHandled() const {
 119         return (PTXTarget >= PTX_SM_2_0 && PTXTarget < PTX_LAST_SM) ||
 120                (PTXTarget >= PTX_COMPUTE_2_0 && PTXTarget < PTX_LAST_COMPUTE);
 121       }
 122
 123       bool emitPtrAttribute() const {
 124         return PTXVersion >= PTX_VERSION_2_2;
 125       }
 126
 127       void ParseSubtargetFeatures(StringRef CPU, StringRef FS);
 128   }; // class PTXSubtarget
 129 } // namespace llvm
 130
 131 #endif // PTX_SUBTARGET_H