LLVM 19.0.0git
CallLowering.h
Go to the documentation of this file.
1//===- llvm/CodeGen/GlobalISel/CallLowering.h - 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 describes how to lower LLVM calls to machine code calls.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CODEGEN_GLOBALISEL_CALLLOWERING_H
15#define LLVM_CODEGEN_GLOBALISEL_CALLLOWERING_H
16
17#include "llvm/ADT/ArrayRef.h"
24#include "llvm/IR/CallingConv.h"
25#include "llvm/IR/Type.h"
26#include "llvm/IR/Value.h"
28#include <cstdint>
29#include <functional>
30
31namespace llvm {
32
33class AttributeList;
34class CallBase;
35class DataLayout;
36class Function;
37class FunctionLoweringInfo;
38class MachineIRBuilder;
39class MachineFunction;
40struct MachinePointerInfo;
41class MachineRegisterInfo;
42class TargetLowering;
43
45 const TargetLowering *TLI;
46
47 virtual void anchor();
48public:
49 struct BaseArgInfo {
52 bool IsFixed;
53
56 bool IsFixed = true)
57 : Ty(Ty), Flags(Flags.begin(), Flags.end()), IsFixed(IsFixed) {}
58
59 BaseArgInfo() : Ty(nullptr), IsFixed(false) {}
60 };
61
62 struct ArgInfo : public BaseArgInfo {
64 // If the argument had to be split into multiple parts according to the
65 // target calling convention, then this contains the original vregs
66 // if the argument was an incoming arg.
68
69 /// Optionally track the original IR value for the argument. This may not be
70 /// meaningful in all contexts. This should only be used on for forwarding
71 /// through to use for aliasing information in MachinePointerInfo for memory
72 /// arguments.
73 const Value *OrigValue = nullptr;
74
75 /// Index original Function's argument.
76 unsigned OrigArgIndex;
77
78 /// Sentinel value for implicit machine-level input arguments.
79 static const unsigned NoArgIndex = UINT_MAX;
80
81 ArgInfo(ArrayRef<Register> Regs, Type *Ty, unsigned OrigIndex,
83 bool IsFixed = true, const Value *OrigValue = nullptr)
84 : BaseArgInfo(Ty, Flags, IsFixed), Regs(Regs.begin(), Regs.end()),
85 OrigValue(OrigValue), OrigArgIndex(OrigIndex) {
86 if (!Regs.empty() && Flags.empty())
87 this->Flags.push_back(ISD::ArgFlagsTy());
88 // FIXME: We should have just one way of saying "no register".
89 assert(((Ty->isVoidTy() || Ty->isEmptyTy()) ==
90 (Regs.empty() || Regs[0] == 0)) &&
91 "only void types should have no register");
92 }
93
94 ArgInfo(ArrayRef<Register> Regs, const Value &OrigValue, unsigned OrigIndex,
96 bool IsFixed = true)
97 : ArgInfo(Regs, OrigValue.getType(), OrigIndex, Flags, IsFixed, &OrigValue) {}
98
99 ArgInfo() = default;
100 };
101
103 /// Calling convention to be used for the call.
105
106 /// Destination of the call. It should be either a register, globaladdress,
107 /// or externalsymbol.
109
110 /// Descriptor for the return type of the function.
112
113 /// List of descriptors of the arguments passed to the function.
115
116 /// Valid if the call has a swifterror inout parameter, and contains the
117 /// vreg that the swifterror should be copied into after the call.
119
120 /// Original IR callsite corresponding to this call, if available.
121 const CallBase *CB = nullptr;
122
124
125 /// True if the call must be tail call optimized.
126 bool IsMustTailCall = false;
127
128 /// True if the call passes all target-independent checks for tail call
129 /// optimization.
130 bool IsTailCall = false;
131
132 /// True if the call was lowered as a tail call. This is consumed by the
133 /// legalizer. This allows the legalizer to lower libcalls as tail calls.
134 bool LoweredTailCall = false;
135
136 /// True if the call is to a vararg function.
137 bool IsVarArg = false;
138
139 /// True if the function's return value can be lowered to registers.
140 bool CanLowerReturn = true;
141
142 /// VReg to hold the hidden sret parameter.
144
145 /// The stack index for sret demotion.
147
148 /// Expected type identifier for indirect calls with a CFI check.
149 const ConstantInt *CFIType = nullptr;
150
151 /// True if this call results in convergent operations.
152 bool IsConvergent = true;
153 };
154
155 /// Argument handling is mostly uniform between the four places that
156 /// make these decisions: function formal arguments, call
157 /// instruction args, call instruction returns and function
158 /// returns. However, once a decision has been made on where an
159 /// argument should go, exactly what happens can vary slightly. This
160 /// class abstracts the differences.
161 ///
162 /// ValueAssigner should not depend on any specific function state, and
163 /// only determine the types and locations for arguments.
165 ValueAssigner(bool IsIncoming, CCAssignFn *AssignFn_,
166 CCAssignFn *AssignFnVarArg_ = nullptr)
167 : AssignFn(AssignFn_), AssignFnVarArg(AssignFnVarArg_),
168 IsIncomingArgumentHandler(IsIncoming) {
169
170 // Some targets change the handler depending on whether the call is
171 // varargs or not. If
172 if (!AssignFnVarArg)
174 }
175
176 virtual ~ValueAssigner() = default;
177
178 /// Returns true if the handler is dealing with incoming arguments,
179 /// i.e. those that move values from some physical location to vregs.
181 return IsIncomingArgumentHandler;
182 }
183
184 /// Wrap call to (typically tablegenerated CCAssignFn). This may be
185 /// overridden to track additional state information as arguments are
186 /// assigned or apply target specific hacks around the legacy
187 /// infrastructure.
188 virtual bool assignArg(unsigned ValNo, EVT OrigVT, MVT ValVT, MVT LocVT,
189 CCValAssign::LocInfo LocInfo, const ArgInfo &Info,
190 ISD::ArgFlagsTy Flags, CCState &State) {
191 if (getAssignFn(State.isVarArg())(ValNo, ValVT, LocVT, LocInfo, Flags,
192 State))
193 return true;
194 StackSize = State.getStackSize();
195 return false;
196 }
197
198 /// Assignment function to use for a general call.
200
201 /// Assignment function to use for a variadic call. This is usually the same
202 /// as AssignFn on most targets.
204
205 /// The size of the currently allocated portion of the stack.
207
208 /// Select the appropriate assignment function depending on whether this is
209 /// a variadic call.
210 CCAssignFn *getAssignFn(bool IsVarArg) const {
211 return IsVarArg ? AssignFnVarArg : AssignFn;
212 }
213
214 private:
215 const bool IsIncomingArgumentHandler;
216 virtual void anchor();
217 };
218
221 CCAssignFn *AssignFnVarArg_ = nullptr)
222 : ValueAssigner(true, AssignFn_, AssignFnVarArg_) {}
223 };
224
227 CCAssignFn *AssignFnVarArg_ = nullptr)
228 : ValueAssigner(false, AssignFn_, AssignFnVarArg_) {}
229 };
230
235
239 IsIncomingArgumentHandler(IsIncoming) {}
240
241 virtual ~ValueHandler() = default;
242
243 /// Returns true if the handler is dealing with incoming arguments,
244 /// i.e. those that move values from some physical location to vregs.
247 }
248
249 /// Materialize a VReg containing the address of the specified
250 /// stack-based object. This is either based on a FrameIndex or
251 /// direct SP manipulation, depending on the context. \p MPO
252 /// should be initialized to an appropriate description of the
253 /// address created.
254 virtual Register getStackAddress(uint64_t MemSize, int64_t Offset,
256 ISD::ArgFlagsTy Flags) = 0;
257
258 /// Return the in-memory size to write for the argument at \p VA. This may
259 /// be smaller than the allocated stack slot size.
260 ///
261 /// This is overridable primarily for targets to maintain compatibility with
262 /// hacks around the existing DAG call lowering infrastructure.
264 const CCValAssign &VA,
265 ISD::ArgFlagsTy Flags) const;
266
267 /// The specified value has been assigned to a physical register,
268 /// handle the appropriate COPY (either to or from) and mark any
269 /// relevant uses/defines as needed.
270 virtual void assignValueToReg(Register ValVReg, Register PhysReg,
271 const CCValAssign &VA) = 0;
272
273 /// The specified value has been assigned to a stack
274 /// location. Load or store it there, with appropriate extension
275 /// if necessary.
277 LLT MemTy, const MachinePointerInfo &MPO,
278 const CCValAssign &VA) = 0;
279
280 /// An overload which takes an ArgInfo if additional information about the
281 /// arg is needed. \p ValRegIndex is the index in \p Arg.Regs for the value
282 /// to store.
283 virtual void assignValueToAddress(const ArgInfo &Arg, unsigned ValRegIndex,
284 Register Addr, LLT MemTy,
285 const MachinePointerInfo &MPO,
286 const CCValAssign &VA) {
287 assignValueToAddress(Arg.Regs[ValRegIndex], Addr, MemTy, MPO, VA);
288 }
289
290 /// Handle custom values, which may be passed into one or more of \p VAs.
291 /// \p If the handler wants the assignments to be delayed until after
292 /// mem loc assignments, then it sets \p Thunk to the thunk to do the
293 /// assignment.
294 /// \return The number of \p VAs that have been assigned including the
295 /// first one, and which should therefore be skipped from further
296 /// processing.
298 std::function<void()> *Thunk = nullptr) {
299 // This is not a pure virtual method because not all targets need to worry
300 // about custom values.
301 llvm_unreachable("Custom values not supported");
302 }
303
304 /// Do a memory copy of \p MemSize bytes from \p SrcPtr to \p DstPtr. This
305 /// is necessary for outgoing stack-passed byval arguments.
306 void
307 copyArgumentMemory(const ArgInfo &Arg, Register DstPtr, Register SrcPtr,
308 const MachinePointerInfo &DstPtrInfo, Align DstAlign,
309 const MachinePointerInfo &SrcPtrInfo, Align SrcAlign,
310 uint64_t MemSize, CCValAssign &VA) const;
311
312 /// Extend a register to the location type given in VA, capped at extending
313 /// to at most MaxSize bits. If MaxSizeBits is 0 then no maximum is set.
315 unsigned MaxSizeBits = 0);
316 };
317
318 /// Base class for ValueHandlers used for arguments coming into the current
319 /// function, or for return values received from a call.
322 : ValueHandler(/*IsIncoming*/ true, MIRBuilder, MRI) {}
323
324 /// Insert G_ASSERT_ZEXT/G_ASSERT_SEXT or other hint instruction based on \p
325 /// VA, returning the new register if a hint was inserted.
327 LLT NarrowTy);
328
329 /// Provides a default implementation for argument handling.
330 void assignValueToReg(Register ValVReg, Register PhysReg,
331 const CCValAssign &VA) override;
332 };
333
334 /// Base class for ValueHandlers used for arguments passed to a function call,
335 /// or for return values.
338 : ValueHandler(/*IsIncoming*/ false, MIRBuilder, MRI) {}
339 };
340
341protected:
342 /// Getter for generic TargetLowering class.
343 const TargetLowering *getTLI() const {
344 return TLI;
345 }
346
347 /// Getter for target specific TargetLowering class.
348 template <class XXXTargetLowering>
349 const XXXTargetLowering *getTLI() const {
350 return static_cast<const XXXTargetLowering *>(TLI);
351 }
352
353 /// \returns Flags corresponding to the attributes on the \p ArgIdx-th
354 /// parameter of \p Call.
356 unsigned ArgIdx) const;
357
358 /// \returns Flags corresponding to the attributes on the return from \p Call.
360
361 /// Adds flags to \p Flags based off of the attributes in \p Attrs.
362 /// \p OpIdx is the index in \p Attrs to add flags from.
364 const AttributeList &Attrs,
365 unsigned OpIdx) const;
366
367 template <typename FuncInfoTy>
368 void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL,
369 const FuncInfoTy &FuncInfo) const;
370
371 /// Break \p OrigArgInfo into one or more pieces the calling convention can
372 /// process, returned in \p SplitArgs. For example, this should break structs
373 /// down into individual fields.
374 ///
375 /// If \p Offsets is non-null, it points to a vector to be filled in
376 /// with the in-memory offsets of each of the individual values.
377 void splitToValueTypes(const ArgInfo &OrigArgInfo,
378 SmallVectorImpl<ArgInfo> &SplitArgs,
379 const DataLayout &DL, CallingConv::ID CallConv,
380 SmallVectorImpl<uint64_t> *Offsets = nullptr) const;
381
382 /// Analyze the argument list in \p Args, using \p Assigner to populate \p
383 /// CCInfo. This will determine the types and locations to use for passed or
384 /// returned values. This may resize fields in \p Args if the value is split
385 /// across multiple registers or stack slots.
386 ///
387 /// This is independent of the function state and can be used
388 /// to determine how a call would pass arguments without needing to change the
389 /// function. This can be used to check if arguments are suitable for tail
390 /// call lowering.
391 ///
392 /// \return True if everything has succeeded, false otherwise.
393 bool determineAssignments(ValueAssigner &Assigner,
395 CCState &CCInfo) const;
396
397 /// Invoke ValueAssigner::assignArg on each of the given \p Args and then use
398 /// \p Handler to move them to the assigned locations.
399 ///
400 /// \return True if everything has succeeded, false otherwise.
402 ValueHandler &Handler, ValueAssigner &Assigner,
404 CallingConv::ID CallConv, bool IsVarArg,
405 ArrayRef<Register> ThisReturnRegs = std::nullopt) const;
406
407 /// Use \p Handler to insert code to handle the argument/return values
408 /// represented by \p Args. It's expected determineAssignments previously
409 /// processed these arguments to populate \p CCState and \p ArgLocs.
410 bool
411 handleAssignments(ValueHandler &Handler, SmallVectorImpl<ArgInfo> &Args,
413 MachineIRBuilder &MIRBuilder,
414 ArrayRef<Register> ThisReturnRegs = std::nullopt) const;
415
416 /// Check whether parameters to a call that are passed in callee saved
417 /// registers are the same as from the calling function. This needs to be
418 /// checked for tail call eligibility.
420 const uint32_t *CallerPreservedMask,
421 const SmallVectorImpl<CCValAssign> &ArgLocs,
422 const SmallVectorImpl<ArgInfo> &OutVals) const;
423
424 /// \returns True if the calling convention for a callee and its caller pass
425 /// results in the same way. Typically used for tail call eligibility checks.
426 ///
427 /// \p Info is the CallLoweringInfo for the call.
428 /// \p MF is the MachineFunction for the caller.
429 /// \p InArgs contains the results of the call.
430 /// \p CalleeAssigner specifies the target's handling of the argument types
431 /// for the callee.
432 /// \p CallerAssigner specifies the target's handling of the
433 /// argument types for the caller.
434 bool resultsCompatible(CallLoweringInfo &Info, MachineFunction &MF,
436 ValueAssigner &CalleeAssigner,
437 ValueAssigner &CallerAssigner) const;
438
439public:
440 CallLowering(const TargetLowering *TLI) : TLI(TLI) {}
441 virtual ~CallLowering() = default;
442
443 /// \return true if the target is capable of handling swifterror values that
444 /// have been promoted to a specified register. The extended versions of
445 /// lowerReturn and lowerCall should be implemented.
446 virtual bool supportSwiftError() const {
447 return false;
448 }
449
450 /// Load the returned value from the stack into virtual registers in \p VRegs.
451 /// It uses the frame index \p FI and the start offset from \p DemoteReg.
452 /// The loaded data size will be determined from \p RetTy.
453 void insertSRetLoads(MachineIRBuilder &MIRBuilder, Type *RetTy,
454 ArrayRef<Register> VRegs, Register DemoteReg,
455 int FI) const;
456
457 /// Store the return value given by \p VRegs into stack starting at the offset
458 /// specified in \p DemoteReg.
459 void insertSRetStores(MachineIRBuilder &MIRBuilder, Type *RetTy,
460 ArrayRef<Register> VRegs, Register DemoteReg) const;
461
462 /// Insert the hidden sret ArgInfo to the beginning of \p SplitArgs.
463 /// This function should be called from the target specific
464 /// lowerFormalArguments when \p F requires the sret demotion.
466 SmallVectorImpl<ArgInfo> &SplitArgs,
467 Register &DemoteReg, MachineRegisterInfo &MRI,
468 const DataLayout &DL) const;
469
470 /// For the call-base described by \p CB, insert the hidden sret ArgInfo to
471 /// the OrigArgs field of \p Info.
473 const CallBase &CB,
474 CallLoweringInfo &Info) const;
475
476 /// \return True if the return type described by \p Outs can be returned
477 /// without performing sret demotion.
479 CCAssignFn *Fn) const;
480
481 /// Get the type and the ArgFlags for the split components of \p RetTy as
482 /// returned by \c ComputeValueVTs.
485 const DataLayout &DL) const;
486
487 /// Toplevel function to check the return type based on the target calling
488 /// convention. \return True if the return value of \p MF can be returned
489 /// without performing sret demotion.
491
492 /// This hook must be implemented to check whether the return values
493 /// described by \p Outs can fit into the return registers. If false
494 /// is returned, an sret-demotion is performed.
497 bool IsVarArg) const {
498 return true;
499 }
500
501 /// This hook must be implemented to lower outgoing return values, described
502 /// by \p Val, into the specified virtual registers \p VRegs.
503 /// This hook is used by GlobalISel.
504 ///
505 /// \p FLI is required for sret demotion.
506 ///
507 /// \p SwiftErrorVReg is non-zero if the function has a swifterror parameter
508 /// that needs to be implicitly returned.
509 ///
510 /// \return True if the lowering succeeds, false otherwise.
511 virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
513 Register SwiftErrorVReg) const {
514 if (!supportSwiftError()) {
515 assert(SwiftErrorVReg == 0 && "attempt to use unsupported swifterror");
516 return lowerReturn(MIRBuilder, Val, VRegs, FLI);
517 }
518 return false;
519 }
520
521 /// This hook behaves as the extended lowerReturn function, but for targets
522 /// that do not support swifterror value promotion.
523 virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
524 ArrayRef<Register> VRegs,
525 FunctionLoweringInfo &FLI) const {
526 return false;
527 }
528
529 virtual bool fallBackToDAGISel(const MachineFunction &MF) const {
530 return false;
531 }
532
533 /// This hook must be implemented to lower the incoming (formal)
534 /// arguments, described by \p VRegs, for GlobalISel. Each argument
535 /// must end up in the related virtual registers described by \p VRegs.
536 /// In other words, the first argument should end up in \c VRegs[0],
537 /// the second in \c VRegs[1], and so on. For each argument, there will be one
538 /// register for each non-aggregate type, as returned by \c computeValueLLTs.
539 /// \p MIRBuilder is set to the proper insertion for the argument
540 /// lowering. \p FLI is required for sret demotion.
541 ///
542 /// \return True if the lowering succeeded, false otherwise.
543 virtual bool lowerFormalArguments(MachineIRBuilder &MIRBuilder,
544 const Function &F,
546 FunctionLoweringInfo &FLI) const {
547 return false;
548 }
549
550 /// This hook must be implemented to lower the given call instruction,
551 /// including argument and return value marshalling.
552 ///
553 ///
554 /// \return true if the lowering succeeded, false otherwise.
555 virtual bool lowerCall(MachineIRBuilder &MIRBuilder,
556 CallLoweringInfo &Info) const {
557 return false;
558 }
559
560 /// Lower the given call instruction, including argument and return value
561 /// marshalling.
562 ///
563 /// \p CI is the call/invoke instruction.
564 ///
565 /// \p ResRegs are the registers where the call's return value should be
566 /// stored (or 0 if there is no return value). There will be one register for
567 /// each non-aggregate type, as returned by \c computeValueLLTs.
568 ///
569 /// \p ArgRegs is a list of lists of virtual registers containing each
570 /// argument that needs to be passed (argument \c i should be placed in \c
571 /// ArgRegs[i]). For each argument, there will be one register for each
572 /// non-aggregate type, as returned by \c computeValueLLTs.
573 ///
574 /// \p SwiftErrorVReg is non-zero if the call has a swifterror inout
575 /// parameter, and contains the vreg that the swifterror should be copied into
576 /// after the call.
577 ///
578 /// \p GetCalleeReg is a callback to materialize a register for the callee if
579 /// the target determines it cannot jump to the destination based purely on \p
580 /// CI. This might be because \p CI is indirect, or because of the limited
581 /// range of an immediate jump.
582 ///
583 /// \return true if the lowering succeeded, false otherwise.
584 bool lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &Call,
585 ArrayRef<Register> ResRegs,
586 ArrayRef<ArrayRef<Register>> ArgRegs, Register SwiftErrorVReg,
587 std::function<unsigned()> GetCalleeReg) const;
588
589 /// For targets which want to use big-endian can enable it with
590 /// enableBigEndian() hook
591 virtual bool enableBigEndian() const { return false; }
592
593 /// For targets which support the "returned" parameter attribute, returns
594 /// true if the given type is a valid one to use with "returned".
595 virtual bool isTypeIsValidForThisReturn(EVT Ty) const { return false; }
596};
597
598} // end namespace llvm
599
600#endif // LLVM_CODEGEN_GLOBALISEL_CALLLOWERING_H
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
basic Basic Alias true
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
return RetTy
uint64_t Addr
Implement a low-level type suitable for MachineInstr level instruction selection.
#define F(x, y, z)
Definition: MD5.cpp:55
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static SymbolRef::Type getType(const Symbol *Sym)
Definition: TapiFile.cpp:40
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
CCState - This class holds information needed while lowering arguments and return values.
uint64_t getStackSize() const
Returns the size of the currently allocated portion of the stack.
bool isVarArg() const
CCValAssign - Represent assignment of one arg/retval to a location.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1457
virtual ~CallLowering()=default
bool handleAssignments(ValueHandler &Handler, SmallVectorImpl< ArgInfo > &Args, CCState &CCState, SmallVectorImpl< CCValAssign > &ArgLocs, MachineIRBuilder &MIRBuilder, ArrayRef< Register > ThisReturnRegs=std::nullopt) const
Use Handler to insert code to handle the argument/return values represented by Args.
void insertSRetOutgoingArgument(MachineIRBuilder &MIRBuilder, const CallBase &CB, CallLoweringInfo &Info) const
For the call-base described by CB, insert the hidden sret ArgInfo to the OrigArgs field of Info.
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 checkReturnTypeForCallConv(MachineFunction &MF) const
Toplevel function to check the return type based on the target calling convention.
bool determineAndHandleAssignments(ValueHandler &Handler, ValueAssigner &Assigner, SmallVectorImpl< ArgInfo > &Args, MachineIRBuilder &MIRBuilder, CallingConv::ID CallConv, bool IsVarArg, ArrayRef< Register > ThisReturnRegs=std::nullopt) const
Invoke ValueAssigner::assignArg on each of the given Args and then use Handler to move them to the as...
bool resultsCompatible(CallLoweringInfo &Info, MachineFunction &MF, SmallVectorImpl< ArgInfo > &InArgs, ValueAssigner &CalleeAssigner, ValueAssigner &CallerAssigner) const
void splitToValueTypes(const ArgInfo &OrigArgInfo, SmallVectorImpl< ArgInfo > &SplitArgs, const DataLayout &DL, CallingConv::ID CallConv, SmallVectorImpl< uint64_t > *Offsets=nullptr) const
Break OrigArgInfo into one or more pieces the calling convention can process, returned in SplitArgs.
virtual bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F, ArrayRef< ArrayRef< Register > > VRegs, FunctionLoweringInfo &FLI) const
This hook must be implemented to lower the incoming (formal) arguments, described by VRegs,...
Definition: CallLowering.h:543
virtual bool canLowerReturn(MachineFunction &MF, CallingConv::ID CallConv, SmallVectorImpl< BaseArgInfo > &Outs, bool IsVarArg) const
This hook must be implemented to check whether the return values described by Outs can fit into the r...
Definition: CallLowering.h:495
virtual bool isTypeIsValidForThisReturn(EVT Ty) const
For targets which support the "returned" parameter attribute, returns true if the given type is a val...
Definition: CallLowering.h:595
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.
ISD::ArgFlagsTy getAttributesForArgIdx(const CallBase &Call, unsigned ArgIdx) const
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.
void addArgFlagsFromAttributes(ISD::ArgFlagsTy &Flags, const AttributeList &Attrs, unsigned OpIdx) const
Adds flags to Flags based off of the attributes in Attrs.
virtual bool enableBigEndian() const
For targets which want to use big-endian can enable it with enableBigEndian() hook.
Definition: CallLowering.h:591
virtual bool supportSwiftError() const
Definition: CallLowering.h:446
bool parametersInCSRMatch(const MachineRegisterInfo &MRI, const uint32_t *CallerPreservedMask, const SmallVectorImpl< CCValAssign > &ArgLocs, const SmallVectorImpl< ArgInfo > &OutVals) const
Check whether parameters to a call that are passed in callee saved registers are the same as from the...
void getReturnInfo(CallingConv::ID CallConv, Type *RetTy, AttributeList Attrs, SmallVectorImpl< BaseArgInfo > &Outs, const DataLayout &DL) const
Get the type and the ArgFlags for the split components of RetTy as returned by ComputeValueVTs.
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)
Definition: CallLowering.h:440
virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val, ArrayRef< Register > VRegs, FunctionLoweringInfo &FLI, Register SwiftErrorVReg) const
This hook must be implemented to lower outgoing return values, described by Val, into the specified v...
Definition: CallLowering.h:511
virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val, ArrayRef< Register > VRegs, FunctionLoweringInfo &FLI) const
This hook behaves as the extended lowerReturn function, but for targets that do not support swifterro...
Definition: CallLowering.h:523
const TargetLowering * getTLI() const
Getter for generic TargetLowering class.
Definition: CallLowering.h:343
const XXXTargetLowering * getTLI() const
Getter for target specific TargetLowering class.
Definition: CallLowering.h:349
virtual bool lowerCall(MachineIRBuilder &MIRBuilder, CallLoweringInfo &Info) const
This hook must be implemented to lower the given call instruction, including argument and return valu...
Definition: CallLowering.h:555
void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL, const FuncInfoTy &FuncInfo) const
virtual bool fallBackToDAGISel(const MachineFunction &MF) const
Definition: CallLowering.h:529
ISD::ArgFlagsTy getAttributesForReturn(const CallBase &Call) const
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
Metadata node.
Definition: Metadata.h:1067
Machine Value Type.
Helper class to build MachineInstr.
MachineOperand class - Representation of each machine instruction operand.
static MachineOperand CreateImm(int64_t Val)
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
bool isEmptyTy() const
Return true if this type is empty, that is, it has no elements or all of its elements are empty.
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:140
LLVM Value Representation.
Definition: Value.h:74
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
bool CCAssignFn(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
CCAssignFn - This function assigns a location for Val, updating State to reflect the change.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Helper struct shared between Function Specialization and SCCP Solver.
Definition: SCCPSolver.h:41
const Value * OrigValue
Optionally track the original IR value for the argument.
Definition: CallLowering.h:73
SmallVector< Register, 4 > Regs
Definition: CallLowering.h:63
SmallVector< Register, 2 > OrigRegs
Definition: CallLowering.h:67
unsigned OrigArgIndex
Index original Function's argument.
Definition: CallLowering.h:76
ArgInfo(ArrayRef< Register > Regs, Type *Ty, unsigned OrigIndex, ArrayRef< ISD::ArgFlagsTy > Flags=ArrayRef< ISD::ArgFlagsTy >(), bool IsFixed=true, const Value *OrigValue=nullptr)
Definition: CallLowering.h:81
ArgInfo(ArrayRef< Register > Regs, const Value &OrigValue, unsigned OrigIndex, ArrayRef< ISD::ArgFlagsTy > Flags=ArrayRef< ISD::ArgFlagsTy >(), bool IsFixed=true)
Definition: CallLowering.h:94
static const unsigned NoArgIndex
Sentinel value for implicit machine-level input arguments.
Definition: CallLowering.h:79
SmallVector< ISD::ArgFlagsTy, 4 > Flags
Definition: CallLowering.h:51
BaseArgInfo(Type *Ty, ArrayRef< ISD::ArgFlagsTy > Flags=ArrayRef< ISD::ArgFlagsTy >(), bool IsFixed=true)
Definition: CallLowering.h:54
bool IsVarArg
True if the call is to a vararg function.
Definition: CallLowering.h:137
bool IsMustTailCall
True if the call must be tail call optimized.
Definition: CallLowering.h:126
bool IsTailCall
True if the call passes all target-independent checks for tail call optimization.
Definition: CallLowering.h:130
MachineOperand Callee
Destination of the call.
Definition: CallLowering.h:108
bool CanLowerReturn
True if the function's return value can be lowered to registers.
Definition: CallLowering.h:140
ArgInfo OrigRet
Descriptor for the return type of the function.
Definition: CallLowering.h:111
const ConstantInt * CFIType
Expected type identifier for indirect calls with a CFI check.
Definition: CallLowering.h:149
CallingConv::ID CallConv
Calling convention to be used for the call.
Definition: CallLowering.h:104
const CallBase * CB
Original IR callsite corresponding to this call, if available.
Definition: CallLowering.h:121
Register DemoteRegister
VReg to hold the hidden sret parameter.
Definition: CallLowering.h:143
bool IsConvergent
True if this call results in convergent operations.
Definition: CallLowering.h:152
int DemoteStackIndex
The stack index for sret demotion.
Definition: CallLowering.h:146
Register SwiftErrorVReg
Valid if the call has a swifterror inout parameter, and contains the vreg that the swifterror should ...
Definition: CallLowering.h:118
SmallVector< ArgInfo, 32 > OrigArgs
List of descriptors of the arguments passed to the function.
Definition: CallLowering.h:114
bool LoweredTailCall
True if the call was lowered as a tail call.
Definition: CallLowering.h:134
IncomingValueAssigner(CCAssignFn *AssignFn_, CCAssignFn *AssignFnVarArg_=nullptr)
Definition: CallLowering.h:220
Base class for ValueHandlers used for arguments coming into the current function, or for return value...
Definition: CallLowering.h:320
void assignValueToReg(Register ValVReg, Register PhysReg, const CCValAssign &VA) override
Provides a default implementation for argument handling.
Register buildExtensionHint(const CCValAssign &VA, Register SrcReg, LLT NarrowTy)
Insert G_ASSERT_ZEXT/G_ASSERT_SEXT or other hint instruction based on VA, returning the new register ...
IncomingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:321
OutgoingValueAssigner(CCAssignFn *AssignFn_, CCAssignFn *AssignFnVarArg_=nullptr)
Definition: CallLowering.h:226
Base class for ValueHandlers used for arguments passed to a function call, or for return values.
Definition: CallLowering.h:336
OutgoingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:337
Argument handling is mostly uniform between the four places that make these decisions: function forma...
Definition: CallLowering.h:164
CCAssignFn * getAssignFn(bool IsVarArg) const
Select the appropriate assignment function depending on whether this is a variadic call.
Definition: CallLowering.h:210
CCAssignFn * AssignFn
Assignment function to use for a general call.
Definition: CallLowering.h:199
bool isIncomingArgumentHandler() const
Returns true if the handler is dealing with incoming arguments, i.e.
Definition: CallLowering.h:180
ValueAssigner(bool IsIncoming, CCAssignFn *AssignFn_, CCAssignFn *AssignFnVarArg_=nullptr)
Definition: CallLowering.h:165
CCAssignFn * AssignFnVarArg
Assignment function to use for a variadic call.
Definition: CallLowering.h:203
virtual bool assignArg(unsigned ValNo, EVT OrigVT, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, const ArgInfo &Info, ISD::ArgFlagsTy Flags, CCState &State)
Wrap call to (typically tablegenerated CCAssignFn).
Definition: CallLowering.h:188
uint64_t StackSize
The size of the currently allocated portion of the stack.
Definition: CallLowering.h:206
void copyArgumentMemory(const ArgInfo &Arg, Register DstPtr, Register SrcPtr, const MachinePointerInfo &DstPtrInfo, Align DstAlign, const MachinePointerInfo &SrcPtrInfo, Align SrcAlign, uint64_t MemSize, CCValAssign &VA) const
Do a memory copy of MemSize bytes from SrcPtr to DstPtr.
MachineRegisterInfo & MRI
Definition: CallLowering.h:233
virtual Register getStackAddress(uint64_t MemSize, int64_t Offset, MachinePointerInfo &MPO, ISD::ArgFlagsTy Flags)=0
Materialize a VReg containing the address of the specified stack-based object.
virtual void assignValueToAddress(const ArgInfo &Arg, unsigned ValRegIndex, Register Addr, LLT MemTy, const MachinePointerInfo &MPO, const CCValAssign &VA)
An overload which takes an ArgInfo if additional information about the arg is needed.
Definition: CallLowering.h:283
virtual LLT getStackValueStoreType(const DataLayout &DL, const CCValAssign &VA, ISD::ArgFlagsTy Flags) const
Return the in-memory size to write for the argument at VA.
bool isIncomingArgumentHandler() const
Returns true if the handler is dealing with incoming arguments, i.e.
Definition: CallLowering.h:245
virtual void assignValueToAddress(Register ValVReg, Register Addr, LLT MemTy, const MachinePointerInfo &MPO, const CCValAssign &VA)=0
The specified value has been assigned to a stack location.
Register extendRegister(Register ValReg, const CCValAssign &VA, unsigned MaxSizeBits=0)
Extend a register to the location type given in VA, capped at extending to at most MaxSize bits.
virtual unsigned assignCustomValue(ArgInfo &Arg, ArrayRef< CCValAssign > VAs, std::function< void()> *Thunk=nullptr)
Handle custom values, which may be passed into one or more of VAs.
Definition: CallLowering.h:297
virtual void assignValueToReg(Register ValVReg, Register PhysReg, const CCValAssign &VA)=0
The specified value has been assigned to a physical register, handle the appropriate COPY (either to ...
ValueHandler(bool IsIncoming, MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:236
Extended Value Type.
Definition: ValueTypes.h:34
This class contains a discriminated union of information about pointers in memory operands,...