LLVM 17.0.0git
ARMISelLowering.h
Go to the documentation of this file.
1//===- ARMISelLowering.h - ARM 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 ARM uses to lower LLVM code into a
10// selection DAG.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_ARM_ARMISELLOWERING_H
15#define LLVM_LIB_TARGET_ARM_ARMISELLOWERING_H
16
19#include "llvm/ADT/StringRef.h"
27#include "llvm/IR/Attributes.h"
28#include "llvm/IR/CallingConv.h"
29#include "llvm/IR/Function.h"
30#include "llvm/IR/IRBuilder.h"
31#include "llvm/IR/InlineAsm.h"
33#include <optional>
34#include <utility>
35
36namespace llvm {
37
38class ARMSubtarget;
39class DataLayout;
40class FastISel;
41class FunctionLoweringInfo;
42class GlobalValue;
43class InstrItineraryData;
44class Instruction;
45class MachineBasicBlock;
46class MachineInstr;
47class SelectionDAG;
48class TargetLibraryInfo;
49class TargetMachine;
50class TargetRegisterInfo;
51class VectorType;
52
53 namespace ARMISD {
54
55 // ARM Specific DAG Nodes
56 enum NodeType : unsigned {
57 // Start the numbering where the builtin ops and target ops leave off.
59
60 Wrapper, // Wrapper - A wrapper node for TargetConstantPool,
61 // TargetExternalSymbol, and TargetGlobalAddress.
62 WrapperPIC, // WrapperPIC - A wrapper node for TargetGlobalAddress in
63 // PIC mode.
64 WrapperJT, // WrapperJT - A wrapper node for TargetJumpTable
65
66 // Add pseudo op to model memcpy for struct byval.
68
69 CALL, // Function call.
70 CALL_PRED, // Function call that's predicable.
71 CALL_NOLINK, // Function call with branch not branch-and-link.
72 tSECALL, // CMSE non-secure function call.
73 t2CALL_BTI, // Thumb function call followed by BTI instruction.
74 BRCOND, // Conditional branch.
75 BR_JT, // Jumptable branch.
76 BR2_JT, // Jumptable branch (2 level - jumptable entry is a jump).
77 RET_GLUE, // Return with a flag operand.
78 SERET_GLUE, // CMSE Entry function return with a flag operand.
79 INTRET_GLUE, // Interrupt return with an LR-offset and a flag operand.
80
81 PIC_ADD, // Add with a PC operand and a PIC label.
82
83 ASRL, // MVE long arithmetic shift right.
84 LSRL, // MVE long shift right.
85 LSLL, // MVE long shift left.
86
87 CMP, // ARM compare instructions.
88 CMN, // ARM CMN instructions.
89 CMPZ, // ARM compare that sets only Z flag.
90 CMPFP, // ARM VFP compare instruction, sets FPSCR.
91 CMPFPE, // ARM VFP signalling compare instruction, sets FPSCR.
92 CMPFPw0, // ARM VFP compare against zero instruction, sets FPSCR.
93 CMPFPEw0, // ARM VFP signalling compare against zero instruction, sets
94 // FPSCR.
95 FMSTAT, // ARM fmstat instruction.
96
97 CMOV, // ARM conditional move instructions.
98 SUBS, // Flag-setting subtraction.
99
100 SSAT, // Signed saturation
101 USAT, // Unsigned saturation
102
104
105 SRL_GLUE, // V,Flag = srl_flag X -> srl X, 1 + save carry out.
106 SRA_GLUE, // V,Flag = sra_flag X -> sra X, 1 + save carry out.
107 RRX, // V = RRX X, Flag -> srl X, 1 + shift in carry flag.
108
109 ADDC, // Add with carry
110 ADDE, // Add using carry
111 SUBC, // Sub with carry
112 SUBE, // Sub using carry
113 LSLS, // Shift left producing carry
114
115 VMOVRRD, // double to two gprs.
116 VMOVDRR, // Two gprs to double.
117 VMOVSR, // move gpr to single, used for f32 literal constructed in a gpr
118
119 EH_SJLJ_SETJMP, // SjLj exception handling setjmp.
120 EH_SJLJ_LONGJMP, // SjLj exception handling longjmp.
121 EH_SJLJ_SETUP_DISPATCH, // SjLj exception handling setup_dispatch.
122
123 TC_RETURN, // Tail call return pseudo.
124
126
127 DYN_ALLOC, // Dynamic allocation on the stack.
128
129 MEMBARRIER_MCR, // Memory barrier (MCR)
130
131 PRELOAD, // Preload
132
133 WIN__CHKSTK, // Windows' __chkstk call to do stack probing.
134 WIN__DBZCHK, // Windows' divide by zero check
135
136 WLS, // Low-overhead loops, While Loop Start branch. See t2WhileLoopStart
137 WLSSETUP, // Setup for the iteration count of a WLS. See t2WhileLoopSetup.
138 LOOP_DEC, // Really a part of LE, performs the sub
139 LE, // Low-overhead loops, Loop End
140
141 PREDICATE_CAST, // Predicate cast for MVE i1 types
142 VECTOR_REG_CAST, // Reinterpret the current contents of a vector register
143
144 MVESEXT, // Legalization aids for extending a vector into two/four vectors.
145 MVEZEXT, // or truncating two/four vectors into one. Eventually becomes
146 MVETRUNC, // stack store/load sequence, if not optimized to anything else.
147
148 VCMP, // Vector compare.
149 VCMPZ, // Vector compare to zero.
150 VTST, // Vector test bits.
151
152 // Vector shift by vector
153 VSHLs, // ...left/right by signed
154 VSHLu, // ...left/right by unsigned
155
156 // Vector shift by immediate:
157 VSHLIMM, // ...left
158 VSHRsIMM, // ...right (signed)
159 VSHRuIMM, // ...right (unsigned)
160
161 // Vector rounding shift by immediate:
162 VRSHRsIMM, // ...right (signed)
163 VRSHRuIMM, // ...right (unsigned)
164 VRSHRNIMM, // ...right narrow
165
166 // Vector saturating shift by immediate:
167 VQSHLsIMM, // ...left (signed)
168 VQSHLuIMM, // ...left (unsigned)
169 VQSHLsuIMM, // ...left (signed to unsigned)
170 VQSHRNsIMM, // ...right narrow (signed)
171 VQSHRNuIMM, // ...right narrow (unsigned)
172 VQSHRNsuIMM, // ...right narrow (signed to unsigned)
173
174 // Vector saturating rounding shift by immediate:
175 VQRSHRNsIMM, // ...right narrow (signed)
176 VQRSHRNuIMM, // ...right narrow (unsigned)
177 VQRSHRNsuIMM, // ...right narrow (signed to unsigned)
178
179 // Vector shift and insert:
180 VSLIIMM, // ...left
181 VSRIIMM, // ...right
182
183 // Vector get lane (VMOV scalar to ARM core register)
184 // (These are used for 8- and 16-bit element types only.)
185 VGETLANEu, // zero-extend vector extract element
186 VGETLANEs, // sign-extend vector extract element
187
188 // Vector move immediate and move negated immediate:
191
192 // Vector move f32 immediate:
194
195 // Move H <-> R, clearing top 16 bits
198
199 // Vector duplicate:
202
203 // Vector shuffles:
204 VEXT, // extract
205 VREV64, // reverse elements within 64-bit doublewords
206 VREV32, // reverse elements within 32-bit words
207 VREV16, // reverse elements within 16-bit halfwords
208 VZIP, // zip (interleave)
209 VUZP, // unzip (deinterleave)
210 VTRN, // transpose
211 VTBL1, // 1-register shuffle with mask
212 VTBL2, // 2-register shuffle with mask
213 VMOVN, // MVE vmovn
214
215 // MVE Saturating truncates
216 VQMOVNs, // Vector (V) Saturating (Q) Move and Narrow (N), signed (s)
217 VQMOVNu, // Vector (V) Saturating (Q) Move and Narrow (N), unsigned (u)
218
219 // MVE float <> half converts
220 VCVTN, // MVE vcvt f32 -> f16, truncating into either the bottom or top
221 // lanes
222 VCVTL, // MVE vcvt f16 -> f32, extending from either the bottom or top lanes
223
224 // MVE VIDUP instruction, taking a start value and increment.
226
227 // Vector multiply long:
228 VMULLs, // ...signed
229 VMULLu, // ...unsigned
230
231 VQDMULH, // MVE vqdmulh instruction
232
233 // MVE reductions
234 VADDVs, // sign- or zero-extend the elements of a vector to i32,
235 VADDVu, // add them all together, and return an i32 of their sum
236 VADDVps, // Same as VADDV[su] but with a v4i1 predicate mask
238 VADDLVs, // sign- or zero-extend elements to i64 and sum, returning
239 VADDLVu, // the low and high 32-bit halves of the sum
240 VADDLVAs, // Same as VADDLV[su] but also add an input accumulator
241 VADDLVAu, // provided as low and high halves
242 VADDLVps, // Same as VADDLV[su] but with a v4i1 predicate mask
244 VADDLVAps, // Same as VADDLVp[su] but with a v4i1 predicate mask
246 VMLAVs, // sign- or zero-extend the elements of two vectors to i32, multiply
247 VMLAVu, // them and add the results together, returning an i32 of their sum
248 VMLAVps, // Same as VMLAV[su] with a v4i1 predicate mask
250 VMLALVs, // Same as VMLAV but with i64, returning the low and
251 VMLALVu, // high 32-bit halves of the sum
252 VMLALVps, // Same as VMLALV[su] with a v4i1 predicate mask
254 VMLALVAs, // Same as VMLALV but also add an input accumulator
255 VMLALVAu, // provided as low and high halves
256 VMLALVAps, // Same as VMLALVA[su] with a v4i1 predicate mask
258 VMINVu, // Find minimum unsigned value of a vector and register
259 VMINVs, // Find minimum signed value of a vector and register
260 VMAXVu, // Find maximum unsigned value of a vector and register
261 VMAXVs, // Find maximum signed value of a vector and register
262
263 SMULWB, // Signed multiply word by half word, bottom
264 SMULWT, // Signed multiply word by half word, top
265 UMLAL, // 64bit Unsigned Accumulate Multiply
266 SMLAL, // 64bit Signed Accumulate Multiply
267 UMAAL, // 64-bit Unsigned Accumulate Accumulate Multiply
268 SMLALBB, // 64-bit signed accumulate multiply bottom, bottom 16
269 SMLALBT, // 64-bit signed accumulate multiply bottom, top 16
270 SMLALTB, // 64-bit signed accumulate multiply top, bottom 16
271 SMLALTT, // 64-bit signed accumulate multiply top, top 16
272 SMLALD, // Signed multiply accumulate long dual
273 SMLALDX, // Signed multiply accumulate long dual exchange
274 SMLSLD, // Signed multiply subtract long dual
275 SMLSLDX, // Signed multiply subtract long dual exchange
276 SMMLAR, // Signed multiply long, round and add
277 SMMLSR, // Signed multiply long, subtract and round
278
279 // Single Lane QADD8 and QADD16. Only the bottom lane. That's what the b
280 // stands for.
289
290 // Operands of the standard BUILD_VECTOR node are not legalized, which
291 // is fine if BUILD_VECTORs are always lowered to shuffles or other
292 // operations, but for ARM some BUILD_VECTORs are legal as-is and their
293 // operands need to be legalized. Define an ARM-specific version of
294 // BUILD_VECTOR for this purpose.
296
297 // Bit-field insert
299
300 // Vector OR with immediate
302 // Vector AND with NOT of immediate
304
305 // Pseudo vector bitwise select
307
308 // Pseudo-instruction representing a memory copy using ldm/stm
309 // instructions.
311
312 // Pseudo-instruction representing a memory copy using a tail predicated
313 // loop
315 // Pseudo-instruction representing a memset using a tail predicated
316 // loop
318
319 // V8.1MMainline condition select
320 CSINV, // Conditional select invert.
321 CSNEG, // Conditional select negate.
322 CSINC, // Conditional select increment.
323
324 // Vector load N-element structure to all lanes:
329
330 // NEON loads with post-increment base updates:
345
346 // NEON stores with post-increment base updates:
357
358 // Load/Store of dual registers
360 STRD
361 };
362
363 } // end namespace ARMISD
364
365 namespace ARM {
366 /// Possible values of current rounding mode, which is specified in bits
367 /// 23:22 of FPSCR.
368 enum Rounding {
369 RN = 0, // Round to Nearest
370 RP = 1, // Round towards Plus infinity
371 RM = 2, // Round towards Minus infinity
372 RZ = 3, // Round towards Zero
373 rmMask = 3 // Bit mask selecting rounding mode
374 };
375
376 // Bit position of rounding mode bits in FPSCR.
377 const unsigned RoundingBitsPos = 22;
378 } // namespace ARM
379
380 /// Define some predicates that are used for node matching.
381 namespace ARM {
382
383 bool isBitFieldInvertedMask(unsigned v);
384
385 } // end namespace ARM
386
387 //===--------------------------------------------------------------------===//
388 // ARMTargetLowering - ARM Implementation of the TargetLowering interface
389
391 public:
392 explicit ARMTargetLowering(const TargetMachine &TM,
393 const ARMSubtarget &STI);
394
395 unsigned getJumpTableEncoding() const override;
396 bool useSoftFloat() const override;
397
398 SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
399
400 /// ReplaceNodeResults - Replace the results of node with an illegal result
401 /// type with new values built out of custom code.
403 SelectionDAG &DAG) const override;
404
405 const char *getTargetNodeName(unsigned Opcode) const override;
406
407 bool isSelectSupported(SelectSupportKind Kind) const override {
408 // ARM does not support scalar condition selects on vectors.
409 return (Kind != ScalarCondVectorVal);
410 }
411
412 bool isReadOnly(const GlobalValue *GV) const;
413
414 /// getSetCCResultType - Return the value type to use for ISD::SETCC.
416 EVT VT) const override;
417
420 MachineBasicBlock *MBB) const override;
421
423 SDNode *Node) const override;
424
428 SDValue PerformIntrinsicCombine(SDNode *N, DAGCombinerInfo &DCI) const;
429 SDValue PerformMVEExtCombine(SDNode *N, DAGCombinerInfo &DCI) const;
430 SDValue PerformMVETruncCombine(SDNode *N, DAGCombinerInfo &DCI) const;
431 SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
432
434 const APInt &OriginalDemandedBits,
435 const APInt &OriginalDemandedElts,
436 KnownBits &Known,
437 TargetLoweringOpt &TLO,
438 unsigned Depth) const override;
439
440 bool isDesirableToTransformToIntegerOp(unsigned Opc, EVT VT) const override;
441
442 /// allowsMisalignedMemoryAccesses - Returns true if the target allows
443 /// unaligned memory accesses of the specified type. Returns whether it
444 /// is "fast" by reference in the second argument.
445 bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace,
446 Align Alignment,
448 unsigned *Fast) const override;
449
450 EVT getOptimalMemOpType(const MemOp &Op,
451 const AttributeList &FuncAttributes) const override;
452
453 bool isTruncateFree(Type *SrcTy, Type *DstTy) const override;
454 bool isTruncateFree(EVT SrcVT, EVT DstVT) const override;
455 bool isZExtFree(SDValue Val, EVT VT2) const override;
457 SmallVectorImpl<Use *> &Ops) const override;
458 Type* shouldConvertSplatType(ShuffleVectorInst* SVI) const override;
459
460 bool isFNegFree(EVT VT) const override;
461
462 bool isVectorLoadExtDesirable(SDValue ExtVal) const override;
463
464 bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
465
466
467 /// isLegalAddressingMode - Return true if the addressing mode represented
468 /// by AM is legal for this target, for a load/store of the specified type.
469 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM,
470 Type *Ty, unsigned AS,
471 Instruction *I = nullptr) const override;
472
473 bool isLegalT2ScaledAddressingMode(const AddrMode &AM, EVT VT) const;
474
475 /// Returns true if the addressing mode representing by AM is legal
476 /// for the Thumb1 target, for a load/store of the specified type.
477 bool isLegalT1ScaledAddressingMode(const AddrMode &AM, EVT VT) const;
478
479 /// isLegalICmpImmediate - Return true if the specified immediate is legal
480 /// icmp immediate, that is the target has icmp instructions which can
481 /// compare a register against the immediate without having to materialize
482 /// the immediate into a register.
483 bool isLegalICmpImmediate(int64_t Imm) const override;
484
485 /// isLegalAddImmediate - Return true if the specified immediate is legal
486 /// add immediate, that is the target has add instructions which can
487 /// add a register and the immediate without having to materialize
488 /// the immediate into a register.
489 bool isLegalAddImmediate(int64_t Imm) const override;
490
491 /// getPreIndexedAddressParts - returns true by value, base pointer and
492 /// offset pointer and addressing mode by reference if the node's address
493 /// can be legally represented as pre-indexed load / store address.
496 SelectionDAG &DAG) const override;
497
498 /// getPostIndexedAddressParts - returns true by value, base pointer and
499 /// offset pointer and addressing mode by reference if this node can be
500 /// combined with a load / store to form a post-indexed load / store.
503 SelectionDAG &DAG) const override;
504
505 void computeKnownBitsForTargetNode(const SDValue Op, KnownBits &Known,
506 const APInt &DemandedElts,
507 const SelectionDAG &DAG,
508 unsigned Depth) const override;
509
511 const APInt &DemandedElts,
512 TargetLoweringOpt &TLO) const override;
513
514 bool ExpandInlineAsm(CallInst *CI) const override;
515
516 ConstraintType getConstraintType(StringRef Constraint) const override;
517
518 /// Examine constraint string and operand type and determine a weight value.
519 /// The operand object must already have been set up with the operand type.
521 AsmOperandInfo &info, const char *constraint) const override;
522
523 std::pair<unsigned, const TargetRegisterClass *>
525 StringRef Constraint, MVT VT) const override;
526
527 const char *LowerXConstraint(EVT ConstraintVT) const override;
528
529 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
530 /// vector. If it is invalid, don't add anything to Ops. If hasMemory is
531 /// true it means one of the asm constraint of the inline asm instruction
532 /// being processed is 'm'.
533 void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
534 std::vector<SDValue> &Ops,
535 SelectionDAG &DAG) const override;
536
537 unsigned
538 getInlineAsmMemConstraint(StringRef ConstraintCode) const override {
539 if (ConstraintCode == "Q")
541 else if (ConstraintCode.size() == 2) {
542 if (ConstraintCode[0] == 'U') {
543 switch(ConstraintCode[1]) {
544 default:
545 break;
546 case 'm':
548 case 'n':
550 case 'q':
552 case 's':
554 case 't':
556 case 'v':
558 case 'y':
560 }
561 }
562 }
563 return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
564 }
565
566 const ARMSubtarget* getSubtarget() const {
567 return Subtarget;
568 }
569
570 /// getRegClassFor - Return the register class that should be used for the
571 /// specified value type.
572 const TargetRegisterClass *
573 getRegClassFor(MVT VT, bool isDivergent = false) const override;
574
575 bool shouldAlignPointerArgs(CallInst *CI, unsigned &MinSize,
576 Align &PrefAlign) const override;
577
578 /// createFastISel - This method returns a target specific FastISel object,
579 /// or null if the target does not support "fast" ISel.
581 const TargetLibraryInfo *libInfo) const override;
582
584
585 bool preferZeroCompareBranch() const override { return true; }
586
587 bool isMaskAndCmp0FoldingBeneficial(const Instruction &AndI) const override;
588
589 bool
590 isShuffleMaskLegal(ArrayRef<int> M, EVT VT) const override;
591 bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
592
593 /// isFPImmLegal - Returns true if the target can instruction select the
594 /// specified FP immediate natively. If false, the legalizer will
595 /// materialize the FP immediate as a load from a constant pool.
596 bool isFPImmLegal(const APFloat &Imm, EVT VT,
597 bool ForCodeSize = false) const override;
598
599 bool getTgtMemIntrinsic(IntrinsicInfo &Info,
600 const CallInst &I,
601 MachineFunction &MF,
602 unsigned Intrinsic) const override;
603
604 /// Returns true if it is beneficial to convert a load of a constant
605 /// to just the constant itself.
607 Type *Ty) const override;
608
609 /// Return true if EXTRACT_SUBVECTOR is cheap for this result type
610 /// with this index.
611 bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
612 unsigned Index) const override;
613
614 bool shouldFormOverflowOp(unsigned Opcode, EVT VT,
615 bool MathUsed) const override {
616 // Using overflow ops for overflow checks only should beneficial on ARM.
617 return TargetLowering::shouldFormOverflowOp(Opcode, VT, true);
618 }
619
620 bool shouldReassociateReduction(unsigned Opc, EVT VT) const override {
621 return Opc != ISD::VECREDUCE_ADD;
622 }
623
624 /// Returns true if an argument of type Ty needs to be passed in a
625 /// contiguous block of registers in calling convention CallConv.
627 Type *Ty, CallingConv::ID CallConv, bool isVarArg,
628 const DataLayout &DL) const override;
629
630 /// If a physical register, this returns the register that receives the
631 /// exception address on entry to an EH pad.
633 getExceptionPointerRegister(const Constant *PersonalityFn) const override;
634
635 /// If a physical register, this returns the register that receives the
636 /// exception typeid on entry to a landing pad.
638 getExceptionSelectorRegister(const Constant *PersonalityFn) const override;
639
641 Value *emitLoadLinked(IRBuilderBase &Builder, Type *ValueTy, Value *Addr,
642 AtomicOrdering Ord) const override;
644 AtomicOrdering Ord) const override;
645
646 void
647 emitAtomicCmpXchgNoStoreLLBalance(IRBuilderBase &Builder) const override;
648
650 AtomicOrdering Ord) const override;
652 AtomicOrdering Ord) const override;
653
654 unsigned getMaxSupportedInterleaveFactor() const override;
655
658 ArrayRef<unsigned> Indices,
659 unsigned Factor) const override;
661 unsigned Factor) const override;
662
663 bool shouldInsertFencesForAtomic(const Instruction *I) const override;
665 shouldExpandAtomicLoadInIR(LoadInst *LI) const override;
667 shouldExpandAtomicStoreInIR(StoreInst *SI) const override;
669 shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override;
672
673 bool useLoadStackGuardNode() const override;
674
675 void insertSSPDeclarations(Module &M) const override;
676 Value *getSDagStackGuard(const Module &M) const override;
677 Function *getSSPStackGuardCheck(const Module &M) const override;
678
679 bool canCombineStoreAndExtract(Type *VectorTy, Value *Idx,
680 unsigned &Cost) const override;
681
682 bool canMergeStoresTo(unsigned AddressSpace, EVT MemVT,
683 const MachineFunction &MF) const override {
684 // Do not merge to larger than i32.
685 return (MemVT.getSizeInBits() <= 32);
686 }
687
688 bool isCheapToSpeculateCttz(Type *Ty) const override;
689 bool isCheapToSpeculateCtlz(Type *Ty) const override;
690
691 bool convertSetCCLogicToBitwiseLogic(EVT VT) const override {
692 return VT.isScalarInteger();
693 }
694
695 bool supportSwiftError() const override {
696 return true;
697 }
698
699 bool hasStandaloneRem(EVT VT) const override {
700 return HasStandaloneRem;
701 }
702
705 unsigned ExpansionFactor) const override;
706
707 CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool isVarArg) const;
708 CCAssignFn *CCAssignFnForReturn(CallingConv::ID CC, bool isVarArg) const;
709
710 /// Returns true if \p VecTy is a legal interleaved access type. This
711 /// function checks the vector element type and the overall width of the
712 /// vector.
713 bool isLegalInterleavedAccessType(unsigned Factor, FixedVectorType *VecTy,
714 Align Alignment,
715 const DataLayout &DL) const;
716
718 SDValue ConstNode) const override;
719
720 bool alignLoopsWithOptSize() const override;
721
722 /// Returns the number of interleaved accesses that will be generated when
723 /// lowering accesses of the given type.
725 const DataLayout &DL) const;
726
727 void finalizeLowering(MachineFunction &MF) const override;
728
729 /// Return the correct alignment for the current calling convention.
731 const DataLayout &DL) const override;
732
734 CombineLevel Level) const override;
735
736 bool isDesirableToCommuteXorWithShift(const SDNode *N) const override;
737
739 CombineLevel Level) const override;
740
741 bool shouldFoldSelectWithIdentityConstant(unsigned BinOpcode,
742 EVT VT) const override;
743
744 bool preferIncOfAddToSubOfNot(EVT VT) const override;
745
746 bool shouldConvertFpToSat(unsigned Op, EVT FPVT, EVT VT) const override;
747
748 bool isComplexDeinterleavingSupported() const override;
750 ComplexDeinterleavingOperation Operation, Type *Ty) const override;
751
754 ComplexDeinterleavingRotation Rotation, Value *InputA, Value *InputB,
755 Value *Accumulator = nullptr) const override;
756
757 protected:
758 std::pair<const TargetRegisterClass *, uint8_t>
760 MVT VT) const override;
761
762 private:
763 /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
764 /// make the right decision when generating code for different targets.
765 const ARMSubtarget *Subtarget;
766
768
769 const InstrItineraryData *Itins;
770
771 // TODO: remove this, and have shouldInsertFencesForAtomic do the proper
772 // check.
773 bool InsertFencesForAtomic;
774
775 bool HasStandaloneRem = true;
776
777 void addTypeForNEON(MVT VT, MVT PromotedLdStVT);
778 void addDRTypeForNEON(MVT VT);
779 void addQRTypeForNEON(MVT VT);
780 std::pair<SDValue, SDValue> getARMXALUOOp(SDValue Op, SelectionDAG &DAG, SDValue &ARMcc) const;
781
782 using RegsToPassVector = SmallVector<std::pair<unsigned, SDValue>, 8>;
783
784 void PassF64ArgInRegs(const SDLoc &dl, SelectionDAG &DAG, SDValue Chain,
785 SDValue &Arg, RegsToPassVector &RegsToPass,
786 CCValAssign &VA, CCValAssign &NextVA,
787 SDValue &StackPtr,
788 SmallVectorImpl<SDValue> &MemOpChains,
789 bool IsTailCall,
790 int SPDiff) const;
791 SDValue GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA,
792 SDValue &Root, SelectionDAG &DAG,
793 const SDLoc &dl) const;
794
795 CallingConv::ID getEffectiveCallingConv(CallingConv::ID CC,
796 bool isVarArg) const;
797 CCAssignFn *CCAssignFnForNode(CallingConv::ID CC, bool Return,
798 bool isVarArg) const;
799 std::pair<SDValue, MachinePointerInfo>
800 computeAddrForCallArg(const SDLoc &dl, SelectionDAG &DAG,
801 const CCValAssign &VA, SDValue StackPtr,
802 bool IsTailCall, int SPDiff) const;
803 SDValue LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const;
804 SDValue LowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG) const;
805 SDValue LowerEH_SJLJ_SETUP_DISPATCH(SDValue Op, SelectionDAG &DAG) const;
806 SDValue LowerINTRINSIC_VOID(SDValue Op, SelectionDAG &DAG,
807 const ARMSubtarget *Subtarget) const;
808 SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG,
809 const ARMSubtarget *Subtarget) const;
810 SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
811 SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
812 SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
813 SDValue LowerGlobalAddressDarwin(SDValue Op, SelectionDAG &DAG) const;
814 SDValue LowerGlobalAddressELF(SDValue Op, SelectionDAG &DAG) const;
815 SDValue LowerGlobalAddressWindows(SDValue Op, SelectionDAG &DAG) const;
816 SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
817 SDValue LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
818 SelectionDAG &DAG) const;
819 SDValue LowerToTLSExecModels(GlobalAddressSDNode *GA,
820 SelectionDAG &DAG,
821 TLSModel::Model model) const;
822 SDValue LowerGlobalTLSAddressDarwin(SDValue Op, SelectionDAG &DAG) const;
823 SDValue LowerGlobalTLSAddressWindows(SDValue Op, SelectionDAG &DAG) const;
824 SDValue LowerBR_JT(SDValue Op, SelectionDAG &DAG) const;
825 SDValue LowerSignedALUO(SDValue Op, SelectionDAG &DAG) const;
826 SDValue LowerUnsignedALUO(SDValue Op, SelectionDAG &DAG) const;
827 SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
828 SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
829 SDValue LowerBRCOND(SDValue Op, SelectionDAG &DAG) const;
830 SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
831 SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
832 SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
833 SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
834 SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
835 SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
836 SDValue LowerGET_ROUNDING(SDValue Op, SelectionDAG &DAG) const;
837 SDValue LowerSET_ROUNDING(SDValue Op, SelectionDAG &DAG) const;
838 SDValue LowerConstantFP(SDValue Op, SelectionDAG &DAG,
839 const ARMSubtarget *ST) const;
840 SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG,
841 const ARMSubtarget *ST) const;
842 SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
843 SDValue LowerFSINCOS(SDValue Op, SelectionDAG &DAG) const;
844 SDValue LowerDivRem(SDValue Op, SelectionDAG &DAG) const;
845 SDValue LowerDIV_Windows(SDValue Op, SelectionDAG &DAG, bool Signed) const;
846 void ExpandDIV_Windows(SDValue Op, SelectionDAG &DAG, bool Signed,
848 SDValue ExpandBITCAST(SDNode *N, SelectionDAG &DAG,
849 const ARMSubtarget *Subtarget) const;
850 SDValue LowerWindowsDIVLibCall(SDValue Op, SelectionDAG &DAG, bool Signed,
851 SDValue &Chain) const;
852 SDValue LowerREM(SDNode *N, SelectionDAG &DAG) const;
853 SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const;
854 SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
855 SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
856 SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) const;
857 SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
858 SDValue LowerFSETCC(SDValue Op, SelectionDAG &DAG) const;
859 SDValue LowerSPONENTRY(SDValue Op, SelectionDAG &DAG) const;
860 void LowerLOAD(SDNode *N, SmallVectorImpl<SDValue> &Results,
861 SelectionDAG &DAG) const;
862
863 Register getRegisterByName(const char* RegName, LLT VT,
864 const MachineFunction &MF) const override;
865
866 SDValue BuildSDIVPow2(SDNode *N, const APInt &Divisor, SelectionDAG &DAG,
867 SmallVectorImpl<SDNode *> &Created) const override;
868
869 bool isFMAFasterThanFMulAndFAdd(const MachineFunction &MF,
870 EVT VT) const override;
871
872 SDValue MoveToHPR(const SDLoc &dl, SelectionDAG &DAG, MVT LocVT, MVT ValVT,
873 SDValue Val) const;
874 SDValue MoveFromHPR(const SDLoc &dl, SelectionDAG &DAG, MVT LocVT,
875 MVT ValVT, SDValue Val) const;
876
877 SDValue ReconstructShuffle(SDValue Op, SelectionDAG &DAG) const;
878
879 SDValue LowerCallResult(SDValue Chain, SDValue InGlue,
880 CallingConv::ID CallConv, bool isVarArg,
882 const SDLoc &dl, SelectionDAG &DAG,
883 SmallVectorImpl<SDValue> &InVals, bool isThisReturn,
884 SDValue ThisVal) const;
885
886 bool supportSplitCSR(MachineFunction *MF) const override {
888 MF->getFunction().hasFnAttribute(Attribute::NoUnwind);
889 }
890
891 void initializeSplitCSR(MachineBasicBlock *Entry) const override;
892 void insertCopiesSplitCSR(
893 MachineBasicBlock *Entry,
894 const SmallVectorImpl<MachineBasicBlock *> &Exits) const override;
895
896 bool splitValueIntoRegisterParts(
897 SelectionDAG & DAG, const SDLoc &DL, SDValue Val, SDValue *Parts,
898 unsigned NumParts, MVT PartVT, std::optional<CallingConv::ID> CC)
899 const override;
900
901 SDValue joinRegisterPartsIntoValue(
902 SelectionDAG & DAG, const SDLoc &DL, const SDValue *Parts,
903 unsigned NumParts, MVT PartVT, EVT ValueVT,
904 std::optional<CallingConv::ID> CC) const override;
905
906 SDValue
907 LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
908 const SmallVectorImpl<ISD::InputArg> &Ins,
909 const SDLoc &dl, SelectionDAG &DAG,
910 SmallVectorImpl<SDValue> &InVals) const override;
911
912 int StoreByValRegs(CCState &CCInfo, SelectionDAG &DAG, const SDLoc &dl,
913 SDValue &Chain, const Value *OrigArg,
914 unsigned InRegsParamRecordIdx, int ArgOffset,
915 unsigned ArgSize) const;
916
917 void VarArgStyleRegisters(CCState &CCInfo, SelectionDAG &DAG,
918 const SDLoc &dl, SDValue &Chain,
919 unsigned ArgOffset, unsigned TotalArgRegsSaveSize,
920 bool ForceMutable = false) const;
921
922 SDValue LowerCall(TargetLowering::CallLoweringInfo &CLI,
923 SmallVectorImpl<SDValue> &InVals) const override;
924
925 /// HandleByVal - Target-specific cleanup for ByVal support.
926 void HandleByVal(CCState *, unsigned &, Align) const override;
927
928 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
929 /// for tail call optimization. Targets which want to do tail call
930 /// optimization should implement this function.
931 bool IsEligibleForTailCallOptimization(
932 SDValue Callee, CallingConv::ID CalleeCC, bool isVarArg,
933 bool isCalleeStructRet, bool isCallerStructRet,
934 const SmallVectorImpl<ISD::OutputArg> &Outs,
935 const SmallVectorImpl<SDValue> &OutVals,
936 const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG,
937 const bool isIndirect) const;
938
939 bool CanLowerReturn(CallingConv::ID CallConv,
940 MachineFunction &MF, bool isVarArg,
941 const SmallVectorImpl<ISD::OutputArg> &Outs,
942 LLVMContext &Context) const override;
943
944 SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
945 const SmallVectorImpl<ISD::OutputArg> &Outs,
946 const SmallVectorImpl<SDValue> &OutVals,
947 const SDLoc &dl, SelectionDAG &DAG) const override;
948
949 bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const override;
950
951 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
952
953 bool shouldConsiderGEPOffsetSplit() const override { return true; }
954
955 bool isUnsupportedFloatingType(EVT VT) const;
956
957 SDValue getCMOV(const SDLoc &dl, EVT VT, SDValue FalseVal, SDValue TrueVal,
958 SDValue ARMcc, SDValue CCR, SDValue Cmp,
959 SelectionDAG &DAG) const;
960 SDValue getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
961 SDValue &ARMcc, SelectionDAG &DAG, const SDLoc &dl) const;
962 SDValue getVFPCmp(SDValue LHS, SDValue RHS, SelectionDAG &DAG,
963 const SDLoc &dl, bool Signaling = false) const;
964 SDValue duplicateCmp(SDValue Cmp, SelectionDAG &DAG) const;
965
966 SDValue OptimizeVFPBrcond(SDValue Op, SelectionDAG &DAG) const;
967
968 void SetupEntryBlockForSjLj(MachineInstr &MI, MachineBasicBlock *MBB,
969 MachineBasicBlock *DispatchBB, int FI) const;
970
971 void EmitSjLjDispatchBlock(MachineInstr &MI, MachineBasicBlock *MBB) const;
972
973 MachineBasicBlock *EmitStructByval(MachineInstr &MI,
974 MachineBasicBlock *MBB) const;
975
976 MachineBasicBlock *EmitLowered__chkstk(MachineInstr &MI,
977 MachineBasicBlock *MBB) const;
978 MachineBasicBlock *EmitLowered__dbzchk(MachineInstr &MI,
979 MachineBasicBlock *MBB) const;
980 void addMVEVectorTypes(bool HasMVEFP);
981 void addAllExtLoads(const MVT From, const MVT To, LegalizeAction Action);
982 void setAllExpand(MVT VT);
983 };
984
990 };
991
992 namespace ARM {
993
994 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
995 const TargetLibraryInfo *libInfo);
996
997 } // end namespace ARM
998
999} // end namespace llvm
1000
1001#endif // LLVM_LIB_TARGET_ARM_ARMISELLOWERING_H
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu Simplify well known AMD library false FunctionCallee Callee
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Function Alias Analysis Results
This file contains the simple types necessary to represent the attributes associated with functions a...
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
uint64_t Addr
IRTranslator LLVM IR MI
#define RegName(no)
lazy value info
#define I(x, y, z)
Definition: MD5.cpp:58
unsigned const TargetRegisterInfo * TRI
PowerPC Reduce CR logical Operation
const char LLVMTargetMachineRef TM
This file defines the SmallVector class.
This file describes how to lower LLVM code to machine code.
@ Flags
Definition: TextStubV5.cpp:93
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:75
bool isReadOnly(const GlobalValue *GV) const
unsigned getMaxSupportedInterleaveFactor() const override
Get the maximum supported factor for interleaved memory accesses.
TargetLoweringBase::AtomicExpansionKind shouldExpandAtomicLoadInIR(LoadInst *LI) const override
Returns how the given (atomic) load should be expanded by the IR-level AtomicExpand pass.
unsigned getNumInterleavedAccesses(VectorType *VecTy, const DataLayout &DL) const
Returns the number of interleaved accesses that will be generated when lowering accesses of the given...
bool shouldInsertFencesForAtomic(const Instruction *I) const override
Whether AtomicExpandPass should automatically insert fences and reduce ordering for this atomic.
Align getABIAlignmentForCallingConv(Type *ArgTy, const DataLayout &DL) const override
Return the correct alignment for the current calling convention.
void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint, std::vector< SDValue > &Ops, SelectionDAG &DAG) const override
LowerAsmOperandForConstraint - Lower the specified operand into the Ops vector.
bool isDesirableToCommuteWithShift(const SDNode *N, CombineLevel Level) const override
Return true if it is profitable to move this shift by a constant amount through its operand,...
Register getExceptionPointerRegister(const Constant *PersonalityFn) const override
If a physical register, this returns the register that receives the exception address on entry to an ...
ConstraintWeight getSingleConstraintMatchWeight(AsmOperandInfo &info, const char *constraint) const override
Examine constraint string and operand type and determine a weight value.
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...
const ARMSubtarget * getSubtarget() const
bool isLegalT2ScaledAddressingMode(const AddrMode &AM, EVT VT) const
bool isLegalT1ScaledAddressingMode(const AddrMode &AM, EVT VT) const
Returns true if the addressing mode representing by AM is legal for the Thumb1 target,...
bool getPreIndexedAddressParts(SDNode *N, SDValue &Base, SDValue &Offset, ISD::MemIndexedMode &AM, SelectionDAG &DAG) const override
getPreIndexedAddressParts - returns true by value, base pointer and offset pointer and addressing mod...
bool shouldAlignPointerArgs(CallInst *CI, unsigned &MinSize, Align &PrefAlign) const override
Return true if the pointer arguments to CI should be aligned by aligning the object whose address is ...
bool shouldSinkOperands(Instruction *I, SmallVectorImpl< Use * > &Ops) const override
Check if sinking I's operands to I's basic block is profitable, because the operands can be folded in...
void ReplaceNodeResults(SDNode *N, SmallVectorImpl< SDValue > &Results, SelectionDAG &DAG) const override
ReplaceNodeResults - Replace the results of node with an illegal result type with new values built ou...
void emitAtomicCmpXchgNoStoreLLBalance(IRBuilderBase &Builder) const override
bool isMulAddWithConstProfitable(SDValue AddNode, SDValue ConstNode) const override
Return true if it may be profitable to transform (mul (add x, c1), c2) -> (add (mul x,...
bool isLegalAddImmediate(int64_t Imm) const override
isLegalAddImmediate - Return true if the specified immediate is legal add immediate,...
Instruction * emitTrailingFence(IRBuilderBase &Builder, Instruction *Inst, AtomicOrdering Ord) const override
bool supportSwiftError() const override
Return true if the target supports swifterror attribute.
bool isFNegFree(EVT VT) const override
Return true if an fneg operation is free to the point where it is never worthwhile to replace it with...
void finalizeLowering(MachineFunction &MF) const override
Execute target specific actions to finalize target lowering.
SDValue PerformMVETruncCombine(SDNode *N, DAGCombinerInfo &DCI) const
bool isFPImmLegal(const APFloat &Imm, EVT VT, bool ForCodeSize=false) const override
isFPImmLegal - Returns true if the target can instruction select the specified FP immediate natively.
ConstraintType getConstraintType(StringRef Constraint) const override
getConstraintType - Given a constraint letter, return the type of constraint it is for this target.
bool preferIncOfAddToSubOfNot(EVT VT) const override
These two forms are equivalent: sub y, (xor x, -1) add (add x, 1), y The variant with two add's is IR...
Function * getSSPStackGuardCheck(const Module &M) const override
If the target has a standard stack protection check function that performs validation and error handl...
void computeKnownBitsForTargetNode(const SDValue Op, KnownBits &Known, const APInt &DemandedElts, const SelectionDAG &DAG, unsigned Depth) const override
Determine which of the bits specified in Mask are known to be either zero or one and return them in t...
TargetLoweringBase::AtomicExpansionKind shouldExpandAtomicStoreInIR(StoreInst *SI) const override
Returns how the given (atomic) store should be expanded by the IR-level AtomicExpand pass into.
void insertSSPDeclarations(Module &M) const override
Inserts necessary declarations for SSP (stack protection) purpose.
SDValue PerformIntrinsicCombine(SDNode *N, DAGCombinerInfo &DCI) const
PerformIntrinsicCombine - ARM-specific DAG combining for intrinsics.
bool isDesirableToCommuteXorWithShift(const SDNode *N) const override
Return true if it is profitable to combine an XOR of a logical shift to create a logical shift of NOT...
unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const override
bool ExpandInlineAsm(CallInst *CI) const override
This hook allows the target to expand an inline asm call to be explicit llvm code if it wants to.
SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG) const
PerformCMOVCombine - Target-specific DAG combining for ARMISD::CMOV.
Value * createComplexDeinterleavingIR(IRBuilderBase &B, ComplexDeinterleavingOperation OperationType, ComplexDeinterleavingRotation Rotation, Value *InputA, Value *InputB, Value *Accumulator=nullptr) const override
Create the IR node for the given complex deinterleaving operation.
bool isComplexDeinterleavingSupported() const override
Does this target support complex deinterleaving.
Value * getSDagStackGuard(const Module &M) const override
Return the variable that's previously inserted by insertSSPDeclarations, if any, otherwise return nul...
SDValue PerformMVEExtCombine(SDNode *N, DAGCombinerInfo &DCI) const
bool shouldFoldConstantShiftPairToMask(const SDNode *N, CombineLevel Level) const override
Return true if it is profitable to fold a pair of shifts into a mask.
bool shouldFoldSelectWithIdentityConstant(unsigned BinOpcode, EVT VT) const override
Return true if pulling a binary operation into a select with an identity constant is profitable.
bool SimplifyDemandedBitsForTargetNode(SDValue Op, const APInt &OriginalDemandedBits, const APInt &OriginalDemandedElts, KnownBits &Known, TargetLoweringOpt &TLO, unsigned Depth) const override
Attempt to simplify any target nodes based on the demanded bits/elts, returning true on success.
EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context, EVT VT) const override
getSetCCResultType - Return the value type to use for ISD::SETCC.
MachineBasicBlock * EmitInstrWithCustomInserter(MachineInstr &MI, MachineBasicBlock *MBB) const override
This method should be implemented by targets that mark instructions with the 'usesCustomInserter' fla...
Value * emitStoreConditional(IRBuilderBase &Builder, Value *Val, Value *Addr, AtomicOrdering Ord) const override
Perform a store-conditional operation to Addr.
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...
CCAssignFn * CCAssignFnForReturn(CallingConv::ID CC, bool isVarArg) const
FastISel * createFastISel(FunctionLoweringInfo &funcInfo, const TargetLibraryInfo *libInfo) const override
createFastISel - This method returns a target specific FastISel object, or null if the target does no...
void AdjustInstrPostInstrSelection(MachineInstr &MI, SDNode *Node) const override
This method should be implemented by targets that mark instructions with the 'hasPostISelHook' flag.
TargetLoweringBase::AtomicExpansionKind shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override
Returns how the IR-level AtomicExpand pass should expand the given AtomicRMW, if at all.
bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT, unsigned Index) const override
Return true if EXTRACT_SUBVECTOR is cheap for this result type with this index.
bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I, MachineFunction &MF, unsigned Intrinsic) const override
getTgtMemIntrinsic - Represent NEON load and store intrinsics as MemIntrinsicNodes.
bool isTruncateFree(Type *SrcTy, Type *DstTy) const override
Return true if it's free to truncate a value of type FromTy to type ToTy.
bool isShuffleMaskLegal(ArrayRef< int > M, EVT VT) const override
isShuffleMaskLegal - Targets can use this to indicate that they only support some VECTOR_SHUFFLE oper...
bool shouldConvertConstantLoadToIntImm(const APInt &Imm, Type *Ty) const override
Returns true if it is beneficial to convert a load of a constant to just the constant itself.
bool shouldFormOverflowOp(unsigned Opcode, EVT VT, bool MathUsed) const override
Try to convert math with an overflow comparison into the corresponding DAG node operation.
bool useLoadStackGuardNode() const override
If this function returns true, SelectionDAGBuilder emits a LOAD_STACK_GUARD node when it is lowering ...
bool isSelectSupported(SelectSupportKind Kind) const override
const TargetRegisterClass * getRegClassFor(MVT VT, bool isDivergent=false) const override
getRegClassFor - Return the register class that should be used for the specified value type.
std::pair< const TargetRegisterClass *, uint8_t > findRepresentativeClass(const TargetRegisterInfo *TRI, MVT VT) const override
Return the largest legal super-reg register class of the register class for the specified type and it...
bool isZExtFree(SDValue Val, EVT VT2) const override
Return true if zero-extending the specific node Val to type VT2 is free (either because it's implicit...
bool isCheapToSpeculateCttz(Type *Ty) const override
Return true if it is cheap to speculate a call to intrinsic cttz.
bool shouldReassociateReduction(unsigned Opc, EVT VT) const override
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...
bool convertSetCCLogicToBitwiseLogic(EVT VT) const override
Use bitwise logic to make pairs of compares more efficient.
bool isCheapToSpeculateCtlz(Type *Ty) const override
Return true if it is cheap to speculate a call to intrinsic ctlz.
bool targetShrinkDemandedConstant(SDValue Op, const APInt &DemandedBits, const APInt &DemandedElts, TargetLoweringOpt &TLO) const override
bool lowerInterleavedStore(StoreInst *SI, ShuffleVectorInst *SVI, unsigned Factor) const override
Lower an interleaved store into a vstN intrinsic.
bool isComplexDeinterleavingOperationSupported(ComplexDeinterleavingOperation Operation, Type *Ty) const override
Does this target support complex deinterleaving with the given operation and type.
SDValue PerformBRCONDCombine(SDNode *N, SelectionDAG &DAG) const
PerformBRCONDCombine - Target-specific DAG combining for ARMISD::BRCOND.
const char * getTargetNodeName(unsigned Opcode) const override
This method returns the name of a target specific DAG node.
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...
Type * shouldConvertSplatType(ShuffleVectorInst *SVI) const override
Given a shuffle vector SVI representing a vector splat, return a new scalar type of size equal to SVI...
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.
Instruction * makeDMB(IRBuilderBase &Builder, ARM_MB::MemBOpt Domain) const
bool isLegalICmpImmediate(int64_t Imm) const override
isLegalICmpImmediate - Return true if the specified immediate is legal icmp immediate,...
const char * LowerXConstraint(EVT ConstraintVT) const override
Try to replace an X constraint, which matches anything, with another that has more specific requireme...
unsigned getJumpTableEncoding() const override
Return the entry encoding for a jump table in the current function.
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,...
bool isDesirableToTransformToIntegerOp(unsigned Opc, EVT VT) const override
Return true if it is profitable for dag combiner to transform a floating point op of specified opcode...
TargetLoweringBase::AtomicExpansionKind shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const override
Returns how the given atomic cmpxchg should be expanded by the IR-level AtomicExpand pass.
CCAssignFn * CCAssignFnForCall(CallingConv::ID CC, bool isVarArg) const
bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace, Align Alignment, MachineMemOperand::Flags Flags, unsigned *Fast) const override
allowsMisalignedMemoryAccesses - Returns true if the target allows unaligned memory accesses of the s...
bool isLegalInterleavedAccessType(unsigned Factor, FixedVectorType *VecTy, Align Alignment, const DataLayout &DL) const
Returns true if VecTy is a legal interleaved access type.
bool isVectorLoadExtDesirable(SDValue ExtVal) const override
Return true if folding a vector load into ExtVal (a sign, zero, or any extend node) is profitable.
bool canCombineStoreAndExtract(Type *VectorTy, Value *Idx, unsigned &Cost) const override
Return true if the target can combine store(extractelement VectorTy, Idx).
bool lowerInterleavedLoad(LoadInst *LI, ArrayRef< ShuffleVectorInst * > Shuffles, ArrayRef< unsigned > Indices, unsigned Factor) const override
Lower an interleaved load into a vldN intrinsic.
bool preferZeroCompareBranch() const override
Return true if the heuristic to prefer icmp eq zero should be used in code gen prepare.
bool canMergeStoresTo(unsigned AddressSpace, EVT MemVT, const MachineFunction &MF) const override
Returns if it's reasonable to merge stores to MemVT size.
bool useSoftFloat() const override
bool alignLoopsWithOptSize() const override
Should loops be aligned even when the function is marked OptSize (but not MinSize).
SDValue PerformCMOVToBFICombine(SDNode *N, SelectionDAG &DAG) const
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 ...
std::pair< unsigned, const TargetRegisterClass * > getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI, StringRef Constraint, MVT VT) const override
Given a physical register constraint (e.g.
bool shouldConvertFpToSat(unsigned Op, EVT FPVT, EVT VT) const override
Should we generate fp_to_si_sat and fp_to_ui_sat from type FPVT to type VT from min(max(fptoi)) satur...
bool functionArgumentNeedsConsecutiveRegisters(Type *Ty, CallingConv::ID CallConv, bool isVarArg, const DataLayout &DL) const override
Returns true if an argument of type Ty needs to be passed in a contiguous block of registers in calli...
bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override
Return true if folding a constant offset with the given GlobalAddress is legal.
bool isMaskAndCmp0FoldingBeneficial(const Instruction &AndI) const override
Return if the target supports combining a chain like:
bool hasStandaloneRem(EVT VT) const override
Return true if the target can handle a standalone remainder operation.
ShiftLegalizationStrategy preferredShiftLegalizationStrategy(SelectionDAG &DAG, SDNode *N, unsigned ExpansionFactor) const override
bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, SDValue &Base, SDValue &Offset, ISD::MemIndexedMode &AM, SelectionDAG &DAG) const override
getPostIndexedAddressParts - returns true by value, base pointer and offset pointer and addressing mo...
Instruction * emitLeadingFence(IRBuilderBase &Builder, Instruction *Inst, AtomicOrdering Ord) const override
Inserts in the IR a target-specific intrinsic specifying a fence.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:513
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:718
CCValAssign - Represent assignment of one arg/retval to a location.
This class represents a function call, abstracting a target machine's calling convention.
This is an important base class in LLVM.
Definition: Constant.h:41
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
This is a fast-path instruction selection class that generates poor code and doesn't support illegal ...
Definition: FastISel.h:66
Class to represent fixed width SIMD vectors.
Definition: DerivedTypes.h:536
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:237
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:644
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:94
Itinerary data supplied by a subtarget to be used by a target.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
An instruction for reading from memory.
Definition: Instructions.h:177
Machine Value Type.
Function & getFunction()
Return the LLVM function that this machine code represents.
Representation of each machine instruction.
Definition: MachineInstr.h:68
Flags
Flags values. These may be or'd together.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Represents one node in the SelectionDAG.
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:225
This instruction constructs a fixed permutation of two input vectors.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:577
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
An instruction for storing to memory.
Definition: Instructions.h:301
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
Provides information about what library functions are available for the current target.
LegalizeAction
This enum indicates whether operations are valid for a target, and if not, what action should be used...
virtual bool shouldFormOverflowOp(unsigned Opcode, EVT VT, bool MathUsed) const
Try to convert math with an overflow comparison into the corresponding DAG node operation.
ShiftLegalizationStrategy
Return the preferred strategy to legalize tihs SHIFT instruction, with ExpansionFactor being the recu...
SelectSupportKind
Enum that describes what type of support for selects the target has.
Sched::Preference getSchedulingPreference() const
Return target scheduling preference.
AtomicExpansionKind
Enum that specifies what an atomic load/AtomicRMWInst is expanded to, if at all.
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
virtual unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:78
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
Base class of all SIMD vector types.
Definition: DerivedTypes.h:400
bool isBitFieldInvertedMask(unsigned v)
Rounding
Possible values of current rounding mode, which is specified in bits 23:22 of FPSCR.
const unsigned RoundingBitsPos
FastISel * createFastISel(FunctionLoweringInfo &funcInfo, const TargetLibraryInfo *libInfo)
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ CXX_FAST_TLS
Used for access functions.
Definition: CallingConv.h:72
@ Fast
Attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:41
@ BUILTIN_OP_END
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:1324
@ VECREDUCE_ADD
Integer reductions may have a result type larger than the vector element type.
Definition: ISDOpcodes.h:1297
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:1336
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:1396
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
Definition: ISDOpcodes.h:1447
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:440
AddressSpace
Definition: NVPTXBaseInfo.h:21
@ MVEVMVNModImm
AtomicOrdering
Atomic ordering for LLVM's memory model.
bool CCAssignFn(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
CCAssignFn - This function assigns a location for Val, updating State to reflect the change.
CombineLevel
Definition: DAGCombine.h:15
#define N
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Extended Value Type.
Definition: ValueTypes.h:34
TypeSize getSizeInBits() const
Return the size of the specified value type in bits.
Definition: ValueTypes.h:351
bool isScalarInteger() const
Return true if this is an integer, but not a vector.
Definition: ValueTypes.h:149