31 RISCVOutgoingValueHandler(MachineIRBuilder &
B, MachineRegisterInfo &
MRI,
32 MachineInstrBuilder MIB)
33 : OutgoingValueHandler(
B,
MRI), MIB(MIB),
34 Subtarget(MIRBuilder.getMF().getSubtarget<RISCVSubtarget>()) {}
36 MachinePointerInfo &MPO,
37 ISD::ArgFlagsTy Flags)
override {
43 SPReg = MIRBuilder.buildCopy(p0,
Register(RISCV::X2)).getReg(0);
45 auto OffsetReg = MIRBuilder.buildConstant(iXLen,
Offset);
47 auto AddrReg = MIRBuilder.buildPtrAdd(p0, SPReg, OffsetReg);
50 return AddrReg.getReg(0);
54 const MachinePointerInfo &MPO,
55 const CCValAssign &VA)
override {
64 Register ExtReg = extendRegister(ValVReg, VA);
65 MIRBuilder.buildStore(ExtReg, Addr, *MMO);
69 const CCValAssign &VA,
70 ISD::ArgFlagsTy Flags = {})
override {
71 Register ExtReg = extendRegister(ValVReg, VA);
72 MIRBuilder.buildCopy(PhysReg, ExtReg);
73 MIB.addUse(PhysReg, RegState::Implicit);
76 unsigned assignCustomValue(CallLowering::ArgInfo &Arg,
78 std::function<
void()> *Thunk)
override {
79 const CCValAssign &VA = VAs[0];
80 bool NarrowValWideLoc =
83 bool FixedLenVecInScalableVec =
85 if (NarrowValWideLoc || FixedLenVecInScalableVec) {
88 std::function<void()> AssignFunc;
89 if (NarrowValWideLoc) {
96 auto Ext = MIRBuilder.buildAnyExt(LLT(VA.
getLocVT()), Src);
97 MIRBuilder.buildCopy(PhysReg, Ext);
98 MIB.addUse(PhysReg, RegState::Implicit);
100 }
else if (FixedLenVecInScalableVec) {
102 auto SubVec = MIRBuilder.buildInsertSubvector(
105 MIRBuilder.buildCopy(PhysReg, SubVec);
106 MIB.addUse(PhysReg, RegState::Implicit);
110 "A narrower value must be passed in a wider register or a fixed "
111 "length vector in a scalable vector register.");
114 *
Thunk = std::move(AssignFunc);
122 assert(VAs.
size() >= 2 &&
"Expected at least 2 VAs.");
123 const CCValAssign &VAHi = VAs[1];
127 "Values belong to different arguments");
131 "unexpected custom value");
135 MIRBuilder.buildUnmerge(NewRegs, Arg.
Regs[0]);
140 MachinePointerInfo MPO;
141 Register StackAddr = getStackAddress(
144 assignValueToAddress(NewRegs[1], StackAddr, MemTy, MPO,
145 const_cast<CCValAssign &
>(VAHi));
148 auto assignFunc = [=]() {
149 assignValueToReg(NewRegs[0], VA.
getLocReg(), VA);
151 assignValueToReg(NewRegs[1], VAHi.
getLocReg(), VAHi);
155 *
Thunk = std::move(assignFunc);
164 MachineInstrBuilder MIB;
169 const RISCVSubtarget &Subtarget;
173 RISCVIncomingValueHandler(MachineIRBuilder &
B, MachineRegisterInfo &
MRI)
174 : IncomingValueHandler(
B,
MRI),
175 Subtarget(MIRBuilder.getMF().getSubtarget<RISCVSubtarget>()) {}
178 MachinePointerInfo &MPO,
179 ISD::ArgFlagsTy Flags)
override {
180 MachineFrameInfo &MFI = MIRBuilder.getMF().getFrameInfo();
184 return MIRBuilder.buildFrameIndex(
LLT::pointer(0, Subtarget.getXLen()), FI)
189 const MachinePointerInfo &MPO,
190 const CCValAssign &VA)
override {
194 MIRBuilder.buildLoad(ValVReg, Addr, *MMO);
198 const CCValAssign &VA,
199 ISD::ArgFlagsTy Flags = {})
override {
200 markPhysRegUsed(PhysReg);
201 IncomingValueHandler::assignValueToReg(ValVReg, PhysReg, VA);
204 unsigned assignCustomValue(CallLowering::ArgInfo &Arg,
206 std::function<
void()> *Thunk)
override {
207 const CCValAssign &VA = VAs[0];
208 bool NarrowValWideLoc =
211 bool FixedLenVecInScalableVec =
213 if (NarrowValWideLoc || FixedLenVecInScalableVec) {
216 markPhysRegUsed(PhysReg);
219 auto Copy = MIRBuilder.buildCopy(LocTy, PhysReg);
221 if (NarrowValWideLoc) {
226 MIRBuilder.buildBitcast(Arg.
Regs[0], Trunc);
228 MIRBuilder.buildTrunc(Arg.
Regs[0],
Copy.getReg(0));
230 }
else if (FixedLenVecInScalableVec)
231 MIRBuilder.buildExtractSubvector(Arg.
Regs[0],
Copy.getReg(0), 0);
234 "A narrower value must be passed in a wider register or a fixed "
235 "length vector in a scalable vector register.");
239 assert(VAs.
size() >= 2 &&
"Expected at least 2 VAs.");
240 const CCValAssign &VAHi = VAs[1];
244 "Values belong to different arguments");
248 "unexpected custom value");
256 MachinePointerInfo MPO;
257 Register StackAddr = getStackAddress(
260 assignValueToAddress(NewRegs[1], StackAddr, MemTy, MPO,
261 const_cast<CCValAssign &
>(VAHi));
264 assignValueToReg(NewRegs[0], VA.
getLocReg(), VA);
266 assignValueToReg(NewRegs[1], VAHi.
getLocReg(), VAHi);
268 MIRBuilder.buildMergeLikeInstr(Arg.
Regs[0], NewRegs);
276 virtual void markPhysRegUsed(MCRegister PhysReg) = 0;
279 const RISCVSubtarget &Subtarget;
282struct RISCVFormalArgHandler :
public RISCVIncomingValueHandler {
283 RISCVFormalArgHandler(MachineIRBuilder &
B, MachineRegisterInfo &
MRI)
284 : RISCVIncomingValueHandler(
B,
MRI) {}
286 void markPhysRegUsed(MCRegister PhysReg)
override {
287 MIRBuilder.getMRI()->addLiveIn(PhysReg);
288 MIRBuilder.getMBB().addLiveIn(PhysReg);
292struct RISCVCallReturnHandler :
public RISCVIncomingValueHandler {
293 RISCVCallReturnHandler(MachineIRBuilder &
B, MachineRegisterInfo &
MRI,
294 MachineInstrBuilder &MIB)
295 : RISCVIncomingValueHandler(
B,
MRI), MIB(MIB) {}
297 void markPhysRegUsed(MCRegister PhysReg)
override {
298 MIB.addDef(PhysReg, RegState::Implicit);
301 MachineInstrBuilder MIB;
320 return Subtarget.hasVInstructionsF16Minimal();
322 return Subtarget.hasVInstructionsBF16Minimal();
333 bool IsLowerArgs =
false) {
334 if (
T->isIntegerTy())
336 if (
T->isHalfTy() ||
T->isFloatTy() ||
T->isDoubleTy() ||
T->isFP128Ty())
338 if (
T->isPointerTy())
344 if (IsLowerArgs &&
T->isVectorTy() &&
Subtarget.hasVInstructions() &&
348 if (
T->isVectorTy() && !
T->isScalableTy())
358 bool IsLowerRetVal =
false) {
359 if (
T->isIntegerTy() ||
T->isFloatingPointTy() ||
T->isPointerTy())
365 if (
T->isStructTy()) {
367 for (
unsigned i = 0, e = StructT->getNumElements(); i != e; ++i)
373 if (IsLowerRetVal &&
T->isVectorTy() &&
Subtarget.hasVInstructions() &&
377 if (
T->isVectorTy() && !
T->isScalableTy())
386 assert(!Val == VRegs.
empty() &&
"Return value without a vreg");
391 }
else if (!VRegs.
empty()) {
410 RISCVOutgoingValueHandler Handler(MIRBuilder, MF.
getRegInfo(), Ret);
413 CCState CCInfo(
CC,
F.isVarArg(), MF, RetLocs,
F.getContext());
431 bool IsVarArg)
const {
433 CCState CCInfo(CallConv, IsVarArg, MF, RetLocs,
441void RISCVCallLowering::saveVarArgRegisters(
443 IncomingValueAssigner &Assigner,
CCState &CCInfo)
const {
446 unsigned XLenInBytes =
Subtarget.getXLen() / 8;
455 int VarArgsSaveSize = XLenInBytes * (ArgRegs.
size() - Idx);
460 if (VarArgsSaveSize == 0) {
461 int VaArgOffset = Assigner.StackSize;
464 int VaArgOffset = -VarArgsSaveSize;
472 VaArgOffset -
static_cast<int>(XLenInBytes),
true);
473 VarArgsSaveSize += XLenInBytes;
486 const MVT XLenVT =
Subtarget.getXLenVT();
487 for (
unsigned I = Idx;
I < ArgRegs.
size(); ++
I) {
523 if (Arg.
Regs.size() != 1)
530 unsigned BitWidth = IntTy->getBitWidth();
545 for (
auto &Arg :
F.args()) {
563 for (
auto &Arg :
F.args()) {
565 ArgInfo AInfo(VRegs[Index], Arg.getType(), Index);
577 RISCVFormalArgHandler Handler(MIRBuilder, MF.
getRegInfo());
580 CCState CCInfo(
CC,
F.isVarArg(), MIRBuilder.
getMF(), ArgLocs,
F.getContext());
592 saveVarArgRegisters(MIRBuilder, Handler, Assigner, CCInfo);
605 for (
auto &AInfo : Info.OrigArgs) {
608 if (AInfo.Flags[0].isByVal())
612 if (!Info.OrigRet.Ty->isVoidTy() &&
617 MIRBuilder.
buildInstr(RISCV::ADJCALLSTACKDOWN);
620 for (
auto &AInfo : Info.OrigArgs) {
628 Info.IsTailCall =
false;
631 if (!Info.Callee.isReg())
642 Call->setCFIType(MF, Info.CFIType->getZExtValue());
644 Call.addRegMask(
TRI->getCallPreservedMask(MF, Info.CallConv))
648 RISCVOutgoingValueHandler ArgHandler(MIRBuilder, MF.
getRegInfo(),
Call);
650 MIRBuilder,
CC, Info.IsVarArg))
663 if (
Call->getOperand(0).isReg())
667 Call->getDesc(),
Call->getOperand(0), 0);
669 if (Info.CanLowerReturn && !Info.OrigRet.Ty->isVoidTy()) {
674 RISCVCallReturnHandler RetHandler(MIRBuilder, MF.
getRegInfo(),
Call);
676 MIRBuilder,
CC, Info.IsVarArg))
680 if (!Info.CanLowerReturn)
682 Info.DemoteRegister, Info.DemoteStackIndex);
const AArch64Subtarget & Subtarget
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file declares the MachineIRBuilder class.
Register const TargetRegisterInfo * TRI
Promote Memory to Register
static bool isSupportedReturnType(Type *T)
static bool isSupportedArgumentType(Type *T)
static bool isLegalElementTypeForRVV(Type *EltTy, const RISCVSubtarget &Subtarget)
Return true if scalable vector with ScalarTy is legal for lowering.
static void markSExt32Registers(MachineFunction &MF, ArrayRef< CallLowering::ArgInfo > Args, ArrayRef< CCValAssign > ArgLocs)
Note the registers holding incoming arguments that the ABI guarantees are sign extended from 32 bits ...
This file describes how to lower LLVM calls to machine code calls.
MachineRegisterInfo & MRI
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
Get the array size.
bool empty() const
Check if the array is empty.
CCState - This class holds information needed while lowering arguments and return values.
unsigned getFirstUnallocated(ArrayRef< MCPhysReg > Regs) const
getFirstUnallocated - Return the index of the first unallocated register in the set,...
CCValAssign - Represent assignment of one arg/retval to a location.
Register getLocReg() const
static CCValAssign getReg(unsigned ValNo, MVT ValVT, MCRegister Reg, MVT LocVT, LocInfo HTP, bool IsCustom=false)
int64_t getLocMemOffset() const
unsigned getValNo() const
void insertSRetLoads(MachineIRBuilder &MIRBuilder, Type *RetTy, ArrayRef< Register > VRegs, Register DemoteReg, int FI) const
Load the returned value from the stack into virtual registers in VRegs.
bool handleAssignments(ValueHandler &Handler, SmallVectorImpl< ArgInfo > &Args, CCState &CCState, SmallVectorImpl< CCValAssign > &ArgLocs, MachineIRBuilder &MIRBuilder, ArrayRef< Register > ThisReturnRegs={}) const
Use Handler to insert code to handle the argument/return values represented by Args.
void insertSRetIncomingArgument(const Function &F, SmallVectorImpl< ArgInfo > &SplitArgs, Register &DemoteReg, MachineRegisterInfo &MRI, const DataLayout &DL) const
Insert the hidden sret ArgInfo to the beginning of SplitArgs.
void splitToValueTypes(const ArgInfo &OrigArgInfo, SmallVectorImpl< ArgInfo > &SplitArgs, const DataLayout &DL, CallingConv::ID CallConv, SmallVectorImpl< TypeSize > *Offsets=nullptr) const
Break OrigArgInfo into one or more pieces the calling convention can process, returned in SplitArgs.
bool determineAndHandleAssignments(ValueHandler &Handler, ValueAssigner &Assigner, SmallVectorImpl< ArgInfo > &Args, MachineIRBuilder &MIRBuilder, CallingConv::ID CallConv, bool IsVarArg, ArrayRef< Register > ThisReturnRegs={}) const
Invoke ValueAssigner::assignArg on each of the given Args and then use Handler to move them to the as...
void insertSRetStores(MachineIRBuilder &MIRBuilder, Type *RetTy, ArrayRef< Register > VRegs, Register DemoteReg) const
Store the return value given by VRegs into stack starting at the offset specified in DemoteReg.
bool determineAssignments(ValueAssigner &Assigner, SmallVectorImpl< ArgInfo > &Args, CCState &CCInfo) const
Analyze the argument list in Args, using Assigner to populate CCInfo.
bool checkReturn(CCState &CCInfo, SmallVectorImpl< BaseArgInfo > &Outs, CCAssignFn *Fn) const
CallLowering(const TargetLowering *TLI)
void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL, const FuncInfoTy &FuncInfo) const
A parsed version of the target data layout string in and methods for querying it.
unsigned getAllocaAddrSpace() const
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
Register DemoteRegister
DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg allocated to hold a pointer to ...
bool CanLowerReturn
CanLowerReturn - true iff the function's return value can be lowered to registers.
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
constexpr bool isFloat() const
static constexpr LLT pointer(unsigned AddressSpace, unsigned SizeInBits)
Get a low-level pointer in the given address space.
LLT changeToInteger() const
static LLT integer(unsigned SizeInBits)
constexpr TypeSize getSizeInBytes() const
Returns the total size of the type in bytes, i.e.
bool isScalableVector() const
Return true if this is a vector value type where the runtime length is machine dependent.
bool isFixedLengthVector() const
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
LLVM_ABI int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable, bool isAliased=false)
Create a new object at a fixed location on the stack.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
Function & getFunction()
Return the LLVM function that this machine code represents.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags F, LLT MemTy, Align BaseAlignment, const MMOMetadata &Metadata=MMOMetadata(), SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
Helper class to build MachineInstr.
MachineInstrBuilder insertInstr(MachineInstrBuilder MIB)
Insert an existing instruction at the insertion point.
MachineInstrBuilder buildPtrAdd(const DstOp &Res, const SrcOp &Op0, const SrcOp &Op1, std::optional< unsigned > Flags=std::nullopt)
Build and insert Res = G_PTR_ADD Op0, Op1.
MachineInstrBuilder buildStore(const SrcOp &Val, const SrcOp &Addr, MachineMemOperand &MMO)
Build and insert G_STORE Val, Addr, MMO.
MachineInstrBuilder buildInstr(unsigned Opcode)
Build and insert <empty> = Opcode <empty>.
MachineInstrBuilder buildFrameIndex(const DstOp &Res, int Idx)
Build and insert Res = G_FRAME_INDEX Idx.
MachineFunction & getMF()
Getter for the function we currently build.
MachineInstrBuilder buildInstrNoInsert(unsigned Opcode)
Build but don't insert <empty> = Opcode <empty>.
virtual MachineInstrBuilder buildConstant(const DstOp &Res, const ConstantInt &Val)
Build and insert Res = G_CONSTANT Val.
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & add(const MachineOperand &MO) const
@ MOLoad
The memory access reads data.
@ MOStore
The memory access writes data.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
LLT getType(Register Reg) const
Get the low-level type of Reg or LLT{} if Reg is not a generic (target independent) virtual register.
LLVM_ABI Register createGenericVirtualRegister(LLT Ty, StringRef Name="")
Create and return a new generic virtual register with low-level type Ty.
bool lowerReturn(MachineIRBuilder &MIRBuiler, const Value *Val, ArrayRef< Register > VRegs, FunctionLoweringInfo &FLI) const override
This hook behaves as the extended lowerReturn function, but for targets that do not support swifterro...
bool canLowerReturn(MachineFunction &MF, CallingConv::ID CallConv, SmallVectorImpl< BaseArgInfo > &Outs, bool IsVarArg) const override
This hook must be implemented to check whether the return values described by Outs can fit into the r...
bool lowerCall(MachineIRBuilder &MIRBuilder, CallLoweringInfo &Info) const override
This hook must be implemented to lower the given call instruction, including argument and return valu...
bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F, ArrayRef< ArrayRef< Register > > VRegs, FunctionLoweringInfo &FLI) const override
This hook must be implemented to lower the incoming (formal) arguments, described by VRegs,...
RISCVCallLowering(const RISCVTargetLowering &TLI)
RISCVMachineFunctionInfo - This class is derived from MachineFunctionInfo and contains private RISCV-...
void setVarArgsFrameIndex(int Index)
void setVarArgsSaveSize(int Size)
void addSExt32Register(Register Reg)
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
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.
bool isPointerTy() const
True if this is an instance of PointerType.
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
bool isIntegerTy() const
True if this is an instance of IntegerType.
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
ArrayRef< MCPhysReg > getArgGPRs(const RISCVSubtarget &STI)
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI Register constrainOperandRegClass(const MachineFunction &MF, const TargetRegisterInfo &TRI, MachineRegisterInfo &MRI, const TargetInstrInfo &TII, const RegisterBankInfo &RBI, MachineInstr &InsertPt, const TargetRegisterClass &RegClass, MachineOperand &RegMO)
Constrain the Register operand OpIdx, so that it is now constrained to the TargetRegisterClass passed...
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
CCAssignFn RetCC_RISCV
This is used for assigning return values to locations when making calls.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
ArrayRef(const T &OneElt) -> ArrayRef< T >
constexpr unsigned BitWidth
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Align commonAlignment(Align A, uint64_t Offset)
Returns the alignment that satisfies both alignments.
CCAssignFn CC_RISCV
This is used for assigining arguments to locations when making calls.
LLVM_ABI Align inferAlignFromPtrInfo(MachineFunction &MF, const MachinePointerInfo &MPO)
SmallVector< Register, 4 > Regs
SmallVector< ISD::ArgFlagsTy, 4 > Flags
Base class for ValueHandlers used for arguments coming into the current function, or for return value...
void assignValueToReg(Register ValVReg, Register PhysReg, const CCValAssign &VA, ISD::ArgFlagsTy Flags={}) override
Provides a default implementation for argument handling.
Base class for ValueHandlers used for arguments passed to a function call, or for return values.
uint64_t StackSize
The size of the currently allocated portion of the stack.
static LLVM_ABI MachinePointerInfo getStack(MachineFunction &MF, int64_t Offset, uint8_t ID=0)
Stack pointer relative access.
static LLVM_ABI MachinePointerInfo getFixedStack(MachineFunction &MF, int FI, int64_t Offset=0)
Return a MachinePointerInfo record that refers to the specified FrameIndex.