LLVM 24.0.0git
RISCVCallLowering.cpp
Go to the documentation of this file.
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"
19#include "RISCVSubtarget.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(0, Subtarget.getXLen());
40 LLT iXLen = LLT::integer(Subtarget.getXLen());
41
42 if (!SPReg)
43 SPReg = MIRBuilder.buildCopy(p0, Register(RISCV::X2)).getReg(0);
44
45 auto OffsetReg = MIRBuilder.buildConstant(iXLen, Offset);
46
47 auto AddrReg = MIRBuilder.buildPtrAdd(p0, SPReg, OffsetReg);
48
50 return AddrReg.getReg(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 =
62 commonAlignment(Align(16), LocMemOffset));
63
64 Register ExtReg = extendRegister(ValVReg, VA);
65 MIRBuilder.buildStore(ExtReg, Addr, *MMO);
66 }
67
68 void assignValueToReg(Register ValVReg, Register PhysReg,
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);
74 }
75
76 unsigned assignCustomValue(CallLowering::ArgInfo &Arg,
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 =
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(Src);
93 if (SrcTy.isFloat())
94 Src =
95 MIRBuilder.buildBitcast(SrcTy.changeToInteger(), Src).getReg(0);
96 auto Ext = MIRBuilder.buildAnyExt(LLT(VA.getLocVT()), Src);
97 MIRBuilder.buildCopy(PhysReg, Ext);
98 MIB.addUse(PhysReg, RegState::Implicit);
99 };
100 } else if (FixedLenVecInScalableVec) {
101 AssignFunc = [=]() {
102 auto SubVec = MIRBuilder.buildInsertSubvector(
103 LLT(VA.getLocVT()), MIRBuilder.buildUndef(LLT(VA.getLocVT())),
104 Arg.Regs[0], 0);
105 MIRBuilder.buildCopy(PhysReg, SubVec);
106 MIB.addUse(PhysReg, RegState::Implicit);
107 };
108 } else
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
135 MIRBuilder.buildUnmerge(NewRegs, Arg.Regs[0]);
136
137 if (VAHi.isMemLoc()) {
138 LLT MemTy(VAHi.getLocVT());
139
140 MachinePointerInfo MPO;
141 Register StackAddr = getStackAddress(
142 MemTy.getSizeInBytes(), VAHi.getLocMemOffset(), MPO, Arg.Flags[0]);
143
144 assignValueToAddress(NewRegs[1], StackAddr, MemTy, MPO,
145 const_cast<CCValAssign &>(VAHi));
146 }
147
148 auto assignFunc = [=]() {
149 assignValueToReg(NewRegs[0], VA.getLocReg(), VA);
150 if (VAHi.isRegLoc())
151 assignValueToReg(NewRegs[1], VAHi.getLocReg(), 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(MemSize, Offset, /*Immutable=*/true);
183 MPO = MachinePointerInfo::getFixedStack(MIRBuilder.getMF(), FI);
184 return MIRBuilder.buildFrameIndex(LLT::pointer(0, Subtarget.getXLen()), FI)
185 .getReg(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(MPO, MachineMemOperand::MOLoad, MemTy,
193 inferAlignFromPtrInfo(MF, MPO));
194 MIRBuilder.buildLoad(ValVReg, Addr, *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,
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 =
213 if (NarrowValWideLoc || FixedLenVecInScalableVec) {
214 Register PhysReg = VA.getLocReg();
215
216 markPhysRegUsed(PhysReg);
217
218 LLT LocTy(VA.getLocVT());
219 auto Copy = MIRBuilder.buildCopy(LocTy, PhysReg);
220
221 if (NarrowValWideLoc) {
222 LLT ValTy = MRI.getType(Arg.Regs[0]);
223 if (ValTy.isFloat()) {
224 auto Trunc =
225 MIRBuilder.buildTrunc(ValTy.changeToInteger(), Copy.getReg(0));
226 MIRBuilder.buildBitcast(Arg.Regs[0], Trunc);
227 } else {
228 MIRBuilder.buildTrunc(Arg.Regs[0], Copy.getReg(0));
229 }
230 } else if (FixedLenVecInScalableVec)
231 MIRBuilder.buildExtractSubvector(Arg.Regs[0], Copy.getReg(0), 0);
232 else
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
252
253 if (VAHi.isMemLoc()) {
254 LLT MemTy(VAHi.getLocVT());
255
256 MachinePointerInfo MPO;
257 Register StackAddr = getStackAddress(
258 MemTy.getSizeInBytes(), VAHi.getLocMemOffset(), MPO, Arg.Flags[0]);
259
260 assignValueToAddress(NewRegs[1], StackAddr, MemTy, MPO,
261 const_cast<CCValAssign &>(VAHi));
262 }
263
264 assignValueToReg(NewRegs[0], VA.getLocReg(), VA);
265 if (VAHi.isRegLoc())
266 assignValueToReg(NewRegs[1], VAHi.getLocReg(), VAHi);
267
268 MIRBuilder.buildMergeLikeInstr(Arg.Regs[0], 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(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(PhysReg, RegState::Implicit);
299 }
300
301 MachineInstrBuilder MIB;
302};
303
304} // namespace
305
308
309/// Return true if scalable vector with ScalarTy is legal for lowering.
311 const RISCVSubtarget &Subtarget) {
312 if (EltTy->isPointerTy())
313 return Subtarget.is64Bit() ? Subtarget.hasVInstructionsI64() : true;
314 if (EltTy->isIntegerTy(1) || EltTy->isIntegerTy(8) ||
315 EltTy->isIntegerTy(16) || EltTy->isIntegerTy(32))
316 return true;
317 if (EltTy->isIntegerTy(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.
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->getArrayElementType(), Subtarget,
342 IsLowerArgs);
343 // TODO: Support fixed vector types.
344 if (IsLowerArgs && T->isVectorTy() && Subtarget.hasVInstructions() &&
345 T->isScalableTy() &&
346 isLegalElementTypeForRVV(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.
358 bool IsLowerRetVal = false) {
359 if (T->isIntegerTy() || T->isFloatingPointTy() || T->isPointerTy())
360 return true;
361
362 if (T->isArrayTy())
363 return isSupportedReturnType(T->getArrayElementType(), Subtarget);
364
365 if (T->isStructTy()) {
366 auto StructT = cast<StructType>(T);
367 for (unsigned i = 0, e = StructT->getNumElements(); i != e; ++i)
368 if (!isSupportedReturnType(StructT->getElementType(i), Subtarget))
369 return false;
370 return true;
371 }
372
373 if (IsLowerRetVal && T->isVectorTy() && Subtarget.hasVInstructions() &&
374 T->isScalableTy() &&
375 isLegalElementTypeForRVV(T->getScalarType(), Subtarget))
376 return true;
377 if (T->isVectorTy() && !T->isScalableTy())
378 return true;
379
380 return false;
381}
382
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(RISCV::PseudoRET);
388
389 if (!FLI.CanLowerReturn) {
390 insertSRetStores(MIRBuilder, Val->getType(), VRegs, FLI.DemoteRegister);
391 } else if (!VRegs.empty()) {
393 MIRBuilder.getMF().getSubtarget<RISCVSubtarget>();
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(OrigRetInfo, AttributeList::ReturnIndex, DL, F);
405
406 SmallVector<ArgInfo, 4> SplitRetInfos;
407 splitToValueTypes(OrigRetInfo, SplitRetInfos, DL, CC);
408
410 RISCVOutgoingValueHandler Handler(MIRBuilder, MF.getRegInfo(), Ret);
411
413 CCState CCInfo(CC, F.isVarArg(), MF, RetLocs, F.getContext());
414 if (!determineAssignments(Assigner, SplitRetInfos, CCInfo) ||
415 !handleAssignments(Handler, SplitRetInfos, CCInfo, RetLocs, MIRBuilder))
416 return false;
417
418 if (any_of(RetLocs, [](CCValAssign &VA) {
419 return VA.getLocVT().isScalableVector();
420 }))
422 }
423
424 MIRBuilder.insertInstr(Ret);
425 return true;
426}
427
429 CallingConv::ID CallConv,
431 bool IsVarArg) const {
433 CCState CCInfo(CallConv, IsVarArg, MF, RetLocs,
434 MF.getFunction().getContext());
435
436 return checkReturn(CCInfo, Outs, 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(
443 IncomingValueAssigner &Assigner, CCState &CCInfo) const {
444 MachineFunction &MF = MIRBuilder.getMF();
446 unsigned XLenInBytes = Subtarget.getXLen() / 8;
449 unsigned Idx = CCInfo.getFirstUnallocated(ArgRegs);
450 MachineFrameInfo &MFI = MF.getFrameInfo();
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(XLenInBytes, VaArgOffset, true);
463 } else {
464 int VaArgOffset = -VarArgsSaveSize;
465 FI = MFI.CreateFixedObject(VarArgsSaveSize, VaArgOffset, 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(XLenInBytes,
472 VaArgOffset - static_cast<int>(XLenInBytes), true);
473 VarArgsSaveSize += XLenInBytes;
474 }
475
476 const LLT p0 = LLT::pointer(MF.getDataLayout().getAllocaAddrSpace(),
477 Subtarget.getXLen());
478 const LLT iXLen = LLT::integer(Subtarget.getXLen());
479
480 auto FIN = MIRBuilder.buildFrameIndex(p0, FI);
481 auto Offset = MIRBuilder.buildConstant(
482 MRI.createGenericVirtualRegister(iXLen), 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(iXLen);
489 Handler.assignValueToReg(
490 VReg, ArgRegs[I],
492 ArgRegs[I], XLenVT, CCValAssign::Full));
493 auto MPO =
494 MachinePointerInfo::getFixedStack(MF, FI, (I - Idx) * XLenInBytes);
495 MIRBuilder.buildStore(VReg, FIN, MPO, inferAlignFromPtrInfo(MF, MPO));
496 FIN = MIRBuilder.buildPtrAdd(MRI.createGenericVirtualRegister(p0),
497 FIN.getReg(0), 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.
511 ArrayRef<CCValAssign> ArgLocs) {
513 return;
514
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>(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(Arg.Regs[0]);
535 }
536}
537
539 const Function &F,
541 FunctionLoweringInfo &FLI) const {
542 MachineFunction &MF = MIRBuilder.getMF();
543
545 for (auto &Arg : F.args()) {
546 if (!isSupportedArgumentType(Arg.getType(), Subtarget,
547 /*IsLowerArgs=*/true))
548 return false;
549 }
550
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, SplitArgInfos, 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(AInfo, Index + AttributeList::FirstArgIndex, DL, 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(AInfo, SplitArgInfos, DL, CC);
572
573 ++Index;
574 }
575
577 RISCVFormalArgHandler Handler(MIRBuilder, MF.getRegInfo());
578
580 CCState CCInfo(CC, F.isVarArg(), MIRBuilder.getMF(), ArgLocs, F.getContext());
581 if (!determineAssignments(Assigner, SplitArgInfos, CCInfo) ||
582 !handleAssignments(Handler, SplitArgInfos, CCInfo, ArgLocs, MIRBuilder))
583 return false;
584
585 if (any_of(ArgLocs,
586 [](CCValAssign &VA) { return VA.getLocVT().isScalableVector(); }))
588
589 markSExt32Registers(MF, SplitArgInfos, ArgLocs);
590
591 if (F.isVarArg())
592 saveVarArgRegisters(MIRBuilder, Handler, Assigner, CCInfo);
593
594 return true;
595}
596
598 CallLoweringInfo &Info) const {
599 MachineFunction &MF = MIRBuilder.getMF();
600 const DataLayout &DL = MF.getDataLayout();
601 CallingConv::ID CC = Info.CallConv;
602
604 MIRBuilder.getMF().getSubtarget<RISCVSubtarget>();
605 for (auto &AInfo : Info.OrigArgs) {
606 if (!isSupportedArgumentType(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(Info.OrigRet.Ty, Subtarget))
614 return false;
615
616 MachineInstrBuilder CallSeqStart =
617 MIRBuilder.buildInstr(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(AInfo, SplitArgInfos, DL, 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
635 MIRBuilder
636 .buildInstrNoInsert(Info.Callee.isReg() ? RISCV::PseudoCALLIndirect
637 : RISCV::PseudoCALL)
638 .add(Info.Callee);
639 if (Info.NoMerge)
641 if (Info.CFIType)
642 Call->setCFIType(MF, Info.CFIType->getZExtValue());
643 const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
644 Call.addRegMask(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(ArgHandler, ArgAssigner, SplitArgInfos,
650 MIRBuilder, CC, Info.IsVarArg))
651 return false;
652
653 MIRBuilder.insertInstr(Call);
654
655 CallSeqStart.addImm(ArgAssigner.StackSize).addImm(0);
656 MIRBuilder.buildInstr(RISCV::ADJCALLSTACKUP)
657 .addImm(ArgAssigner.StackSize)
658 .addImm(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(0).isReg())
665 *Subtarget.getInstrInfo(),
666 *Subtarget.getRegBankInfo(), *Call,
667 Call->getDesc(), Call->getOperand(0), 0);
668
669 if (Info.CanLowerReturn && !Info.OrigRet.Ty->isVoidTy()) {
670 SmallVector<ArgInfo, 4> SplitRetInfos;
671 splitToValueTypes(Info.OrigRet, SplitRetInfos, DL, CC);
672
674 RISCVCallReturnHandler RetHandler(MIRBuilder, MF.getRegInfo(), Call);
675 if (!determineAndHandleAssignments(RetHandler, RetAssigner, SplitRetInfos,
676 MIRBuilder, CC, Info.IsVarArg))
677 return false;
678 }
679
680 if (!Info.CanLowerReturn)
681 insertSRetLoads(MIRBuilder, Info.OrigRet.Ty, Info.OrigRet.Regs,
682 Info.DemoteRegister, Info.DemoteStackIndex);
683
684 return true;
685}
const AArch64Subtarget & Subtarget
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
uint64_t uint64_t
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
This file declares the MachineIRBuilder class.
Register const TargetRegisterInfo * TRI
Promote Memory to Register
Definition Mem2Reg.cpp:110
#define T
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.
RISCVCC::CondCode CC
MachineRegisterInfo & MRI
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
size_t size() const
Get the array size.
Definition ArrayRef.h:141
bool empty() const
Check if the array is empty.
Definition ArrayRef.h:136
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)
bool needsCustom() const
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.
Definition DataLayout.h:64
unsigned getAllocaAddrSpace() const
Definition DataLayout.h:255
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.
Definition Function.cpp:352
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-...
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.
Definition Type.h:46
bool isPointerTy() const
True if this is an instance of PointerType.
Definition Type.h:277
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition Type.h:155
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
Definition Type.h:147
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
Definition Type.h:144
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition Type.h:158
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition Type.h:252
unsigned getNumOperands() const
Definition User.h:229
LLVM Value Representation.
Definition Value.h:75
Type * getType() const
All values are typed, get the type of this value.
Definition Value.h:257
CallInst * Call
#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.
Definition CallingConv.h:24
ArrayRef< MCPhysReg > getArgGPRs(const RISCVSubtarget &STI)
This is an optimization pass for GlobalISel generic memory operations.
@ Offset
Definition DWP.cpp:577
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...
Definition Utils.cpp:64
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
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.
Definition STLExtras.h:1762
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.
Definition Casting.h:559
Align commonAlignment(Align A, uint64_t Offset)
Returns the alignment that satisfies both alignments.
Definition Alignment.h:206
CCAssignFn CC_RISCV
This is used for assigining arguments to locations when making calls.
LLVM_ABI Align inferAlignFromPtrInfo(MachineFunction &MF, const MachinePointerInfo &MPO)
Definition Utils.cpp:879
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.