LLVM 20.0.0git
LoongArchISelLowering.h
Go to the documentation of this file.
1//=- LoongArchISelLowering.h - LoongArch 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 LoongArch uses to lower LLVM code into
10// a selection DAG.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_LOONGARCH_LOONGARCHISELLOWERING_H
15#define LLVM_LIB_TARGET_LOONGARCH_LOONGARCHISELLOWERING_H
16
17#include "LoongArch.h"
21
22namespace llvm {
23class LoongArchSubtarget;
24namespace LoongArchISD {
25enum NodeType : unsigned {
27
28 // TODO: add more LoongArchISDs
36
37 // 32-bit shifts, directly matching the semantics of the named LoongArch
38 // instructions.
42
45
46 // unsigned 32-bit integer division
49
50 // FPR<->GPR transfer operations
55
57
58 // Bit counting operations
61
64
65 // Byte-swapping and bit-reversal
70
71 // Intrinsic operations start ============================================
78
79 // CRC check operations
88
90
91 // Write new value to CSR and return old value.
92 // Operand 0: A chain pointer.
93 // Operand 1: The new value to write.
94 // Operand 2: The address of the required CSR.
95 // Result 0: The old value of the CSR.
96 // Result 1: The new chain pointer.
98
99 // Similar to CSRWR but with a write mask.
100 // Operand 0: A chain pointer.
101 // Operand 1: The new value to write.
102 // Operand 2: The write mask.
103 // Operand 3: The address of the required CSR.
104 // Result 0: The old value of the CSR.
105 // Result 1: The new chain pointer.
107
108 // IOCSR access operations
117
118 // Read CPU configuration information operation
120
121 // Vector Shuffle
133
134 // Extended vector element extraction
137
138 // Vector comparisons
143
144 // Intrinsic operations end =============================================
145};
146} // end namespace LoongArchISD
147
149 const LoongArchSubtarget &Subtarget;
150
151public:
152 explicit LoongArchTargetLowering(const TargetMachine &TM,
153 const LoongArchSubtarget &STI);
154
155 const LoongArchSubtarget &getSubtarget() const { return Subtarget; }
156
157 bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
158
159 // Provide custom lowering hooks for some operations.
160 SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
162 SelectionDAG &DAG) const override;
163
164 SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
165
166 // This method returns the name of a target specific DAG node.
167 const char *getTargetNodeName(unsigned Opcode) const override;
168
169 // Lower incoming arguments, copy physregs into vregs.
171 bool IsVarArg,
173 const SDLoc &DL, SelectionDAG &DAG,
174 SmallVectorImpl<SDValue> &InVals) const override;
176 bool IsVarArg,
178 LLVMContext &Context) const override;
179 SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool IsVarArg,
181 const SmallVectorImpl<SDValue> &OutVals, const SDLoc &DL,
182 SelectionDAG &DAG) const override;
184 SmallVectorImpl<SDValue> &InVals) const override;
185 bool isCheapToSpeculateCttz(Type *Ty) const override;
186 bool isCheapToSpeculateCtlz(Type *Ty) const override;
187 bool hasAndNot(SDValue Y) const override;
189 shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override;
190
192 Value *AlignedAddr, Value *Incr,
193 Value *Mask, Value *ShiftAmt,
194 AtomicOrdering Ord) const override;
195
197 EVT VT) const override;
202 Value *AlignedAddr, Value *CmpVal,
203 Value *NewVal, Value *Mask,
204 AtomicOrdering Ord) const override;
205
206 bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
207 MachineFunction &MF,
208 unsigned Intrinsic) const override;
209
211 EVT VT) const override;
212
214 getExceptionPointerRegister(const Constant *PersonalityFn) const override;
215
217 getExceptionSelectorRegister(const Constant *PersonalityFn) const override;
218
220 return ISD::SIGN_EXTEND;
221 }
222
224
225 Register getRegisterByName(const char *RegName, LLT VT,
226 const MachineFunction &MF) const override;
227 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
228
229 bool decomposeMulByConstant(LLVMContext &Context, EVT VT,
230 SDValue C) const override;
231
232 bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const override;
233
234 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
235 unsigned AS,
236 Instruction *I = nullptr) const override;
237
238 bool isLegalICmpImmediate(int64_t Imm) const override;
239 bool isLegalAddImmediate(int64_t Imm) const override;
240 bool isZExtFree(SDValue Val, EVT VT2) const override;
241 bool isSExtCheaperThanZExt(EVT SrcVT, EVT DstVT) const override;
242 bool signExtendConstant(const ConstantInt *CI) const override;
243
244 bool hasAndNotCompare(SDValue Y) const override;
245
246 bool convertSelectOfConstantsToMath(EVT VT) const override { return true; }
247
249 EVT VT, unsigned AddrSpace = 0, Align Alignment = Align(1),
251 unsigned *Fast = nullptr) const override;
252
253 bool isShuffleMaskLegal(ArrayRef<int> Mask, EVT VT) const override {
254 return false;
255 }
256 bool shouldConsiderGEPOffsetSplit() const override { return true; }
257 bool shouldSignExtendTypeInLibCall(EVT Type, bool IsSigned) const override;
258 bool shouldExtendTypeInLibCall(EVT Type) const override;
259
260 bool shouldAlignPointerArgs(CallInst *CI, unsigned &MinSize,
261 Align &PrefAlign) const override;
262
263 bool isFPImmVLDILegal(const APFloat &Imm, EVT VT) const;
264
265private:
266 /// Target-specific function used to lower LoongArch calling conventions.
267 typedef bool LoongArchCCAssignFn(const DataLayout &DL, LoongArchABI::ABI ABI,
268 unsigned ValNo, MVT ValVT,
269 CCValAssign::LocInfo LocInfo,
270 ISD::ArgFlagsTy ArgFlags, CCState &State,
271 bool IsFixed, bool IsReg, Type *OrigTy);
272
273 void analyzeInputArgs(MachineFunction &MF, CCState &CCInfo,
274 const SmallVectorImpl<ISD::InputArg> &Ins, bool IsRet,
275 LoongArchCCAssignFn Fn) const;
276 void analyzeOutputArgs(MachineFunction &MF, CCState &CCInfo,
278 bool IsRet, CallLoweringInfo *CLI,
279 LoongArchCCAssignFn Fn) const;
280
281 template <class NodeTy>
282 SDValue getAddr(NodeTy *N, SelectionDAG &DAG, CodeModel::Model M,
283 bool IsLocal = true) const;
284 SDValue getStaticTLSAddr(GlobalAddressSDNode *N, SelectionDAG &DAG,
285 unsigned Opc, bool UseGOT, bool Large = false) const;
286 SDValue getDynamicTLSAddr(GlobalAddressSDNode *N, SelectionDAG &DAG,
287 unsigned Opc, bool Large = false) const;
288 SDValue getTLSDescAddr(GlobalAddressSDNode *N, SelectionDAG &DAG,
289 unsigned Opc, bool Large = false) const;
290 SDValue lowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
291 SDValue lowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
292 SDValue lowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
293 SDValue lowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
294 SDValue lowerShiftLeftParts(SDValue Op, SelectionDAG &DAG) const;
295 SDValue lowerShiftRightParts(SDValue Op, SelectionDAG &DAG, bool IsSRA) const;
296
298 EmitInstrWithCustomInserter(MachineInstr &MI,
299 MachineBasicBlock *BB) const override;
300 SDValue lowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG) const;
301 SDValue lowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
302 SDValue lowerEH_DWARF_CFA(SDValue Op, SelectionDAG &DAG) const;
303 SDValue lowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) const;
304 SDValue lowerBITCAST(SDValue Op, SelectionDAG &DAG) const;
305 SDValue lowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
306 SDValue lowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
307 SDValue lowerVASTART(SDValue Op, SelectionDAG &DAG) const;
308 SDValue lowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
309 SDValue lowerINTRINSIC_W_CHAIN(SDValue Op, SelectionDAG &DAG) const;
310 SDValue lowerINTRINSIC_VOID(SDValue Op, SelectionDAG &DAG) const;
311 SDValue lowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
312 SDValue lowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
313 SDValue lowerWRITE_REGISTER(SDValue Op, SelectionDAG &DAG) const;
314 SDValue lowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
315 SDValue lowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
316 SDValue lowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
317 SDValue lowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
318
319 bool isFPImmLegal(const APFloat &Imm, EVT VT,
320 bool ForCodeSize) const override;
321
322 bool shouldInsertFencesForAtomic(const Instruction *I) const override;
323
324 ConstraintType getConstraintType(StringRef Constraint) const override;
325
327 getInlineAsmMemConstraint(StringRef ConstraintCode) const override;
328
329 std::pair<unsigned, const TargetRegisterClass *>
330 getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
331 StringRef Constraint, MVT VT) const override;
332
333 void LowerAsmOperandForConstraint(SDValue Op, StringRef Constraint,
334 std::vector<SDValue> &Ops,
335 SelectionDAG &DAG) const override;
336
337 bool isEligibleForTailCallOptimization(
338 CCState &CCInfo, CallLoweringInfo &CLI, MachineFunction &MF,
339 const SmallVectorImpl<CCValAssign> &ArgLocs) const;
340};
341
342} // end namespace llvm
343
344#endif // LLVM_LIB_TARGET_LOONGARCH_LOONGARCHISELLOWERING_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Function Alias Analysis Results
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
IRTranslator LLVM IR MI
#define RegName(no)
#define I(x, y, z)
Definition: MD5.cpp:58
unsigned const TargetRegisterInfo * TRI
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
This file describes how to lower LLVM code to machine code.
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:495
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:696
CCState - This class holds information needed while lowering arguments and return values.
This class represents a function call, abstracting a target machine's calling convention.
This is the shared class of boolean and integer constants.
Definition: Constants.h:81
This is an important base class in LLVM.
Definition: Constant.h:42
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:63
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:91
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
bool isShuffleMaskLegal(ArrayRef< int > Mask, EVT VT) const override
Targets can use this to indicate that they only support some VECTOR_SHUFFLE operations,...
bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const override
Return true if result of the specified node is used by a return node only.
bool convertSelectOfConstantsToMath(EVT VT) const override
Return true if a select of constants (select Cond, C1, C2) should be transformed into simple math ops...
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...
const LoongArchSubtarget & getSubtarget() const
bool isLegalICmpImmediate(int64_t Imm) const override
Return true if the specified immediate is legal icmp immediate, that is the target has icmp instructi...
TargetLowering::AtomicExpansionKind shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *CI) const override
Returns how the given atomic cmpxchg should be expanded by the IR-level AtomicExpand pass.
Value * emitMaskedAtomicCmpXchgIntrinsic(IRBuilderBase &Builder, AtomicCmpXchgInst *CI, Value *AlignedAddr, Value *CmpVal, Value *NewVal, Value *Mask, AtomicOrdering Ord) const override
Perform a masked cmpxchg using a target-specific intrinsic.
EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context, EVT VT) const override
Return the ValueType of the result of SETCC operations.
bool isFMAFasterThanFMulAndFAdd(const MachineFunction &MF, EVT VT) const override
Return true if an FMA operation is faster than a pair of fmul and fadd instructions.
SDValue LowerCall(TargetLowering::CallLoweringInfo &CLI, SmallVectorImpl< SDValue > &InVals) const override
This hook must be implemented to lower calls into the specified DAG.
bool decomposeMulByConstant(LLVMContext &Context, EVT VT, SDValue C) const override
Return true if it is profitable to transform an integer multiplication-by-constant into simpler opera...
bool isSExtCheaperThanZExt(EVT SrcVT, EVT DstVT) const override
Return true if sign-extension from FromTy to ToTy is cheaper than zero-extension.
TargetLowering::AtomicExpansionKind shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override
Returns how the IR-level AtomicExpand pass should expand the given AtomicRMW, if at all.
bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace=0, Align Alignment=Align(1), MachineMemOperand::Flags Flags=MachineMemOperand::MONone, unsigned *Fast=nullptr) const override
Determine if the target supports unaligned memory accesses.
bool isCheapToSpeculateCtlz(Type *Ty) const override
Return true if it is cheap to speculate a call to intrinsic ctlz.
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...
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 shouldSignExtendTypeInLibCall(EVT Type, bool IsSigned) const override
Returns true if arguments should be sign-extended in lib calls.
Value * emitMaskedAtomicRMWIntrinsic(IRBuilderBase &Builder, AtomicRMWInst *AI, Value *AlignedAddr, Value *Incr, Value *Mask, Value *ShiftAmt, AtomicOrdering Ord) const override
Perform a masked atomicrmw using a target-specific intrinsic.
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...
Register getExceptionPointerRegister(const Constant *PersonalityFn) const override
If a physical register, this returns the register that receives the exception address on entry to an ...
bool signExtendConstant(const ConstantInt *CI) const override
Return true if this constant should be sign extended when promoting to a larger type.
ISD::NodeType getExtendForAtomicOps() const override
Returns how the platform's atomic operations are extended (ZERO_EXTEND, SIGN_EXTEND,...
const char * getTargetNodeName(unsigned Opcode) const override
This method returns the name of a target specific DAG node.
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...
bool isLegalAddImmediate(int64_t Imm) const override
Return true if the specified immediate is legal add immediate, that is the target has add instruction...
bool isCheapToSpeculateCttz(Type *Ty) const override
Return true if it is cheap to speculate a call to intrinsic cttz.
bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty, unsigned AS, Instruction *I=nullptr) const override
Return true if the addressing mode represented by AM is legal for this target, for a load/store of th...
bool isFPImmVLDILegal(const APFloat &Imm, EVT VT) const
bool shouldExtendTypeInLibCall(EVT Type) const override
Returns true if arguments should be extended in lib calls.
Register getRegisterByName(const char *RegName, LLT VT, const MachineFunction &MF) const override
Return the register ID of the name passed in.
bool hasAndNot(SDValue Y) const override
Return true if the target has a bitwise and-not operation: X = ~A & B This can be used to simplify se...
bool shouldConsiderGEPOffsetSplit() const override
bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override
Return true if folding a constant offset with the given GlobalAddress is legal.
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...
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...
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...
ISD::NodeType getExtendForAtomicCmpSwapArg() const override
Returns how the platform's atomic compare and swap expects its comparison value to be extended (ZERO_...
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,...
bool hasAndNotCompare(SDValue Y) const override
Return true if the target should transform: (X & Y) == Y —> (~X & Y) == 0 (X & Y) !...
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,...
bool mayBeEmittedAsTailCall(const CallInst *CI) const override
Return true if the target may be able emit the call instruction as a tail call.
Machine Value Type.
Representation of each machine instruction.
Definition: MachineInstr.h:69
Flags
Flags values. These may be or'd together.
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:226
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
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...
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
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
@ Fast
Attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:41
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
Definition: ISDOpcodes.h:40
@ BUILTIN_OP_END
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:1480
@ SIGN_EXTEND
Conversion operators.
Definition: ISDOpcodes.h:804
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
AtomicOrdering
Atomic ordering for LLVM's memory model.
#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:35
This structure contains all information that is necessary for lowering calls.