LLVM 18.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 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, MachinePointerInfo &MPO,
278 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,
286 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 after the first
295 /// 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.
326 Register buildExtensionHint(CCValAssign &VA, Register SrcReg, LLT NarrowTy);
327
328 /// Provides a default implementation for argument handling.
329 void assignValueToReg(Register ValVReg, Register PhysReg,
330 CCValAssign VA) override;
331 };
332
333 /// Base class for ValueHandlers used for arguments passed to a function call,
334 /// or for return values.
337 : ValueHandler(/*IsIncoming*/ false, MIRBuilder, MRI) {}
338 };
339
340protected:
341 /// Getter for generic TargetLowering class.
342 const TargetLowering *getTLI() const {
343 return TLI;
344 }
345
346 /// Getter for target specific TargetLowering class.
347 template <class XXXTargetLowering>
348 const XXXTargetLowering *getTLI() const {
349 return static_cast<const XXXTargetLowering *>(TLI);
350 }
351
352 /// \returns Flags corresponding to the attributes on the \p ArgIdx-th
353 /// parameter of \p Call.
355 unsigned ArgIdx) const;
356
357 /// \returns Flags corresponding to the attributes on the return from \p Call.
359
360 /// Adds flags to \p Flags based off of the attributes in \p Attrs.
361 /// \p OpIdx is the index in \p Attrs to add flags from.
363 const AttributeList &Attrs,
364 unsigned OpIdx) const;
365
366 template <typename FuncInfoTy>
367 void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL,
368 const FuncInfoTy &FuncInfo) const;
369
370 /// Break \p OrigArgInfo into one or more pieces the calling convention can
371 /// process, returned in \p SplitArgs. For example, this should break structs
372 /// down into individual fields.
373 ///
374 /// If \p Offsets is non-null, it points to a vector to be filled in
375 /// with the in-memory offsets of each of the individual values.
376 void splitToValueTypes(const ArgInfo &OrigArgInfo,
377 SmallVectorImpl<ArgInfo> &SplitArgs,
378 const DataLayout &DL, CallingConv::ID CallConv,
379 SmallVectorImpl<uint64_t> *Offsets = nullptr) const;
380
381 /// Analyze the argument list in \p Args, using \p Assigner to populate \p
382 /// CCInfo. This will determine the types and locations to use for passed or
383 /// returned values. This may resize fields in \p Args if the value is split
384 /// across multiple registers or stack slots.
385 ///
386 /// This is independent of the function state and can be used
387 /// to determine how a call would pass arguments without needing to change the
388 /// function. This can be used to check if arguments are suitable for tail
389 /// call lowering.
390 ///
391 /// \return True if everything has succeeded, false otherwise.
392 bool determineAssignments(ValueAssigner &Assigner,
394 CCState &CCInfo) const;
395
396 /// Invoke ValueAssigner::assignArg on each of the given \p Args and then use
397 /// \p Handler to move them to the assigned locations.
398 ///
399 /// \return True if everything has succeeded, false otherwise.
401 ValueHandler &Handler, ValueAssigner &Assigner,
403 CallingConv::ID CallConv, bool IsVarArg,
404 ArrayRef<Register> ThisReturnRegs = std::nullopt) const;
405
406 /// Use \p Handler to insert code to handle the argument/return values
407 /// represented by \p Args. It's expected determineAssignments previously
408 /// processed these arguments to populate \p CCState and \p ArgLocs.
409 bool
410 handleAssignments(ValueHandler &Handler, SmallVectorImpl<ArgInfo> &Args,
412 MachineIRBuilder &MIRBuilder,
413 ArrayRef<Register> ThisReturnRegs = std::nullopt) const;
414
415 /// Check whether parameters to a call that are passed in callee saved
416 /// registers are the same as from the calling function. This needs to be
417 /// checked for tail call eligibility.
419 const uint32_t *CallerPreservedMask,
420 const SmallVectorImpl<CCValAssign> &ArgLocs,
421 const SmallVectorImpl<ArgInfo> &OutVals) const;
422
423 /// \returns True if the calling convention for a callee and its caller pass
424 /// results in the same way. Typically used for tail call eligibility checks.
425 ///
426 /// \p Info is the CallLoweringInfo for the call.
427 /// \p MF is the MachineFunction for the caller.
428 /// \p InArgs contains the results of the call.
429 /// \p CalleeAssigner specifies the target's handling of the argument types
430 /// for the callee.
431 /// \p CallerAssigner specifies the target's handling of the
432 /// argument types for the caller.
433 bool resultsCompatible(CallLoweringInfo &Info, MachineFunction &MF,
435 ValueAssigner &CalleeAssigner,
436 ValueAssigner &CallerAssigner) const;
437
438public:
439 CallLowering(const TargetLowering *TLI) : TLI(TLI) {}
440 virtual ~CallLowering() = default;
441
442 /// \return true if the target is capable of handling swifterror values that
443 /// have been promoted to a specified register. The extended versions of
444 /// lowerReturn and lowerCall should be implemented.
445 virtual bool supportSwiftError() const {
446 return false;
447 }
448
449 /// Load the returned value from the stack into virtual registers in \p VRegs.
450 /// It uses the frame index \p FI and the start offset from \p DemoteReg.
451 /// The loaded data size will be determined from \p RetTy.
452 void insertSRetLoads(MachineIRBuilder &MIRBuilder, Type *RetTy,
453 ArrayRef<Register> VRegs, Register DemoteReg,
454 int FI) const;
455
456 /// Store the return value given by \p VRegs into stack starting at the offset
457 /// specified in \p DemoteReg.
458 void insertSRetStores(MachineIRBuilder &MIRBuilder, Type *RetTy,
459 ArrayRef<Register> VRegs, Register DemoteReg) const;
460
461 /// Insert the hidden sret ArgInfo to the beginning of \p SplitArgs.
462 /// This function should be called from the target specific
463 /// lowerFormalArguments when \p F requires the sret demotion.
465 SmallVectorImpl<ArgInfo> &SplitArgs,
466 Register &DemoteReg, MachineRegisterInfo &MRI,
467 const DataLayout &DL) const;
468
469 /// For the call-base described by \p CB, insert the hidden sret ArgInfo to
470 /// the OrigArgs field of \p Info.
472 const CallBase &CB,
473 CallLoweringInfo &Info) const;
474
475 /// \return True if the return type described by \p Outs can be returned
476 /// without performing sret demotion.
478 CCAssignFn *Fn) const;
479
480 /// Get the type and the ArgFlags for the split components of \p RetTy as
481 /// returned by \c ComputeValueVTs.
484 const DataLayout &DL) const;
485
486 /// Toplevel function to check the return type based on the target calling
487 /// convention. \return True if the return value of \p MF can be returned
488 /// without performing sret demotion.
490
491 /// This hook must be implemented to check whether the return values
492 /// described by \p Outs can fit into the return registers. If false
493 /// is returned, an sret-demotion is performed.
496 bool IsVarArg) const {
497 return true;
498 }
499
500 /// This hook must be implemented to lower outgoing return values, described
501 /// by \p Val, into the specified virtual registers \p VRegs.
502 /// This hook is used by GlobalISel.
503 ///
504 /// \p FLI is required for sret demotion.
505 ///
506 /// \p SwiftErrorVReg is non-zero if the function has a swifterror parameter
507 /// that needs to be implicitly returned.
508 ///
509 /// \return True if the lowering succeeds, false otherwise.
510 virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
512 Register SwiftErrorVReg) const {
513 if (!supportSwiftError()) {
514 assert(SwiftErrorVReg == 0 && "attempt to use unsupported swifterror");
515 return lowerReturn(MIRBuilder, Val, VRegs, FLI);
516 }
517 return false;
518 }
519
520 /// This hook behaves as the extended lowerReturn function, but for targets
521 /// that do not support swifterror value promotion.
522 virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
523 ArrayRef<Register> VRegs,
524 FunctionLoweringInfo &FLI) const {
525 return false;
526 }
527
528 virtual bool fallBackToDAGISel(const MachineFunction &MF) const {
529 return false;
530 }
531
532 /// This hook must be implemented to lower the incoming (formal)
533 /// arguments, described by \p VRegs, for GlobalISel. Each argument
534 /// must end up in the related virtual registers described by \p VRegs.
535 /// In other words, the first argument should end up in \c VRegs[0],
536 /// the second in \c VRegs[1], and so on. For each argument, there will be one
537 /// register for each non-aggregate type, as returned by \c computeValueLLTs.
538 /// \p MIRBuilder is set to the proper insertion for the argument
539 /// lowering. \p FLI is required for sret demotion.
540 ///
541 /// \return True if the lowering succeeded, false otherwise.
542 virtual bool lowerFormalArguments(MachineIRBuilder &MIRBuilder,
543 const Function &F,
545 FunctionLoweringInfo &FLI) const {
546 return false;
547 }
548
549 /// This hook must be implemented to lower the given call instruction,
550 /// including argument and return value marshalling.
551 ///
552 ///
553 /// \return true if the lowering succeeded, false otherwise.
554 virtual bool lowerCall(MachineIRBuilder &MIRBuilder,
555 CallLoweringInfo &Info) const {
556 return false;
557 }
558
559 /// Lower the given call instruction, including argument and return value
560 /// marshalling.
561 ///
562 /// \p CI is the call/invoke instruction.
563 ///
564 /// \p ResRegs are the registers where the call's return value should be
565 /// stored (or 0 if there is no return value). There will be one register for
566 /// each non-aggregate type, as returned by \c computeValueLLTs.
567 ///
568 /// \p ArgRegs is a list of lists of virtual registers containing each
569 /// argument that needs to be passed (argument \c i should be placed in \c
570 /// ArgRegs[i]). For each argument, there will be one register for each
571 /// non-aggregate type, as returned by \c computeValueLLTs.
572 ///
573 /// \p SwiftErrorVReg is non-zero if the call has a swifterror inout
574 /// parameter, and contains the vreg that the swifterror should be copied into
575 /// after the call.
576 ///
577 /// \p GetCalleeReg is a callback to materialize a register for the callee if
578 /// the target determines it cannot jump to the destination based purely on \p
579 /// CI. This might be because \p CI is indirect, or because of the limited
580 /// range of an immediate jump.
581 ///
582 /// \return true if the lowering succeeded, false otherwise.
583 bool lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &Call,
584 ArrayRef<Register> ResRegs,
585 ArrayRef<ArrayRef<Register>> ArgRegs, Register SwiftErrorVReg,
586 std::function<unsigned()> GetCalleeReg) const;
587
588 /// For targets which want to use big-endian can enable it with
589 /// enableBigEndian() hook
590 virtual bool enableBigEndian() const { return false; }
591
592 /// For targets which support the "returned" parameter attribute, returns
593 /// true if the given type is a valid one to use with "returned".
594 virtual bool isTypeIsValidForThisReturn(EVT Ty) const { return false; }
595};
596
597} // end namespace llvm
598
599#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:1190
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:542
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:494
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:594
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:590
virtual bool supportSwiftError() const
Definition: CallLowering.h:445
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:439
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:510
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:522
const TargetLowering * getTLI() const
Getter for generic TargetLowering class.
Definition: CallLowering.h:342
const XXXTargetLowering * getTLI() const
Getter for target specific TargetLowering class.
Definition: CallLowering.h:348
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:554
void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL, const FuncInfoTy &FuncInfo) const
virtual bool fallBackToDAGISel(const MachineFunction &MF) const
Definition: CallLowering.h:528
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:110
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
Metadata node.
Definition: Metadata.h:950
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
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:440
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
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: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:335
OutgoingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:336
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
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:283
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 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:245
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, 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,...