LLVM  10.0.0svn
AMDGPUISelLowering.h
Go to the documentation of this file.
1 //===-- AMDGPUISelLowering.h - AMDGPU Lowering Interface --------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 /// \file
10 /// Interface definition of the TargetLowering class that is common
11 /// to all AMD GPUs.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUISELLOWERING_H
16 #define LLVM_LIB_TARGET_AMDGPU_AMDGPUISELLOWERING_H
17 
18 #include "AMDGPU.h"
21 
22 namespace llvm {
23 
24 class AMDGPUMachineFunction;
25 class AMDGPUSubtarget;
26 struct ArgDescriptor;
27 
29 private:
30  const AMDGPUSubtarget *Subtarget;
31 
32  /// \returns AMDGPUISD::FFBH_U32 node if the incoming \p Op may have been
33  /// legalized from a smaller type VT. Need to match pre-legalized type because
34  /// the generic legalization inserts the add/sub between the select and
35  /// compare.
36  SDValue getFFBX_U32(SelectionDAG &DAG, SDValue Op, const SDLoc &DL, unsigned Opc) const;
37 
38 public:
39  static unsigned numBitsUnsigned(SDValue Op, SelectionDAG &DAG);
40  static unsigned numBitsSigned(SDValue Op, SelectionDAG &DAG);
41  static bool hasDefinedInitializer(const GlobalValue *GV);
42 
43 protected:
46  /// Split a vector store into multiple scalar stores.
47  /// \returns The resulting chain.
48 
49  SDValue LowerFREM(SDValue Op, SelectionDAG &DAG) const;
50  SDValue LowerFCEIL(SDValue Op, SelectionDAG &DAG) const;
51  SDValue LowerFTRUNC(SDValue Op, SelectionDAG &DAG) const;
52  SDValue LowerFRINT(SDValue Op, SelectionDAG &DAG) const;
54 
56  SDValue LowerFROUND64(SDValue Op, SelectionDAG &DAG) const;
57  SDValue LowerFROUND(SDValue Op, SelectionDAG &DAG) const;
58  SDValue LowerFFLOOR(SDValue Op, SelectionDAG &DAG) const;
60  double Log2BaseInverted) const;
61  SDValue lowerFEXP(SDValue Op, SelectionDAG &DAG) const;
62 
64 
65  SDValue LowerINT_TO_FP32(SDValue Op, SelectionDAG &DAG, bool Signed) const;
66  SDValue LowerINT_TO_FP64(SDValue Op, SelectionDAG &DAG, bool Signed) const;
69 
70  SDValue LowerFP64_TO_INT(SDValue Op, SelectionDAG &DAG, bool Signed) const;
74 
76 
77 protected:
78  bool shouldCombineMemoryType(EVT VT) const;
83 
85  unsigned Opc, SDValue LHS,
86  uint32_t ValLo, uint32_t ValHi) const;
96  SDValue RHS, DAGCombinerInfo &DCI) const;
98 
99  bool isConstantCostlierToNegate(SDValue N) const;
103 
105 
107  SelectionDAG &DAG) const;
108 
109  /// Return 64-bit value Op as two 32-bit integers.
110  std::pair<SDValue, SDValue> split64BitValue(SDValue Op,
111  SelectionDAG &DAG) const;
112  SDValue getLoHalf64(SDValue Op, SelectionDAG &DAG) const;
113  SDValue getHiHalf64(SDValue Op, SelectionDAG &DAG) const;
114 
115  /// Split a vector type into two parts. The first part is a power of two
116  /// vector. The second part is whatever is left over, and is a scalar if it
117  /// would otherwise be a 1-vector.
118  std::pair<EVT, EVT> getSplitDestVTs(const EVT &VT, SelectionDAG &DAG) const;
119 
120  /// Split a vector value into two parts of types LoVT and HiVT. HiVT could be
121  /// scalar.
122  std::pair<SDValue, SDValue> splitVector(const SDValue &N, const SDLoc &DL,
123  const EVT &LoVT, const EVT &HighVT,
124  SelectionDAG &DAG) const;
125 
126  /// Split a vector load into 2 loads of half the vector.
128 
129  /// Widen a vector load from vec3 to vec4.
131 
132  /// Split a vector store into 2 stores of half the vector.
134 
135  SDValue LowerSTORE(SDValue Op, SelectionDAG &DAG) const;
136  SDValue LowerSDIVREM(SDValue Op, SelectionDAG &DAG) const;
137  SDValue LowerUDIVREM(SDValue Op, SelectionDAG &DAG) const;
138  SDValue LowerDIVREM24(SDValue Op, SelectionDAG &DAG, bool sign) const;
139  void LowerUDIVREM64(SDValue Op, SelectionDAG &DAG,
141 
143  CCState &State,
144  const SmallVectorImpl<ISD::InputArg> &Ins) const;
145 
146 public:
147  AMDGPUTargetLowering(const TargetMachine &TM, const AMDGPUSubtarget &STI);
148 
149  bool mayIgnoreSignedZero(SDValue Op) const {
150  if (getTargetMachine().Options.NoSignedZerosFPMath)
151  return true;
152 
153  const auto Flags = Op.getNode()->getFlags();
154  if (Flags.isDefined())
155  return Flags.hasNoSignedZeros();
156 
157  return false;
158  }
159 
160  static inline SDValue stripBitcast(SDValue Val) {
161  return Val.getOpcode() == ISD::BITCAST ? Val.getOperand(0) : Val;
162  }
163 
164  static bool allUsesHaveSourceMods(const SDNode *N,
165  unsigned CostThreshold = 4);
166  bool isFAbsFree(EVT VT) const override;
167  bool isFNegFree(EVT VT) const override;
168  bool isTruncateFree(EVT Src, EVT Dest) const override;
169  bool isTruncateFree(Type *Src, Type *Dest) const override;
170 
171  bool isZExtFree(Type *Src, Type *Dest) const override;
172  bool isZExtFree(EVT Src, EVT Dest) const override;
173  bool isZExtFree(SDValue Val, EVT VT2) const override;
174 
175  bool isNarrowingProfitable(EVT VT1, EVT VT2) const override;
176 
177  MVT getVectorIdxTy(const DataLayout &) const override;
178  bool isSelectSupported(SelectSupportKind) const override;
179 
180  bool isFPImmLegal(const APFloat &Imm, EVT VT,
181  bool ForCodeSize) const override;
182  bool ShouldShrinkFPConstant(EVT VT) const override;
185  EVT ExtVT) const override;
186 
187  bool isLoadBitCastBeneficial(EVT, EVT, const SelectionDAG &DAG,
188  const MachineMemOperand &MMO) const final;
189 
191  unsigned NumElem,
192  unsigned AS) const override;
193  bool aggressivelyPreferBuildVectorSources(EVT VecVT) const override;
194  bool isCheapToSpeculateCttz() const override;
195  bool isCheapToSpeculateCtlz() const override;
196 
197  bool isSDNodeAlwaysUniform(const SDNode *N) const override;
198  static CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg);
199  static CCAssignFn *CCAssignFnForReturn(CallingConv::ID CC, bool IsVarArg);
200 
201  SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
203  const SmallVectorImpl<SDValue> &OutVals, const SDLoc &DL,
204  SelectionDAG &DAG) const override;
205 
207  SelectionDAG &DAG,
208  MachineFrameInfo &MFI,
209  int ClobberedFI) const;
210 
212  SmallVectorImpl<SDValue> &InVals,
213  StringRef Reason) const;
215  SmallVectorImpl<SDValue> &InVals) const override;
216 
218  SelectionDAG &DAG) const;
219 
220  SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
221  SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
222  void ReplaceNodeResults(SDNode * N,
223  SmallVectorImpl<SDValue> &Results,
224  SelectionDAG &DAG) const override;
225 
226  SDValue combineFMinMaxLegacy(const SDLoc &DL, EVT VT, SDValue LHS,
227  SDValue RHS, SDValue True, SDValue False,
228  SDValue CC, DAGCombinerInfo &DCI) const;
229 
230  const char* getTargetNodeName(unsigned Opcode) const override;
231 
232  // FIXME: Turn off MergeConsecutiveStores() before Instruction Selection for
233  // AMDGPU. Commit r319036,
234  // (https://github.com/llvm/llvm-project/commit/db77e57ea86d941a4262ef60261692f4cb6893e6)
235  // turned on MergeConsecutiveStores() before Instruction Selection for all
236  // targets. Enough AMDGPU compiles go into an infinite loop (
237  // MergeConsecutiveStores() merges two stores; LegalizeStoreOps() un-merges;
238  // MergeConsecutiveStores() re-merges, etc. ) to warrant turning it off for
239  // now.
240  bool mergeStoresAfterLegalization(EVT) const override { return false; }
241 
242  bool isFsqrtCheap(SDValue Operand, SelectionDAG &DAG) const override {
243  return true;
244  }
246  int &RefinementSteps, bool &UseOneConstNR,
247  bool Reciprocal) const override;
248  SDValue getRecipEstimate(SDValue Operand, SelectionDAG &DAG, int Enabled,
249  int &RefinementSteps) const override;
250 
252  SelectionDAG &DAG) const = 0;
253 
254  /// Determine which of the bits specified in \p Mask are known to be
255  /// either zero or one and return them in the \p KnownZero and \p KnownOne
256  /// bitsets.
258  KnownBits &Known,
259  const APInt &DemandedElts,
260  const SelectionDAG &DAG,
261  unsigned Depth = 0) const override;
262 
263  unsigned ComputeNumSignBitsForTargetNode(SDValue Op, const APInt &DemandedElts,
264  const SelectionDAG &DAG,
265  unsigned Depth = 0) const override;
266 
268  const SelectionDAG &DAG,
269  bool SNaN = false,
270  unsigned Depth = 0) const override;
271 
272  /// Helper function that adds Reg to the LiveIn list of the DAG's
273  /// MachineFunction.
274  ///
275  /// \returns a RegisterSDNode representing Reg if \p RawReg is true, otherwise
276  /// a copy from the register.
278  const TargetRegisterClass *RC,
279  unsigned Reg, EVT VT,
280  const SDLoc &SL,
281  bool RawReg = false) const;
283  const TargetRegisterClass *RC,
284  unsigned Reg, EVT VT) const {
285  return CreateLiveInRegister(DAG, RC, Reg, VT, SDLoc(DAG.getEntryNode()));
286  }
287 
288  // Returns the raw live in register rather than a copy from it.
290  const TargetRegisterClass *RC,
291  unsigned Reg, EVT VT) const {
292  return CreateLiveInRegister(DAG, RC, Reg, VT, SDLoc(DAG.getEntryNode()), true);
293  }
294 
295  /// Similar to CreateLiveInRegister, except value maybe loaded from a stack
296  /// slot rather than passed in a register.
298  EVT VT,
299  const SDLoc &SL,
300  int64_t Offset) const;
301 
303  const SDLoc &SL,
304  SDValue Chain,
305  SDValue ArgVal,
306  int64_t Offset) const;
307 
309  const TargetRegisterClass *RC,
310  EVT VT, const SDLoc &SL,
311  const ArgDescriptor &Arg) const;
312 
317  };
318 
319  /// Helper function that returns the byte offset of the given
320  /// type of implicit parameter.
322  const ImplicitParameter Param) const;
323 
324  MVT getFenceOperandTy(const DataLayout &DL) const override {
325  return MVT::i32;
326  }
327 
329 
330  bool SelectFlatOffset(bool IsSigned, SelectionDAG &DAG, SDNode *N,
331  SDValue Addr, SDValue &VAddr, SDValue &Offset,
332  SDValue &SLC) const;
333 };
334 
335 namespace AMDGPUISD {
336 
337 enum NodeType : unsigned {
338  // AMDIL ISD Opcodes
340  UMUL, // 32bit unsigned multiplication
342  // End AMDIL ISD Opcodes
343 
344  // Function call.
348 
349  // Masked control flow nodes.
350  IF,
353 
354  // A uniform kernel return that terminates the wavefront.
356 
357  // Return to a shader part's epilog code.
359 
360  // Return with values from a non-entry function.
362 
365 
366  /// CLAMP value between 0.0 and 1.0. NaN clamped to 0, following clamp output
367  /// modifier behavior with dx10_enable.
369 
370  // This is SETCC with the full mask result which is used for a compare with a
371  // result bit per item in the wavefront.
374 
376 
377  // FP ops with input and output chain.
380 
381  // SIN_HW, COS_HW - f32 for SI, 1 ULP max error, valid from -100 pi to 100 pi.
382  // Denormals handled on some parts.
387 
402  // For emitting ISD::FMAD when f32 denormals are enabled because mac/mad is
403  // treated as an illegal operation.
405  TRIG_PREOP, // 1 ULP max error for f64
406 
407  // RCP, RSQ - For f32, 1 ULP max error, no denormal handling.
408  // For f64, max error 2^29 ULP, handles denormals.
421  BFE_U32, // Extract range of bits with zero extension to 32-bits.
422  BFE_I32, // Extract range of bits with sign extension to 32-bits.
423  BFI, // (src0 & src1) | (~src0 & src2)
424  BFM, // Insert a range of bits into a 32-bit word.
425  FFBH_U32, // ctlz with -1 if input is zero.
427  FFBL_B32, // cttz with -1 if input is zero.
440  EXPORT, // exp on SI+
441  EXPORT_DONE, // exp on SI+ with done bit set
450 
451  // These cvt_f32_ubyte* nodes need to remain consecutive and in order.
456 
457  // Convert two float 32 numbers into a single register holding two packed f16
458  // with round to zero.
464 
465  // Same as the standard node, except the high bits of the resulting integer
466  // are known 0.
468 
469  // Wrapper around fp16 results that are known to zero the high bits.
471 
472  /// This node is for VLIW targets and it is used to represent a vector
473  /// that is stored in consecutive registers with the same channel.
474  /// For example:
475  /// |X |Y|Z|W|
476  /// T0|v.x| | | |
477  /// T1|v.y| | | |
478  /// T2|v.z| | | |
479  /// T3|v.w| | | |
481  /// Pointer to the start of the shader's constant data.
500 
543 
545 };
546 
547 
548 } // End namespace AMDGPUISD
549 
550 } // End namespace llvm
551 
552 #endif
unsigned ComputeNumSignBitsForTargetNode(SDValue Op, const APInt &DemandedElts, const SelectionDAG &DAG, unsigned Depth=0) const override
This method can be implemented by targets that want to expose additional information about sign bits ...
BITCAST - This operator converts between integer, vector and FP values, as if the value was stored to...
Definition: ISDOpcodes.h:595
SDValue LowerFRINT(SDValue Op, SelectionDAG &DAG) const
SDValue LowerINT_TO_FP64(SDValue Op, SelectionDAG &DAG, bool Signed) const
SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg, const SmallVectorImpl< ISD::OutputArg > &Outs, const SmallVectorImpl< SDValue > &OutVals, const SDLoc &DL, SelectionDAG &DAG) const override
This hook must be implemented to lower outgoing return values, described by the Outs array...
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:913
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
SDValue performStoreCombine(SDNode *N, DAGCombinerInfo &DCI) const
SDValue LowerFREM(SDValue Op, SelectionDAG &DAG) const
Split a vector store into multiple scalar stores.
SDValue performCtlz_CttzCombine(const SDLoc &SL, SDValue Cond, SDValue LHS, SDValue RHS, DAGCombinerInfo &DCI) const
bool hasNoSignedZeros() const
bool shouldCombineMemoryType(EVT VT) const
LLVMContext & Context
SDValue CreateLiveInRegister(SelectionDAG &DAG, const TargetRegisterClass *RC, unsigned Reg, EVT VT, const SDLoc &SL, bool RawReg=false) const
Helper function that adds Reg to the LiveIn list of the DAG&#39;s MachineFunction.
SDValue performFAbsCombine(SDNode *N, DAGCombinerInfo &DCI) const
SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override
This method will be invoked for all target nodes and for any target-independent nodes that the target...
SDValue getHiHalf64(SDValue Op, SelectionDAG &DAG) const
static bool hasDefinedInitializer(const GlobalValue *GV)
SDValue LowerFLOG(SDValue Op, SelectionDAG &DAG, double Log2BaseInverted) const
bool shouldReduceLoadWidth(SDNode *Load, ISD::LoadExtType ExtType, EVT ExtVT) const override
Return true if it is profitable to reduce a load to a smaller type.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void analyzeFormalArgumentsCompute(CCState &State, const SmallVectorImpl< ISD::InputArg > &Ins) const
The SelectionDAGBuilder will automatically promote function arguments with illegal types...
SDValue LowerFFLOOR(SDValue Op, SelectionDAG &DAG) const
SDValue performMulhsCombine(SDNode *N, DAGCombinerInfo &DCI) const
SDValue LowerFP_TO_FP16(SDValue Op, SelectionDAG &DAG) const
SDValue loadInputValue(SelectionDAG &DAG, const TargetRegisterClass *RC, EVT VT, const SDLoc &SL, const ArgDescriptor &Arg) const
unsigned Reg
bool CCAssignFn(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
CCAssignFn - This function assigns a location for Val, updating State to reflect the change...
Function Alias Analysis Results
virtual SDNode * PostISelFolding(MachineSDNode *N, SelectionDAG &DAG) const =0
SDValue performAssertSZExtCombine(SDNode *N, DAGCombinerInfo &DCI) const
const SDNodeFlags getFlags() const
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:693
SDNode * getNode() const
get the SDNode which holds the desired result
SDValue LowerCall(CallLoweringInfo &CLI, SmallVectorImpl< SDValue > &InVals) const override
This hook must be implemented to lower calls into the specified DAG.
void computeKnownBitsForTargetNode(const SDValue Op, KnownBits &Known, const APInt &DemandedElts, const SelectionDAG &DAG, unsigned Depth=0) const override
Determine which of the bits specified in Mask are known to be either zero or one and return them in t...
AtomicExpansionKind
Enum that specifies what an atomic load/AtomicRMWInst is expanded to, if at all.
CLAMP value between 0.0 and 1.0.
SDValue LowerSIGN_EXTEND_INREG(SDValue Op, SelectionDAG &DAG) const
SDValue performSrlCombine(SDNode *N, DAGCombinerInfo &DCI) const
std::pair< EVT, EVT > getSplitDestVTs(const EVT &VT, SelectionDAG &DAG) const
Split a vector type into two parts.
bool mayIgnoreSignedZero(SDValue Op) const
bool storeOfVectorConstantIsCheap(EVT MemVT, unsigned NumElem, unsigned AS) const override
Return true if it is expected to be cheaper to do a store of a non-zero vector constant with the give...
bool isCheapToSpeculateCttz() const override
Return true if it is cheap to speculate a call to intrinsic cttz.
std::pair< SDValue, SDValue > splitVector(const SDValue &N, const SDLoc &DL, const EVT &LoVT, const EVT &HighVT, SelectionDAG &DAG) const
Split a vector value into two parts of types LoVT and HiVT.
SDValue performLoadCombine(SDNode *N, DAGCombinerInfo &DCI) const
static unsigned numBitsUnsigned(SDValue Op, SelectionDAG &DAG)
SDValue performTruncateCombine(SDNode *N, DAGCombinerInfo &DCI) const
A description of a memory reference used in the backend.
Pointer to the start of the shader&#39;s constant data.
SDValue performMulhuCombine(SDNode *N, DAGCombinerInfo &DCI) const
bool isFsqrtCheap(SDValue Operand, SelectionDAG &DAG) const override
Return true if SQRT(X) shouldn&#39;t be replaced with X*RSQRT(X).
bool isKnownNeverNaNForTargetNode(SDValue Op, const SelectionDAG &DAG, bool SNaN=false, unsigned Depth=0) const override
If SNaN is false,.
SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
SDValue getRecipEstimate(SDValue Operand, SelectionDAG &DAG, int Enabled, int &RefinementSteps) const override
Return a reciprocal estimate value for the input operand.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
SDValue getEntryNode() const
Return the token chain corresponding to the entry of the function.
Definition: SelectionDAG.h:473
SDValue LowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG) const
SDValue loadStackInputValue(SelectionDAG &DAG, EVT VT, const SDLoc &SL, int64_t Offset) const
Similar to CreateLiveInRegister, except value maybe loaded from a stack slot rather than passed in a ...
SDValue LowerFROUND64(SDValue Op, SelectionDAG &DAG) const
SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override
This callback is invoked for operations that are unsupported by the target, which are registered to u...
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
void ReplaceNodeResults(SDNode *N, SmallVectorImpl< SDValue > &Results, SelectionDAG &DAG) const override
This callback is invoked when a node result type is illegal for the target, and the operation was reg...
SDValue SplitVectorLoad(SDValue Op, SelectionDAG &DAG) const
Split a vector load into 2 loads of half the vector.
bool isCheapToSpeculateCtlz() const override
Return true if it is cheap to speculate a call to intrinsic ctlz.
uint32_t getImplicitParameterOffset(const MachineFunction &MF, const ImplicitParameter Param) const
Helper function that returns the byte offset of the given type of implicit parameter.
std::pair< SDValue, SDValue > split64BitValue(SDValue Op, SelectionDAG &DAG) const
Return 64-bit value Op as two 32-bit integers.
SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const
SDValue performFNegCombine(SDNode *N, DAGCombinerInfo &DCI) const
This node is for VLIW targets and it is used to represent a vector that is stored in consecutive regi...
MVT getFenceOperandTy(const DataLayout &DL) const override
Return the type for operands of fence.
SDValue LowerINT_TO_FP32(SDValue Op, SelectionDAG &DAG, bool Signed) const
bool isSDNodeAlwaysUniform(const SDNode *N) const override
SDValue LowerFP_TO_UINT(SDValue Op, SelectionDAG &DAG) const
SDValue LowerFROUND32_16(SDValue Op, SelectionDAG &DAG) const
SDValue performRcpCombine(SDNode *N, DAGCombinerInfo &DCI) const
Machine Value Type.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
SDValue performMulCombine(SDNode *N, DAGCombinerInfo &DCI) const
SDValue storeStackInputValue(SelectionDAG &DAG, const SDLoc &SL, SDValue Chain, SDValue ArgVal, int64_t Offset) const
SDValue LowerSDIVREM(SDValue Op, SelectionDAG &DAG) const
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:987
virtual SDValue LowerGlobalAddress(AMDGPUMachineFunction *MFI, SDValue Op, SelectionDAG &DAG) const
SDValue LowerUDIVREM(SDValue Op, SelectionDAG &DAG) const
const char * getTargetNodeName(unsigned Opcode) const override
This method returns the name of a target specific DAG node.
SDValue lowerFEXP(SDValue Op, SelectionDAG &DAG) const
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
SDValue LowerSTORE(SDValue Op, SelectionDAG &DAG) const
Extended Value Type.
Definition: ValueTypes.h:33
SDValue CreateLiveInRegister(SelectionDAG &DAG, const TargetRegisterClass *RC, unsigned Reg, EVT VT) const
bool isConstantCostlierToNegate(SDValue N) const
This structure contains all information that is necessary for lowering calls.
const TargetMachine & getTargetMachine() const
static CCAssignFn * CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg)
Selects the correct CCAssignFn for a given CallingConvention value.
SDValue addTokenForArgument(SDValue Chain, SelectionDAG &DAG, MachineFrameInfo &MFI, int ClobberedFI) const
SDValue CreateLiveInRegisterRaw(SelectionDAG &DAG, const TargetRegisterClass *RC, unsigned Reg, EVT VT) const
SDValue LowerDIVREM24(SDValue Op, SelectionDAG &DAG, bool sign) const
bool isFPImmLegal(const APFloat &Imm, EVT VT, bool ForCodeSize) const override
Returns true if the target can instruction select the specified FP immediate natively.
CCState - This class holds information needed while lowering arguments and return values...
SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) const
bool isFAbsFree(EVT VT) const override
Return true if an fabs operation is free to the point where it is never worthwhile to replace it with...
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:221
SDValue lowerUnhandledCall(CallLoweringInfo &CLI, SmallVectorImpl< SDValue > &InVals, StringRef Reason) const
SDValue LowerFTRUNC(SDValue Op, SelectionDAG &DAG) const
SDValue WidenVectorLoad(SDValue Op, SelectionDAG &DAG) const
Widen a vector load from vec3 to vec4.
An SDNode that represents everything that will be needed to construct a MachineInstr.
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
static const int FIRST_TARGET_MEMORY_OPCODE
FIRST_TARGET_MEMORY_OPCODE - Target-specific pre-isel operations which do not reference a specific me...
Definition: ISDOpcodes.h:920
Represents one node in the SelectionDAG.
SDValue combineFMinMaxLegacy(const SDLoc &DL, EVT VT, SDValue LHS, SDValue RHS, SDValue True, SDValue False, SDValue CC, DAGCombinerInfo &DCI) const
Generate Min/Max node.
static bool allUsesHaveSourceMods(const SDNode *N, unsigned CostThreshold=4)
SDValue performShlCombine(SDNode *N, DAGCombinerInfo &DCI) const
Class for arbitrary precision integers.
Definition: APInt.h:69
bool SelectFlatOffset(bool IsSigned, SelectionDAG &DAG, SDNode *N, SDValue Addr, SDValue &VAddr, SDValue &Offset, SDValue &SLC) const
bool mergeStoresAfterLegalization(EVT) const override
Allow store merging for the specified type after legalization in addition to before legalization...
static unsigned numBitsSigned(SDValue Op, SelectionDAG &DAG)
SDValue performIntrinsicWOChainCombine(SDNode *N, DAGCombinerInfo &DCI) const
static SDValue stripBitcast(SDValue Val)
static CCAssignFn * CCAssignFnForReturn(CallingConv::ID CC, bool IsVarArg)
SDValue LowerFNEARBYINT(SDValue Op, SelectionDAG &DAG) const
SDValue LowerFCEIL(SDValue Op, SelectionDAG &DAG) const
void LowerUDIVREM64(SDValue Op, SelectionDAG &DAG, SmallVectorImpl< SDValue > &Results) const
bool isNarrowingProfitable(EVT VT1, EVT VT2) const override
Return true if it&#39;s profitable to narrow operations of type VT1 to VT2.
SelectSupportKind
Enum that describes what type of support for selects the target has.
SDValue getLoHalf64(SDValue Op, SelectionDAG &DAG) const
SDValue LowerCTLZ_CTTZ(SDValue Op, SelectionDAG &DAG) const
SDValue performMulLoHi24Combine(SDNode *N, DAGCombinerInfo &DCI) const
SDValue splitBinaryBitConstantOpImpl(DAGCombinerInfo &DCI, const SDLoc &SL, unsigned Opc, SDValue LHS, uint32_t ValLo, uint32_t ValHi) const
Split the 64-bit value LHS into two 32-bit components, and perform the binary operation Opc to it wit...
#define N
bool isTruncateFree(EVT Src, EVT Dest) const override
AMDGPUTargetLowering(const TargetMachine &TM, const AMDGPUSubtarget &STI)
SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) const
unsigned getOpcode() const
bool isFNegFree(EVT VT) const override
Return true if an fneg operation is free to the point where it is never worthwhile to replace it with...
SDValue performSraCombine(SDNode *N, DAGCombinerInfo &DCI) const
#define AMDGPUSubtarget
SDValue LowerFP64_TO_INT(SDValue Op, SelectionDAG &DAG, bool Signed) const
static EVT getEquivalentMemType(LLVMContext &Context, EVT VT)
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:65
bool isZExtFree(Type *Src, Type *Dest) const override
Return true if any actual instruction that defines a value of type FromTy implicitly zero-extends the...
bool isLoadBitCastBeneficial(EVT, EVT, const SelectionDAG &DAG, const MachineMemOperand &MMO) const final
Return true if the following transform is beneficial: fold (conv (load x)) -> (load (conv*)x) On arch...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
SDValue SplitVectorStore(SDValue Op, SelectionDAG &DAG) const
Split a vector store into 2 stores of half the vector.
const SDValue & getOperand(unsigned i) const
bool aggressivelyPreferBuildVectorSources(EVT VecVT) const override
SDValue LowerFROUND(SDValue Op, SelectionDAG &DAG) const
AtomicExpansionKind shouldExpandAtomicRMWInIR(AtomicRMWInst *) const override
Returns how the IR-level AtomicExpand pass should expand the given AtomicRMW, if at all...
bool ShouldShrinkFPConstant(EVT VT) const override
If true, then instruction selection should seek to shrink the FP constant of the specified type to a ...
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
MVT getVectorIdxTy(const DataLayout &) const override
Returns the type to be used for the index operand of: ISD::INSERT_VECTOR_ELT, ISD::EXTRACT_VECTOR_ELT...
SDValue getSqrtEstimate(SDValue Operand, SelectionDAG &DAG, int Enabled, int &RefinementSteps, bool &UseOneConstNR, bool Reciprocal) const override
Hooks for building estimates in place of slower divisions and square roots.
This file describes how to lower LLVM code to machine code.
SDValue performSelectCombine(SDNode *N, DAGCombinerInfo &DCI) const
SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const
bool isSelectSupported(SelectSupportKind) const override