1 //==-- AArch64ISelLowering.h - AArch64 DAG Lowering Interface ----*- C++ -*-==//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the interfaces that AArch64 uses to lower LLVM code into a
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_TARGET_AARCH64_ISELLOWERING_H
16 #define LLVM_TARGET_AARCH64_ISELLOWERING_H
18 #include "Utils/AArch64BaseInfo.h"
19 #include "llvm/CodeGen/CallingConvLower.h"
20 #include "llvm/CodeGen/SelectionDAG.h"
21 #include "llvm/IR/Intrinsics.h"
22 #include "llvm/Target/TargetLowering.h"
25 namespace AArch64ISD {
27 // Start the numbering from where ISD NodeType finishes.
28 FIRST_NUMBER = ISD::BUILTIN_OP_END,
30 // This is a conditional branch which also notes the flag needed
31 // (eq/sgt/...). A64 puts this information on the branches rather than
32 // compares as LLVM does.
35 // A node to be selected to an actual call operation: either BL or BLR in
36 // the absence of tail calls.
39 // Indicates a floating-point immediate which fits into the format required
40 // by the FMOV instructions. First (and only) operand is the 8-bit encoded
41 // value of that immediate.
44 // Corresponds directly to an EXTR instruction. Operands are an LHS an RHS
48 // Wraps a load from the GOT, which should always be performed with a 64-bit
49 // load instruction. This prevents the DAG combiner folding a truncate to
50 // form a smaller memory access.
53 // Performs a bitfield insert. Arguments are: the value being inserted into;
54 // the value being inserted; least significant bit changed; width of the
58 // Simply a convenient node inserted during ISelLowering to represent
59 // procedure return. Will almost certainly be selected to "RET".
62 /// Extracts a field of contiguous bits from the source and sign extends
63 /// them into a single register. Arguments are: source; immr; imms. Note
64 /// these are pre-encoded since DAG matching can't cope with combining LSB
65 /// and Width into these values itself.
68 /// This is an A64-ification of the standard LLVM SELECT_CC operation. The
69 /// main difference is that it only has the values and an A64 condition,
70 /// which will be produced by a setcc instruction.
73 /// This serves most of the functions of the LLVM SETCC instruction, for two
74 /// purposes. First, it prevents optimisations from fiddling with the
75 /// compare after we've moved the CondCode information onto the SELECT_CC or
76 /// BR_CC instructions. Second, it gives a legal instruction for the actual
79 /// It keeps a record of the condition flags asked for because certain
80 /// instructions are only valid for a subset of condition codes.
83 // Designates a node which is a tail call: both a call and a return
84 // instruction as far as selction is concerned. It should be selected to an
85 // unconditional branch. Has the usual plethora of call operands, but: 1st
86 // is callee, 2nd is stack adjustment required immediately before branch.
89 // Designates a call used to support the TLS descriptor ABI. The call itself
90 // will be indirect ("BLR xN") but a relocation-specifier (".tlsdesccall
91 // var") must be attached somehow during code generation. It takes two
92 // operands: the callee and the symbol to be relocated against.
95 // Leaf node which will be lowered to an appropriate MRS to obtain the
96 // thread pointer: TPIDR_EL0.
99 /// Extracts a field of contiguous bits from the source and zero extends
100 /// them into a single register. Arguments are: source; immr; imms. Note
101 /// these are pre-encoded since DAG matching can't cope with combining LSB
102 /// and Width into these values itself.
105 // Wraps an address which the ISelLowering phase has decided should be
106 // created using the large memory model style: i.e. a sequence of four
107 // movz/movk instructions.
110 // Wraps an address which the ISelLowering phase has decided should be
111 // created using the small memory model style: i.e. adrp/add or
112 // adrp/mem-op. This exists to prevent bare TargetAddresses which may never
116 // Vector move immediate
119 // Vector Move Inverted Immediate
122 // Vector FP move immediate
133 // Vector Element reverse
141 // Vector compare zero
144 // Vector compare bitwise test
147 // Vector saturating shift
154 // Vector dup by lane
160 // NEON duplicate lane loads
161 NEON_LD2DUP = ISD::FIRST_TARGET_MEMORY_OPCODE,
165 // NEON loads with post-increment base updates:
174 // NEON stores with post-increment base updates:
183 // NEON duplicate lane loads with post-increment base updates:
188 // NEON lane loads with post-increment base updates:
193 // NEON lane store with post-increment base updates:
201 class AArch64Subtarget;
202 class AArch64TargetMachine;
204 class AArch64TargetLowering : public TargetLowering {
206 explicit AArch64TargetLowering(AArch64TargetMachine &TM);
208 const char *getTargetNodeName(unsigned Opcode) const override;
210 CCAssignFn *CCAssignFnForNode(CallingConv::ID CC) const;
212 SDValue LowerFormalArguments(SDValue Chain,
213 CallingConv::ID CallConv, bool isVarArg,
214 const SmallVectorImpl<ISD::InputArg> &Ins,
215 SDLoc dl, SelectionDAG &DAG,
216 SmallVectorImpl<SDValue> &InVals) const override;
218 SDValue LowerReturn(SDValue Chain,
219 CallingConv::ID CallConv, bool isVarArg,
220 const SmallVectorImpl<ISD::OutputArg> &Outs,
221 const SmallVectorImpl<SDValue> &OutVals,
222 SDLoc dl, SelectionDAG &DAG) const override;
224 unsigned getByValTypeAlignment(Type *Ty) const override;
226 SDValue LowerCall(CallLoweringInfo &CLI,
227 SmallVectorImpl<SDValue> &InVals) const override;
229 SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
230 CallingConv::ID CallConv, bool IsVarArg,
231 const SmallVectorImpl<ISD::InputArg> &Ins,
232 SDLoc dl, SelectionDAG &DAG,
233 SmallVectorImpl<SDValue> &InVals) const;
235 SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
236 SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
238 bool isConcatVector(SDValue Op, SelectionDAG &DAG, SDValue V0, SDValue V1,
239 const int *Mask, SDValue &Res) const;
241 bool isKnownShuffleVector(SDValue Op, SelectionDAG &DAG, SDValue &V0,
242 SDValue &V1, int *Mask) const;
244 SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG,
245 const AArch64Subtarget *ST) const;
247 SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
249 void SaveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, SDLoc DL,
250 SDValue &Chain) const;
252 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
253 /// for tail call optimization. Targets which want to do tail call
254 /// optimization should implement this function.
255 bool IsEligibleForTailCallOptimization(SDValue Callee,
256 CallingConv::ID CalleeCC,
258 bool IsCalleeStructRet,
259 bool IsCallerStructRet,
260 const SmallVectorImpl<ISD::OutputArg> &Outs,
261 const SmallVectorImpl<SDValue> &OutVals,
262 const SmallVectorImpl<ISD::InputArg> &Ins,
263 SelectionDAG& DAG) const;
265 /// Finds the incoming stack arguments which overlap the given fixed stack
266 /// object and incorporates their load into the current chain. This prevents
267 /// an upcoming store from clobbering the stack argument before it's used.
268 SDValue addTokenForArgument(SDValue Chain, SelectionDAG &DAG,
269 MachineFrameInfo *MFI, int ClobberedFI) const;
271 EVT getSetCCResultType(LLVMContext &Context, EVT VT) const override;
273 bool DoesCalleeRestoreStack(CallingConv::ID CallCC, bool TailCallOpt) const;
275 bool IsTailCallConvention(CallingConv::ID CallCC) const;
277 SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
279 bool isLegalICmpImmediate(int64_t Val) const override;
281 /// \brief Return true if the addressing mode represented by AM is legal for
282 /// this target, for a load/store of the specified type.
283 bool isLegalAddressingMode(const AddrMode &AM, Type *Ty) const override;
285 /// \brief Return the cost of the scaling factor used in the addressing
286 /// mode represented by AM for this target, for a load/store
287 /// of the specified type.
288 /// If the AM is supported, the return value must be >= 0.
289 /// If the AM is not supported, it returns a negative value.
290 int getScalingFactorCost(const AddrMode &AM, Type *Ty) const override;
292 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
293 bool isTruncateFree(EVT VT1, EVT VT2) const override;
295 bool isZExtFree(Type *Ty1, Type *Ty2) const override;
296 bool isZExtFree(EVT VT1, EVT VT2) const override;
297 bool isZExtFree(SDValue Val, EVT VT2) const override;
299 SDValue getSelectableIntSetCC(SDValue LHS, SDValue RHS, ISD::CondCode CC,
300 SDValue &A64cc, SelectionDAG &DAG, SDLoc &dl) const;
303 EmitInstrWithCustomInserter(MachineInstr *MI,
304 MachineBasicBlock *MBB) const override;
307 emitAtomicBinary(MachineInstr *MI, MachineBasicBlock *MBB,
308 unsigned Size, unsigned Opcode) const;
311 emitAtomicBinaryMinMax(MachineInstr *MI, MachineBasicBlock *BB,
312 unsigned Size, unsigned CmpOp,
313 A64CC::CondCodes Cond) const;
315 emitAtomicCmpSwap(MachineInstr *MI, MachineBasicBlock *BB,
316 unsigned Size) const;
319 EmitF128CSEL(MachineInstr *MI, MachineBasicBlock *MBB) const;
321 SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG) const;
322 SDValue LowerATOMIC_STORE(SDValue Op, SelectionDAG &DAG) const;
323 SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
324 SDValue LowerBRCOND(SDValue Op, SelectionDAG &DAG) const;
325 SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
326 SDValue LowerF128ToCall(SDValue Op, SelectionDAG &DAG,
327 RTLIB::Libcall Call) const;
328 SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
329 SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
330 SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG, bool IsSigned) const;
331 SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
332 SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
334 SDValue LowerGlobalAddressELFSmall(SDValue Op, SelectionDAG &DAG) const;
335 SDValue LowerGlobalAddressELFLarge(SDValue Op, SelectionDAG &DAG) const;
336 SDValue LowerGlobalAddressELF(SDValue Op, SelectionDAG &DAG) const;
338 SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
340 SDValue LowerTLSDescCall(SDValue SymAddr, SDValue DescAddr, SDLoc DL,
341 SelectionDAG &DAG) const;
342 SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
343 SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG, bool IsSigned) const;
344 SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
345 SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
346 SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
347 SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
348 SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
349 SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
351 SDValue PerformDAGCombine(SDNode *N,DAGCombinerInfo &DCI) const override;
353 unsigned getRegisterByName(const char* RegName, EVT VT) const override;
355 /// isFMAFasterThanFMulAndFAdd - Return true if an FMA operation is faster
356 /// than a pair of fmul and fadd instructions. fmuladd intrinsics will be
357 /// expanded to FMAs when this method returns true, otherwise fmuladd is
358 /// expanded to fmul + fadd.
359 bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
361 /// allowsUnalignedMemoryAccesses - Returns true if the target allows
362 /// unaligned memory accesses of the specified type. Returns whether it
363 /// is "fast" by reference in the second argument.
364 bool allowsUnalignedMemoryAccesses(EVT VT, unsigned AddrSpace,
365 bool *Fast) const override;
368 getConstraintType(const std::string &Constraint) const override;
371 getSingleConstraintMatchWeight(AsmOperandInfo &Info,
372 const char *Constraint) const override;
373 void LowerAsmOperandForConstraint(SDValue Op,
374 std::string &Constraint,
375 std::vector<SDValue> &Ops,
376 SelectionDAG &DAG) const override;
378 std::pair<unsigned, const TargetRegisterClass*>
379 getRegForInlineAsmConstraint(const std::string &Constraint,
380 MVT VT) const override;
382 bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
383 unsigned Intrinsic) const override;
385 /// getMaximalGlobalOffset - Returns the maximal possible offset which can
386 /// be used for loads / stores from the global.
387 unsigned getMaximalGlobalOffset() const override;
390 std::pair<const TargetRegisterClass*, uint8_t>
391 findRepresentativeClass(MVT VT) const override;
394 const InstrItineraryData *Itins;
396 const AArch64Subtarget *getSubtarget() const {
397 return &getTargetMachine().getSubtarget<AArch64Subtarget>();
400 enum NeonModImmType {
405 extern SDValue ScanBUILD_VECTOR(SDValue Op, bool &isOnlyLowElement,
406 bool &usesOnlyOneValue, bool &hasDominantValue,
407 bool &isConstant, bool &isUNDEF);
410 #endif // LLVM_TARGET_AARCH64_ISELLOWERING_H