LLVM  4.0.0
NVPTXISelLowering.h
Go to the documentation of this file.
1 //===-- NVPTXISelLowering.h - NVPTX DAG 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 // This file defines the interfaces that NVPTX uses to lower LLVM code into a
11 // selection DAG.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_LIB_TARGET_NVPTX_NVPTXISELLOWERING_H
16 #define LLVM_LIB_TARGET_NVPTX_NVPTXISELLOWERING_H
17 
18 #include "NVPTX.h"
21 
22 namespace llvm {
23 namespace NVPTXISD {
24 enum NodeType : unsigned {
25  // Start the numbering from where ISD NodeType finishes.
60 
63  LDGV2, // LDG.v2
64  LDGV4, // LDG.v4
65  LDUV2, // LDU.v2
66  LDUV4, // LDU.v4
75  StoreParamS32, // to sext and store a <32bit value, not used currently
76  StoreParamU32, // to zext and store a <32bit value, not used currently
80 
81  // Texture intrinsics
250 
251  // Surface intrinsics
263 
275 
287 
299 
311 
323 
335 
347 
359 
371 
383 
395 
407 
419 
431 };
432 }
433 
434 class NVPTXSubtarget;
435 
436 //===--------------------------------------------------------------------===//
437 // TargetLowering Implementation
438 //===--------------------------------------------------------------------===//
440 public:
441  explicit NVPTXTargetLowering(const NVPTXTargetMachine &TM,
442  const NVPTXSubtarget &STI);
443  SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
444 
446 
447  const char *getTargetNodeName(unsigned Opcode) const override;
448 
449  bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
450  unsigned Intrinsic) const override;
451 
452  /// isLegalAddressingMode - Return true if the addressing mode represented
453  /// by AM is legal for this target, for a load/store of the specified type
454  /// Used to guide target specific optimizations, like loop strength
455  /// reduction (LoopStrengthReduce.cpp) and memory optimization for
456  /// address mode (CodeGenPrepare.cpp)
457  bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
458  unsigned AS) const override;
459 
460  bool isTruncateFree(Type *SrcTy, Type *DstTy) const override {
461  // Truncating 64-bit to 32-bit is free in SASS.
462  if (!SrcTy->isIntegerTy() || !DstTy->isIntegerTy())
463  return false;
464  return SrcTy->getPrimitiveSizeInBits() == 64 &&
465  DstTy->getPrimitiveSizeInBits() == 32;
466  }
467 
469  EVT VT) const override {
470  if (VT.isVector())
471  return EVT::getVectorVT(Ctx, MVT::i1, VT.getVectorNumElements());
472  return MVT::i1;
473  }
474 
475  ConstraintType getConstraintType(StringRef Constraint) const override;
476  std::pair<unsigned, const TargetRegisterClass *>
478  StringRef Constraint, MVT VT) const override;
479 
481  bool isVarArg,
483  const SDLoc &dl, SelectionDAG &DAG,
484  SmallVectorImpl<SDValue> &InVals) const override;
485 
486  SDValue LowerCall(CallLoweringInfo &CLI,
487  SmallVectorImpl<SDValue> &InVals) const override;
488 
489  std::string getPrototype(const DataLayout &DL, Type *, const ArgListTy &,
491  unsigned retAlignment,
492  const ImmutableCallSite *CS) const;
493 
494  SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
496  const SmallVectorImpl<SDValue> &OutVals, const SDLoc &dl,
497  SelectionDAG &DAG) const override;
498 
499  void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
500  std::vector<SDValue> &Ops,
501  SelectionDAG &DAG) const override;
502 
504 
505  // PTX always uses 32-bit shift amounts
506  MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
507  return MVT::i32;
508  }
509 
511  getPreferredVectorAction(EVT VT) const override;
512 
513  bool allowFMA(MachineFunction &MF, CodeGenOpt::Level OptLevel) const;
514 
515  bool isFMAFasterThanFMulAndFAdd(EVT) const override { return true; }
516 
517  bool enableAggressiveFMAFusion(EVT VT) const override { return true; }
518 
519 private:
520  const NVPTXSubtarget &STI; // cache the subtarget here
521  SDValue getParamSymbol(SelectionDAG &DAG, int idx, EVT) const;
522 
523  SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
524 
525  SDValue LowerLOAD(SDValue Op, SelectionDAG &DAG) const;
526  SDValue LowerLOADi1(SDValue Op, SelectionDAG &DAG) const;
527 
528  SDValue LowerSTORE(SDValue Op, SelectionDAG &DAG) const;
529  SDValue LowerSTOREi1(SDValue Op, SelectionDAG &DAG) const;
530  SDValue LowerSTOREVector(SDValue Op, SelectionDAG &DAG) const;
531 
532  SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
533  SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
534 
535  SDValue LowerSelect(SDValue Op, SelectionDAG &DAG) const;
536 
537  void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
538  SelectionDAG &DAG) const override;
539  SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
540 
541  unsigned getArgumentAlignment(SDValue Callee, const ImmutableCallSite *CS,
542  Type *Ty, unsigned Idx,
543  const DataLayout &DL) const;
544 };
545 } // namespace llvm
546 
547 #endif
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:762
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
This represents an addressing mode of: BaseGV + BaseOffs + BaseReg + Scale*ScaleReg If BaseGV is null...
bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty, unsigned AS) const override
isLegalAddressingMode - Return true if the addressing mode represented by AM is legal for this target...
bool isFMAFasterThanFMulAndFAdd(EVT) const override
Return true if an FMA operation is faster than a pair of fmul and fadd instructions.
EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Ctx, EVT VT) const override
Return the ValueType of the result of SETCC operations.
This class represents a function call, abstracting a target machine's calling convention.
std::string getPrototype(const DataLayout &DL, Type *, const ArgListTy &, const SmallVectorImpl< ISD::OutputArg > &, unsigned retAlignment, const ImmutableCallSite *CS) const
Function Alias Analysis Results
bool enableAggressiveFMAFusion(EVT VT) const override
Return true if target always beneficiates from combining into FMA for a given value type...
ConstraintType getConstraintType(StringRef Constraint) const override
getConstraintType - Given a constraint letter, return the type of constraint it is for this target...
SDValue LowerCall(CallLoweringInfo &CLI, SmallVectorImpl< SDValue > &InVals) const override
This hook must be implemented to lower calls into the specified DAG.
void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint, std::vector< SDValue > &Ops, SelectionDAG &DAG) const override
Lower the specified operand into the Ops vector.
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...
bool isVector() const
isVector - Return true if this is a vector value type.
Definition: ValueTypes.h:133
SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const
MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override
EVT is not used in-tree, but is used by out-of-tree target.
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
SDValue LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg, const SmallVectorImpl< ISD::InputArg > &Ins, const SDLoc &dl, SelectionDAG &DAG, SmallVectorImpl< SDValue > &InVals) const override
This hook must be implemented to lower the incoming (formal) arguments, described by the Ins array...
bool allowFMA(MachineFunction &MF, CodeGenOpt::Level OptLevel) const
MVT - 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:48
std::pair< unsigned, const TargetRegisterClass * > getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI, StringRef Constraint, MVT VT) const override
Given a physical register constraint (e.g.
const char * getTargetNodeName(unsigned Opcode) const override
This method returns the name of a target specific DAG node.
EVT - Extended Value Type.
Definition: ValueTypes.h:31
std::vector< ArgListEntry > ArgListTy
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements)
getVectorVT - Returns the EVT that represents a vector NumElements in length, where each element is o...
Definition: ValueTypes.h:70
TargetLoweringBase::LegalizeTypeAction getPreferredVectorAction(EVT VT) const override
Return the preferred vector type legalization action.
bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I, unsigned Intrinsic) const override
Given an intrinsic, checks if on the target the intrinsic will need to map to a MemIntrinsicNode (tou...
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:166
NVPTXTargetLowering(const NVPTXTargetMachine &TM, const NVPTXSubtarget &STI)
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:769
Represents one node in the SelectionDAG.
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:195
NVPTXTargetMachine.
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...
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:665
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
LegalizeTypeAction
This enum indicates whether a types are legal for a target, and if not, what action should be used to...
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:108
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
This file describes how to lower LLVM code to machine code.
bool isTruncateFree(Type *SrcTy, Type *DstTy) const override
Return true if it's free to truncate a value of type FromTy to type ToTy.
unsigned getVectorNumElements() const
getVectorNumElements - Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:248
const NVPTXTargetMachine * nvTM