1//===-- WebAssemblyCallLowering.cpp - Call lowering for GlobalISel -*- 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 "WebAssemblyCallLowering.h"
16#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
17#include "Utils/WebAssemblyTypeUtilities.h"
18#include "WebAssemblyISelLowering.h"
19#include "WebAssemblyMachineFunctionInfo.h"
20#include "WebAssemblyRegisterInfo.h"
21#include "WebAssemblySubtarget.h"
22#include "WebAssemblyUtilities.h"
23#include "llvm/CodeGen/Analysis.h"
24#include "llvm/CodeGen/FunctionLoweringInfo.h"
25#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
26#include "llvm/CodeGen/LowLevelTypeUtils.h"
27#include "llvm/CodeGen/MachineInstrBuilder.h"
28#include "llvm/CodeGen/RegisterBankInfo.h"
29#include "llvm/IR/DataLayout.h"
30#include "llvm/IR/DebugLoc.h"
31#include "llvm/IR/Value.h"
32#include "llvm/Support/ErrorHandling.h"
33
34#define DEBUG_TYPE "wasm-call-lowering"
35
36using namespace llvm;
37
38// Test whether the given calling convention is supported.
39static bool callingConvSupported(CallingConv::ID CallConv) {
40 // We currently support the language-independent target-independent
41 // conventions. We don't yet have a way to annotate calls with properties like
42 // "cold", and we don't have any call-clobbered registers, so these are mostly
43 // all handled the same.
44 return CallConv == CallingConv::C || CallConv == CallingConv::Fast ||
45 CallConv == CallingConv::Cold ||
46 CallConv == CallingConv::PreserveMost ||
47 CallConv == CallingConv::PreserveAll ||
48 CallConv == CallingConv::CXX_FAST_TLS ||
49 CallConv == CallingConv::WASM_EmscriptenInvoke ||
50 CallConv == CallingConv::Swift;
51}
52
53static unsigned extendOpFromFlags(ISD::ArgFlagsTy Flags) {
54 if (Flags.isSExt())
55 return TargetOpcode::G_SEXT;
56 if (Flags.isZExt())
57 return TargetOpcode::G_ZEXT;
58 return TargetOpcode::G_ANYEXT;
59}
60
61// GlobalISel doesn't handle reference types. We bail out of GlobalISel for
62// functions passing/returning references and fall back to SDAG.
63static bool typeContainsReference(const Type *Ty) {
64 if (WebAssembly::isWebAssemblyReferenceType(Ty))
65 return true;
66 if (const auto *ArrTy = dyn_cast<ArrayType>(Val: Ty))
67 return typeContainsReference(Ty: ArrTy->getElementType());
68 if (const auto *StructTy = dyn_cast<StructType>(Val: Ty))
69 return any_of(Range: StructTy->elements(), P: [](const Type *ElemTy) {
70 return typeContainsReference(Ty: ElemTy);
71 });
72 return false;
73}
74
75WebAssemblyCallLowering::WebAssemblyCallLowering(
76 const WebAssemblyTargetLowering &TLI)
77 : CallLowering(&TLI) {}
78
79bool WebAssemblyCallLowering::canLowerReturn(MachineFunction &MF,
80 CallingConv::ID CallConv,
81 SmallVectorImpl<BaseArgInfo> &Outs,
82 bool IsVarArg) const {
83 return WebAssembly::canLowerReturn(ResultSize: Outs.size(),
84 Subtarget: &MF.getSubtarget<WebAssemblySubtarget>());
85}
86
87bool WebAssemblyCallLowering::lowerReturn(MachineIRBuilder &MIRBuilder,
88 const Value *Val,
89 ArrayRef<Register> VRegs,
90 FunctionLoweringInfo &FLI,
91 Register SwiftErrorVReg) const {
92 MachineFunction &MF = MIRBuilder.getMF();
93 const Function &F = MF.getFunction();
94 MachineRegisterInfo &MRI = MF.getRegInfo();
95 const WebAssemblyTargetLowering &TLI = *getTLI<WebAssemblyTargetLowering>();
96 const DataLayout &DL = F.getDataLayout();
97
98 if (Val && typeContainsReference(Ty: Val->getType()))
99 return false;
100
101 MachineInstrBuilder MIB = MIRBuilder.buildInstrNoInsert(Opcode: WebAssembly::RETURN);
102
103 assert(((Val && !VRegs.empty()) || (!Val && VRegs.empty())) &&
104 "Return value without a vreg or vice versa");
105
106 if (Val) {
107 LLVMContext &Ctx = Val->getType()->getContext();
108
109 if (!FLI.CanLowerReturn) {
110 insertSRetStores(MIRBuilder, RetTy: Val->getType(), VRegs, DemoteReg: FLI.DemoteRegister);
111 } else {
112 SmallVector<EVT, 4> SplitEVTs;
113 ComputeValueVTs(TLI, DL, Ty: Val->getType(), ValueVTs&: SplitEVTs);
114 assert(VRegs.size() == SplitEVTs.size() &&
115 "For each split Type there should be exactly one VReg.");
116
117 SmallVector<ArgInfo, 8> SplitRets;
118 CallingConv::ID CallConv = F.getCallingConv();
119
120 unsigned RetIdx = 0;
121 for (EVT SplitEVT : SplitEVTs) {
122 Register CurVReg = VRegs[RetIdx];
123 ArgInfo CurRetInfo = ArgInfo{CurVReg, SplitEVT.getTypeForEVT(Context&: Ctx), 0};
124 setArgFlags(Arg&: CurRetInfo, OpIdx: AttributeList::ReturnIndex, DL, FuncInfo: F);
125
126 splitToValueTypes(OrigArgInfo: CurRetInfo, SplitArgs&: SplitRets, DL, CallConv);
127 ++RetIdx;
128 }
129
130 for (ArgInfo &Ret : SplitRets) {
131 const EVT OrigVT = TLI.getValueType(DL, Ty: Ret.Ty);
132 const MVT NewVT =
133 TLI.getRegisterTypeForCallingConv(Context&: Ctx, CC: CallConv, VT: OrigVT);
134 const LLT OrigLLT =
135 getLLTForType(Ty&: *OrigVT.getTypeForEVT(Context&: F.getContext()), DL);
136 const LLT NewLLT = getLLTForMVT(Ty: NewVT);
137
138 const TargetRegisterClass &NewRegClass = *TLI.getRegClassFor(VT: NewVT);
139
140 // If we need to split the type over multiple regs, check it's a
141 // scenario we currently support.
142 const unsigned NumParts =
143 TLI.getNumRegistersForCallingConv(Context&: Ctx, CC: CallConv, VT: OrigVT);
144
145 const ISD::ArgFlagsTy OrigFlags = Ret.Flags[0];
146 Ret.Flags.clear();
147
148 for (unsigned Part = 0; Part < NumParts; ++Part) {
149 ISD::ArgFlagsTy Flags = OrigFlags;
150
151 if (Part == 0) {
152 Flags.setSplit();
153 } else {
154 Flags.setOrigAlign(Align(1));
155 if (Part == NumParts - 1)
156 Flags.setSplitEnd();
157 }
158
159 Ret.Flags.push_back(Elt: Flags);
160 }
161
162 Ret.OrigRegs.assign(in_start: Ret.Regs.begin(), in_end: Ret.Regs.end());
163 if (NumParts != 1 || OrigLLT != NewLLT) {
164 // If we can't directly assign the register, we need one or more
165 // intermediate values.
166 Ret.Regs.resize(N: NumParts);
167
168 // For each split register, create and assign a vreg that will store
169 // the incoming component of the larger value. These will later be
170 // merged to form the final vreg.
171 for (unsigned Part = 0; Part < NumParts; ++Part) {
172 Register NewReg = MRI.createVirtualRegister(RegClass: &NewRegClass);
173 MRI.setType(VReg: NewReg, Ty: NewLLT);
174 MIB.addUse(RegNo: NewReg);
175 Ret.Regs[Part] = NewReg;
176 }
177
178 buildCopyToRegs(B&: MIRBuilder, DstRegs: Ret.Regs, SrcReg: Ret.OrigRegs[0], SrcTy: OrigLLT,
179 PartTy: NewLLT, ExtendOp: extendOpFromFlags(Flags: Ret.Flags[0]));
180 } else {
181 MIB.addUse(RegNo: Ret.Regs[0]);
182 }
183 }
184 }
185 }
186
187 if (SwiftErrorVReg) {
188 reportFatalInternalError(
189 reason: "Wasm does not `supportSwiftError`, yet SwiftErrorVReg is "
190 "improperly valid.");
191 }
192
193 MIRBuilder.insertInstr(MIB);
194 return true;
195}
196
197static unsigned getWasmArgumentOpcode(MVT ArgType) {
198 switch (ArgType.SimpleTy) {
199 case MVT::i32:
200 return WebAssembly::ARGUMENT_i32;
201 case MVT::i64:
202 return WebAssembly::ARGUMENT_i64;
203 case MVT::f32:
204 return WebAssembly::ARGUMENT_f32;
205 case MVT::f64:
206 return WebAssembly::ARGUMENT_f64;
207
208 case MVT::funcref:
209 return WebAssembly::ARGUMENT_funcref;
210 case MVT::externref:
211 return WebAssembly::ARGUMENT_externref;
212 case MVT::exnref:
213 return WebAssembly::ARGUMENT_exnref;
214
215 case MVT::v16i8:
216 return WebAssembly::ARGUMENT_v16i8;
217 case MVT::v8i16:
218 return WebAssembly::ARGUMENT_v8i16;
219 case MVT::v4i32:
220 return WebAssembly::ARGUMENT_v4i32;
221 case MVT::v2i64:
222 return WebAssembly::ARGUMENT_v2i64;
223 case MVT::v8f16:
224 return WebAssembly::ARGUMENT_v8f16;
225 case MVT::v4f32:
226 return WebAssembly::ARGUMENT_v4f32;
227 case MVT::v2f64:
228 return WebAssembly::ARGUMENT_v2f64;
229 default:
230 break;
231 }
232 llvm_unreachable("Found unexpected type for Wasm argument");
233}
234
235static Register buildWasmArgument(unsigned Idx, MVT ArgVT, LLT ArgLLT,
236 MachineIRBuilder &MIRBuilder,
237 Register Def = Register()) {
238 unsigned Op = getWasmArgumentOpcode(ArgType: ArgVT);
239
240 const TargetInstrInfo &TII = MIRBuilder.getTII();
241 MachineFunction &MF = MIRBuilder.getMF();
242 MachineRegisterInfo &MRI = MF.getRegInfo();
243 const TargetRegisterClass &RegClass = *TII.getRegClass(MCID: TII.get(Opcode: Op), OpNum: 0);
244
245 Register NewReg;
246
247 if (Def.isValid()) {
248 assert(MRI.getRegClassOrRegBank(Def).isNull() &&
249 "Def already has reg bank or reg class?");
250 MRI.setRegClass(Reg: Def, RC: &RegClass);
251
252 NewReg = Def;
253 } else {
254 NewReg = MRI.createVirtualRegister(RegClass: &RegClass);
255 MRI.setType(VReg: NewReg, Ty: ArgLLT);
256 }
257
258 MIRBuilder.buildInstr(Opcode: Op).addDef(RegNo: NewReg).addImm(Val: Idx);
259
260 return NewReg;
261}
262
263bool WebAssemblyCallLowering::lowerFormalArguments(
264 MachineIRBuilder &MIRBuilder, const Function &F,
265 ArrayRef<ArrayRef<Register>> VRegs, FunctionLoweringInfo &FLI) const {
266 MachineFunction &MF = MIRBuilder.getMF();
267 MachineRegisterInfo &MRI = MF.getRegInfo();
268 WebAssemblyFunctionInfo *MFI = MF.getInfo<WebAssemblyFunctionInfo>();
269 const DataLayout &DL = F.getDataLayout();
270 const WebAssemblyTargetLowering &TLI = *getTLI<WebAssemblyTargetLowering>();
271
272 LLVMContext &Ctx = MIRBuilder.getContext();
273 const CallingConv::ID CallConv = F.getCallingConv();
274
275 if (!callingConvSupported(CallConv))
276 return false;
277
278 if (typeContainsReference(Ty: F.getReturnType()))
279 return false;
280 for (const Argument &Arg : F.args())
281 if (typeContainsReference(Ty: Arg.getType()))
282 return false;
283
284 MF.getRegInfo().addLiveIn(Reg: WebAssembly::ARGUMENTS);
285 MF.front().addLiveIn(PhysReg: WebAssembly::ARGUMENTS);
286
287 SmallVector<ArgInfo, 8> SplitArgs;
288
289 if (!FLI.CanLowerReturn)
290 insertSRetIncomingArgument(F, SplitArgs, DemoteReg&: FLI.DemoteRegister, MRI, DL);
291
292 unsigned ArgIdx = 0;
293 bool HasSwiftErrorArg = false;
294 bool HasSwiftSelfArg = false;
295 for (const Argument &Arg : F.args()) {
296 ArgInfo OrigArg{VRegs[ArgIdx], Arg.getType(), ArgIdx};
297 setArgFlags(Arg&: OrigArg, OpIdx: ArgIdx + AttributeList::FirstArgIndex, DL, FuncInfo: F);
298
299 HasSwiftSelfArg |= Arg.hasSwiftSelfAttr();
300 HasSwiftErrorArg |= Arg.hasSwiftErrorAttr();
301 // TODO: Support SwiftAsync attributes instead of falling back to
302 // SelectionDAG.
303 if (Arg.hasAttribute(Kind: Attribute::SwiftAsync))
304 return false;
305 if (Arg.hasInAllocaAttr())
306 return false;
307 if (Arg.hasNestAttr())
308 return false;
309
310 splitToValueTypes(OrigArgInfo: OrigArg, SplitArgs, DL, CallConv: F.getCallingConv());
311 ++ArgIdx;
312 }
313
314 unsigned FinalArgIdx = 0;
315 for (ArgInfo &Arg : SplitArgs) {
316 const EVT OrigVT = TLI.getValueType(DL, Ty: Arg.Ty);
317 const MVT NewVT = TLI.getRegisterTypeForCallingConv(Context&: Ctx, CC: CallConv, VT: OrigVT);
318 const LLT OrigLLT =
319 getLLTForType(Ty&: *OrigVT.getTypeForEVT(Context&: F.getContext()), DL);
320 const LLT NewLLT = getLLTForMVT(Ty: NewVT);
321
322 // If we need to split the type over multiple regs, check it's a scenario
323 // we currently support.
324 const unsigned NumParts =
325 TLI.getNumRegistersForCallingConv(Context&: Ctx, CC: CallConv, VT: OrigVT);
326
327 const ISD::ArgFlagsTy OrigFlags = Arg.Flags[0];
328 Arg.Flags.clear();
329
330 for (unsigned Part = 0; Part < NumParts; ++Part) {
331 ISD::ArgFlagsTy Flags = OrigFlags;
332 if (Part == 0) {
333 Flags.setSplit();
334 } else {
335 Flags.setOrigAlign(Align(1));
336 if (Part == NumParts - 1)
337 Flags.setSplitEnd();
338 }
339
340 Arg.Flags.push_back(Elt: Flags);
341 }
342
343 Arg.OrigRegs.assign(in_start: Arg.Regs.begin(), in_end: Arg.Regs.end());
344 if (NumParts != 1 || OrigLLT != NewLLT) {
345 // If we can't directly assign the register, we need one or more
346 // intermediate values.
347 Arg.Regs.resize(N: NumParts);
348
349 // For each split register, create and assign a vreg that will store
350 // the incoming component of the larger value. These will later be
351 // merged to form the final vreg.
352 for (unsigned Part = 0; Part < NumParts; ++Part) {
353 Arg.Regs[Part] =
354 buildWasmArgument(Idx: FinalArgIdx++, ArgVT: NewVT, ArgLLT: NewLLT, MIRBuilder);
355 MFI->addParam(VT: NewVT);
356 }
357
358 buildCopyFromRegs(B&: MIRBuilder, OrigRegs: Arg.OrigRegs, Regs: Arg.Regs, LLTy: OrigLLT, PartLLT: NewLLT,
359 Flags: Arg.Flags[0]);
360 } else {
361 buildWasmArgument(Idx: FinalArgIdx++, ArgVT: NewVT, ArgLLT: NewLLT, MIRBuilder, Def: Arg.Regs[0]);
362 MFI->addParam(VT: NewVT);
363 }
364 }
365
366 // For swiftcc, emit additional swiftself and swifterror arguments
367 // if there aren't. These additional arguments are also added for callee
368 // signature They are necessary to match callee and caller signature for
369 // indirect call.
370 if (CallConv == CallingConv::Swift) {
371 const MVT PtrVT = TLI.getPointerTy(DL);
372
373 if (!HasSwiftSelfArg)
374 MFI->addParam(VT: PtrVT);
375 if (!HasSwiftErrorArg)
376 MFI->addParam(VT: PtrVT);
377 }
378
379 // Varargs are copied into a buffer allocated by the caller, and a pointer to
380 // the buffer is passed as an argument.
381 if (F.isVarArg()) {
382 const MVT PtrVT = TLI.getPointerTy(DL, AS: 0);
383 const LLT PtrLLT = LLT::pointer(AddressSpace: 0, SizeInBits: DL.getPointerSizeInBits(AS: 0));
384
385 Register VarargVreg =
386 buildWasmArgument(Idx: FinalArgIdx++, ArgVT: PtrVT, ArgLLT: PtrLLT, MIRBuilder);
387 MFI->setVarargBufferVreg(VarargVreg);
388
389 MFI->addParam(VT: PtrVT);
390 ++FinalArgIdx;
391 }
392
393 // Record the number and types of arguments and results.
394 SmallVector<MVT, 4> Params;
395 SmallVector<MVT, 4> Results;
396 computeSignatureVTs(Ty: MF.getFunction().getFunctionType(), TargetFunc: &MF.getFunction(),
397 ContextFunc: MF.getFunction(), TM: MF.getTarget(), Params, Results);
398 for (MVT VT : Results)
399 MFI->addResult(VT);
400
401 // TODO: Use signatures in WebAssemblyMachineFunctionInfo too and unify
402 // the param logic here with ComputeSignatureVTs
403 assert(MFI->getParams().size() == Params.size() &&
404 std::equal(MFI->getParams().begin(), MFI->getParams().end(),
405 Params.begin()));
406 return true;
407}
408
409bool WebAssemblyCallLowering::lowerCall(MachineIRBuilder &MIRBuilder,
410 CallLoweringInfo &Info) const {
411 MachineFunction &MF = MIRBuilder.getMF();
412 const DataLayout &DL = MIRBuilder.getDataLayout();
413 LLVMContext &Ctx = MIRBuilder.getContext();
414 const WebAssemblyTargetLowering &TLI = *getTLI<WebAssemblyTargetLowering>();
415 MachineRegisterInfo &MRI = *MIRBuilder.getMRI();
416 const Function &F = MF.getFunction();
417
418 CallingConv::ID CallConv = Info.CallConv;
419 if (!callingConvSupported(CallConv))
420 return false;
421
422 if (typeContainsReference(Ty: Info.OrigRet.Ty))
423 return false;
424 for (const ArgInfo &Arg : Info.OrigArgs)
425 if (typeContainsReference(Ty: Arg.Ty))
426 return false;
427
428 // TODO: tail calls
429 if (Info.IsMustTailCall)
430 return false;
431
432 // TODO: varargs
433 if (Info.IsVarArg)
434 return false;
435
436 // TODO: swiftcc
437 if (CallConv == CallingConv::Swift)
438 return false;
439
440 // TODO: Support SwiftAsync attributes instead of falling back to
441 // SelectionDAG.
442 if (Info.CB)
443 for (unsigned I = 0, E = Info.CB->arg_size(); I != E; ++I)
444 if (Info.CB->paramHasAttr(ArgNo: I, Kind: Attribute::SwiftAsync))
445 return false;
446
447 MachineInstrBuilder CallInst;
448
449 // TODO: indirect calls
450 if (Info.Callee.isReg())
451 return false;
452
453 CallInst = MIRBuilder.buildInstrNoInsert(Opcode: WebAssembly::CALL);
454 if (Info.NoMerge)
455 CallInst.setMIFlag(MachineInstr::MIFlag::NoMerge);
456
457 SmallVector<ArgInfo, 8> SplitArgs;
458
459 for (const ArgInfo &Arg : Info.OrigArgs) {
460 if (Arg.Flags[0].isNest())
461 return false;
462 if (Arg.Flags[0].isInAlloca())
463 return false;
464 if (Arg.Flags[0].isInConsecutiveRegs())
465 return false;
466 if (Arg.Flags[0].isInConsecutiveRegsLast())
467 return false;
468
469 // TODO: bulk memory, then byval
470 if (Arg.Flags[0].isByVal() && Arg.Flags[0].getByValSize() != 0)
471 return false;
472
473 splitToValueTypes(OrigArgInfo: Arg, SplitArgs, DL, CallConv);
474 }
475
476 SmallVector<Register> CallUseRegs;
477
478 for (ArgInfo &Arg : SplitArgs) {
479 const EVT OrigVT = TLI.getValueType(DL, Ty: Arg.Ty);
480 const MVT NewVT = TLI.getRegisterTypeForCallingConv(Context&: Ctx, CC: CallConv, VT: OrigVT);
481 const LLT OrigLLT =
482 getLLTForType(Ty&: *OrigVT.getTypeForEVT(Context&: F.getContext()), DL);
483 const LLT NewLLT = getLLTForMVT(Ty: NewVT);
484
485 const TargetRegisterClass &NewRegClass = *TLI.getRegClassFor(VT: NewVT);
486
487 // If we need to split the type over multiple regs, check it's a scenario
488 // we currently support.
489 const unsigned NumParts =
490 TLI.getNumRegistersForCallingConv(Context&: Ctx, CC: CallConv, VT: OrigVT);
491
492 const ISD::ArgFlagsTy OrigFlags = Arg.Flags[0];
493 Arg.Flags.clear();
494
495 for (unsigned Part = 0; Part < NumParts; ++Part) {
496 ISD::ArgFlagsTy Flags = OrigFlags;
497 if (Part == 0) {
498 Flags.setSplit();
499 } else {
500 Flags.setOrigAlign(Align(1));
501 if (Part == NumParts - 1)
502 Flags.setSplitEnd();
503 }
504
505 Arg.Flags.push_back(Elt: Flags);
506 }
507
508 Arg.OrigRegs.assign(in_start: Arg.Regs.begin(), in_end: Arg.Regs.end());
509 if (NumParts != 1 || OrigLLT != NewLLT) {
510 // If we can't directly assign the register, we need one or more
511 // intermediate values.
512 Arg.Regs.resize(N: NumParts);
513
514 // For each split register, create and assign a vreg that will store
515 // the incoming component of the larger value. These will later be
516 // merged to form the final vreg.
517 for (unsigned Part = 0; Part < NumParts; ++Part) {
518 Register NewReg = MRI.createVirtualRegister(RegClass: &NewRegClass);
519 MRI.setType(VReg: NewReg, Ty: NewLLT);
520 CallUseRegs.push_back(Elt: NewReg);
521 Arg.Regs[Part] = NewReg;
522 }
523
524 buildCopyToRegs(B&: MIRBuilder, DstRegs: Arg.Regs, SrcReg: Arg.OrigRegs[0], SrcTy: OrigLLT, PartTy: NewLLT,
525 ExtendOp: extendOpFromFlags(Flags: Arg.Flags[0]));
526 } else {
527 CallUseRegs.push_back(Elt: Arg.Regs[0]);
528 }
529 }
530
531 MIRBuilder.insertInstr(MIB: CallInst);
532
533 if (Info.CanLowerReturn && !Info.OrigRet.Ty->isVoidTy()) {
534 SmallVector<EVT, 4> SplitEVTs;
535 ComputeValueVTs(TLI, DL, Ty: Info.OrigRet.Ty, ValueVTs&: SplitEVTs);
536 assert(Info.OrigRet.Regs.size() == SplitEVTs.size() &&
537 "For each split Type there should be exactly one VReg.");
538
539 SmallVector<ArgInfo, 8> SplitRets;
540
541 unsigned RetIdx = 0;
542 for (EVT SplitEVT : SplitEVTs) {
543 Register CurVReg = Info.OrigRet.Regs[RetIdx];
544 ArgInfo CurArgInfo = ArgInfo{CurVReg, SplitEVT.getTypeForEVT(Context&: Ctx), 0};
545
546 if (Info.CB) {
547 setArgFlags(Arg&: CurArgInfo, OpIdx: AttributeList::ReturnIndex, DL, FuncInfo: *Info.CB);
548 } else {
549 // We don't have a call base, so chances are we're looking at a
550 // libcall (external symbol).
551
552 // TODO: figure out how to get ALL the correct attributes
553 ISD::ArgFlagsTy &Flags = CurArgInfo.Flags[0];
554 PointerType *PtrTy =
555 dyn_cast<PointerType>(Val: CurArgInfo.Ty->getScalarType());
556 if (PtrTy) {
557 Flags.setPointer();
558 Flags.setPointerAddrSpace(PtrTy->getPointerAddressSpace());
559 }
560 Align MemAlign = DL.getABITypeAlign(Ty: CurArgInfo.Ty);
561 Flags.setMemAlign(MemAlign);
562 Flags.setOrigAlign(MemAlign);
563 }
564
565 splitToValueTypes(OrigArgInfo: CurArgInfo, SplitArgs&: SplitRets, DL, CallConv);
566 ++RetIdx;
567 }
568
569 for (ArgInfo &Ret : SplitRets) {
570 const EVT OrigVT = TLI.getValueType(DL, Ty: Ret.Ty);
571 const MVT NewVT =
572 TLI.getRegisterTypeForCallingConv(Context&: Ctx, CC: CallConv, VT: OrigVT);
573 const LLT OrigLLT =
574 getLLTForType(Ty&: *OrigVT.getTypeForEVT(Context&: F.getContext()), DL);
575 const LLT NewLLT = getLLTForMVT(Ty: NewVT);
576
577 const TargetRegisterClass &NewRegClass = *TLI.getRegClassFor(VT: NewVT);
578
579 // If we need to split the type over multiple regs, check it's a scenario
580 // we currently support.
581 const unsigned NumParts =
582 TLI.getNumRegistersForCallingConv(Context&: Ctx, CC: CallConv, VT: OrigVT);
583
584 const ISD::ArgFlagsTy OrigFlags = Ret.Flags[0];
585 Ret.Flags.clear();
586
587 for (unsigned Part = 0; Part < NumParts; ++Part) {
588 ISD::ArgFlagsTy Flags = OrigFlags;
589 if (Part == 0) {
590 Flags.setSplit();
591 } else {
592 Flags.setOrigAlign(Align(1));
593 if (Part == NumParts - 1)
594 Flags.setSplitEnd();
595 }
596
597 Ret.Flags.push_back(Elt: Flags);
598 }
599
600 Ret.OrigRegs.assign(in_start: Ret.Regs.begin(), in_end: Ret.Regs.end());
601
602 if (NumParts != 1 || OrigLLT != NewLLT) {
603 // If we can't directly assign the register, we need one or more
604 // intermediate values.
605 Ret.Regs.resize(N: NumParts);
606
607 // For each split register, create and assign a vreg that will store
608 // the incoming component of the larger value. These will later be
609 // merged to form the final vreg.
610 for (unsigned Part = 0; Part < NumParts; ++Part) {
611 Register NewReg = MRI.createVirtualRegister(RegClass: &NewRegClass);
612 MRI.setType(VReg: NewReg, Ty: NewLLT);
613 CallInst.addDef(RegNo: NewReg);
614 Ret.Regs[Part] = NewReg;
615 }
616
617 buildCopyFromRegs(B&: MIRBuilder, OrigRegs: Ret.OrigRegs, Regs: Ret.Regs, LLTy: OrigLLT, PartLLT: NewLLT,
618 Flags: Ret.Flags[0]);
619 } else {
620 MRI.setRegClass(Reg: Ret.Regs[0], RC: &NewRegClass);
621 CallInst.addDef(RegNo: Ret.Regs[0]);
622 }
623 }
624 }
625
626 if (Info.Callee.isGlobal()) {
627 CallInst.addGlobalAddress(GV: Info.Callee.getGlobal());
628 } else if (Info.Callee.isSymbol()) {
629 CallInst.addExternalSymbol(FnName: Info.Callee.getSymbolName());
630 } else {
631 return false;
632 }
633
634 for (Register Reg : CallUseRegs) {
635 CallInst.addUse(RegNo: Reg);
636 }
637
638 if (!Info.CanLowerReturn)
639 insertSRetLoads(MIRBuilder, RetTy: Info.OrigRet.Ty, VRegs: Info.OrigRet.Regs,
640 DemoteReg: Info.DemoteRegister, FI: Info.DemoteStackIndex);
641
642 return true;
643}
644