1//===-- RISCVCallLowering.cpp - Call lowering -------------------*- 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/// \file
10/// This file implements the lowering of LLVM calls to machine code calls for
11/// GlobalISel.
12//
13//===----------------------------------------------------------------------===//
14
15#include "RISCVCallLowering.h"
16#include "RISCVCallingConv.h"
17#include "RISCVISelLowering.h"
18#include "RISCVMachineFunctionInfo.h"
19#include "RISCVSubtarget.h"
20#include "llvm/CodeGen/Analysis.h"
21#include "llvm/CodeGen/FunctionLoweringInfo.h"
22#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
23#include "llvm/CodeGen/MachineFrameInfo.h"
24#include <functional>
25
26using namespace llvm;
27
28namespace {
29
30struct RISCVOutgoingValueHandler : public CallLowering::OutgoingValueHandler {
31 RISCVOutgoingValueHandler(MachineIRBuilder &B, MachineRegisterInfo &MRI,
32 MachineInstrBuilder MIB)
33 : OutgoingValueHandler(B, MRI), MIB(MIB),
34 Subtarget(MIRBuilder.getMF().getSubtarget<RISCVSubtarget>()) {}
35 Register getStackAddress(uint64_t MemSize, int64_t Offset,
36 MachinePointerInfo &MPO,
37 ISD::ArgFlagsTy Flags) override {
38 MachineFunction &MF = MIRBuilder.getMF();
39 LLT p0 = LLT::pointer(AddressSpace: 0, SizeInBits: Subtarget.getXLen());
40 LLT iXLen = LLT::integer(SizeInBits: Subtarget.getXLen());
41
42 if (!SPReg)
43 SPReg = MIRBuilder.buildCopy(Res: p0, Op: Register(RISCV::X2)).getReg(Idx: 0);
44
45 auto OffsetReg = MIRBuilder.buildConstant(Res: iXLen, Val: Offset);
46
47 auto AddrReg = MIRBuilder.buildPtrAdd(Res: p0, Op0: SPReg, Op1: OffsetReg);
48
49 MPO = MachinePointerInfo::getStack(MF, Offset);
50 return AddrReg.getReg(Idx: 0);
51 }
52
53 void assignValueToAddress(Register ValVReg, Register Addr, LLT MemTy,
54 const MachinePointerInfo &MPO,
55 const CCValAssign &VA) override {
56 MachineFunction &MF = MIRBuilder.getMF();
57 uint64_t LocMemOffset = VA.getLocMemOffset();
58
59 // TODO: Move StackAlignment to subtarget and share with FrameLowering.
60 auto MMO =
61 MF.getMachineMemOperand(PtrInfo: MPO, F: MachineMemOperand::MOStore, MemTy,
62 BaseAlignment: commonAlignment(A: Align(16), Offset: LocMemOffset));
63
64 Register ExtReg = extendRegister(ValReg: ValVReg, VA);
65 MIRBuilder.buildStore(Val: ExtReg, Addr, MMO&: *MMO);
66 }
67
68 void assignValueToReg(Register ValVReg, Register PhysReg,
69 const CCValAssign &VA,
70 ISD::ArgFlagsTy Flags = {}) override {
71 Register ExtReg = extendRegister(ValReg: ValVReg, VA);
72 MIRBuilder.buildCopy(Res: PhysReg, Op: ExtReg);
73 MIB.addUse(RegNo: PhysReg, Flags: RegState::Implicit);
74 }
75
76 unsigned assignCustomValue(CallLowering::ArgInfo &Arg,
77 ArrayRef<CCValAssign> VAs,
78 std::function<void()> *Thunk) override {
79 const CCValAssign &VA = VAs[0];
80 bool NarrowValWideLoc =
81 (VA.getLocVT() == MVT::i64 && VA.getValVT() == MVT::f32) ||
82 (VA.getLocVT().isInteger() && VA.getValVT() == MVT::f16);
83 bool FixedLenVecInScalableVec =
84 VA.getValVT().isFixedLengthVector() && VA.getLocVT().isScalableVector();
85 if (NarrowValWideLoc || FixedLenVecInScalableVec) {
86 Register PhysReg = VA.getLocReg();
87
88 std::function<void()> AssignFunc;
89 if (NarrowValWideLoc) {
90 AssignFunc = [=]() {
91 Register Src = Arg.Regs[0];
92 LLT SrcTy = MRI.getType(Reg: Src);
93 if (SrcTy.isFloat())
94 Src =
95 MIRBuilder.buildBitcast(Dst: SrcTy.changeToInteger(), Src).getReg(Idx: 0);
96 auto Ext = MIRBuilder.buildAnyExt(Res: LLT(VA.getLocVT()), Op: Src);
97 MIRBuilder.buildCopy(Res: PhysReg, Op: Ext);
98 MIB.addUse(RegNo: PhysReg, Flags: RegState::Implicit);
99 };
100 } else if (FixedLenVecInScalableVec) {
101 AssignFunc = [=]() {
102 auto SubVec = MIRBuilder.buildInsertSubvector(
103 Res: LLT(VA.getLocVT()), Src0: MIRBuilder.buildUndef(Res: LLT(VA.getLocVT())),
104 Src1: Arg.Regs[0], Index: 0);
105 MIRBuilder.buildCopy(Res: PhysReg, Op: SubVec);
106 MIB.addUse(RegNo: PhysReg, Flags: RegState::Implicit);
107 };
108 } else
109 llvm_unreachable(
110 "A narrower value must be passed in a wider register or a fixed "
111 "length vector in a scalable vector register.");
112
113 if (Thunk) {
114 *Thunk = std::move(AssignFunc);
115 return 1;
116 }
117
118 AssignFunc();
119 return 1;
120 }
121
122 assert(VAs.size() >= 2 && "Expected at least 2 VAs.");
123 const CCValAssign &VAHi = VAs[1];
124
125 assert(VAHi.needsCustom() && "Value doesn't need custom handling");
126 assert(VA.getValNo() == VAHi.getValNo() &&
127 "Values belong to different arguments");
128
129 assert(VA.getLocVT() == MVT::i32 && VAHi.getLocVT() == MVT::i32 &&
130 VA.getValVT() == MVT::f64 && VAHi.getValVT() == MVT::f64 &&
131 "unexpected custom value");
132
133 Register NewRegs[] = {MRI.createGenericVirtualRegister(Ty: LLT::integer(SizeInBits: 32)),
134 MRI.createGenericVirtualRegister(Ty: LLT::integer(SizeInBits: 32))};
135 MIRBuilder.buildUnmerge(Res: NewRegs, Op: Arg.Regs[0]);
136
137 if (VAHi.isMemLoc()) {
138 LLT MemTy(VAHi.getLocVT());
139
140 MachinePointerInfo MPO;
141 Register StackAddr = getStackAddress(
142 MemSize: MemTy.getSizeInBytes(), Offset: VAHi.getLocMemOffset(), MPO, Flags: Arg.Flags[0]);
143
144 assignValueToAddress(ValVReg: NewRegs[1], Addr: StackAddr, MemTy, MPO,
145 VA: const_cast<CCValAssign &>(VAHi));
146 }
147
148 auto assignFunc = [=]() {
149 assignValueToReg(ValVReg: NewRegs[0], PhysReg: VA.getLocReg(), VA);
150 if (VAHi.isRegLoc())
151 assignValueToReg(ValVReg: NewRegs[1], PhysReg: VAHi.getLocReg(), VA: VAHi);
152 };
153
154 if (Thunk) {
155 *Thunk = std::move(assignFunc);
156 return 2;
157 }
158
159 assignFunc();
160 return 2;
161 }
162
163private:
164 MachineInstrBuilder MIB;
165
166 // Cache the SP register vreg if we need it more than once in this call site.
167 Register SPReg;
168
169 const RISCVSubtarget &Subtarget;
170};
171
172struct RISCVIncomingValueHandler : public CallLowering::IncomingValueHandler {
173 RISCVIncomingValueHandler(MachineIRBuilder &B, MachineRegisterInfo &MRI)
174 : IncomingValueHandler(B, MRI),
175 Subtarget(MIRBuilder.getMF().getSubtarget<RISCVSubtarget>()) {}
176
177 Register getStackAddress(uint64_t MemSize, int64_t Offset,
178 MachinePointerInfo &MPO,
179 ISD::ArgFlagsTy Flags) override {
180 MachineFrameInfo &MFI = MIRBuilder.getMF().getFrameInfo();
181
182 int FI = MFI.CreateFixedObject(Size: MemSize, SPOffset: Offset, /*Immutable=*/IsImmutable: true);
183 MPO = MachinePointerInfo::getFixedStack(MF&: MIRBuilder.getMF(), FI);
184 return MIRBuilder.buildFrameIndex(Res: LLT::pointer(AddressSpace: 0, SizeInBits: Subtarget.getXLen()), Idx: FI)
185 .getReg(Idx: 0);
186 }
187
188 void assignValueToAddress(Register ValVReg, Register Addr, LLT MemTy,
189 const MachinePointerInfo &MPO,
190 const CCValAssign &VA) override {
191 MachineFunction &MF = MIRBuilder.getMF();
192 auto MMO = MF.getMachineMemOperand(PtrInfo: MPO, F: MachineMemOperand::MOLoad, MemTy,
193 BaseAlignment: inferAlignFromPtrInfo(MF, MPO));
194 MIRBuilder.buildLoad(Res: ValVReg, Addr, MMO&: *MMO);
195 }
196
197 void assignValueToReg(Register ValVReg, Register PhysReg,
198 const CCValAssign &VA,
199 ISD::ArgFlagsTy Flags = {}) override {
200 markPhysRegUsed(PhysReg);
201 IncomingValueHandler::assignValueToReg(ValVReg, PhysReg, VA);
202 }
203
204 unsigned assignCustomValue(CallLowering::ArgInfo &Arg,
205 ArrayRef<CCValAssign> VAs,
206 std::function<void()> *Thunk) override {
207 const CCValAssign &VA = VAs[0];
208 bool NarrowValWideLoc =
209 (VA.getLocVT() == MVT::i64 && VA.getValVT() == MVT::f32) ||
210 (VA.getLocVT().isInteger() && VA.getValVT() == MVT::f16);
211 bool FixedLenVecInScalableVec =
212 VA.getValVT().isFixedLengthVector() && VA.getLocVT().isScalableVector();
213 if (NarrowValWideLoc || FixedLenVecInScalableVec) {
214 Register PhysReg = VA.getLocReg();
215
216 markPhysRegUsed(PhysReg);
217
218 LLT LocTy(VA.getLocVT());
219 auto Copy = MIRBuilder.buildCopy(Res: LocTy, Op: PhysReg);
220
221 if (NarrowValWideLoc) {
222 LLT ValTy = MRI.getType(Reg: Arg.Regs[0]);
223 if (ValTy.isFloat()) {
224 auto Trunc =
225 MIRBuilder.buildTrunc(Res: ValTy.changeToInteger(), Op: Copy.getReg(Idx: 0));
226 MIRBuilder.buildBitcast(Dst: Arg.Regs[0], Src: Trunc);
227 } else {
228 MIRBuilder.buildTrunc(Res: Arg.Regs[0], Op: Copy.getReg(Idx: 0));
229 }
230 } else if (FixedLenVecInScalableVec)
231 MIRBuilder.buildExtractSubvector(Res: Arg.Regs[0], Src: Copy.getReg(Idx: 0), Index: 0);
232 else
233 llvm_unreachable(
234 "A narrower value must be passed in a wider register or a fixed "
235 "length vector in a scalable vector register.");
236 return 1;
237 }
238
239 assert(VAs.size() >= 2 && "Expected at least 2 VAs.");
240 const CCValAssign &VAHi = VAs[1];
241
242 assert(VAHi.needsCustom() && "Value doesn't need custom handling");
243 assert(VA.getValNo() == VAHi.getValNo() &&
244 "Values belong to different arguments");
245
246 assert(VA.getLocVT() == MVT::i32 && VAHi.getLocVT() == MVT::i32 &&
247 VA.getValVT() == MVT::f64 && VAHi.getValVT() == MVT::f64 &&
248 "unexpected custom value");
249
250 Register NewRegs[] = {MRI.createGenericVirtualRegister(Ty: LLT::integer(SizeInBits: 32)),
251 MRI.createGenericVirtualRegister(Ty: LLT::integer(SizeInBits: 32))};
252
253 if (VAHi.isMemLoc()) {
254 LLT MemTy(VAHi.getLocVT());
255
256 MachinePointerInfo MPO;
257 Register StackAddr = getStackAddress(
258 MemSize: MemTy.getSizeInBytes(), Offset: VAHi.getLocMemOffset(), MPO, Flags: Arg.Flags[0]);
259
260 assignValueToAddress(ValVReg: NewRegs[1], Addr: StackAddr, MemTy, MPO,
261 VA: const_cast<CCValAssign &>(VAHi));
262 }
263
264 assignValueToReg(ValVReg: NewRegs[0], PhysReg: VA.getLocReg(), VA);
265 if (VAHi.isRegLoc())
266 assignValueToReg(ValVReg: NewRegs[1], PhysReg: VAHi.getLocReg(), VA: VAHi);
267
268 MIRBuilder.buildMergeLikeInstr(Res: Arg.Regs[0], Ops: NewRegs);
269
270 return 2;
271 }
272
273 /// How the physical register gets marked varies between formal
274 /// parameters (it's a basic-block live-in), and a call instruction
275 /// (it's an implicit-def of the BL).
276 virtual void markPhysRegUsed(MCRegister PhysReg) = 0;
277
278private:
279 const RISCVSubtarget &Subtarget;
280};
281
282struct RISCVFormalArgHandler : public RISCVIncomingValueHandler {
283 RISCVFormalArgHandler(MachineIRBuilder &B, MachineRegisterInfo &MRI)
284 : RISCVIncomingValueHandler(B, MRI) {}
285
286 void markPhysRegUsed(MCRegister PhysReg) override {
287 MIRBuilder.getMRI()->addLiveIn(Reg: PhysReg);
288 MIRBuilder.getMBB().addLiveIn(PhysReg);
289 }
290};
291
292struct RISCVCallReturnHandler : public RISCVIncomingValueHandler {
293 RISCVCallReturnHandler(MachineIRBuilder &B, MachineRegisterInfo &MRI,
294 MachineInstrBuilder &MIB)
295 : RISCVIncomingValueHandler(B, MRI), MIB(MIB) {}
296
297 void markPhysRegUsed(MCRegister PhysReg) override {
298 MIB.addDef(RegNo: PhysReg, Flags: RegState::Implicit);
299 }
300
301 MachineInstrBuilder MIB;
302};
303
304} // namespace
305
306RISCVCallLowering::RISCVCallLowering(const RISCVTargetLowering &TLI)
307 : CallLowering(&TLI) {}
308
309/// Return true if scalable vector with ScalarTy is legal for lowering.
310static bool isLegalElementTypeForRVV(Type *EltTy,
311 const RISCVSubtarget &Subtarget) {
312 if (EltTy->isPointerTy())
313 return Subtarget.is64Bit() ? Subtarget.hasVInstructionsI64() : true;
314 if (EltTy->isIntegerTy(BitWidth: 1) || EltTy->isIntegerTy(BitWidth: 8) ||
315 EltTy->isIntegerTy(BitWidth: 16) || EltTy->isIntegerTy(BitWidth: 32))
316 return true;
317 if (EltTy->isIntegerTy(BitWidth: 64))
318 return Subtarget.hasVInstructionsI64();
319 if (EltTy->isHalfTy())
320 return Subtarget.hasVInstructionsF16Minimal();
321 if (EltTy->isBFloatTy())
322 return Subtarget.hasVInstructionsBF16Minimal();
323 if (EltTy->isFloatTy())
324 return Subtarget.hasVInstructionsF32();
325 if (EltTy->isDoubleTy())
326 return Subtarget.hasVInstructionsF64();
327 return false;
328}
329
330// TODO: Support all argument types.
331// TODO: Remove IsLowerArgs argument by adding support for vectors in lowerCall.
332static bool isSupportedArgumentType(Type *T, const RISCVSubtarget &Subtarget,
333 bool IsLowerArgs = false) {
334 if (T->isIntegerTy())
335 return true;
336 if (T->isHalfTy() || T->isFloatTy() || T->isDoubleTy() || T->isFP128Ty())
337 return true;
338 if (T->isPointerTy())
339 return true;
340 if (T->isArrayTy())
341 return isSupportedArgumentType(T: T->getArrayElementType(), Subtarget,
342 IsLowerArgs);
343 // TODO: Support fixed vector types.
344 if (IsLowerArgs && T->isVectorTy() && Subtarget.hasVInstructions() &&
345 T->isScalableTy() &&
346 isLegalElementTypeForRVV(EltTy: T->getScalarType(), Subtarget))
347 return true;
348 if (T->isVectorTy() && !T->isScalableTy())
349 return true;
350
351 return false;
352}
353
354// TODO: Only integer, pointer and aggregate types are supported now.
355// TODO: Remove IsLowerRetVal argument by adding support for vectors in
356// lowerCall.
357static bool isSupportedReturnType(Type *T, const RISCVSubtarget &Subtarget,
358 bool IsLowerRetVal = false) {
359 if (T->isIntegerTy() || T->isFloatingPointTy() || T->isPointerTy())
360 return true;
361
362 if (T->isArrayTy())
363 return isSupportedReturnType(T: T->getArrayElementType(), Subtarget);
364
365 if (T->isStructTy()) {
366 auto StructT = cast<StructType>(Val: T);
367 for (unsigned i = 0, e = StructT->getNumElements(); i != e; ++i)
368 if (!isSupportedReturnType(T: StructT->getElementType(N: i), Subtarget))
369 return false;
370 return true;
371 }
372
373 if (IsLowerRetVal && T->isVectorTy() && Subtarget.hasVInstructions() &&
374 T->isScalableTy() &&
375 isLegalElementTypeForRVV(EltTy: T->getScalarType(), Subtarget))
376 return true;
377 if (T->isVectorTy() && !T->isScalableTy())
378 return true;
379
380 return false;
381}
382
383bool RISCVCallLowering::lowerReturn(MachineIRBuilder &MIRBuilder,
384 const Value *Val, ArrayRef<Register> VRegs,
385 FunctionLoweringInfo &FLI) const {
386 assert(!Val == VRegs.empty() && "Return value without a vreg");
387 MachineInstrBuilder Ret = MIRBuilder.buildInstrNoInsert(Opcode: RISCV::PseudoRET);
388
389 if (!FLI.CanLowerReturn) {
390 insertSRetStores(MIRBuilder, RetTy: Val->getType(), VRegs, DemoteReg: FLI.DemoteRegister);
391 } else if (!VRegs.empty()) {
392 const RISCVSubtarget &Subtarget =
393 MIRBuilder.getMF().getSubtarget<RISCVSubtarget>();
394 if (!isSupportedReturnType(T: Val->getType(), Subtarget,
395 /*IsLowerRetVal=*/true))
396 return false;
397
398 MachineFunction &MF = MIRBuilder.getMF();
399 const DataLayout &DL = MF.getDataLayout();
400 const Function &F = MF.getFunction();
401 CallingConv::ID CC = F.getCallingConv();
402
403 ArgInfo OrigRetInfo(VRegs, Val->getType(), 0);
404 setArgFlags(Arg&: OrigRetInfo, OpIdx: AttributeList::ReturnIndex, DL, FuncInfo: F);
405
406 SmallVector<ArgInfo, 4> SplitRetInfos;
407 splitToValueTypes(OrigArgInfo: OrigRetInfo, SplitArgs&: SplitRetInfos, DL, CallConv: CC);
408
409 OutgoingValueAssigner Assigner(RetCC_RISCV);
410 RISCVOutgoingValueHandler Handler(MIRBuilder, MF.getRegInfo(), Ret);
411
412 SmallVector<CCValAssign, 16> RetLocs;
413 CCState CCInfo(CC, F.isVarArg(), MF, RetLocs, F.getContext());
414 if (!determineAssignments(Assigner, Args&: SplitRetInfos, CCInfo) ||
415 !handleAssignments(Handler, Args&: SplitRetInfos, CCState&: CCInfo, ArgLocs&: RetLocs, MIRBuilder))
416 return false;
417
418 if (any_of(Range&: RetLocs, P: [](CCValAssign &VA) {
419 return VA.getLocVT().isScalableVector();
420 }))
421 MF.getInfo<RISCVMachineFunctionInfo>()->setIsVectorCall();
422 }
423
424 MIRBuilder.insertInstr(MIB: Ret);
425 return true;
426}
427
428bool RISCVCallLowering::canLowerReturn(MachineFunction &MF,
429 CallingConv::ID CallConv,
430 SmallVectorImpl<BaseArgInfo> &Outs,
431 bool IsVarArg) const {
432 SmallVector<CCValAssign, 16> RetLocs;
433 CCState CCInfo(CallConv, IsVarArg, MF, RetLocs,
434 MF.getFunction().getContext());
435
436 return checkReturn(CCInfo, Outs, Fn: RetCC_RISCV);
437}
438
439/// If there are varargs that were passed in a0-a7, the data in those registers
440/// must be copied to the varargs save area on the stack.
441void RISCVCallLowering::saveVarArgRegisters(
442 MachineIRBuilder &MIRBuilder, CallLowering::IncomingValueHandler &Handler,
443 IncomingValueAssigner &Assigner, CCState &CCInfo) const {
444 MachineFunction &MF = MIRBuilder.getMF();
445 const RISCVSubtarget &Subtarget = MF.getSubtarget<RISCVSubtarget>();
446 unsigned XLenInBytes = Subtarget.getXLen() / 8;
447 ArrayRef<MCPhysReg> ArgRegs = RISCV::getArgGPRs(STI: Subtarget);
448 MachineRegisterInfo &MRI = MF.getRegInfo();
449 unsigned Idx = CCInfo.getFirstUnallocated(Regs: ArgRegs);
450 MachineFrameInfo &MFI = MF.getFrameInfo();
451 RISCVMachineFunctionInfo *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
452
453 // Size of the vararg save area. For now, the varargs save area is either
454 // zero or large enough to hold a0-a7.
455 int VarArgsSaveSize = XLenInBytes * (ArgRegs.size() - Idx);
456 int FI;
457
458 // If all registers are allocated, then all varargs must be passed on the
459 // stack and we don't need to save any argregs.
460 if (VarArgsSaveSize == 0) {
461 int VaArgOffset = Assigner.StackSize;
462 FI = MFI.CreateFixedObject(Size: XLenInBytes, SPOffset: VaArgOffset, IsImmutable: true);
463 } else {
464 int VaArgOffset = -VarArgsSaveSize;
465 FI = MFI.CreateFixedObject(Size: VarArgsSaveSize, SPOffset: VaArgOffset, IsImmutable: true);
466
467 // If saving an odd number of registers then create an extra stack slot to
468 // ensure that the frame pointer is 2*XLEN-aligned, which in turn ensures
469 // offsets to even-numbered registered remain 2*XLEN-aligned.
470 if (Idx % 2) {
471 MFI.CreateFixedObject(Size: XLenInBytes,
472 SPOffset: VaArgOffset - static_cast<int>(XLenInBytes), IsImmutable: true);
473 VarArgsSaveSize += XLenInBytes;
474 }
475
476 const LLT p0 = LLT::pointer(AddressSpace: MF.getDataLayout().getAllocaAddrSpace(),
477 SizeInBits: Subtarget.getXLen());
478 const LLT iXLen = LLT::integer(SizeInBits: Subtarget.getXLen());
479
480 auto FIN = MIRBuilder.buildFrameIndex(Res: p0, Idx: FI);
481 auto Offset = MIRBuilder.buildConstant(
482 Res: MRI.createGenericVirtualRegister(Ty: iXLen), Val: XLenInBytes);
483
484 // Copy the integer registers that may have been used for passing varargs
485 // to the vararg save area.
486 const MVT XLenVT = Subtarget.getXLenVT();
487 for (unsigned I = Idx; I < ArgRegs.size(); ++I) {
488 const Register VReg = MRI.createGenericVirtualRegister(Ty: iXLen);
489 Handler.assignValueToReg(
490 ValVReg: VReg, PhysReg: ArgRegs[I],
491 VA: CCValAssign::getReg(ValNo: I + MF.getFunction().getNumOperands(), ValVT: XLenVT,
492 Reg: ArgRegs[I], LocVT: XLenVT, HTP: CCValAssign::Full));
493 auto MPO =
494 MachinePointerInfo::getFixedStack(MF, FI, Offset: (I - Idx) * XLenInBytes);
495 MIRBuilder.buildStore(Val: VReg, Addr: FIN, PtrInfo: MPO, Alignment: inferAlignFromPtrInfo(MF, MPO));
496 FIN = MIRBuilder.buildPtrAdd(Res: MRI.createGenericVirtualRegister(Ty: p0),
497 Op0: FIN.getReg(Idx: 0), Op1: Offset);
498 }
499 }
500
501 // Record the frame index of the first variable argument which is a value
502 // necessary to G_VASTART.
503 RVFI->setVarArgsFrameIndex(FI);
504 RVFI->setVarArgsSaveSize(VarArgsSaveSize);
505}
506
507/// Note the registers holding incoming arguments that the ABI guarantees are
508/// sign extended from 32 bits for the RISCVOptWInstrs pass.
509static void markSExt32Registers(MachineFunction &MF,
510 ArrayRef<CallLowering::ArgInfo> Args,
511 ArrayRef<CCValAssign> ArgLocs) {
512 if (!MF.getSubtarget<RISCVSubtarget>().is64Bit())
513 return;
514
515 RISCVMachineFunctionInfo *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
516 for (const CCValAssign &VA : ArgLocs) {
517 if (!VA.isRegLoc() || VA.getLocVT() != MVT::i64)
518 continue;
519
520 // handleAssignments leaves Regs holding the registers the incoming values
521 // were copied into from the physical registers.
522 const CallLowering::ArgInfo &Arg = Args[VA.getValNo()];
523 if (Arg.Regs.size() != 1)
524 continue;
525
526 auto *IntTy = dyn_cast<IntegerType>(Val: Arg.Ty);
527 if (!IntTy)
528 continue;
529
530 unsigned BitWidth = IntTy->getBitWidth();
531 // An input zero extended from i31 can also be considered sign extended.
532 if ((BitWidth <= 32 && Arg.Flags[0].isSExt()) ||
533 (BitWidth < 32 && Arg.Flags[0].isZExt()))
534 RVFI->addSExt32Register(Reg: Arg.Regs[0]);
535 }
536}
537
538bool RISCVCallLowering::lowerFormalArguments(MachineIRBuilder &MIRBuilder,
539 const Function &F,
540 ArrayRef<ArrayRef<Register>> VRegs,
541 FunctionLoweringInfo &FLI) const {
542 MachineFunction &MF = MIRBuilder.getMF();
543
544 const RISCVSubtarget &Subtarget = MF.getSubtarget<RISCVSubtarget>();
545 for (auto &Arg : F.args()) {
546 if (!isSupportedArgumentType(T: Arg.getType(), Subtarget,
547 /*IsLowerArgs=*/true))
548 return false;
549 }
550
551 MachineRegisterInfo &MRI = MF.getRegInfo();
552 const DataLayout &DL = MF.getDataLayout();
553 CallingConv::ID CC = F.getCallingConv();
554
555 SmallVector<ArgInfo, 32> SplitArgInfos;
556
557 // Insert the hidden sret parameter if the return value won't fit in the
558 // return registers.
559 if (!FLI.CanLowerReturn)
560 insertSRetIncomingArgument(F, SplitArgs&: SplitArgInfos, DemoteReg&: FLI.DemoteRegister, MRI, DL);
561
562 unsigned Index = 0;
563 for (auto &Arg : F.args()) {
564 // Construct the ArgInfo object from destination register and argument type.
565 ArgInfo AInfo(VRegs[Index], Arg.getType(), Index);
566 setArgFlags(Arg&: AInfo, OpIdx: Index + AttributeList::FirstArgIndex, DL, FuncInfo: F);
567
568 // Handle any required merging from split value types from physical
569 // registers into the desired VReg. ArgInfo objects are constructed
570 // correspondingly and appended to SplitArgInfos.
571 splitToValueTypes(OrigArgInfo: AInfo, SplitArgs&: SplitArgInfos, DL, CallConv: CC);
572
573 ++Index;
574 }
575
576 IncomingValueAssigner Assigner(CC_RISCV);
577 RISCVFormalArgHandler Handler(MIRBuilder, MF.getRegInfo());
578
579 SmallVector<CCValAssign, 16> ArgLocs;
580 CCState CCInfo(CC, F.isVarArg(), MIRBuilder.getMF(), ArgLocs, F.getContext());
581 if (!determineAssignments(Assigner, Args&: SplitArgInfos, CCInfo) ||
582 !handleAssignments(Handler, Args&: SplitArgInfos, CCState&: CCInfo, ArgLocs, MIRBuilder))
583 return false;
584
585 if (any_of(Range&: ArgLocs,
586 P: [](CCValAssign &VA) { return VA.getLocVT().isScalableVector(); }))
587 MF.getInfo<RISCVMachineFunctionInfo>()->setIsVectorCall();
588
589 markSExt32Registers(MF, Args: SplitArgInfos, ArgLocs);
590
591 if (F.isVarArg())
592 saveVarArgRegisters(MIRBuilder, Handler, Assigner, CCInfo);
593
594 return true;
595}
596
597bool RISCVCallLowering::lowerCall(MachineIRBuilder &MIRBuilder,
598 CallLoweringInfo &Info) const {
599 MachineFunction &MF = MIRBuilder.getMF();
600 const DataLayout &DL = MF.getDataLayout();
601 CallingConv::ID CC = Info.CallConv;
602
603 const RISCVSubtarget &Subtarget =
604 MIRBuilder.getMF().getSubtarget<RISCVSubtarget>();
605 for (auto &AInfo : Info.OrigArgs) {
606 if (!isSupportedArgumentType(T: AInfo.Ty, Subtarget))
607 return false;
608 if (AInfo.Flags[0].isByVal())
609 return false;
610 }
611
612 if (!Info.OrigRet.Ty->isVoidTy() &&
613 !isSupportedReturnType(T: Info.OrigRet.Ty, Subtarget))
614 return false;
615
616 MachineInstrBuilder CallSeqStart =
617 MIRBuilder.buildInstr(Opcode: RISCV::ADJCALLSTACKDOWN);
618
619 SmallVector<ArgInfo, 32> SplitArgInfos;
620 for (auto &AInfo : Info.OrigArgs) {
621 // Handle any required unmerging of split value types from a given VReg into
622 // physical registers. ArgInfo objects are constructed correspondingly and
623 // appended to SplitArgInfos.
624 splitToValueTypes(OrigArgInfo: AInfo, SplitArgs&: SplitArgInfos, DL, CallConv: CC);
625 }
626
627 // TODO: Support tail calls.
628 Info.IsTailCall = false;
629
630 // Select the recommended relocation type R_RISCV_CALL_PLT.
631 if (!Info.Callee.isReg())
632 Info.Callee.setTargetFlags(RISCVII::MO_CALL);
633
634 MachineInstrBuilder Call =
635 MIRBuilder
636 .buildInstrNoInsert(Opcode: Info.Callee.isReg() ? RISCV::PseudoCALLIndirect
637 : RISCV::PseudoCALL)
638 .add(MO: Info.Callee);
639 if (Info.NoMerge)
640 Call.setMIFlag(MachineInstr::MIFlag::NoMerge);
641 if (Info.CFIType)
642 Call->setCFIType(MF, Type: Info.CFIType->getZExtValue());
643 const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
644 Call.addRegMask(Mask: TRI->getCallPreservedMask(MF, Info.CallConv))
645 .setOperandDead(2); // $x1 (ra)
646
647 OutgoingValueAssigner ArgAssigner(CC_RISCV);
648 RISCVOutgoingValueHandler ArgHandler(MIRBuilder, MF.getRegInfo(), Call);
649 if (!determineAndHandleAssignments(Handler&: ArgHandler, Assigner&: ArgAssigner, Args&: SplitArgInfos,
650 MIRBuilder, CallConv: CC, IsVarArg: Info.IsVarArg))
651 return false;
652
653 MIRBuilder.insertInstr(MIB: Call);
654
655 CallSeqStart.addImm(Val: ArgAssigner.StackSize).addImm(Val: 0);
656 MIRBuilder.buildInstr(Opcode: RISCV::ADJCALLSTACKUP)
657 .addImm(Val: ArgAssigner.StackSize)
658 .addImm(Val: 0);
659
660 // If Callee is a reg, since it is used by a target specific
661 // instruction, it must have a register class matching the
662 // constraint of that instruction.
663 if (Call->getOperand(i: 0).isReg())
664 constrainOperandRegClass(MF, TRI: *TRI, MRI&: MF.getRegInfo(),
665 TII: *Subtarget.getInstrInfo(),
666 RBI: *Subtarget.getRegBankInfo(), InsertPt&: *Call,
667 II: Call->getDesc(), RegMO&: Call->getOperand(i: 0), OpIdx: 0);
668
669 if (Info.CanLowerReturn && !Info.OrigRet.Ty->isVoidTy()) {
670 SmallVector<ArgInfo, 4> SplitRetInfos;
671 splitToValueTypes(OrigArgInfo: Info.OrigRet, SplitArgs&: SplitRetInfos, DL, CallConv: CC);
672
673 IncomingValueAssigner RetAssigner(RetCC_RISCV);
674 RISCVCallReturnHandler RetHandler(MIRBuilder, MF.getRegInfo(), Call);
675 if (!determineAndHandleAssignments(Handler&: RetHandler, Assigner&: RetAssigner, Args&: SplitRetInfos,
676 MIRBuilder, CallConv: CC, IsVarArg: Info.IsVarArg))
677 return false;
678 }
679
680 if (!Info.CanLowerReturn)
681 insertSRetLoads(MIRBuilder, RetTy: Info.OrigRet.Ty, VRegs: Info.OrigRet.Regs,
682 DemoteReg: Info.DemoteRegister, FI: Info.DemoteStackIndex);
683
684 return true;
685}
686