LLVM  10.0.0svn
HexagonISelLowering.h
Go to the documentation of this file.
1 //===-- HexagonISelLowering.h - Hexagon DAG 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 // This file defines the interfaces that Hexagon uses to lower LLVM code into a
10 // selection DAG.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_TARGET_HEXAGON_HEXAGONISELLOWERING_H
15 #define LLVM_LIB_TARGET_HEXAGON_HEXAGONISELLOWERING_H
16 
17 #include "Hexagon.h"
18 #include "llvm/ADT/StringRef.h"
23 #include "llvm/IR/CallingConv.h"
24 #include "llvm/IR/InlineAsm.h"
26 #include <cstdint>
27 #include <utility>
28 
29 namespace llvm {
30 
31 namespace HexagonISD {
32 
33  enum NodeType : unsigned {
35 
37  CONST32_GP, // For marking data present in GP.
38  ADDC, // Add with carry: (X, Y, Cin) -> (X+Y, Cout).
39  SUBC, // Sub with carry: (X, Y, Cin) -> (X+~Y+Cin, Cout).
41 
42  AT_GOT, // Index in GOT.
43  AT_PCREL, // Offset relative to PC.
44 
45  CALL, // Function call.
46  CALLnr, // Function call that does not return.
48 
49  RET_FLAG, // Return with a flag operand.
50  BARRIER, // Memory barrier.
51  JT, // Jump table.
52  CP, // Constant pool.
53 
55  VSPLAT, // Generic splat, selection depends on argument/return
56  // types.
60 
73  D2P, // Convert 8-byte value to 8-bit predicate register. [*]
74  P2D, // Convert 8-bit predicate register to 8-byte value. [*]
75  V2Q, // Convert HVX vector to a vector predicate reg. [*]
76  Q2V, // Convert vector predicate to an HVX vector. [*]
77  // [*] The equivalence is defined as "Q <=> (V != 0)",
78  // where the != operation compares bytes.
79  // Note: V != 0 is implemented as V >u 0.
84  VSPLATW, // HVX splat of a 32-bit word with an arbitrary result type.
85  TYPECAST, // No-op that's used to convert between different legal
86  // types in a register.
87  VALIGN, // Align two vectors (in Op0, Op1) to one that would have
88  // been loaded from address in Op2.
89  VALIGNADDR, // Align vector address: Op0 & -Op1, except when it is
90  // an address in a vector load, then it's a no-op.
92  };
93 
94 } // end namespace HexagonISD
95 
96  class HexagonSubtarget;
97 
99  int VarArgsFrameOffset; // Frame offset to start of varargs area.
100  const HexagonTargetMachine &HTM;
101  const HexagonSubtarget &Subtarget;
102 
103  bool CanReturnSmallStruct(const Function* CalleeFn, unsigned& RetSize)
104  const;
105 
106  public:
107  explicit HexagonTargetLowering(const TargetMachine &TM,
108  const HexagonSubtarget &ST);
109 
110  bool isHVXVectorType(MVT Ty) const;
111 
112  /// IsEligibleForTailCallOptimization - Check whether the call is eligible
113  /// for tail call optimization. Targets which want to do tail call
114  /// optimization should implement this function.
115  bool IsEligibleForTailCallOptimization(SDValue Callee,
116  CallingConv::ID CalleeCC, bool isVarArg, bool isCalleeStructRet,
117  bool isCallerStructRet, const SmallVectorImpl<ISD::OutputArg> &Outs,
118  const SmallVectorImpl<SDValue> &OutVals,
119  const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG& DAG) const;
120 
121  bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
122  MachineFunction &MF,
123  unsigned Intrinsic) const override;
124 
125  bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
126  bool isTruncateFree(EVT VT1, EVT VT2) const override;
127 
128  bool isCheapToSpeculateCttz() const override { return true; }
129  bool isCheapToSpeculateCtlz() const override { return true; }
130  bool isCtlzFast() const override { return true; }
131 
132  bool hasBitTest(SDValue X, SDValue Y) const override;
133 
134  bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
135 
136  /// Return true if an FMA operation is faster than a pair of mul and add
137  /// instructions. fmuladd intrinsics will be expanded to FMAs when this
138  /// method returns true (and FMAs are legal), otherwise fmuladd is
139  /// expanded to mul + add.
140  bool isFMAFasterThanFMulAndFAdd(EVT) const override;
141 
142  // Should we expand the build vector with shuffles?
143  bool shouldExpandBuildVectorWithShuffles(EVT VT,
144  unsigned DefinedValues) const override;
145 
146  bool isShuffleMaskLegal(ArrayRef<int> Mask, EVT VT) const override;
147  TargetLoweringBase::LegalizeTypeAction getPreferredVectorAction(MVT VT)
148  const override;
149 
150  SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
151  void LowerOperationWrapper(SDNode *N, SmallVectorImpl<SDValue> &Results,
152  SelectionDAG &DAG) const override;
153  void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
154  SelectionDAG &DAG) const override;
155 
156  const char *getTargetNodeName(unsigned Opcode) const override;
157 
158  SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
162  SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
165  SDValue LowerVECTOR_SHIFT(SDValue Op, SelectionDAG &DAG) const;
166  SDValue LowerROTL(SDValue Op, SelectionDAG &DAG) const;
167  SDValue LowerBITCAST(SDValue Op, SelectionDAG &DAG) const;
171  SDValue LowerLoad(SDValue Op, SelectionDAG &DAG) const;
172  SDValue LowerStore(SDValue Op, SelectionDAG &DAG) const;
173  SDValue LowerUnalignedLoad(SDValue Op, SelectionDAG &DAG) const;
174  SDValue LowerUAddSubO(SDValue Op, SelectionDAG &DAG) const;
175  SDValue LowerAddSubCarry(SDValue Op, SelectionDAG &DAG) const;
176 
178  SDValue LowerINLINEASM(SDValue Op, SelectionDAG &DAG) const;
179  SDValue LowerPREFETCH(SDValue Op, SelectionDAG &DAG) const;
181  SDValue LowerEH_LABEL(SDValue Op, SelectionDAG &DAG) const;
182  SDValue LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const;
183  SDValue
184  LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
186  const SDLoc &dl, SelectionDAG &DAG,
187  SmallVectorImpl<SDValue> &InVals) const override;
188  SDValue LowerGLOBALADDRESS(SDValue Op, SelectionDAG &DAG) const;
189  SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
190  SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
191  SDValue LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
192  SelectionDAG &DAG) const;
193  SDValue LowerToTLSInitialExecModel(GlobalAddressSDNode *GA,
194  SelectionDAG &DAG) const;
195  SDValue LowerToTLSLocalExecModel(GlobalAddressSDNode *GA,
196  SelectionDAG &DAG) const;
197  SDValue GetDynamicTLSAddr(SelectionDAG &DAG, SDValue Chain,
198  GlobalAddressSDNode *GA, SDValue InFlag, EVT PtrVT,
199  unsigned ReturnReg, unsigned char OperandFlags) const;
200  SDValue LowerGLOBAL_OFFSET_TABLE(SDValue Op, SelectionDAG &DAG) const;
201 
203  SmallVectorImpl<SDValue> &InVals) const override;
204  SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
205  CallingConv::ID CallConv, bool isVarArg,
207  const SDLoc &dl, SelectionDAG &DAG,
208  SmallVectorImpl<SDValue> &InVals,
209  const SmallVectorImpl<SDValue> &OutVals,
210  SDValue Callee) const;
211 
212  SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
213  SDValue LowerVSELECT(SDValue Op, SelectionDAG &DAG) const;
214  SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
217 
218  bool CanLowerReturn(CallingConv::ID CallConv,
219  MachineFunction &MF, bool isVarArg,
221  LLVMContext &Context) const override;
222 
223  SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
225  const SmallVectorImpl<SDValue> &OutVals,
226  const SDLoc &dl, SelectionDAG &DAG) const override;
227 
228  SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
229 
230  bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
231 
232  unsigned getRegisterByName(const char* RegName, EVT VT,
233  SelectionDAG &DAG) const override;
234 
235  /// If a physical register, this returns the register that receives the
236  /// exception address on entry to an EH pad.
237  unsigned
238  getExceptionPointerRegister(const Constant *PersonalityFn) const override {
239  return Hexagon::R0;
240  }
241 
242  /// If a physical register, this returns the register that receives the
243  /// exception typeid on entry to a landing pad.
244  unsigned
245  getExceptionSelectorRegister(const Constant *PersonalityFn) const override {
246  return Hexagon::R1;
247  }
248 
249  SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
250  SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
251  SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
252 
254  EVT VT) const override {
255  if (!VT.isVector())
256  return MVT::i1;
257  else
259  }
260 
261  bool getPostIndexedAddressParts(SDNode *N, SDNode *Op,
264  SelectionDAG &DAG) const override;
265 
266  ConstraintType getConstraintType(StringRef Constraint) const override;
267 
268  std::pair<unsigned, const TargetRegisterClass *>
269  getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
270  StringRef Constraint, MVT VT) const override;
271 
272  unsigned
273  getInlineAsmMemConstraint(StringRef ConstraintCode) const override {
274  if (ConstraintCode == "o")
276  return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
277  }
278 
279  // Intrinsics
280  SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
281  SDValue LowerINTRINSIC_VOID(SDValue Op, SelectionDAG &DAG) const;
282  /// isLegalAddressingMode - Return true if the addressing mode represented
283  /// by AM is legal for this target, for a load/store of the specified type.
284  /// The type may be VoidTy, in which case only return true if the addressing
285  /// mode is legal for a load/store of any legal type.
286  /// TODO: Handle pre/postinc as well.
287  bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM,
288  Type *Ty, unsigned AS,
289  Instruction *I = nullptr) const override;
290  /// Return true if folding a constant offset with the given GlobalAddress
291  /// is legal. It is frequently not legal in PIC relocation models.
292  bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
293 
294  bool isFPImmLegal(const APFloat &Imm, EVT VT,
295  bool ForCodeSize) const override;
296 
297  /// isLegalICmpImmediate - Return true if the specified immediate is legal
298  /// icmp immediate, that is the target has icmp instructions which can
299  /// compare a register against the immediate without having to materialize
300  /// the immediate into a register.
301  bool isLegalICmpImmediate(int64_t Imm) const override;
302 
303  EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign,
304  unsigned SrcAlign, bool IsMemset, bool ZeroMemset, bool MemcpyStrSrc,
305  const AttributeList &FuncAttributes) const override;
306 
307  bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace,
308  unsigned Align, MachineMemOperand::Flags Flags, bool *Fast)
309  const override;
310 
311  /// Returns relocation base for the given PIC jumptable.
312  SDValue getPICJumpTableRelocBase(SDValue Table, SelectionDAG &DAG)
313  const override;
314 
315  bool shouldReduceLoadWidth(SDNode *Load, ISD::LoadExtType ExtTy,
316  EVT NewVT) const override;
317 
318  // Handling of atomic RMW instructions.
319  Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
320  AtomicOrdering Ord) const override;
321  Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
322  Value *Addr, AtomicOrdering Ord) const override;
323  AtomicExpansionKind shouldExpandAtomicLoadInIR(LoadInst *LI) const override;
324  bool shouldExpandAtomicStoreInIR(StoreInst *SI) const override;
326  shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const override;
327 
330  return AtomicExpansionKind::LLSC;
331  }
332 
333  private:
334  void initializeHVXLowering();
335  void validateConstPtrAlignment(SDValue Ptr, const SDLoc &dl,
336  unsigned NeedAlign) const;
337 
338  std::pair<SDValue,int> getBaseAndOffset(SDValue Addr) const;
339 
340  bool getBuildVectorConstInts(ArrayRef<SDValue> Values, MVT VecTy,
341  SelectionDAG &DAG,
342  MutableArrayRef<ConstantInt*> Consts) const;
343  SDValue buildVector32(ArrayRef<SDValue> Elem, const SDLoc &dl, MVT VecTy,
344  SelectionDAG &DAG) const;
345  SDValue buildVector64(ArrayRef<SDValue> Elem, const SDLoc &dl, MVT VecTy,
346  SelectionDAG &DAG) const;
347  SDValue extractVector(SDValue VecV, SDValue IdxV, const SDLoc &dl,
348  MVT ValTy, MVT ResTy, SelectionDAG &DAG) const;
349  SDValue insertVector(SDValue VecV, SDValue ValV, SDValue IdxV,
350  const SDLoc &dl, MVT ValTy, SelectionDAG &DAG) const;
351  SDValue expandPredicate(SDValue Vec32, const SDLoc &dl,
352  SelectionDAG &DAG) const;
353  SDValue contractPredicate(SDValue Vec64, const SDLoc &dl,
354  SelectionDAG &DAG) const;
355  SDValue getVectorShiftByInt(SDValue Op, SelectionDAG &DAG) const;
356 
357  bool isUndef(SDValue Op) const {
358  if (Op.isMachineOpcode())
359  return Op.getMachineOpcode() == TargetOpcode::IMPLICIT_DEF;
360  return Op.getOpcode() == ISD::UNDEF;
361  }
362  SDValue getInstr(unsigned MachineOpc, const SDLoc &dl, MVT Ty,
363  ArrayRef<SDValue> Ops, SelectionDAG &DAG) const {
364  SDNode *N = DAG.getMachineNode(MachineOpc, dl, Ty, Ops);
365  return SDValue(N, 0);
366  }
367  SDValue getZero(const SDLoc &dl, MVT Ty, SelectionDAG &DAG) const;
368 
369  using VectorPair = std::pair<SDValue, SDValue>;
370  using TypePair = std::pair<MVT, MVT>;
371 
372  SDValue getInt(unsigned IntId, MVT ResTy, ArrayRef<SDValue> Ops,
373  const SDLoc &dl, SelectionDAG &DAG) const;
374 
375  MVT ty(SDValue Op) const {
376  return Op.getValueType().getSimpleVT();
377  }
378  TypePair ty(const VectorPair &Ops) const {
379  return { Ops.first.getValueType().getSimpleVT(),
380  Ops.second.getValueType().getSimpleVT() };
381  }
382  MVT tyScalar(MVT Ty) const {
383  if (!Ty.isVector())
384  return Ty;
385  return MVT::getIntegerVT(Ty.getSizeInBits());
386  }
387  MVT tyVector(MVT Ty, MVT ElemTy) const {
388  if (Ty.isVector() && Ty.getVectorElementType() == ElemTy)
389  return Ty;
390  unsigned TyWidth = Ty.getSizeInBits();
391  unsigned ElemWidth = ElemTy.getSizeInBits();
392  assert((TyWidth % ElemWidth) == 0);
393  return MVT::getVectorVT(ElemTy, TyWidth/ElemWidth);
394  }
395 
396  MVT typeJoin(const TypePair &Tys) const;
397  TypePair typeSplit(MVT Ty) const;
398  MVT typeExtElem(MVT VecTy, unsigned Factor) const;
399  MVT typeTruncElem(MVT VecTy, unsigned Factor) const;
400 
401  SDValue opJoin(const VectorPair &Ops, const SDLoc &dl,
402  SelectionDAG &DAG) const;
403  VectorPair opSplit(SDValue Vec, const SDLoc &dl, SelectionDAG &DAG) const;
404  SDValue opCastElem(SDValue Vec, MVT ElemTy, SelectionDAG &DAG) const;
405 
406  bool isHvxSingleTy(MVT Ty) const;
407  bool isHvxPairTy(MVT Ty) const;
408  SDValue convertToByteIndex(SDValue ElemIdx, MVT ElemTy,
409  SelectionDAG &DAG) const;
410  SDValue getIndexInWord32(SDValue Idx, MVT ElemTy, SelectionDAG &DAG) const;
411  SDValue getByteShuffle(const SDLoc &dl, SDValue Op0, SDValue Op1,
412  ArrayRef<int> Mask, SelectionDAG &DAG) const;
413 
414  SDValue buildHvxVectorReg(ArrayRef<SDValue> Values, const SDLoc &dl,
415  MVT VecTy, SelectionDAG &DAG) const;
416  SDValue buildHvxVectorPred(ArrayRef<SDValue> Values, const SDLoc &dl,
417  MVT VecTy, SelectionDAG &DAG) const;
418  SDValue createHvxPrefixPred(SDValue PredV, const SDLoc &dl,
419  unsigned BitBytes, bool ZeroFill,
420  SelectionDAG &DAG) const;
421  SDValue extractHvxElementReg(SDValue VecV, SDValue IdxV, const SDLoc &dl,
422  MVT ResTy, SelectionDAG &DAG) const;
423  SDValue extractHvxElementPred(SDValue VecV, SDValue IdxV, const SDLoc &dl,
424  MVT ResTy, SelectionDAG &DAG) const;
425  SDValue insertHvxElementReg(SDValue VecV, SDValue IdxV, SDValue ValV,
426  const SDLoc &dl, SelectionDAG &DAG) const;
427  SDValue insertHvxElementPred(SDValue VecV, SDValue IdxV, SDValue ValV,
428  const SDLoc &dl, SelectionDAG &DAG) const;
429  SDValue extractHvxSubvectorReg(SDValue VecV, SDValue IdxV, const SDLoc &dl,
430  MVT ResTy, SelectionDAG &DAG) const;
431  SDValue extractHvxSubvectorPred(SDValue VecV, SDValue IdxV, const SDLoc &dl,
432  MVT ResTy, SelectionDAG &DAG) const;
433  SDValue insertHvxSubvectorReg(SDValue VecV, SDValue SubV, SDValue IdxV,
434  const SDLoc &dl, SelectionDAG &DAG) const;
435  SDValue insertHvxSubvectorPred(SDValue VecV, SDValue SubV, SDValue IdxV,
436  const SDLoc &dl, SelectionDAG &DAG) const;
437  SDValue extendHvxVectorPred(SDValue VecV, const SDLoc &dl, MVT ResTy,
438  bool ZeroExt, SelectionDAG &DAG) const;
439 
440  SDValue LowerHvxBuildVector(SDValue Op, SelectionDAG &DAG) const;
441  SDValue LowerHvxConcatVectors(SDValue Op, SelectionDAG &DAG) const;
442  SDValue LowerHvxExtractElement(SDValue Op, SelectionDAG &DAG) const;
443  SDValue LowerHvxInsertElement(SDValue Op, SelectionDAG &DAG) const;
444  SDValue LowerHvxExtractSubvector(SDValue Op, SelectionDAG &DAG) const;
445  SDValue LowerHvxInsertSubvector(SDValue Op, SelectionDAG &DAG) const;
446 
447  SDValue LowerHvxAnyExt(SDValue Op, SelectionDAG &DAG) const;
448  SDValue LowerHvxSignExt(SDValue Op, SelectionDAG &DAG) const;
449  SDValue LowerHvxZeroExt(SDValue Op, SelectionDAG &DAG) const;
450  SDValue LowerHvxCttz(SDValue Op, SelectionDAG &DAG) const;
451  SDValue LowerHvxMul(SDValue Op, SelectionDAG &DAG) const;
452  SDValue LowerHvxMulh(SDValue Op, SelectionDAG &DAG) const;
453  SDValue LowerHvxSetCC(SDValue Op, SelectionDAG &DAG) const;
454  SDValue LowerHvxExtend(SDValue Op, SelectionDAG &DAG) const;
455  SDValue LowerHvxShift(SDValue Op, SelectionDAG &DAG) const;
456 
457  SDValue SplitHvxPairOp(SDValue Op, SelectionDAG &DAG) const;
458  SDValue SplitHvxMemOp(SDValue Op, SelectionDAG &DAG) const;
459 
460  std::pair<const TargetRegisterClass*, uint8_t>
461  findRepresentativeClass(const TargetRegisterInfo *TRI, MVT VT)
462  const override;
463 
464  bool isHvxOperation(SDValue Op) const;
465  SDValue LowerHvxOperation(SDValue Op, SelectionDAG &DAG) const;
466 
467  SDValue PerformHvxDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const;
468  };
469 
470 } // end namespace llvm
471 
472 #endif // LLVM_LIB_TARGET_HEXAGON_HEXAGONISELLOWERING_H
uint64_t CallInst * C
static MVT getIntegerVT(unsigned BitWidth)
static SDValue LowerCallResult(SDValue Chain, SDValue InFlag, const SmallVectorImpl< CCValAssign > &RVLocs, const SDLoc &dl, SelectionDAG &DAG, SmallVectorImpl< SDValue > &InVals)
LowerCallResult - Lower the result values of a call into the appropriate copies out of appropriate ph...
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
static SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG, const ARMSubtarget *ST)
EVT getValueType() const
Return the ValueType of the referenced return value.
This represents an addressing mode of: BaseGV + BaseOffs + BaseReg + Scale*ScaleReg If BaseGV is null...
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
LLVMContext & Context
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static SDValue LowerREADCYCLECOUNTER(SDValue Op, const X86Subtarget &Subtarget, SelectionDAG &DAG)
static SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG, const ARMSubtarget *Subtarget)
static MVT getVectorVT(MVT VT, unsigned NumElements)
An instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:530
bool isVector() const
Return true if this is a vector value type.
unsigned getExceptionSelectorRegister(const Constant *PersonalityFn) const override
If a physical register, this returns the register that receives the exception typeid on entry to a la...
static SDValue LowerSIGN_EXTEND(SDValue Op, const X86Subtarget &Subtarget, SelectionDAG &DAG)
static SDValue LowerINSERT_SUBVECTOR(SDValue Op, const X86Subtarget &Subtarget, SelectionDAG &DAG)
static SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG, const ARMSubtarget *ST)
This class represents a function call, abstracting a target machine&#39;s calling convention.
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:252
Function Alias Analysis Results
static SDValue LowerPREFETCH(SDValue Op, SelectionDAG &DAG)
unsigned const TargetRegisterInfo * TRI
bool isCheapToSpeculateCttz() const override
Return true if it is cheap to speculate a call to intrinsic cttz.
An instruction for reading from memory.
Definition: Instructions.h:167
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:693
AtomicExpansionKind
Enum that specifies what an atomic load/AtomicRMWInst is expanded to, if at all.
AtomicExpansionKind shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override
Returns how the IR-level AtomicExpand pass should expand the given AtomicRMW, if at all...
unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const override
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
static SDValue LowerLoad(SDValue Op, const X86Subtarget &Subtarget, SelectionDAG &DAG)
static unsigned getInt(StringRef R)
Get an unsigned integer, including error checks.
Definition: DataLayout.cpp:214
MachineSDNode * getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT)
These are used for target selectors to create a new node with specified return type(s), MachineInstr opcode, and operands.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:779
bool isCtlzFast() const override
Return true if ctlz instruction is fast.
static SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG, const SparcTargetLowering &TLI, const SparcSubtarget *Subtarget)
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
unsigned getSizeInBits() const
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
An instruction for storing to memory.
Definition: Instructions.h:320
virtual unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const
MVT getVectorElementType() const
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
UNDEF - An undefined node.
Definition: ISDOpcodes.h:177
bool isCheapToSpeculateCtlz() const override
Return true if it is cheap to speculate a call to intrinsic ctlz.
static SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG, const ARMSubtarget *ST)
static SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG, const ARMSubtarget *ST)
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:290
Machine Value Type.
static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG)
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
bool isMachineOpcode() const
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:272
This is an important base class in LLVM.
Definition: Constant.h:41
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:987
OperandFlags
These are flags set on operands, but should be considered private, all access should go through the M...
Definition: MCInstrDesc.h:40
Fast - This calling convention attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:42
unsigned getMachineOpcode() const
static SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG, const SparcSubtarget *Subtarget)
static SDValue LowerStore(SDValue Op, const X86Subtarget &Subtarget, SelectionDAG &DAG)
static SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG, const SparcSubtarget *Subtarget)
Extended Value Type.
Definition: ValueTypes.h:33
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
This structure contains all information that is necessary for lowering calls.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
unsigned getExceptionPointerRegister(const Constant *PersonalityFn) const override
If a physical register, this returns the register that receives the exception address on entry to an ...
static bool isUndef(ArrayRef< int > Mask)
static SDValue LowerBITCAST(SDValue Op, SelectionDAG &DAG)
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:221
static Value * insertVector(IRBuilderTy &IRB, Value *Old, Value *V, unsigned BeginIndex, const Twine &Name)
Definition: SROA.cpp:2200
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Represents one node in the SelectionDAG.
EVT getSetCCResultType(const DataLayout &, LLVMContext &C, EVT VT) const override
Return the ValueType of the result of SETCC operations.
static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements, bool IsScalable=false)
Returns the EVT that represents a vector NumElements in length, where each element is of type VT...
Definition: ValueTypes.h:72
amdgpu Simplify well known AMD library false FunctionCallee Callee
static SDValue LowerANY_EXTEND(SDValue Op, const X86Subtarget &Subtarget, SelectionDAG &DAG)
Flags
Flags values. These may be or&#39;d together.
bool isVector() const
Return true if this is a vector value type.
Definition: ValueTypes.h:150
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
uint32_t Size
Definition: Profile.cpp:46
static SDValue LowerZERO_EXTEND(SDValue Op, const X86Subtarget &Subtarget, SelectionDAG &DAG)
unsigned getOpcode() const
static Value * extractVector(IRBuilderTy &IRB, Value *V, unsigned BeginIndex, unsigned EndIndex, const Twine &Name)
Definition: SROA.cpp:2174
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LegalizeTypeAction
This enum indicates whether a types are legal for a target, and if not, what action should be used to...
LLVM Value Representation.
Definition: Value.h:73
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:80
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:65
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
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.
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:950