LLVM 17.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"
22#include "llvm/IR/CallingConv.h"
23#include "llvm/IR/Type.h"
24#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
152 /// Argument handling is mostly uniform between the four places that
153 /// make these decisions: function formal arguments, call
154 /// instruction args, call instruction returns and function
155 /// returns. However, once a decision has been made on where an
156 /// argument should go, exactly what happens can vary slightly. This
157 /// class abstracts the differences.
158 ///
159 /// ValueAssigner should not depend on any specific function state, and
160 /// only determine the types and locations for arguments.
162 ValueAssigner(bool IsIncoming, CCAssignFn *AssignFn_,
163 CCAssignFn *AssignFnVarArg_ = nullptr)
164 : AssignFn(AssignFn_), AssignFnVarArg(AssignFnVarArg_),
165 IsIncomingArgumentHandler(IsIncoming) {
166
167 // Some targets change the handler depending on whether the call is
168 // varargs or not. If
169 if (!AssignFnVarArg)
171 }
172
173 virtual ~ValueAssigner() = default;
174
175 /// Returns true if the handler is dealing with incoming arguments,
176 /// i.e. those that move values from some physical location to vregs.
178 return IsIncomingArgumentHandler;
179 }
180
181 /// Wrap call to (typically tablegenerated CCAssignFn). This may be
182 /// overridden to track additional state information as arguments are
183 /// assigned or apply target specific hacks around the legacy
184 /// infrastructure.
185 virtual bool assignArg(unsigned ValNo, EVT OrigVT, MVT ValVT, MVT LocVT,
186 CCValAssign::LocInfo LocInfo, const ArgInfo &Info,
187 ISD::ArgFlagsTy Flags, CCState &State) {
188 if (getAssignFn(State.isVarArg())(ValNo, ValVT, LocVT, LocInfo, Flags,
189 State))
190 return true;
192 return false;
193 }
194
195 /// Assignment function to use for a general call.
197
198 /// Assignment function to use for a variadic call. This is usually the same
199 /// as AssignFn on most targets.
201
202 /// Stack offset for next argument. At the end of argument evaluation, this
203 /// is typically the total stack size.
205
206 /// Select the appropriate assignment function depending on whether this is
207 /// a variadic call.
208 CCAssignFn *getAssignFn(bool IsVarArg) const {
209 return IsVarArg ? AssignFnVarArg : AssignFn;
210 }
211
212 private:
213 const bool IsIncomingArgumentHandler;
214 virtual void anchor();
215 };
216
219 CCAssignFn *AssignFnVarArg_ = nullptr)
220 : ValueAssigner(true, AssignFn_, AssignFnVarArg_) {}
221 };
222
225 CCAssignFn *AssignFnVarArg_ = nullptr)
226 : ValueAssigner(false, AssignFn_, AssignFnVarArg_) {}
227 };
228
233
237 IsIncomingArgumentHandler(IsIncoming) {}
238
239 virtual ~ValueHandler() = default;
240
241 /// Returns true if the handler is dealing with incoming arguments,
242 /// i.e. those that move values from some physical location to vregs.
245 }
246
247 /// Materialize a VReg containing the address of the specified
248 /// stack-based object. This is either based on a FrameIndex or
249 /// direct SP manipulation, depending on the context. \p MPO
250 /// should be initialized to an appropriate description of the
251 /// address created.
252 virtual Register getStackAddress(uint64_t MemSize, int64_t Offset,
254 ISD::ArgFlagsTy Flags) = 0;
255
256 /// Return the in-memory size to write for the argument at \p VA. This may
257 /// be smaller than the allocated stack slot size.
258 ///
259 /// This is overridable primarily for targets to maintain compatibility with
260 /// hacks around the existing DAG call lowering infrastructure.
262 const CCValAssign &VA,
263 ISD::ArgFlagsTy Flags) const;
264
265 /// The specified value has been assigned to a physical register,
266 /// handle the appropriate COPY (either to or from) and mark any
267 /// relevant uses/defines as needed.
268 virtual void assignValueToReg(Register ValVReg, Register PhysReg,
269 CCValAssign VA) = 0;
270
271 /// The specified value has been assigned to a stack
272 /// location. Load or store it there, with appropriate extension
273 /// if necessary.
275 LLT MemTy, MachinePointerInfo &MPO,
276 CCValAssign &VA) = 0;
277
278 /// An overload which takes an ArgInfo if additional information about the
279 /// arg is needed. \p ValRegIndex is the index in \p Arg.Regs for the value
280 /// to store.
281 virtual void assignValueToAddress(const ArgInfo &Arg, unsigned ValRegIndex,
282 Register Addr, LLT MemTy,
284 CCValAssign &VA) {
285 assignValueToAddress(Arg.Regs[ValRegIndex], Addr, MemTy, MPO, VA);
286 }
287
288 /// Handle custom values, which may be passed into one or more of \p VAs.
289 /// \p If the handler wants the assignments to be delayed until after
290 /// mem loc assignments, then it sets \p Thunk to the thunk to do the
291 /// assignment.
292 /// \return The number of \p VAs that have been assigned after the first
293 /// one, and which should therefore be skipped from further
294 /// processing.
296 std::function<void()> *Thunk = nullptr) {
297 // This is not a pure virtual method because not all targets need to worry
298 // about custom values.
299 llvm_unreachable("Custom values not supported");
300 }
301
302 /// Do a memory copy of \p MemSize bytes from \p SrcPtr to \p DstPtr. This
303 /// is necessary for outgoing stack-passed byval arguments.
304 void
305 copyArgumentMemory(const ArgInfo &Arg, Register DstPtr, Register SrcPtr,
306 const MachinePointerInfo &DstPtrInfo, Align DstAlign,
307 const MachinePointerInfo &SrcPtrInfo, Align SrcAlign,
308 uint64_t MemSize, CCValAssign &VA) const;
309
310 /// Extend a register to the location type given in VA, capped at extending
311 /// to at most MaxSize bits. If MaxSizeBits is 0 then no maximum is set.
313 unsigned MaxSizeBits = 0);
314 };
315
316 /// Base class for ValueHandlers used for arguments coming into the current
317 /// function, or for return values received from a call.
320 : ValueHandler(/*IsIncoming*/ true, MIRBuilder, MRI) {}
321
322 /// Insert G_ASSERT_ZEXT/G_ASSERT_SEXT or other hint instruction based on \p
323 /// VA, returning the new register if a hint was inserted.
324 Register buildExtensionHint(CCValAssign &VA, Register SrcReg, LLT NarrowTy);
325
326 /// Provides a default implementation for argument handling.
327 void assignValueToReg(Register ValVReg, Register PhysReg,
328 CCValAssign VA) override;
329 };
330
331 /// Base class for ValueHandlers used for arguments passed to a function call,
332 /// or for return values.
335 : ValueHandler(/*IsIncoming*/ false, MIRBuilder, MRI) {}
336 };
337
338protected:
339 /// Getter for generic TargetLowering class.
340 const TargetLowering *getTLI() const {
341 return TLI;
342 }
343
344 /// Getter for target specific TargetLowering class.
345 template <class XXXTargetLowering>
346 const XXXTargetLowering *getTLI() const {
347 return static_cast<const XXXTargetLowering *>(TLI);
348 }
349
350 /// \returns Flags corresponding to the attributes on the \p ArgIdx-th
351 /// parameter of \p Call.
353 unsigned ArgIdx) const;
354
355 /// \returns Flags corresponding to the attributes on the return from \p Call.
357
358 /// Adds flags to \p Flags based off of the attributes in \p Attrs.
359 /// \p OpIdx is the index in \p Attrs to add flags from.
361 const AttributeList &Attrs,
362 unsigned OpIdx) const;
363
364 template <typename FuncInfoTy>
365 void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL,
366 const FuncInfoTy &FuncInfo) const;
367
368 /// Break \p OrigArgInfo into one or more pieces the calling convention can
369 /// process, returned in \p SplitArgs. For example, this should break structs
370 /// down into individual fields.
371 ///
372 /// If \p Offsets is non-null, it points to a vector to be filled in
373 /// with the in-memory offsets of each of the individual values.
374 void splitToValueTypes(const ArgInfo &OrigArgInfo,
375 SmallVectorImpl<ArgInfo> &SplitArgs,
376 const DataLayout &DL, CallingConv::ID CallConv,
377 SmallVectorImpl<uint64_t> *Offsets = nullptr) const;
378
379 /// Analyze the argument list in \p Args, using \p Assigner to populate \p
380 /// CCInfo. This will determine the types and locations to use for passed or
381 /// returned values. This may resize fields in \p Args if the value is split
382 /// across multiple registers or stack slots.
383 ///
384 /// This is independent of the function state and can be used
385 /// to determine how a call would pass arguments without needing to change the
386 /// function. This can be used to check if arguments are suitable for tail
387 /// call lowering.
388 ///
389 /// \return True if everything has succeeded, false otherwise.
390 bool determineAssignments(ValueAssigner &Assigner,
392 CCState &CCInfo) const;
393
394 /// Invoke ValueAssigner::assignArg on each of the given \p Args and then use
395 /// \p Handler to move them to the assigned locations.
396 ///
397 /// \return True if everything has succeeded, false otherwise.
399 ValueHandler &Handler, ValueAssigner &Assigner,
401 CallingConv::ID CallConv, bool IsVarArg,
402 ArrayRef<Register> ThisReturnRegs = std::nullopt) const;
403
404 /// Use \p Handler to insert code to handle the argument/return values
405 /// represented by \p Args. It's expected determineAssignments previously
406 /// processed these arguments to populate \p CCState and \p ArgLocs.
407 bool
408 handleAssignments(ValueHandler &Handler, SmallVectorImpl<ArgInfo> &Args,
410 MachineIRBuilder &MIRBuilder,
411 ArrayRef<Register> ThisReturnRegs = std::nullopt) const;
412
413 /// Check whether parameters to a call that are passed in callee saved
414 /// registers are the same as from the calling function. This needs to be
415 /// checked for tail call eligibility.
417 const uint32_t *CallerPreservedMask,
418 const SmallVectorImpl<CCValAssign> &ArgLocs,
419 const SmallVectorImpl<ArgInfo> &OutVals) const;
420
421 /// \returns True if the calling convention for a callee and its caller pass
422 /// results in the same way. Typically used for tail call eligibility checks.
423 ///
424 /// \p Info is the CallLoweringInfo for the call.
425 /// \p MF is the MachineFunction for the caller.
426 /// \p InArgs contains the results of the call.
427 /// \p CalleeAssigner specifies the target's handling of the argument types
428 /// for the callee.
429 /// \p CallerAssigner specifies the target's handling of the
430 /// argument types for the caller.
431 bool resultsCompatible(CallLoweringInfo &Info, MachineFunction &MF,
433 ValueAssigner &CalleeAssigner,
434 ValueAssigner &CallerAssigner) const;
435
436public:
437 CallLowering(const TargetLowering *TLI) : TLI(TLI) {}
438 virtual ~CallLowering() = default;
439
440 /// \return true if the target is capable of handling swifterror values that
441 /// have been promoted to a specified register. The extended versions of
442 /// lowerReturn and lowerCall should be implemented.
443 virtual bool supportSwiftError() const {
444 return false;
445 }
446
447 /// Load the returned value from the stack into virtual registers in \p VRegs.
448 /// It uses the frame index \p FI and the start offset from \p DemoteReg.
449 /// The loaded data size will be determined from \p RetTy.
450 void insertSRetLoads(MachineIRBuilder &MIRBuilder, Type *RetTy,
451 ArrayRef<Register> VRegs, Register DemoteReg,
452 int FI) const;
453
454 /// Store the return value given by \p VRegs into stack starting at the offset
455 /// specified in \p DemoteReg.
456 void insertSRetStores(MachineIRBuilder &MIRBuilder, Type *RetTy,
457 ArrayRef<Register> VRegs, Register DemoteReg) const;
458
459 /// Insert the hidden sret ArgInfo to the beginning of \p SplitArgs.
460 /// This function should be called from the target specific
461 /// lowerFormalArguments when \p F requires the sret demotion.
463 SmallVectorImpl<ArgInfo> &SplitArgs,
464 Register &DemoteReg, MachineRegisterInfo &MRI,
465 const DataLayout &DL) const;
466
467 /// For the call-base described by \p CB, insert the hidden sret ArgInfo to
468 /// the OrigArgs field of \p Info.
470 const CallBase &CB,
471 CallLoweringInfo &Info) const;
472
473 /// \return True if the return type described by \p Outs can be returned
474 /// without performing sret demotion.
476 CCAssignFn *Fn) const;
477
478 /// Get the type and the ArgFlags for the split components of \p RetTy as
479 /// returned by \c ComputeValueVTs.
482 const DataLayout &DL) const;
483
484 /// Toplevel function to check the return type based on the target calling
485 /// convention. \return True if the return value of \p MF can be returned
486 /// without performing sret demotion.
488
489 /// This hook must be implemented to check whether the return values
490 /// described by \p Outs can fit into the return registers. If false
491 /// is returned, an sret-demotion is performed.
494 bool IsVarArg) const {
495 return true;
496 }
497
498 /// This hook must be implemented to lower outgoing return values, described
499 /// by \p Val, into the specified virtual registers \p VRegs.
500 /// This hook is used by GlobalISel.
501 ///
502 /// \p FLI is required for sret demotion.
503 ///
504 /// \p SwiftErrorVReg is non-zero if the function has a swifterror parameter
505 /// that needs to be implicitly returned.
506 ///
507 /// \return True if the lowering succeeds, false otherwise.
508 virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
510 Register SwiftErrorVReg) const {
511 if (!supportSwiftError()) {
512 assert(SwiftErrorVReg == 0 && "attempt to use unsupported swifterror");
513 return lowerReturn(MIRBuilder, Val, VRegs, FLI);
514 }
515 return false;
516 }
517
518 /// This hook behaves as the extended lowerReturn function, but for targets
519 /// that do not support swifterror value promotion.
520 virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
521 ArrayRef<Register> VRegs,
522 FunctionLoweringInfo &FLI) const {
523 return false;
524 }
525
526 virtual bool fallBackToDAGISel(const MachineFunction &MF) const {
527 return false;
528 }
529
530 /// This hook must be implemented to lower the incoming (formal)
531 /// arguments, described by \p VRegs, for GlobalISel. Each argument
532 /// must end up in the related virtual registers described by \p VRegs.
533 /// In other words, the first argument should end up in \c VRegs[0],
534 /// the second in \c VRegs[1], and so on. For each argument, there will be one
535 /// register for each non-aggregate type, as returned by \c computeValueLLTs.
536 /// \p MIRBuilder is set to the proper insertion for the argument
537 /// lowering. \p FLI is required for sret demotion.
538 ///
539 /// \return True if the lowering succeeded, false otherwise.
540 virtual bool lowerFormalArguments(MachineIRBuilder &MIRBuilder,
541 const Function &F,
543 FunctionLoweringInfo &FLI) const {
544 return false;
545 }
546
547 /// This hook must be implemented to lower the given call instruction,
548 /// including argument and return value marshalling.
549 ///
550 ///
551 /// \return true if the lowering succeeded, false otherwise.
552 virtual bool lowerCall(MachineIRBuilder &MIRBuilder,
553 CallLoweringInfo &Info) const {
554 return false;
555 }
556
557 /// Lower the given call instruction, including argument and return value
558 /// marshalling.
559 ///
560 /// \p CI is the call/invoke instruction.
561 ///
562 /// \p ResRegs are the registers where the call's return value should be
563 /// stored (or 0 if there is no return value). There will be one register for
564 /// each non-aggregate type, as returned by \c computeValueLLTs.
565 ///
566 /// \p ArgRegs is a list of lists of virtual registers containing each
567 /// argument that needs to be passed (argument \c i should be placed in \c
568 /// ArgRegs[i]). For each argument, there will be one register for each
569 /// non-aggregate type, as returned by \c computeValueLLTs.
570 ///
571 /// \p SwiftErrorVReg is non-zero if the call has a swifterror inout
572 /// parameter, and contains the vreg that the swifterror should be copied into
573 /// after the call.
574 ///
575 /// \p GetCalleeReg is a callback to materialize a register for the callee if
576 /// the target determines it cannot jump to the destination based purely on \p
577 /// CI. This might be because \p CI is indirect, or because of the limited
578 /// range of an immediate jump.
579 ///
580 /// \return true if the lowering succeeded, false otherwise.
581 bool lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &Call,
582 ArrayRef<Register> ResRegs,
583 ArrayRef<ArrayRef<Register>> ArgRegs, Register SwiftErrorVReg,
584 std::function<unsigned()> GetCalleeReg) const;
585
586 /// For targets which want to use big-endian can enable it with
587 /// enableBigEndian() hook
588 virtual bool enableBigEndian() const { return false; }
589
590 /// For targets which support the "returned" parameter attribute, returns
591 /// true if the given type is a valid one to use with "returned".
592 virtual bool isTypeIsValidForThisReturn(EVT Ty) const { return false; }
593};
594
595} // end namespace llvm
596
597#endif // LLVM_CODEGEN_GLOBALISEL_CALLLOWERING_H
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
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.
static M68kRelType getType(unsigned Kind, MCSymbolRefExpr::VariantKind &Modifier, bool &IsPCRel)
#define F(x, y, z)
Definition: MD5.cpp:55
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
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.
unsigned getNextStackOffset() const
getNextStackOffset - Return the next stack offset such that all stack slots satisfy their alignment r...
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:1184
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:540
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:492
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:592
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:588
virtual bool supportSwiftError() const
Definition: CallLowering.h:443
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:437
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:508
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:520
const TargetLowering * getTLI() const
Getter for generic TargetLowering class.
Definition: CallLowering.h:340
const XXXTargetLowering * getTLI() const
Getter for target specific TargetLowering class.
Definition: CallLowering.h:346
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:552
void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL, const FuncInfoTy &FuncInfo) const
virtual bool fallBackToDAGISel(const MachineFunction &MF) const
Definition: CallLowering.h:526
ISD::ArgFlagsTy getAttributesForReturn(const CallBase &Call) const
This is the shared class of boolean and integer constants.
Definition: Constants.h:78
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:114
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
Metadata node.
Definition: Metadata.h:943
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:577
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StackOffset holds a fixed and a scalable offset in bytes.
Definition: TypeSize.h:36
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:406
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:51
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
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:218
Base class for ValueHandlers used for arguments coming into the current function, or for return value...
Definition: CallLowering.h:318
Register buildExtensionHint(CCValAssign &VA, Register SrcReg, LLT NarrowTy)
Insert G_ASSERT_ZEXT/G_ASSERT_SEXT or other hint instruction based on VA, returning the new register ...
void assignValueToReg(Register ValVReg, Register PhysReg, CCValAssign VA) override
Provides a default implementation for argument handling.
IncomingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:319
OutgoingValueAssigner(CCAssignFn *AssignFn_, CCAssignFn *AssignFnVarArg_=nullptr)
Definition: CallLowering.h:224
Base class for ValueHandlers used for arguments passed to a function call, or for return values.
Definition: CallLowering.h:333
OutgoingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:334
Argument handling is mostly uniform between the four places that make these decisions: function forma...
Definition: CallLowering.h:161
CCAssignFn * getAssignFn(bool IsVarArg) const
Select the appropriate assignment function depending on whether this is a variadic call.
Definition: CallLowering.h:208
CCAssignFn * AssignFn
Assignment function to use for a general call.
Definition: CallLowering.h:196
bool isIncomingArgumentHandler() const
Returns true if the handler is dealing with incoming arguments, i.e.
Definition: CallLowering.h:177
ValueAssigner(bool IsIncoming, CCAssignFn *AssignFn_, CCAssignFn *AssignFnVarArg_=nullptr)
Definition: CallLowering.h:162
CCAssignFn * AssignFnVarArg
Assignment function to use for a variadic call.
Definition: CallLowering.h:200
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:185
Register extendRegister(Register ValReg, CCValAssign &VA, unsigned MaxSizeBits=0)
Extend a register to the location type given in VA, capped at extending to at most MaxSize bits.
virtual void assignValueToAddress(const ArgInfo &Arg, unsigned ValRegIndex, Register Addr, LLT MemTy, MachinePointerInfo &MPO, CCValAssign &VA)
An overload which takes an ArgInfo if additional information about the arg is needed.
Definition: CallLowering.h:281
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:231
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 LLT getStackValueStoreType(const DataLayout &DL, const CCValAssign &VA, ISD::ArgFlagsTy Flags) const
Return the in-memory size to write for the argument at VA.
virtual void assignValueToAddress(Register ValVReg, Register Addr, LLT MemTy, MachinePointerInfo &MPO, CCValAssign &VA)=0
The specified value has been assigned to a stack location.
bool isIncomingArgumentHandler() const
Returns true if the handler is dealing with incoming arguments, i.e.
Definition: CallLowering.h:243
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:295
virtual void assignValueToReg(Register ValVReg, Register PhysReg, 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:234
Extended Value Type.
Definition: ValueTypes.h:34
This class contains a discriminated union of information about pointers in memory operands,...