LLVM  16.0.0git
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 "MCTargetDesc/HexagonMCTargetDesc.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/CodeGen/ISDOpcodes.h"
21 #include "llvm/CodeGen/SelectionDAGNodes.h"
22 #include "llvm/CodeGen/TargetLowering.h"
23 #include "llvm/CodeGen/ValueTypes.h"
24 #include "llvm/IR/CallingConv.h"
25 #include "llvm/IR/InlineAsm.h"
26 #include "llvm/Support/MachineValueType.h"
27 #include <cstdint>
28 #include <utility>
29 
30 namespace llvm {
31 
32 namespace HexagonISD {
33 
34 enum NodeType : unsigned {
35  OP_BEGIN = ISD::BUILTIN_OP_END,
36 
37  CONST32 = OP_BEGIN,
38  CONST32_GP, // For marking data present in GP.
39  ADDC, // Add with carry: (X, Y, Cin) -> (X+Y, Cout).
40  SUBC, // Sub with carry: (X, Y, Cin) -> (X+~Y+Cin, Cout).
41  ALLOCA,
42 
43  AT_GOT, // Index in GOT.
44  AT_PCREL, // Offset relative to PC.
45 
46  CALL, // Function call.
47  CALLnr, // Function call that does not return.
48  CALLR,
49 
50  RET_FLAG, // Return with a flag operand.
51  BARRIER, // Memory barrier.
52  JT, // Jump table.
53  CP, // Constant pool.
54 
55  COMBINE,
56  VASL,
57  VASR,
58  VLSR,
59 
60  SSAT, // Signed saturate.
61  USAT, // Unsigned saturate.
62  TSTBIT,
63  INSERT,
64  EXTRACTU,
65  VEXTRACTW,
66  VINSERTW0,
67  VROR,
68  TC_RETURN,
69  EH_RETURN,
70  DCFETCH,
71  READCYCLE,
72  PTRUE,
73  PFALSE,
74  D2P, // Convert 8-byte value to 8-bit predicate register. [*]
75  P2D, // Convert 8-bit predicate register to 8-byte value. [*]
76  V2Q, // Convert HVX vector to a vector predicate reg. [*]
77  Q2V, // Convert vector predicate to an HVX vector. [*]
78  // [*] The equivalence is defined as "Q <=> (V != 0)",
79  // where the != operation compares bytes.
80  // Note: V != 0 is implemented as V >u 0.
81  QCAT,
82  QTRUE,
83  QFALSE,
84 
85  TL_EXTEND, // Wrappers for ISD::*_EXTEND and ISD::TRUNCATE to prevent DAG
86  TL_TRUNCATE, // from auto-folding operations, e.g.
87  // (i32 ext (i16 ext i8)) would be folded to (i32 ext i8).
88  // To simplify the type legalization, we want to keep these
89  // single steps separate during type legalization.
90  // TL_[EXTEND|TRUNCATE] Inp, i128 _, i32 Opc
91  // * Inp is the original input to extend/truncate,
92  // * _ is a dummy operand with an illegal type (can be undef),
93  // * Opc is the original opcode.
94  // The legalization process (in Hexagon lowering code) will
95  // first deal with the "real" types (i.e. Inp and the result),
96  // and once all of them are processed, the wrapper node will
97  // be replaced with the original ISD node. The dummy illegal
98  // operand is there to make sure that the legalization hooks
99  // are called again after everything else is legal, giving
100  // us the opportunity to undo the wrapping.
101 
102  TYPECAST, // No-op that's used to convert between different legal
103  // types in a register.
104  VALIGN, // Align two vectors (in Op0, Op1) to one that would have
105  // been loaded from address in Op2.
106  VALIGNADDR, // Align vector address: Op0 & -Op1, except when it is
107  // an address in a vector load, then it's a no-op.
108  ISEL, // Marker for nodes that were created during ISel, and
109  // which need explicit selection (would have been left
110  // unselected otherwise).
111  OP_END
112 };
113 
114 } // end namespace HexagonISD
115 
116 class HexagonSubtarget;
117 
118 class HexagonTargetLowering : public TargetLowering {
119  int VarArgsFrameOffset; // Frame offset to start of varargs area.
120  const HexagonTargetMachine &HTM;
121  const HexagonSubtarget &Subtarget;
122 
123 public:
124  explicit HexagonTargetLowering(const TargetMachine &TM,
125  const HexagonSubtarget &ST);
126 
127  /// IsEligibleForTailCallOptimization - Check whether the call is eligible
128  /// for tail call optimization. Targets which want to do tail call
129  /// optimization should implement this function.
130  bool IsEligibleForTailCallOptimization(SDValue Callee,
131  CallingConv::ID CalleeCC, bool isVarArg, bool isCalleeStructRet,
132  bool isCallerStructRet, const SmallVectorImpl<ISD::OutputArg> &Outs,
133  const SmallVectorImpl<SDValue> &OutVals,
134  const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG& DAG) const;
135 
136  bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
137  MachineFunction &MF,
138  unsigned Intrinsic) const override;
139 
140  bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
141  bool isTruncateFree(EVT VT1, EVT VT2) const override;
142 
143  bool isCheapToSpeculateCttz(Type *) const override { return true; }
144  bool isCheapToSpeculateCtlz(Type *) const override { return true; }
145  bool isCtlzFast() const override { return true; }
146 
147  bool hasBitTest(SDValue X, SDValue Y) const override;
148 
149  bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
150 
151  /// Return true if an FMA operation is faster than a pair of mul and add
152  /// instructions. fmuladd intrinsics will be expanded to FMAs when this
153  /// method returns true (and FMAs are legal), otherwise fmuladd is
154  /// expanded to mul + add.
155  bool isFMAFasterThanFMulAndFAdd(const MachineFunction &,
156  EVT) const override;
157 
158  // Should we expand the build vector with shuffles?
159  bool shouldExpandBuildVectorWithShuffles(EVT VT,
160  unsigned DefinedValues) const override;
161 
162  bool isShuffleMaskLegal(ArrayRef<int> Mask, EVT VT) const override;
163  TargetLoweringBase::LegalizeTypeAction getPreferredVectorAction(MVT VT)
164  const override;
165 
166  SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
167  void LowerOperationWrapper(SDNode *N, SmallVectorImpl<SDValue> &Results,
168  SelectionDAG &DAG) const override;
169  void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
170  SelectionDAG &DAG) const override;
171 
172  const char *getTargetNodeName(unsigned Opcode) const override;
173 
174  SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
175  SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
176  SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
177  SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
178  SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
179  SDValue LowerINSERT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
180  SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
181  SDValue LowerVECTOR_SHIFT(SDValue Op, SelectionDAG &DAG) const;
182  SDValue LowerROTL(SDValue Op, SelectionDAG &DAG) const;
183  SDValue LowerBITCAST(SDValue Op, SelectionDAG &DAG) const;
184  SDValue LowerANY_EXTEND(SDValue Op, SelectionDAG &DAG) const;
185  SDValue LowerSIGN_EXTEND(SDValue Op, SelectionDAG &DAG) const;
186  SDValue LowerZERO_EXTEND(SDValue Op, SelectionDAG &DAG) const;
187  SDValue LowerLoad(SDValue Op, SelectionDAG &DAG) const;
188  SDValue LowerStore(SDValue Op, SelectionDAG &DAG) const;
189  SDValue LowerUnalignedLoad(SDValue Op, SelectionDAG &DAG) const;
190  SDValue LowerUAddSubO(SDValue Op, SelectionDAG &DAG) const;
191  SDValue LowerAddSubCarry(SDValue Op, SelectionDAG &DAG) const;
192 
193  SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const;
194  SDValue LowerINLINEASM(SDValue Op, SelectionDAG &DAG) const;
195  SDValue LowerPREFETCH(SDValue Op, SelectionDAG &DAG) const;
196  SDValue LowerREADCYCLECOUNTER(SDValue Op, SelectionDAG &DAG) const;
197  SDValue LowerEH_LABEL(SDValue Op, SelectionDAG &DAG) const;
198  SDValue LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const;
199  SDValue
200  LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
201  const SmallVectorImpl<ISD::InputArg> &Ins,
202  const SDLoc &dl, SelectionDAG &DAG,
203  SmallVectorImpl<SDValue> &InVals) const override;
204  SDValue LowerGLOBALADDRESS(SDValue Op, SelectionDAG &DAG) const;
205  SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
206  SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
207  SDValue LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
208  SelectionDAG &DAG) const;
209  SDValue LowerToTLSInitialExecModel(GlobalAddressSDNode *GA,
210  SelectionDAG &DAG) const;
211  SDValue LowerToTLSLocalExecModel(GlobalAddressSDNode *GA,
212  SelectionDAG &DAG) const;
213  SDValue GetDynamicTLSAddr(SelectionDAG &DAG, SDValue Chain,
214  GlobalAddressSDNode *GA, SDValue InFlag, EVT PtrVT,
215  unsigned ReturnReg, unsigned char OperandFlags) const;
216  SDValue LowerGLOBAL_OFFSET_TABLE(SDValue Op, SelectionDAG &DAG) const;
217 
218  SDValue LowerCall(TargetLowering::CallLoweringInfo &CLI,
219  SmallVectorImpl<SDValue> &InVals) const override;
220  SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
221  CallingConv::ID CallConv, bool isVarArg,
222  const SmallVectorImpl<ISD::InputArg> &Ins,
223  const SDLoc &dl, SelectionDAG &DAG,
224  SmallVectorImpl<SDValue> &InVals,
225  const SmallVectorImpl<SDValue> &OutVals,
226  SDValue Callee) const;
227 
228  SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
229  SDValue LowerVSELECT(SDValue Op, SelectionDAG &DAG) const;
230  SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
231  SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG& DAG) const;
232  SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
233 
234  bool CanLowerReturn(CallingConv::ID CallConv,
235  MachineFunction &MF, bool isVarArg,
236  const SmallVectorImpl<ISD::OutputArg> &Outs,
237  LLVMContext &Context) const override;
238 
239  SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
240  const SmallVectorImpl<ISD::OutputArg> &Outs,
241  const SmallVectorImpl<SDValue> &OutVals,
242  const SDLoc &dl, SelectionDAG &DAG) const override;
243 
244  SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
245 
246  bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
247 
248  Register getRegisterByName(const char* RegName, LLT VT,
249  const MachineFunction &MF) const override;
250 
251  /// If a physical register, this returns the register that receives the
252  /// exception address on entry to an EH pad.
253  Register
254  getExceptionPointerRegister(const Constant *PersonalityFn) const override {
255  return Hexagon::R0;
256  }
257 
258  /// If a physical register, this returns the register that receives the
259  /// exception typeid on entry to a landing pad.
260  Register
261  getExceptionSelectorRegister(const Constant *PersonalityFn) const override {
262  return Hexagon::R1;
263  }
264 
265  SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
266  SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
267  SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
268  SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
269 
270  EVT getSetCCResultType(const DataLayout &, LLVMContext &C,
271  EVT VT) const override {
272  if (!VT.isVector())
273  return MVT::i1;
274  else
275  return EVT::getVectorVT(C, MVT::i1, VT.getVectorNumElements());
276  }
277 
278  bool getPostIndexedAddressParts(SDNode *N, SDNode *Op,
279  SDValue &Base, SDValue &Offset,
280  ISD::MemIndexedMode &AM,
281  SelectionDAG &DAG) const override;
282 
283  ConstraintType getConstraintType(StringRef Constraint) const override;
284 
285  std::pair<unsigned, const TargetRegisterClass *>
286  getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
287  StringRef Constraint, MVT VT) const override;
288 
289  // Intrinsics
290  SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
291  SDValue LowerINTRINSIC_VOID(SDValue Op, SelectionDAG &DAG) const;
292  /// isLegalAddressingMode - Return true if the addressing mode represented
293  /// by AM is legal for this target, for a load/store of the specified type.
294  /// The type may be VoidTy, in which case only return true if the addressing
295  /// mode is legal for a load/store of any legal type.
296  /// TODO: Handle pre/postinc as well.
297  bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM,
298  Type *Ty, unsigned AS,
299  Instruction *I = nullptr) const override;
300  /// Return true if folding a constant offset with the given GlobalAddress
301  /// is legal. It is frequently not legal in PIC relocation models.
302  bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
303 
304  bool isFPImmLegal(const APFloat &Imm, EVT VT,
305  bool ForCodeSize) const override;
306 
307  /// isLegalICmpImmediate - Return true if the specified immediate is legal
308  /// icmp immediate, that is the target has icmp instructions which can
309  /// compare a register against the immediate without having to materialize
310  /// the immediate into a register.
311  bool isLegalICmpImmediate(int64_t Imm) const override;
312 
313  EVT getOptimalMemOpType(const MemOp &Op,
314  const AttributeList &FuncAttributes) const override;
315 
316  bool allowsMemoryAccess(LLVMContext &Context, const DataLayout &DL, EVT VT,
317  unsigned AddrSpace, Align Alignment,
318  MachineMemOperand::Flags Flags,
319  bool *Fast) const override;
320 
321  bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace,
322  Align Alignment,
323  MachineMemOperand::Flags Flags,
324  bool *Fast) const override;
325 
326  /// Returns relocation base for the given PIC jumptable.
327  SDValue getPICJumpTableRelocBase(SDValue Table, SelectionDAG &DAG)
328  const override;
329 
330  bool shouldReduceLoadWidth(SDNode *Load, ISD::LoadExtType ExtTy,
331  EVT NewVT) const override;
332 
333  // Handling of atomic RMW instructions.
334  Value *emitLoadLinked(IRBuilderBase &Builder, Type *ValueTy, Value *Addr,
335  AtomicOrdering Ord) const override;
336  Value *emitStoreConditional(IRBuilderBase &Builder, Value *Val, Value *Addr,
337  AtomicOrdering Ord) const override;
338  AtomicExpansionKind shouldExpandAtomicLoadInIR(LoadInst *LI) const override;
339  AtomicExpansionKind shouldExpandAtomicStoreInIR(StoreInst *SI) const override;
340  AtomicExpansionKind
341  shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const override;
342 
343  AtomicExpansionKind
344  shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override {
345  return AtomicExpansionKind::LLSC;
346  }
347 
348 private:
349  void initializeHVXLowering();
350  unsigned getPreferredHvxVectorAction(MVT VecTy) const;
351 
352  bool validateConstPtrAlignment(SDValue Ptr, Align NeedAlign, const SDLoc &dl,
353  SelectionDAG &DAG) const;
354  SDValue replaceMemWithUndef(SDValue Op, SelectionDAG &DAG) const;
355 
356  std::pair<SDValue,int> getBaseAndOffset(SDValue Addr) const;
357 
358  bool getBuildVectorConstInts(ArrayRef<SDValue> Values, MVT VecTy,
359  SelectionDAG &DAG,
360  MutableArrayRef<ConstantInt*> Consts) const;
361  SDValue buildVector32(ArrayRef<SDValue> Elem, const SDLoc &dl, MVT VecTy,
362  SelectionDAG &DAG) const;
363  SDValue buildVector64(ArrayRef<SDValue> Elem, const SDLoc &dl, MVT VecTy,
364  SelectionDAG &DAG) const;
365  SDValue extractVector(SDValue VecV, SDValue IdxV, const SDLoc &dl,
366  MVT ValTy, MVT ResTy, SelectionDAG &DAG) const;
367  SDValue insertVector(SDValue VecV, SDValue ValV, SDValue IdxV,
368  const SDLoc &dl, MVT ValTy, SelectionDAG &DAG) const;
369  SDValue expandPredicate(SDValue Vec32, const SDLoc &dl,
370  SelectionDAG &DAG) const;
371  SDValue contractPredicate(SDValue Vec64, const SDLoc &dl,
372  SelectionDAG &DAG) const;
373  SDValue getVectorShiftByInt(SDValue Op, SelectionDAG &DAG) const;
374  SDValue appendUndef(SDValue Val, MVT ResTy, SelectionDAG &DAG) const;
375 
376  bool isUndef(SDValue Op) const {
377  if (Op.isMachineOpcode())
378  return Op.getMachineOpcode() == TargetOpcode::IMPLICIT_DEF;
379  return Op.getOpcode() == ISD::UNDEF;
380  }
381  SDValue getInstr(unsigned MachineOpc, const SDLoc &dl, MVT Ty,
382  ArrayRef<SDValue> Ops, SelectionDAG &DAG) const {
383  SDNode *N = DAG.getMachineNode(MachineOpc, dl, Ty, Ops);
384  return SDValue(N, 0);
385  }
386  SDValue getZero(const SDLoc &dl, MVT Ty, SelectionDAG &DAG) const;
387 
388  using VectorPair = std::pair<SDValue, SDValue>;
389  using TypePair = std::pair<MVT, MVT>;
390 
391  SDValue getInt(unsigned IntId, MVT ResTy, ArrayRef<SDValue> Ops,
392  const SDLoc &dl, SelectionDAG &DAG) const;
393 
394  MVT ty(SDValue Op) const {
395  return Op.getValueType().getSimpleVT();
396  }
397  TypePair ty(const VectorPair &Ops) const {
398  return { Ops.first.getValueType().getSimpleVT(),
399  Ops.second.getValueType().getSimpleVT() };
400  }
401  MVT tyScalar(MVT Ty) const {
402  if (!Ty.isVector())
403  return Ty;
404  return MVT::getIntegerVT(Ty.getSizeInBits());
405  }
406  MVT tyVector(MVT Ty, MVT ElemTy) const {
407  if (Ty.isVector() && Ty.getVectorElementType() == ElemTy)
408  return Ty;
409  unsigned TyWidth = Ty.getSizeInBits();
410  unsigned ElemWidth = ElemTy.getSizeInBits();
411  assert((TyWidth % ElemWidth) == 0);
412  return MVT::getVectorVT(ElemTy, TyWidth/ElemWidth);
413  }
414 
415  MVT typeJoin(const TypePair &Tys) const;
416  TypePair typeSplit(MVT Ty) const;
417  MVT typeExtElem(MVT VecTy, unsigned Factor) const;
418  MVT typeTruncElem(MVT VecTy, unsigned Factor) const;
419  TypePair typeExtendToWider(MVT Ty0, MVT Ty1) const;
420  TypePair typeWidenToWider(MVT Ty0, MVT Ty1) const;
421  MVT typeLegalize(MVT Ty, SelectionDAG &DAG) const;
422  MVT typeWidenToHvx(MVT Ty) const;
423 
424  SDValue opJoin(const VectorPair &Ops, const SDLoc &dl,
425  SelectionDAG &DAG) const;
426  VectorPair opSplit(SDValue Vec, const SDLoc &dl, SelectionDAG &DAG) const;
427  SDValue opCastElem(SDValue Vec, MVT ElemTy, SelectionDAG &DAG) const;
428 
429  bool allowsHvxMemoryAccess(MVT VecTy, MachineMemOperand::Flags Flags,
430  bool *Fast) const;
431  bool allowsHvxMisalignedMemoryAccesses(MVT VecTy,
432  MachineMemOperand::Flags Flags,
433  bool *Fast) const;
434 
435  bool isHvxSingleTy(MVT Ty) const;
436  bool isHvxPairTy(MVT Ty) const;
437  bool isHvxBoolTy(MVT Ty) const;
438  SDValue convertToByteIndex(SDValue ElemIdx, MVT ElemTy,
439  SelectionDAG &DAG) const;
440  SDValue getIndexInWord32(SDValue Idx, MVT ElemTy, SelectionDAG &DAG) const;
441  SDValue getByteShuffle(const SDLoc &dl, SDValue Op0, SDValue Op1,
442  ArrayRef<int> Mask, SelectionDAG &DAG) const;
443 
444  SDValue buildHvxVectorReg(ArrayRef<SDValue> Values, const SDLoc &dl,
445  MVT VecTy, SelectionDAG &DAG) const;
446  SDValue buildHvxVectorPred(ArrayRef<SDValue> Values, const SDLoc &dl,
447  MVT VecTy, SelectionDAG &DAG) const;
448  SDValue createHvxPrefixPred(SDValue PredV, const SDLoc &dl,
449  unsigned BitBytes, bool ZeroFill,
450  SelectionDAG &DAG) const;
451  SDValue extractHvxElementReg(SDValue VecV, SDValue IdxV, const SDLoc &dl,
452  MVT ResTy, SelectionDAG &DAG) const;
453  SDValue extractHvxElementPred(SDValue VecV, SDValue IdxV, const SDLoc &dl,
454  MVT ResTy, SelectionDAG &DAG) const;
455  SDValue insertHvxElementReg(SDValue VecV, SDValue IdxV, SDValue ValV,
456  const SDLoc &dl, SelectionDAG &DAG) const;
457  SDValue insertHvxElementPred(SDValue VecV, SDValue IdxV, SDValue ValV,
458  const SDLoc &dl, SelectionDAG &DAG) const;
459  SDValue extractHvxSubvectorReg(SDValue VecV, SDValue IdxV, const SDLoc &dl,
460  MVT ResTy, SelectionDAG &DAG) const;
461  SDValue extractHvxSubvectorPred(SDValue VecV, SDValue IdxV, const SDLoc &dl,
462  MVT ResTy, SelectionDAG &DAG) const;
463  SDValue insertHvxSubvectorReg(SDValue VecV, SDValue SubV, SDValue IdxV,
464  const SDLoc &dl, SelectionDAG &DAG) const;
465  SDValue insertHvxSubvectorPred(SDValue VecV, SDValue SubV, SDValue IdxV,
466  const SDLoc &dl, SelectionDAG &DAG) const;
467  SDValue extendHvxVectorPred(SDValue VecV, const SDLoc &dl, MVT ResTy,
468  bool ZeroExt, SelectionDAG &DAG) const;
469  SDValue compressHvxPred(SDValue VecQ, const SDLoc &dl, MVT ResTy,
470  SelectionDAG &DAG) const;
471  SDValue resizeToWidth(SDValue VecV, MVT ResTy, bool Signed, const SDLoc &dl,
472  SelectionDAG &DAG) const;
473  SDValue extractSubvector(SDValue Vec, MVT SubTy, unsigned SubIdx,
474  SelectionDAG &DAG) const;
475  VectorPair emitHvxAddWithOverflow(SDValue A, SDValue B, const SDLoc &dl,
476  bool Signed, SelectionDAG &DAG) const;
477  VectorPair emitHvxShiftRightRnd(SDValue Val, unsigned Amt, bool Signed,
478  SelectionDAG &DAG) const;
479 
480  SDValue LowerHvxBuildVector(SDValue Op, SelectionDAG &DAG) const;
481  SDValue LowerHvxSplatVector(SDValue Op, SelectionDAG &DAG) const;
482  SDValue LowerHvxConcatVectors(SDValue Op, SelectionDAG &DAG) const;
483  SDValue LowerHvxExtractElement(SDValue Op, SelectionDAG &DAG) const;
484  SDValue LowerHvxInsertElement(SDValue Op, SelectionDAG &DAG) const;
485  SDValue LowerHvxExtractSubvector(SDValue Op, SelectionDAG &DAG) const;
486  SDValue LowerHvxInsertSubvector(SDValue Op, SelectionDAG &DAG) const;
487  SDValue LowerHvxBitcast(SDValue Op, SelectionDAG &DAG) const;
488  SDValue LowerHvxAnyExt(SDValue Op, SelectionDAG &DAG) const;
489  SDValue LowerHvxSignExt(SDValue Op, SelectionDAG &DAG) const;
490  SDValue LowerHvxZeroExt(SDValue Op, SelectionDAG &DAG) const;
491  SDValue LowerHvxCttz(SDValue Op, SelectionDAG &DAG) const;
492  SDValue LowerHvxMulh(SDValue Op, SelectionDAG &DAG) const;
493  SDValue LowerHvxSetCC(SDValue Op, SelectionDAG &DAG) const;
494  SDValue LowerHvxExtend(SDValue Op, SelectionDAG &DAG) const;
495  SDValue LowerHvxSelect(SDValue Op, SelectionDAG &DAG) const;
496  SDValue LowerHvxShift(SDValue Op, SelectionDAG &DAG) const;
497  SDValue LowerHvxIntrinsic(SDValue Op, SelectionDAG &DAG) const;
498  SDValue LowerHvxMaskedOp(SDValue Op, SelectionDAG &DAG) const;
499  SDValue LowerHvxFpExtend(SDValue Op, SelectionDAG &DAG) const;
500  SDValue LowerHvxFpToInt(SDValue Op, SelectionDAG &DAG) const;
501  SDValue LowerHvxIntToFp(SDValue Op, SelectionDAG &DAG) const;
502  SDValue ExpandHvxFpToInt(SDValue Op, SelectionDAG &DAG) const;
503  SDValue ExpandHvxIntToFp(SDValue Op, SelectionDAG &DAG) const;
504 
505  VectorPair SplitVectorOp(SDValue Op, SelectionDAG &DAG) const;
506 
507  SDValue SplitHvxMemOp(SDValue Op, SelectionDAG &DAG) const;
508  SDValue WidenHvxLoad(SDValue Op, SelectionDAG &DAG) const;
509  SDValue WidenHvxStore(SDValue Op, SelectionDAG &DAG) const;
510  SDValue WidenHvxSetCC(SDValue Op, SelectionDAG &DAG) const;
511  SDValue LegalizeHvxResize(SDValue Op, SelectionDAG &DAG) const;
512  SDValue WidenHvxFpIntConv(SDValue Op, SelectionDAG &DAG) const;
513  SDValue ExpandHvxResizeIntoSteps(SDValue Op, SelectionDAG &DAG) const;
514  SDValue EqualizeFpIntConversion(SDValue Op, SelectionDAG &DAG) const;
515 
516  SDValue CreateTLWrapper(SDValue Op, SelectionDAG &DAG) const;
517  SDValue RemoveTLWrapper(SDValue Op, SelectionDAG &DAG) const;
518 
519  std::pair<const TargetRegisterClass*, uint8_t>
520  findRepresentativeClass(const TargetRegisterInfo *TRI, MVT VT)
521  const override;
522 
523  bool shouldSplitToHvx(MVT Ty, SelectionDAG &DAG) const;
524  bool shouldWidenToHvx(MVT Ty, SelectionDAG &DAG) const;
525  bool isHvxOperation(SDNode *N, SelectionDAG &DAG) const;
526  SDValue LowerHvxOperation(SDValue Op, SelectionDAG &DAG) const;
527  void LowerHvxOperationWrapper(SDNode *N, SmallVectorImpl<SDValue> &Results,
528  SelectionDAG &DAG) const;
529  void ReplaceHvxNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
530  SelectionDAG &DAG) const;
531  SDValue PerformHvxDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const;
532 };
533 
534 } // end namespace llvm
535 
536 #endif // LLVM_LIB_TARGET_HEXAGON_HEXAGONISELLOWERING_H
HexagonMCTargetDesc.h
ValueTypes.h
llvm::HexagonISD::QFALSE
@ QFALSE
Definition: HexagonISelLowering.h:83
llvm::HexagonTargetLowering::shouldExpandAtomicStoreInIR
AtomicExpansionKind shouldExpandAtomicStoreInIR(StoreInst *SI) const override
Returns how the given (atomic) store should be expanded by the IR-level AtomicExpand pass into.
Definition: HexagonISelLowering.cpp:3728
llvm::HexagonTargetLowering::LowerRETURNADDR
SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1167
llvm::HexagonTargetLowering::IsEligibleForTailCallOptimization
bool IsEligibleForTailCallOptimization(SDValue Callee, CallingConv::ID CalleeCC, bool isVarArg, bool isCalleeStructRet, bool isCallerStructRet, const SmallVectorImpl< ISD::OutputArg > &Outs, const SmallVectorImpl< SDValue > &OutVals, const SmallVectorImpl< ISD::InputArg > &Ins, SelectionDAG &DAG) const
IsEligibleForTailCallOptimization - Check whether the call is eligible for tail call optimization.
Definition: HexagonISelLowering.cpp:3541
llvm::HexagonTargetLowering::isFMAFasterThanFMulAndFAdd
bool isFMAFasterThanFMulAndFAdd(const MachineFunction &, EVT) const override
Return true if an FMA operation is faster than a pair of mul and add instructions.
Definition: HexagonISelLowering.cpp:2133
Signed
@ Signed
Definition: NVPTXISelLowering.cpp:4710
llvm::HexagonTargetLowering::LowerConstantPool
SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1111
llvm::HexagonTargetLowering::LowerEH_RETURN
SDValue LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:3193
llvm::HexagonTargetLowering::shouldExpandAtomicCmpXchgInIR
AtomicExpansionKind shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const override
Returns how the given atomic cmpxchg should be expanded by the IR-level AtomicExpand pass.
Definition: HexagonISelLowering.cpp:3736
llvm::ISD::MemIndexedMode
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:1373
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::SDLoc
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Definition: SelectionDAGNodes.h:1103
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::TargetLowering::ConstraintType
ConstraintType
Definition: TargetLowering.h:4495
llvm::HexagonTargetLowering::emitLoadLinked
Value * emitLoadLinked(IRBuilderBase &Builder, Type *ValueTy, Value *Addr, AtomicOrdering Ord) const override
Perform a load-linked operation on Addr, returning a "Value *" with the corresponding pointee type.
Definition: HexagonISelLowering.cpp:3672
llvm::HexagonISD::JT
@ JT
Definition: HexagonISelLowering.h:52
llvm::HexagonISD::EH_RETURN
@ EH_RETURN
Definition: HexagonISelLowering.h:69
llvm::HexagonTargetLowering::emitStoreConditional
Value * emitStoreConditional(IRBuilderBase &Builder, Value *Val, Value *Addr, AtomicOrdering Ord) const override
Perform a store-conditional operation to Addr.
Definition: HexagonISelLowering.cpp:3695
StringRef.h
llvm::HexagonTargetLowering::getConstraintType
ConstraintType getConstraintType(StringRef Constraint) const override
Given a constraint, return the type of constraint it is for this target.
Definition: HexagonISelLowering.cpp:3404
llvm::HexagonTargetLowering::LowerINLINEASM
SDValue LowerINLINEASM(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:657
llvm::HexagonISD::INSERT
@ INSERT
Definition: HexagonISelLowering.h:63
llvm::HexagonTargetLowering::LowerVECTOR_SHIFT
SDValue LowerVECTOR_SHIFT(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2347
llvm::HexagonTargetLowering::getPICJumpTableRelocBase
SDValue getPICJumpTableRelocBase(SDValue Table, SelectionDAG &DAG) const override
Returns relocation base for the given PIC jumptable.
Definition: HexagonISelLowering.cpp:3391
InlineAsm.h
llvm::HexagonISD::QCAT
@ QCAT
Definition: HexagonISelLowering.h:81
llvm::HexagonTargetLowering::PerformDAGCombine
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...
Definition: HexagonISelLowering.cpp:3346
llvm::HexagonTargetLowering::LowerOperation
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...
Definition: HexagonISelLowering.cpp:3220
llvm::HexagonTargetMachine
Definition: HexagonTargetMachine.h:25
llvm::HexagonISD::PFALSE
@ PFALSE
Definition: HexagonISelLowering.h:73
llvm::HexagonISD::READCYCLE
@ READCYCLE
Definition: HexagonISelLowering.h:71
llvm::HexagonISD::COMBINE
@ COMBINE
Definition: HexagonISelLowering.h:55
llvm::HexagonTargetLowering::HexagonTargetLowering
HexagonTargetLowering(const TargetMachine &TM, const HexagonSubtarget &ST)
Definition: HexagonISelLowering.cpp:1432
llvm::HexagonISD::USAT
@ USAT
Definition: HexagonISelLowering.h:61
llvm::SDNode
Represents one node in the SelectionDAG.
Definition: SelectionDAGNodes.h:462
llvm::MemOp
Definition: TargetLowering.h:110
llvm::HexagonISD::SUBC
@ SUBC
Definition: HexagonISelLowering.h:40
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:237
llvm::HexagonTargetLowering::LowerGLOBAL_OFFSET_TABLE
SDValue LowerGLOBAL_OFFSET_TABLE(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1266
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::HexagonTargetLowering::isTruncateFree
bool isTruncateFree(Type *Ty1, Type *Ty2) const override
Return true if it's free to truncate a value of type FromTy to type ToTy.
Definition: HexagonISelLowering.cpp:2123
llvm::HexagonTargetLowering::LowerToTLSLocalExecModel
SDValue LowerToTLSLocalExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1354
llvm::AttributeList
Definition: Attributes.h:425
llvm::HexagonTargetLowering::LowerCall
SDValue LowerCall(TargetLowering::CallLoweringInfo &CLI, SmallVectorImpl< SDValue > &InVals) const override
LowerCall - Functions arguments are copied from virtual regs to (physical regs)/(stack frame),...
Definition: HexagonISelLowering.cpp:403
llvm::HexagonISD::D2P
@ D2P
Definition: HexagonISelLowering.h:74
llvm::HexagonTargetLowering::CanLowerReturn
bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF, bool isVarArg, const SmallVectorImpl< ISD::OutputArg > &Outs, LLVMContext &Context) const override
This hook should be implemented to check whether the return values described by the Outs array can fi...
Definition: HexagonISelLowering.cpp:185
llvm::EVT::getVectorVT
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:73
llvm::HexagonISD::OP_BEGIN
@ OP_BEGIN
Definition: HexagonISelLowering.h:35
Results
Function Alias Analysis Results
Definition: AliasAnalysis.cpp:830
llvm::HexagonTargetLowering::shouldReduceLoadWidth
bool shouldReduceLoadWidth(SDNode *Load, ISD::LoadExtType ExtTy, EVT NewVT) const override
Return true if it is profitable to reduce a load to a smaller type.
Definition: HexagonISelLowering.cpp:3653
llvm::HexagonISD::TC_RETURN
@ TC_RETURN
Definition: HexagonISelLowering.h:68
llvm::HexagonTargetLowering::LowerSETCC
SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1028
llvm::HexagonTargetLowering::LowerROTL
SDValue LowerROTL(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2394
llvm::HexagonTargetLowering::getSetCCResultType
EVT getSetCCResultType(const DataLayout &, LLVMContext &C, EVT VT) const override
Return the ValueType of the result of SETCC operations.
Definition: HexagonISelLowering.h:270
llvm::HexagonTargetLowering::LowerPREFETCH
SDValue LowerPREFETCH(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:705
llvm::HexagonISD::RET_FLAG
@ RET_FLAG
Definition: HexagonISelLowering.h:50
llvm::HexagonISD::TL_TRUNCATE
@ TL_TRUNCATE
Definition: HexagonISelLowering.h:86
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1628
llvm::HexagonISD::V2Q
@ V2Q
Definition: HexagonISelLowering.h:76
llvm::HexagonISD::VINSERTW0
@ VINSERTW0
Definition: HexagonISelLowering.h:66
llvm::HexagonTargetLowering::LowerEXTRACT_VECTOR_ELT
SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2945
MachineValueType.h
llvm::HexagonTargetLowering::shouldExpandAtomicRMWInIR
AtomicExpansionKind shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override
Returns how the IR-level AtomicExpand pass should expand the given AtomicRMW, if at all.
Definition: HexagonISelLowering.h:344
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::BitmaskEnumDetail::Mask
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::ISD::LoadExtType
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:1404
llvm::HexagonTargetLowering::getPreferredVectorAction
TargetLoweringBase::LegalizeTypeAction getPreferredVectorAction(MVT VT) const override
Return the preferred vector type legalization action.
Definition: HexagonISelLowering.cpp:2150
TargetLowering.h
llvm::HexagonISD::SSAT
@ SSAT
Definition: HexagonISelLowering.h:60
llvm::MVT::i1
@ i1
Definition: MachineValueType.h:43
llvm::HexagonTargetLowering::LowerGLOBALADDRESS
SDValue LowerGLOBALADDRESS(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1216
llvm::HexagonTargetLowering::getRegForInlineAsmConstraint
std::pair< unsigned, const TargetRegisterClass * > getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI, StringRef Constraint, MVT VT) const override
Given a physical register constraint (e.g.
Definition: HexagonISelLowering.cpp:3422
llvm::HexagonISD::VALIGNADDR
@ VALIGNADDR
Definition: HexagonISelLowering.h:106
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:28
llvm::SelectionDAG
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:220
SelectionDAGNodes.h
llvm::HexagonTargetLowering::ReplaceNodeResults
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...
Definition: HexagonISelLowering.cpp:3316
llvm::HexagonTargetLowering::LowerATOMIC_FENCE
SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1210
llvm::HexagonISD::TL_EXTEND
@ TL_EXTEND
Definition: HexagonISelLowering.h:85
llvm::HexagonTargetLowering::LowerANY_EXTEND
SDValue LowerANY_EXTEND(SDValue Op, SelectionDAG &DAG) const
llvm::HexagonISD::ISEL
@ ISEL
Definition: HexagonISelLowering.h:108
llvm::MCOI::OperandFlags
OperandFlags
These are flags set on operands, but should be considered private, all access should go through the M...
Definition: MCInstrDesc.h:49
llvm::HexagonISD::Q2V
@ Q2V
Definition: HexagonISelLowering.h:77
llvm::EVT
Extended Value Type.
Definition: ValueTypes.h:34
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::HexagonTargetLowering::isLegalAddressingMode
bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty, unsigned AS, Instruction *I=nullptr) const override
isLegalAddressingMode - Return true if the addressing mode represented by AM is legal for this target...
Definition: HexagonISelLowering.cpp:3487
llvm::EVT::getVectorNumElements
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:308
llvm::TargetLowering
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Definition: TargetLowering.h:3446
llvm::HexagonTargetLowering::shouldExpandBuildVectorWithShuffles
bool shouldExpandBuildVectorWithShuffles(EVT VT, unsigned DefinedValues) const override
Definition: HexagonISelLowering.cpp:2139
llvm::HexagonTargetLowering::isShuffleMaskLegal
bool isShuffleMaskLegal(ArrayRef< int > Mask, EVT VT) const override
Targets can use this to indicate that they only support some VECTOR_SHUFFLE operations,...
Definition: HexagonISelLowering.cpp:2144
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
llvm::HexagonTargetLowering::getPostIndexedAddressParts
bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, SDValue &Base, SDValue &Offset, ISD::MemIndexedMode &AM, SelectionDAG &DAG) const override
Returns true by value, base pointer and offset pointer and addressing mode by reference if this node ...
Definition: HexagonISelLowering.cpp:627
llvm::HexagonTargetLowering::mayBeEmittedAsTailCall
bool mayBeEmittedAsTailCall(const CallInst *CI) const override
Return true if the target may be able emit the call instruction as a tail call.
Definition: HexagonISelLowering.cpp:263
llvm::HexagonISD::QTRUE
@ QTRUE
Definition: HexagonISelLowering.h:82
llvm::HexagonTargetLowering::isOffsetFoldingLegal
bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override
Return true if folding a constant offset with the given GlobalAddress is legal.
Definition: HexagonISelLowering.cpp:3525
llvm::HexagonTargetLowering::getTgtMemIntrinsic
bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I, MachineFunction &MF, unsigned Intrinsic) const override
Given an intrinsic, checks if on the target the intrinsic will need to map to a MemIntrinsicNode (tou...
Definition: HexagonISelLowering.cpp:2060
llvm::HexagonTargetLowering::getRegisterByName
Register getRegisterByName(const char *RegName, LLT VT, const MachineFunction &MF) const override
Return the register ID of the name passed in.
Definition: HexagonISelLowering.cpp:268
llvm::HexagonTargetLowering::getExceptionSelectorRegister
Register getExceptionSelectorRegister(const Constant *PersonalityFn) const override
If a physical register, this returns the register that receives the exception typeid on entry to a la...
Definition: HexagonISelLowering.h:261
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::Instruction
Definition: Instruction.h:42
llvm::HexagonTargetLowering::LowerJumpTable
SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1154
llvm::HexagonISD::NodeType
NodeType
Definition: HexagonISelLowering.h:34
llvm::HexagonISD::VLSR
@ VLSR
Definition: HexagonISelLowering.h:58
llvm::HexagonISD::VEXTRACTW
@ VEXTRACTW
Definition: HexagonISelLowering.h:65
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::HexagonTargetLowering::LowerINSERT_SUBVECTOR
SDValue LowerINSERT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2967
llvm::HexagonISD::TYPECAST
@ TYPECAST
Definition: HexagonISelLowering.h:102
llvm::HexagonISD::DCFETCH
@ DCFETCH
Definition: HexagonISelLowering.h:70
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
Hexagon.h
llvm::HexagonTargetLowering::getExceptionPointerRegister
Register getExceptionPointerRegister(const Constant *PersonalityFn) const override
If a physical register, this returns the register that receives the exception address on entry to an ...
Definition: HexagonISelLowering.h:254
llvm::AtomicOrdering
AtomicOrdering
Atomic ordering for LLVM's memory model.
Definition: AtomicOrdering.h:56
llvm::HexagonTargetLowering::LowerEH_LABEL
SDValue LowerEH_LABEL(SDValue Op, SelectionDAG &DAG) const
llvm::APFloat
Definition: APFloat.h:707
llvm::HexagonTargetLowering::LowerINSERT_VECTOR_ELT
SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2960
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:298
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::HexagonISD::CONST32
@ CONST32
Definition: HexagonISelLowering.h:37
llvm::HexagonTargetLowering::LowerREADCYCLECOUNTER
SDValue LowerREADCYCLECOUNTER(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:720
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:78
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::HexagonISD::VASR
@ VASR
Definition: HexagonISelLowering.h:57
llvm::HexagonISD::VASL
@ VASL
Definition: HexagonISelLowering.h:56
llvm::HexagonTargetLowering::LowerToTLSInitialExecModel
SDValue LowerToTLSInitialExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1312
llvm::HexagonTargetLowering::LowerCallResult
SDValue LowerCallResult(SDValue Chain, SDValue InFlag, CallingConv::ID CallConv, bool isVarArg, const SmallVectorImpl< ISD::InputArg > &Ins, const SDLoc &dl, SelectionDAG &DAG, SmallVectorImpl< SDValue > &InVals, const SmallVectorImpl< SDValue > &OutVals, SDValue Callee) const
LowerCallResult - Lower the result values of an ISD::CALL into the appropriate copies out of appropri...
Definition: HexagonISelLowering.cpp:349
llvm::HexagonISD::PTRUE
@ PTRUE
Definition: HexagonISelLowering.h:72
llvm::HexagonTargetLowering::LowerCONCAT_VECTORS
SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2881
llvm::MachineMemOperand::Flags
Flags
Flags values. These may be or'd together.
Definition: MachineMemOperand.h:130
llvm::TargetLowering::CallLoweringInfo
This structure contains all information that is necessary for lowering calls.
Definition: TargetLowering.h:4079
llvm::HexagonTargetLowering::LowerINTRINSIC_WO_CHAIN
SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:164
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
llvm::HexagonTargetLowering::LowerLoad
SDValue LowerLoad(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2988
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::HexagonTargetLowering::getTargetNodeName
const char * getTargetNodeName(unsigned Opcode) const override
This method returns the name of a target specific DAG node.
Definition: HexagonISelLowering.cpp:1876
llvm::TargetLoweringBase::AtomicExpansionKind::LLSC
@ LLSC
llvm::HexagonTargetLowering::LowerVECTOR_SHUFFLE
SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2188
Ptr
@ Ptr
Definition: TargetLibraryInfo.cpp:60
llvm::HexagonTargetLowering::isCheapToSpeculateCtlz
bool isCheapToSpeculateCtlz(Type *) const override
Return true if it is cheap to speculate a call to intrinsic ctlz.
Definition: HexagonISelLowering.h:144
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:31
llvm::HexagonISD::VROR
@ VROR
Definition: HexagonISelLowering.h:67
llvm::HexagonTargetLowering::isCheapToSpeculateCttz
bool isCheapToSpeculateCttz(Type *) const override
Return true if it is cheap to speculate a call to intrinsic cttz.
Definition: HexagonISelLowering.h:143
llvm::HexagonTargetLowering::LowerBlockAddress
SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1250
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::MachineFunction
Definition: MachineFunction.h:257
llvm::MVT::getVectorVT
static MVT getVectorVT(MVT VT, unsigned NumElements)
Definition: MachineValueType.h:1225
llvm::HexagonTargetLowering::LowerBITCAST
SDValue LowerBITCAST(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2401
llvm::ArrayRef< int >
llvm::EVT::isVector
bool isVector() const
Return true if this is a vector value type.
Definition: ValueTypes.h:154
llvm::HexagonTargetLowering::LowerEXTRACT_SUBVECTOR
SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2953
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::HexagonISD::AT_GOT
@ AT_GOT
Definition: HexagonISelLowering.h:43
llvm::HexagonTargetLowering
Definition: HexagonISelLowering.h:118
llvm::IRBuilderBase
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:93
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
AddrMode
AddrMode
Definition: MSP430Disassembler.cpp:142
llvm::ISD::UNDEF
@ UNDEF
UNDEF - An undefined node.
Definition: ISDOpcodes.h:211
llvm::ISD::BUILTIN_OP_END
@ BUILTIN_OP_END
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:1307
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:174
llvm::HexagonTargetLowering::LowerSIGN_EXTEND
SDValue LowerSIGN_EXTEND(SDValue Op, SelectionDAG &DAG) const
llvm::HexagonTargetLowering::LowerUAddSubO
SDValue LowerUAddSubO(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:3138
llvm::HexagonTargetLowering::LowerOperationWrapper
void LowerOperationWrapper(SDNode *N, SmallVectorImpl< SDValue > &Results, SelectionDAG &DAG) const override
This callback is invoked by the type legalizer to legalize nodes with an illegal operand type but leg...
Definition: HexagonISelLowering.cpp:3285
llvm::AtomicRMWInst
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:715
llvm::HexagonISD::VALIGN
@ VALIGN
Definition: HexagonISelLowering.h:104
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:187
llvm::HexagonTargetLowering::LowerUnalignedLoad
SDValue LowerUnalignedLoad(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:3050
CallingConv.h
llvm::HexagonISD::CP
@ CP
Definition: HexagonISelLowering.h:53
llvm::TargetLoweringBase::IntrinsicInfo
Definition: TargetLowering.h:1045
llvm::HexagonISD::CALLR
@ CALLR
Definition: HexagonISelLowering.h:48
llvm::GlobalAddressSDNode
Definition: SelectionDAGNodes.h:1757
llvm::HexagonISD::CALL
@ CALL
Definition: HexagonISelLowering.h:46
llvm::TargetLoweringBase::AtomicExpansionKind
AtomicExpansionKind
Enum that specifies what an atomic load/AtomicRMWInst is expanded to, if at all.
Definition: TargetLowering.h:248
llvm::HexagonISD::BARRIER
@ BARRIER
Definition: HexagonISelLowering.h:51
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:348
llvm::HexagonTargetLowering::LowerAddSubCarry
SDValue LowerAddSubCarry(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:3175
ISDOpcodes.h
llvm::HexagonTargetLowering::LowerFRAMEADDR
SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1193
llvm::HexagonISD::EXTRACTU
@ EXTRACTU
Definition: HexagonISelLowering.h:64
llvm::TargetLoweringBase::LegalizeTypeAction
LegalizeTypeAction
This enum indicates whether a types are legal for a target, and if not, what action should be used to...
Definition: TargetLowering.h:204
llvm::HexagonISD::AT_PCREL
@ AT_PCREL
Definition: HexagonISelLowering.h:44
llvm::SDValue
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
Definition: SelectionDAGNodes.h:145
llvm::HexagonISD::P2D
@ P2D
Definition: HexagonISelLowering.h:75
llvm::HexagonTargetLowering::GetDynamicTLSAddr
SDValue GetDynamicTLSAddr(SelectionDAG &DAG, SDValue Chain, GlobalAddressSDNode *GA, SDValue InFlag, EVT PtrVT, unsigned ReturnReg, unsigned char OperandFlags) const
Definition: HexagonISelLowering.cpp:1275
llvm::HexagonTargetLowering::getOptimalMemOpType
EVT getOptimalMemOpType(const MemOp &Op, const AttributeList &FuncAttributes) const override
Returns the target specific optimal type for load and store operations as a result of memset,...
Definition: HexagonISelLowering.cpp:3603
llvm::RISCVMatInt::Imm
@ Imm
Definition: RISCVMatInt.h:23
llvm::HexagonTargetLowering::hasBitTest
bool hasBitTest(SDValue X, SDValue Y) const override
Return true if the target has a bit-test instruction: (X & (1 << Y)) ==/!= 0 This knowledge can be us...
Definition: HexagonISelLowering.cpp:2119
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
llvm::HexagonISD::CALLnr
@ CALLnr
Definition: HexagonISelLowering.h:47
llvm::HexagonTargetLowering::LowerReturn
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,...
Definition: HexagonISelLowering.cpp:201
N
#define N
llvm::HexagonTargetLowering::LowerBUILD_VECTOR
SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:2827
llvm::HexagonTargetLowering::LowerStore
SDValue LowerStore(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:3020
llvm::HexagonSubtarget
Definition: HexagonSubtarget.h:43
llvm::HexagonTargetLowering::isFPImmLegal
bool isFPImmLegal(const APFloat &Imm, EVT VT, bool ForCodeSize) const override
isFPImmLegal - Returns true if the target can instruction select the specified FP immediate natively.
Definition: HexagonISelLowering.cpp:3480
llvm::MipsISD::Ins
@ Ins
Definition: MipsISelLowering.h:160
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
llvm::HexagonTargetLowering::LowerDYNAMIC_STACKALLOC
SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:743
RegName
#define RegName(no)
llvm::HexagonTargetLowering::LowerVSELECT
SDValue LowerVSELECT(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1088
llvm::HexagonTargetLowering::isLegalICmpImmediate
bool isLegalICmpImmediate(int64_t Imm) const override
isLegalICmpImmediate - Return true if the specified immediate is legal icmp immediate,...
Definition: HexagonISelLowering.cpp:3534
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::HexagonTargetLowering::allowsMemoryAccess
bool allowsMemoryAccess(LLVMContext &Context, const DataLayout &DL, EVT VT, unsigned AddrSpace, Align Alignment, MachineMemOperand::Flags Flags, bool *Fast) const override
Return true if the target supports a memory access of this type for the given address space and align...
Definition: HexagonISelLowering.cpp:3614
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1474
llvm::HexagonTargetLowering::LowerVACOPY
SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1011
llvm::HexagonISD::TSTBIT
@ TSTBIT
Definition: HexagonISelLowering.h:62
llvm::HexagonISD::CONST32_GP
@ CONST32_GP
Definition: HexagonISelLowering.h:38
llvm::HexagonTargetLowering::LowerFormalArguments
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,...
Definition: HexagonISelLowering.cpp:773
llvm::HexagonTargetLowering::LowerToTLSGeneralDynamicModel
SDValue LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1376
llvm::HexagonTargetLowering::LowerZERO_EXTEND
SDValue LowerZERO_EXTEND(SDValue Op, SelectionDAG &DAG) const
llvm::HexagonTargetLowering::isCtlzFast
bool isCtlzFast() const override
Return true if ctlz instruction is fast.
Definition: HexagonISelLowering.h:145
llvm::HexagonISD::ALLOCA
@ ALLOCA
Definition: HexagonISelLowering.h:41
llvm::HexagonTargetLowering::allowTruncateForTailCall
bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override
Return true if a truncation from FromTy to ToTy is permitted when deciding whether a call is in tail ...
Definition: HexagonISelLowering.cpp:2975
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::AtomicCmpXchgInst
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:510
llvm::HexagonTargetLowering::LowerGlobalTLSAddress
SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:1412
llvm::HexagonISD::OP_END
@ OP_END
Definition: HexagonISelLowering.h:111
llvm::HexagonISD::ADDC
@ ADDC
Definition: HexagonISelLowering.h:39
llvm::HexagonTargetLowering::allowsMisalignedMemoryAccesses
bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace, Align Alignment, MachineMemOperand::Flags Flags, bool *Fast) const override
Determine if the target supports unaligned memory accesses.
Definition: HexagonISelLowering.cpp:3624
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::HexagonTargetLowering::shouldExpandAtomicLoadInIR
AtomicExpansionKind shouldExpandAtomicLoadInIR(LoadInst *LI) const override
Returns how the given (atomic) load should be expanded by the IR-level AtomicExpand pass.
Definition: HexagonISelLowering.cpp:3720
llvm::MVT::getIntegerVT
static MVT getIntegerVT(unsigned BitWidth)
Definition: MachineValueType.h:1202
llvm::HexagonTargetLowering::LowerVASTART
SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:944
llvm::HexagonTargetLowering::LowerINTRINSIC_VOID
SDValue LowerINTRINSIC_VOID(SDValue Op, SelectionDAG &DAG) const
Definition: HexagonISelLowering.cpp:728
llvm::LLT
Definition: LowLevelTypeImpl.h:39
Generated on Wed Oct 5 2022 10:38:20 for LLVM by   doxygen 1.8.17