1 //==-- ARM64ISelLowering.h - ARM64 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 ARM64 uses to lower LLVM code into a
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_TARGET_ARM64_ISELLOWERING_H
16 #define LLVM_TARGET_ARM64_ISELLOWERING_H
18 #include "llvm/CodeGen/CallingConvLower.h"
19 #include "llvm/CodeGen/SelectionDAG.h"
20 #include "llvm/IR/CallingConv.h"
21 #include "llvm/Target/TargetLowering.h"
28 FIRST_NUMBER = ISD::BUILTIN_OP_END,
29 WrapperLarge, // 4-instruction MOVZ/MOVK sequence for 64-bit addresses.
30 CALL, // Function call.
32 // Almost the same as a normal call node, except that a TLSDesc relocation is
33 // needed so the linker can relax it correctly if possible.
35 ADRP, // Page address of a TargetGlobalAddress operand.
36 ADDlow, // Add the low 12 bits of a TargetGlobalAddress operand.
37 LOADgot, // Load from automatically generated descriptor (e.g. Global
38 // Offset Table, TLS record).
39 RET_FLAG, // Return with a flag operand. Operand 0 is the chain operand.
40 BRCOND, // Conditional branch instruction; "b.cond".
42 FCSEL, // Conditional move instruction.
43 CSINV, // Conditional select invert.
44 CSNEG, // Conditional select negate.
45 CSINC, // Conditional select increment.
47 // Pointer to the thread's local storage area. Materialised from TPIDR_EL0 on
51 SBC, // adc, sbc instructions
53 // Arithmetic instructions which write flags.
60 // Floating point comparison
63 // Floating point max and min instructions.
70 // Scalar-to-vector duplication
77 // Vector immedate moves
86 // Vector immediate ops
90 // Vector arithmetic negation
105 // Vector shift by scalar
110 // Vector shift by scalar (again)
117 // Vector comparisons
127 // Vector zero comparisons
139 // Vector bitwise negation
142 // Vector bitwise selection
145 // Compare-and-branch
154 // Custom prefetch handling
157 // {s|u}int to FP within a FP register.
162 } // end namespace ARM64ISD
164 class ARM64Subtarget;
165 class ARM64TargetMachine;
167 class ARM64TargetLowering : public TargetLowering {
168 bool RequireStrictAlign;
171 explicit ARM64TargetLowering(ARM64TargetMachine &TM);
173 /// Selects the correct CCAssignFn for a the given CallingConvention
175 CCAssignFn *CCAssignFnForCall(CallingConv::ID CC, bool IsVarArg) const;
177 /// computeMaskedBitsForTargetNode - Determine which of the bits specified in
178 /// Mask are known to be either zero or one and return them in the
179 /// KnownZero/KnownOne bitsets.
180 void computeMaskedBitsForTargetNode(const SDValue Op, APInt &KnownZero,
181 APInt &KnownOne, const SelectionDAG &DAG,
182 unsigned Depth = 0) const;
184 virtual MVT getScalarShiftAmountTy(EVT LHSTy) const;
186 /// allowsUnalignedMemoryAccesses - Returns true if the target allows
187 /// unaligned memory accesses. of the specified type.
188 virtual bool allowsUnalignedMemoryAccesses(EVT VT, unsigned AddrSpace = 0,
189 bool *Fast = 0) const {
190 if (RequireStrictAlign)
192 // FIXME: True for Cyclone, but not necessary others.
198 /// LowerOperation - Provide custom lowering hooks for some operations.
199 virtual SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const;
201 virtual const char *getTargetNodeName(unsigned Opcode) const;
203 virtual SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const;
205 /// getFunctionAlignment - Return the Log2 alignment of this function.
206 virtual unsigned getFunctionAlignment(const Function *F) const;
208 /// getMaximalGlobalOffset - Returns the maximal possible offset which can
209 /// be used for loads / stores from the global.
210 virtual unsigned getMaximalGlobalOffset() const;
212 /// Returns true if a cast between SrcAS and DestAS is a noop.
213 virtual bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const {
214 // Addrspacecasts are always noops.
218 /// createFastISel - This method returns a target specific FastISel object,
219 /// or null if the target does not support "fast" ISel.
220 virtual FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
221 const TargetLibraryInfo *libInfo) const;
223 virtual bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const;
225 virtual bool isFPImmLegal(const APFloat &Imm, EVT VT) const;
227 /// isShuffleMaskLegal - Return true if the given shuffle mask can be
228 /// codegen'd directly, or if it should be stack expanded.
229 virtual bool isShuffleMaskLegal(const SmallVectorImpl<int> &M, EVT VT) const;
231 /// getSetCCResultType - Return the ISD::SETCC ValueType
232 virtual EVT getSetCCResultType(LLVMContext &Context, EVT VT) const;
234 SDValue ReconstructShuffle(SDValue Op, SelectionDAG &DAG) const;
236 MachineBasicBlock *EmitAtomicBinary(MachineInstr *MI, MachineBasicBlock *BB,
237 unsigned Size, unsigned BinOpcode) const;
238 MachineBasicBlock *EmitAtomicCmpSwap(MachineInstr *MI, MachineBasicBlock *BB,
239 unsigned Size) const;
240 MachineBasicBlock *EmitAtomicBinary128(MachineInstr *MI,
241 MachineBasicBlock *BB,
242 unsigned BinOpcodeLo,
243 unsigned BinOpcodeHi) const;
244 MachineBasicBlock *EmitAtomicCmpSwap128(MachineInstr *MI,
245 MachineBasicBlock *BB) const;
246 MachineBasicBlock *EmitAtomicMinMax128(MachineInstr *MI,
247 MachineBasicBlock *BB,
248 unsigned CondCode) const;
249 MachineBasicBlock *EmitF128CSEL(MachineInstr *MI,
250 MachineBasicBlock *BB) const;
252 virtual MachineBasicBlock *
253 EmitInstrWithCustomInserter(MachineInstr *MI, MachineBasicBlock *MBB) const;
255 virtual bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
256 unsigned Intrinsic) const;
258 virtual bool isTruncateFree(Type *Ty1, Type *Ty2) const;
259 virtual bool isTruncateFree(EVT VT1, EVT VT2) const;
261 virtual bool isZExtFree(Type *Ty1, Type *Ty2) const;
262 virtual bool isZExtFree(EVT VT1, EVT VT2) const;
263 virtual bool isZExtFree(SDValue Val, EVT VT2) const;
265 virtual bool hasPairedLoad(Type *LoadedType,
266 unsigned &RequiredAligment) const;
267 virtual bool hasPairedLoad(EVT LoadedType, unsigned &RequiredAligment) const;
269 virtual bool isLegalAddImmediate(int64_t) const;
270 virtual bool isLegalICmpImmediate(int64_t) const;
272 virtual EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign,
273 unsigned SrcAlign, bool IsMemset,
274 bool ZeroMemset, bool MemcpyStrSrc,
275 MachineFunction &MF) const;
277 /// isLegalAddressingMode - Return true if the addressing mode represented
278 /// by AM is legal for this target, for a load/store of the specified type.
279 virtual bool isLegalAddressingMode(const AddrMode &AM, Type *Ty) const;
281 /// \brief Return the cost of the scaling factor used in the addressing
282 /// mode represented by AM for this target, for a load/store
283 /// of the specified type.
284 /// If the AM is supported, the return value must be >= 0.
285 /// If the AM is not supported, it returns a negative value.
286 virtual int getScalingFactorCost(const AddrMode &AM, Type *Ty) const;
288 /// isFMAFasterThanFMulAndFAdd - Return true if an FMA operation is faster
289 /// than a pair of fmul and fadd instructions. fmuladd intrinsics will be
290 /// expanded to FMAs when this method returns true, otherwise fmuladd is
291 /// expanded to fmul + fadd.
292 virtual bool isFMAFasterThanFMulAndFAdd(EVT VT) const;
294 virtual const uint16_t *getScratchRegisters(CallingConv::ID CC) const;
296 virtual bool shouldConvertConstantLoadToIntImm(const APInt &Imm,
300 /// Subtarget - Keep a pointer to the ARM64Subtarget around so that we can
301 /// make the right decision when generating code for different targets.
302 const ARM64Subtarget *Subtarget;
304 void addTypeForNEON(EVT VT, EVT PromotedBitwiseVT);
305 void addDRTypeForNEON(MVT VT);
306 void addQRTypeForNEON(MVT VT);
309 LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
310 const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
312 SmallVectorImpl<SDValue> &InVals) const;
314 virtual SDValue LowerCall(CallLoweringInfo & /*CLI*/,
315 SmallVectorImpl<SDValue> &InVals) const;
317 SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
318 CallingConv::ID CallConv, bool isVarArg,
319 const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc DL,
320 SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
321 bool isThisReturn, SDValue ThisVal) const;
323 bool isEligibleForTailCallOptimization(
324 SDValue Callee, CallingConv::ID CalleeCC, bool isVarArg,
325 bool isCalleeStructRet, bool isCallerStructRet,
326 const SmallVectorImpl<ISD::OutputArg> &Outs,
327 const SmallVectorImpl<SDValue> &OutVals,
328 const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG) const;
330 void saveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, SDLoc DL,
331 SDValue &Chain) const;
333 virtual bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
335 const SmallVectorImpl<ISD::OutputArg> &Outs,
336 LLVMContext &Context) const;
338 virtual SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv,
340 const SmallVectorImpl<ISD::OutputArg> &Outs,
341 const SmallVectorImpl<SDValue> &OutVals, SDLoc DL,
342 SelectionDAG &DAG) const;
344 SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
345 SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
346 SDValue LowerDarwinGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
347 SDValue LowerELFGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
348 SDValue LowerELFTLSDescCall(SDValue SymAddr, SDValue DescAddr, SDLoc DL,
349 SelectionDAG &DAG) const;
350 SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
351 SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) const;
352 SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
353 SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
354 SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
355 SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
356 SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
357 SDValue LowerAAPCS_VASTART(SDValue Op, SelectionDAG &DAG) const;
358 SDValue LowerDarwin_VASTART(SDValue Op, SelectionDAG &DAG) const;
359 SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
360 SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
361 SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
362 SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
363 SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
364 SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
365 SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
366 SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
367 SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
368 SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
369 SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
370 SDValue LowerVectorSRA_SRL_SHL(SDValue Op, SelectionDAG &DAG) const;
371 SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
372 SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG) const;
373 SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) const;
374 SDValue LowerCTPOP(SDValue Op, SelectionDAG &DAG) const;
375 SDValue LowerF128Call(SDValue Op, SelectionDAG &DAG,
376 RTLIB::Libcall Call) const;
377 SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
378 SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
379 SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
380 SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) const;
381 SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
382 SDValue LowerVectorAND(SDValue Op, SelectionDAG &DAG) const;
383 SDValue LowerVectorOR(SDValue Op, SelectionDAG &DAG) const;
384 SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
385 SDValue LowerFSINCOS(SDValue Op, SelectionDAG &DAG) const;
387 ConstraintType getConstraintType(const std::string &Constraint) const;
389 /// Examine constraint string and operand type and determine a weight value.
390 /// The operand object must already have been set up with the operand type.
391 ConstraintWeight getSingleConstraintMatchWeight(AsmOperandInfo &info,
392 const char *constraint) const;
394 std::pair<unsigned, const TargetRegisterClass *>
395 getRegForInlineAsmConstraint(const std::string &Constraint, MVT VT) const;
396 void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
397 std::vector<SDValue> &Ops,
398 SelectionDAG &DAG) const;
400 bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const;
401 bool mayBeEmittedAsTailCall(CallInst *CI) const;
402 bool getIndexedAddressParts(SDNode *Op, SDValue &Base, SDValue &Offset,
403 ISD::MemIndexedMode &AM, bool &IsInc,
404 SelectionDAG &DAG) const;
405 bool getPreIndexedAddressParts(SDNode *N, SDValue &Base, SDValue &Offset,
406 ISD::MemIndexedMode &AM,
407 SelectionDAG &DAG) const;
408 bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, SDValue &Base,
409 SDValue &Offset, ISD::MemIndexedMode &AM,
410 SelectionDAG &DAG) const;
412 void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue> &Results,
413 SelectionDAG &DAG) const;
417 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
418 const TargetLibraryInfo *libInfo);
419 } // end namespace ARM64
421 } // end namespace llvm
423 #endif // LLVM_TARGET_ARM64_ISELLOWERING_H