952fd4cc5024dcfbacacb04817dbbd575de57c24
[oota-llvm.git] / lib / Target / AMDGPU / AMDGPUISelLowering.h
1 //===-- AMDGPUISelLowering.h - AMDGPU Lowering Interface --------*- 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 Interface definition of the TargetLowering class that is common
12 /// to all AMD GPUs.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #ifndef LLVM_LIB_TARGET_R600_AMDGPUISELLOWERING_H
17 #define LLVM_LIB_TARGET_R600_AMDGPUISELLOWERING_H
18
19 #include "llvm/Target/TargetLowering.h"
20
21 namespace llvm {
22
23 class AMDGPUMachineFunction;
24 class AMDGPUSubtarget;
25 class MachineRegisterInfo;
26
27 class AMDGPUTargetLowering : public TargetLowering {
28 protected:
29   const AMDGPUSubtarget *Subtarget;
30
31 private:
32   SDValue LowerConstantInitializer(const Constant* Init, const GlobalValue *GV,
33                                    const SDValue &InitPtr,
34                                    SDValue Chain,
35                                    SelectionDAG &DAG) const;
36   SDValue LowerFrameIndex(SDValue Op, SelectionDAG &DAG) const;
37   SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
38   SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
39   SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
40   /// \brief Lower vector stores by merging the vector elements into an integer
41   /// of the same bitwidth.
42   SDValue MergeVectorStore(const SDValue &Op, SelectionDAG &DAG) const;
43   /// \brief Split a vector store into multiple scalar stores.
44   /// \returns The resulting chain.
45
46   SDValue LowerFREM(SDValue Op, SelectionDAG &DAG) const;
47   SDValue LowerFCEIL(SDValue Op, SelectionDAG &DAG) const;
48   SDValue LowerFTRUNC(SDValue Op, SelectionDAG &DAG) const;
49   SDValue LowerFRINT(SDValue Op, SelectionDAG &DAG) const;
50   SDValue LowerFNEARBYINT(SDValue Op, SelectionDAG &DAG) const;
51
52   SDValue LowerFROUND32(SDValue Op, SelectionDAG &DAG) const;
53   SDValue LowerFROUND64(SDValue Op, SelectionDAG &DAG) const;
54   SDValue LowerFROUND(SDValue Op, SelectionDAG &DAG) const;
55   SDValue LowerFFLOOR(SDValue Op, SelectionDAG &DAG) const;
56
57   SDValue LowerCTLZ(SDValue Op, SelectionDAG &DAG) const;
58
59   SDValue LowerINT_TO_FP64(SDValue Op, SelectionDAG &DAG, bool Signed) const;
60   SDValue LowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
61   SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
62
63   SDValue LowerFP64_TO_INT(SDValue Op, SelectionDAG &DAG, bool Signed) const;
64   SDValue LowerFP_TO_UINT(SDValue Op, SelectionDAG &DAG) const;
65   SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) const;
66
67   SDValue LowerSIGN_EXTEND_INREG(SDValue Op, SelectionDAG &DAG) const;
68
69   SDValue performStoreCombine(SDNode *N, DAGCombinerInfo &DCI) const;
70   SDValue performShlCombine(SDNode *N, DAGCombinerInfo &DCI) const;
71   SDValue performMulCombine(SDNode *N, DAGCombinerInfo &DCI) const;
72   SDValue performCtlzCombine(SDLoc SL, SDValue Cond, SDValue LHS, SDValue RHS,
73                              DAGCombinerInfo &DCI) const;
74   SDValue performSelectCombine(SDNode *N, DAGCombinerInfo &DCI) const;
75
76 protected:
77   static EVT getEquivalentMemType(LLVMContext &Context, EVT VT);
78   static EVT getEquivalentLoadRegType(LLVMContext &Context, EVT VT);
79
80   virtual SDValue LowerGlobalAddress(AMDGPUMachineFunction *MFI, SDValue Op,
81                                      SelectionDAG &DAG) const;
82
83   /// \brief Split a vector load into a scalar load of each component.
84   SDValue ScalarizeVectorLoad(SDValue Op, SelectionDAG &DAG) const;
85
86   /// \brief Split a vector load into 2 loads of half the vector.
87   SDValue SplitVectorLoad(SDValue Op, SelectionDAG &DAG) const;
88
89   /// \brief Split a vector store into a scalar store of each component.
90   SDValue ScalarizeVectorStore(SDValue Op, SelectionDAG &DAG) const;
91
92   /// \brief Split a vector store into 2 stores of half the vector.
93   SDValue SplitVectorStore(SDValue Op, SelectionDAG &DAG) const;
94
95   SDValue LowerLOAD(SDValue Op, SelectionDAG &DAG) const;
96   SDValue LowerSTORE(SDValue Op, SelectionDAG &DAG) const;
97   SDValue LowerSDIVREM(SDValue Op, SelectionDAG &DAG) const;
98   SDValue LowerUDIVREM(SDValue Op, SelectionDAG &DAG) const;
99   SDValue LowerDIVREM24(SDValue Op, SelectionDAG &DAG, bool sign) const;
100   void LowerUDIVREM64(SDValue Op, SelectionDAG &DAG,
101                                     SmallVectorImpl<SDValue> &Results) const;
102   bool isHWTrueValue(SDValue Op) const;
103   bool isHWFalseValue(SDValue Op) const;
104
105   /// The SelectionDAGBuilder will automatically promote function arguments
106   /// with illegal types.  However, this does not work for the AMDGPU targets
107   /// since the function arguments are stored in memory as these illegal types.
108   /// In order to handle this properly we need to get the origianl types sizes
109   /// from the LLVM IR Function and fixup the ISD:InputArg values before
110   /// passing them to AnalyzeFormalArguments()
111   void getOriginalFunctionArgs(SelectionDAG &DAG,
112                                const Function *F,
113                                const SmallVectorImpl<ISD::InputArg> &Ins,
114                                SmallVectorImpl<ISD::InputArg> &OrigIns) const;
115   void AnalyzeFormalArguments(CCState &State,
116                               const SmallVectorImpl<ISD::InputArg> &Ins) const;
117
118 public:
119   AMDGPUTargetLowering(TargetMachine &TM, const AMDGPUSubtarget &STI);
120
121   bool isFAbsFree(EVT VT) const override;
122   bool isFNegFree(EVT VT) const override;
123   bool isTruncateFree(EVT Src, EVT Dest) const override;
124   bool isTruncateFree(Type *Src, Type *Dest) const override;
125
126   bool isZExtFree(Type *Src, Type *Dest) const override;
127   bool isZExtFree(EVT Src, EVT Dest) const override;
128   bool isZExtFree(SDValue Val, EVT VT2) const override;
129
130   bool isNarrowingProfitable(EVT VT1, EVT VT2) const override;
131
132   MVT getVectorIdxTy(const DataLayout &) const override;
133   bool isSelectSupported(SelectSupportKind) const override;
134
135   bool isFPImmLegal(const APFloat &Imm, EVT VT) const override;
136   bool ShouldShrinkFPConstant(EVT VT) const override;
137   bool shouldReduceLoadWidth(SDNode *Load,
138                              ISD::LoadExtType ExtType,
139                              EVT ExtVT) const override;
140
141   bool isLoadBitCastBeneficial(EVT, EVT) const override;
142
143   bool storeOfVectorConstantIsCheap(EVT MemVT,
144                                     unsigned NumElem,
145                                     unsigned AS) const override;
146   bool aggressivelyPreferBuildVectorSources(EVT VecVT) const override;
147   bool isCheapToSpeculateCttz() const override;
148   bool isCheapToSpeculateCtlz() const override;
149
150   SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv,
151                       bool isVarArg,
152                       const SmallVectorImpl<ISD::OutputArg> &Outs,
153                       const SmallVectorImpl<SDValue> &OutVals,
154                       SDLoc DL, SelectionDAG &DAG) const override;
155   SDValue LowerCall(CallLoweringInfo &CLI,
156                     SmallVectorImpl<SDValue> &InVals) const override;
157
158   SDValue LowerDYNAMIC_STACKALLOC(SDValue Op,
159                                   SelectionDAG &DAG) const;
160
161   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
162   SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
163   void ReplaceNodeResults(SDNode * N,
164                           SmallVectorImpl<SDValue> &Results,
165                           SelectionDAG &DAG) const override;
166
167   SDValue LowerIntrinsicIABS(SDValue Op, SelectionDAG &DAG) const;
168   SDValue LowerIntrinsicLRP(SDValue Op, SelectionDAG &DAG) const;
169   SDValue CombineFMinMaxLegacy(SDLoc DL,
170                                EVT VT,
171                                SDValue LHS,
172                                SDValue RHS,
173                                SDValue True,
174                                SDValue False,
175                                SDValue CC,
176                                DAGCombinerInfo &DCI) const;
177
178   const char* getTargetNodeName(unsigned Opcode) const override;
179
180   SDValue getRsqrtEstimate(SDValue Operand,
181                            DAGCombinerInfo &DCI,
182                            unsigned &RefinementSteps,
183                            bool &UseOneConstNR) const override;
184   SDValue getRecipEstimate(SDValue Operand,
185                            DAGCombinerInfo &DCI,
186                            unsigned &RefinementSteps) const override;
187
188   virtual SDNode *PostISelFolding(MachineSDNode *N,
189                                   SelectionDAG &DAG) const {
190     return N;
191   }
192
193   /// \brief Determine which of the bits specified in \p Mask are known to be
194   /// either zero or one and return them in the \p KnownZero and \p KnownOne
195   /// bitsets.
196   void computeKnownBitsForTargetNode(const SDValue Op,
197                                      APInt &KnownZero,
198                                      APInt &KnownOne,
199                                      const SelectionDAG &DAG,
200                                      unsigned Depth = 0) const override;
201
202   unsigned ComputeNumSignBitsForTargetNode(SDValue Op, const SelectionDAG &DAG,
203                                            unsigned Depth = 0) const override;
204
205   /// \brief Helper function that adds Reg to the LiveIn list of the DAG's
206   /// MachineFunction.
207   ///
208   /// \returns a RegisterSDNode representing Reg.
209   virtual SDValue CreateLiveInRegister(SelectionDAG &DAG,
210                                        const TargetRegisterClass *RC,
211                                        unsigned Reg, EVT VT) const;
212
213   enum ImplicitParameter {
214     GRID_DIM,
215     GRID_OFFSET
216   };
217
218   /// \brief Helper function that returns the byte offset of the given
219   /// type of implicit parameter.
220   uint32_t getImplicitParameterOffset(const AMDGPUMachineFunction *MFI,
221                                       const ImplicitParameter Param) const;
222 };
223
224 namespace AMDGPUISD {
225
226 enum NodeType : unsigned {
227   // AMDIL ISD Opcodes
228   FIRST_NUMBER = ISD::BUILTIN_OP_END,
229   CALL,        // Function call based on a single integer
230   UMUL,        // 32bit unsigned multiplication
231   RET_FLAG,
232   BRANCH_COND,
233   // End AMDIL ISD Opcodes
234   DWORDADDR,
235   FRACT,
236   CLAMP,
237
238   // SIN_HW, COS_HW - f32 for SI, 1 ULP max error, valid from -100 pi to 100 pi.
239   // Denormals handled on some parts.
240   COS_HW,
241   SIN_HW,
242   FMAX_LEGACY,
243   FMIN_LEGACY,
244   FMAX3,
245   SMAX3,
246   UMAX3,
247   FMIN3,
248   SMIN3,
249   UMIN3,
250   URECIP,
251   DIV_SCALE,
252   DIV_FMAS,
253   DIV_FIXUP,
254   TRIG_PREOP, // 1 ULP max error for f64
255
256   // RCP, RSQ - For f32, 1 ULP max error, no denormal handling.
257   //            For f64, max error 2^29 ULP, handles denormals.
258   RCP,
259   RSQ,
260   RSQ_LEGACY,
261   RSQ_CLAMPED,
262   LDEXP,
263   FP_CLASS,
264   DOT4,
265   CARRY,
266   BORROW,
267   BFE_U32, // Extract range of bits with zero extension to 32-bits.
268   BFE_I32, // Extract range of bits with sign extension to 32-bits.
269   BFI, // (src0 & src1) | (~src0 & src2)
270   BFM, // Insert a range of bits into a 32-bit word.
271   FFBH_U32, // ctlz with -1 if input is zero.
272   MUL_U24,
273   MUL_I24,
274   MAD_U24,
275   MAD_I24,
276   TEXTURE_FETCH,
277   EXPORT,
278   CONST_ADDRESS,
279   REGISTER_LOAD,
280   REGISTER_STORE,
281   LOAD_INPUT,
282   SAMPLE,
283   SAMPLEB,
284   SAMPLED,
285   SAMPLEL,
286
287   // These cvt_f32_ubyte* nodes need to remain consecutive and in order.
288   CVT_F32_UBYTE0,
289   CVT_F32_UBYTE1,
290   CVT_F32_UBYTE2,
291   CVT_F32_UBYTE3,
292   /// This node is for VLIW targets and it is used to represent a vector
293   /// that is stored in consecutive registers with the same channel.
294   /// For example:
295   ///   |X  |Y|Z|W|
296   /// T0|v.x| | | |
297   /// T1|v.y| | | |
298   /// T2|v.z| | | |
299   /// T3|v.w| | | |
300   BUILD_VERTICAL_VECTOR,
301   /// Pointer to the start of the shader's constant data.
302   CONST_DATA_PTR,
303   SENDMSG,
304   INTERP_MOV,
305   INTERP_P1,
306   INTERP_P2,
307   FIRST_MEM_OPCODE_NUMBER = ISD::FIRST_TARGET_MEMORY_OPCODE,
308   STORE_MSKOR,
309   LOAD_CONSTANT,
310   TBUFFER_STORE_FORMAT,
311   LAST_AMDGPU_ISD_NUMBER
312 };
313
314
315 } // End namespace AMDGPUISD
316
317 } // End namespace llvm
318
319 #endif