AMDGPU/SI: Add hsa code object directives
[oota-llvm.git] / lib / Target / AMDGPU / AMDGPUSubtarget.h
1 //=====-- AMDGPUSubtarget.h - Define Subtarget for the AMDIL ---*- 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 /// \file
11 /// \brief AMDGPU specific subclass of TargetSubtarget.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_LIB_TARGET_R600_AMDGPUSUBTARGET_H
16 #define LLVM_LIB_TARGET_R600_AMDGPUSUBTARGET_H
17 #include "AMDGPU.h"
18 #include "AMDGPUFrameLowering.h"
19 #include "AMDGPUInstrInfo.h"
20 #include "AMDGPUIntrinsicInfo.h"
21 #include "AMDGPUSubtarget.h"
22 #include "R600ISelLowering.h"
23 #include "AMDKernelCodeT.h"
24 #include "Utils/AMDGPUBaseInfo.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/Target/TargetSubtargetInfo.h"
28
29 #define GET_SUBTARGETINFO_HEADER
30 #include "AMDGPUGenSubtargetInfo.inc"
31
32 namespace llvm {
33
34 class SIMachineFunctionInfo;
35
36 class AMDGPUSubtarget : public AMDGPUGenSubtargetInfo {
37
38 public:
39   enum Generation {
40     R600 = 0,
41     R700,
42     EVERGREEN,
43     NORTHERN_ISLANDS,
44     SOUTHERN_ISLANDS,
45     SEA_ISLANDS,
46     VOLCANIC_ISLANDS,
47   };
48
49   enum {
50     FIXED_SGPR_COUNT_FOR_INIT_BUG = 80
51   };
52
53   enum {
54     ISAVersion0_0_0,
55     ISAVersion7_0_0,
56     ISAVersion7_0_1,
57     ISAVersion8_0_0,
58     ISAVersion8_0_1
59   };
60
61 private:
62   std::string DevName;
63   bool Is64bit;
64   bool DumpCode;
65   bool R600ALUInst;
66   bool HasVertexCache;
67   short TexVTXClauseSize;
68   Generation Gen;
69   bool FP64;
70   bool FP64Denormals;
71   bool FP32Denormals;
72   bool FastFMAF32;
73   bool CaymanISA;
74   bool FlatAddressSpace;
75   bool EnableIRStructurizer;
76   bool EnablePromoteAlloca;
77   bool EnableIfCvt;
78   bool EnableLoadStoreOpt;
79   unsigned WavefrontSize;
80   bool CFALUBug;
81   int LocalMemorySize;
82   bool EnableVGPRSpilling;
83   bool SGPRInitBug;
84   bool IsGCN;
85   bool GCN1Encoding;
86   bool GCN3Encoding;
87   bool CIInsts;
88   bool FeatureDisable;
89   int LDSBankCount;
90   unsigned IsaVersion; 
91
92   AMDGPUFrameLowering FrameLowering;
93   std::unique_ptr<AMDGPUTargetLowering> TLInfo;
94   std::unique_ptr<AMDGPUInstrInfo> InstrInfo;
95   InstrItineraryData InstrItins;
96   Triple TargetTriple;
97
98 public:
99   AMDGPUSubtarget(const Triple &TT, StringRef CPU, StringRef FS,
100                   TargetMachine &TM);
101   AMDGPUSubtarget &initializeSubtargetDependencies(const Triple &TT,
102                                                    StringRef GPU, StringRef FS);
103
104   const AMDGPUFrameLowering *getFrameLowering() const override {
105     return &FrameLowering;
106   }
107   const AMDGPUInstrInfo *getInstrInfo() const override {
108     return InstrInfo.get();
109   }
110   const AMDGPURegisterInfo *getRegisterInfo() const override {
111     return &InstrInfo->getRegisterInfo();
112   }
113   AMDGPUTargetLowering *getTargetLowering() const override {
114     return TLInfo.get();
115   }
116   const InstrItineraryData *getInstrItineraryData() const override {
117     return &InstrItins;
118   }
119
120   void ParseSubtargetFeatures(StringRef CPU, StringRef FS);
121
122   bool is64bit() const {
123     return Is64bit;
124   }
125
126   bool hasVertexCache() const {
127     return HasVertexCache;
128   }
129
130   short getTexVTXClauseSize() const {
131     return TexVTXClauseSize;
132   }
133
134   Generation getGeneration() const {
135     return Gen;
136   }
137
138   bool hasHWFP64() const {
139     return FP64;
140   }
141
142   bool hasCaymanISA() const {
143     return CaymanISA;
144   }
145
146   bool hasFP32Denormals() const {
147     return FP32Denormals;
148   }
149
150   bool hasFP64Denormals() const {
151     return FP64Denormals;
152   }
153
154   bool hasFastFMAF32() const {
155     return FastFMAF32;
156   }
157
158   bool hasFlatAddressSpace() const {
159     return FlatAddressSpace;
160   }
161
162   bool hasBFE() const {
163     return (getGeneration() >= EVERGREEN);
164   }
165
166   bool hasBFI() const {
167     return (getGeneration() >= EVERGREEN);
168   }
169
170   bool hasBFM() const {
171     return hasBFE();
172   }
173
174   bool hasBCNT(unsigned Size) const {
175     if (Size == 32)
176       return (getGeneration() >= EVERGREEN);
177
178     if (Size == 64)
179       return (getGeneration() >= SOUTHERN_ISLANDS);
180
181     return false;
182   }
183
184   bool hasMulU24() const {
185     return (getGeneration() >= EVERGREEN);
186   }
187
188   bool hasMulI24() const {
189     return (getGeneration() >= SOUTHERN_ISLANDS ||
190             hasCaymanISA());
191   }
192
193   bool hasFFBL() const {
194     return (getGeneration() >= EVERGREEN);
195   }
196
197   bool hasFFBH() const {
198     return (getGeneration() >= EVERGREEN);
199   }
200
201   bool hasCARRY() const {
202     return (getGeneration() >= EVERGREEN);
203   }
204
205   bool hasBORROW() const {
206     return (getGeneration() >= EVERGREEN);
207   }
208
209   bool IsIRStructurizerEnabled() const {
210     return EnableIRStructurizer;
211   }
212
213   bool isPromoteAllocaEnabled() const {
214     return EnablePromoteAlloca;
215   }
216
217   bool isIfCvtEnabled() const {
218     return EnableIfCvt;
219   }
220
221   bool loadStoreOptEnabled() const {
222     return EnableLoadStoreOpt;
223   }
224
225   unsigned getWavefrontSize() const {
226     return WavefrontSize;
227   }
228
229   unsigned getStackEntrySize() const;
230
231   bool hasCFAluBug() const {
232     assert(getGeneration() <= NORTHERN_ISLANDS);
233     return CFALUBug;
234   }
235
236   int getLocalMemorySize() const {
237     return LocalMemorySize;
238   }
239
240   bool hasSGPRInitBug() const {
241     return SGPRInitBug;
242   }
243
244   int getLDSBankCount() const {
245     return LDSBankCount;
246   }
247
248   unsigned getAmdKernelCodeChipID() const;
249
250   AMDGPU::IsaVersion getIsaVersion() const;
251
252   bool enableMachineScheduler() const override {
253     return true;
254   }
255
256   void overrideSchedPolicy(MachineSchedPolicy &Policy,
257                            MachineInstr *begin, MachineInstr *end,
258                            unsigned NumRegionInstrs) const override;
259
260   // Helper functions to simplify if statements
261   bool isTargetELF() const {
262     return false;
263   }
264
265   StringRef getDeviceName() const {
266     return DevName;
267   }
268
269   bool dumpCode() const {
270     return DumpCode;
271   }
272   bool r600ALUEncoding() const {
273     return R600ALUInst;
274   }
275   bool isAmdHsaOS() const {
276     return TargetTriple.getOS() == Triple::AMDHSA;
277   }
278   bool isVGPRSpillingEnabled(const SIMachineFunctionInfo *MFI) const;
279
280   unsigned getMaxWavesPerCU() const {
281     if (getGeneration() >= AMDGPUSubtarget::SOUTHERN_ISLANDS)
282       return 10;
283
284     // FIXME: Not sure what this is for other subtagets.
285     llvm_unreachable("do not know max waves per CU for this subtarget.");
286   }
287
288   bool enableSubRegLiveness() const override {
289     return true;
290   }
291
292   /// \brief Returns the offset in bytes from the start of the input buffer
293   ///        of the first explicit kernel argument.
294   unsigned getExplicitKernelArgOffset() const {
295     return isAmdHsaOS() ? 0 : 36;
296   }
297
298 };
299
300 } // End namespace llvm
301
302 #endif