LLVM  16.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"
18 #include "llvm/ADT/SmallVector.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 
31 namespace llvm {
32 
33 class AttributeList;
34 class CallBase;
35 class DataLayout;
36 class Function;
37 class FunctionLoweringInfo;
38 class MachineIRBuilder;
39 class MachineFunction;
40 struct MachinePointerInfo;
41 class MachineRegisterInfo;
42 class TargetLowering;
43 
44 class CallLowering {
45  const TargetLowering *TLI;
46 
47  virtual void anchor();
48 public:
49  struct BaseArgInfo {
50  Type *Ty;
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)
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 
123  MDNode *KnownCallees = nullptr;
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.
161  struct ValueAssigner {
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 
229  struct ValueHandler {
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,
253  MachinePointerInfo &MPO,
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.
261  virtual LLT getStackValueStoreType(const DataLayout &DL,
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.
274  virtual void assignValueToAddress(Register ValVReg, Register Addr,
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,
283  MachinePointerInfo &MPO,
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 
338 protected:
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.
398  bool
399  determineAndHandleAssignments(ValueHandler &Handler, ValueAssigner &Assigner,
401  MachineIRBuilder &MIRBuilder,
402  CallingConv::ID CallConv, bool IsVarArg,
403  ArrayRef<Register> ThisReturnRegs = None) const;
404 
405  /// Use \p Handler to insert code to handle the argument/return values
406  /// represented by \p Args. It's expected determineAssignments previously
407  /// processed these arguments to populate \p CCState and \p ArgLocs.
408  bool handleAssignments(ValueHandler &Handler, SmallVectorImpl<ArgInfo> &Args,
409  CCState &CCState,
411  MachineIRBuilder &MIRBuilder,
412  ArrayRef<Register> ThisReturnRegs = None) const;
413 
414  /// Check whether parameters to a call that are passed in callee saved
415  /// registers are the same as from the calling function. This needs to be
416  /// checked for tail call eligibility.
418  const uint32_t *CallerPreservedMask,
419  const SmallVectorImpl<CCValAssign> &ArgLocs,
420  const SmallVectorImpl<ArgInfo> &OutVals) const;
421 
422  /// \returns True if the calling convention for a callee and its caller pass
423  /// results in the same way. Typically used for tail call eligibility checks.
424  ///
425  /// \p Info is the CallLoweringInfo for the call.
426  /// \p MF is the MachineFunction for the caller.
427  /// \p InArgs contains the results of the call.
428  /// \p CalleeAssigner specifies the target's handling of the argument types
429  /// for the callee.
430  /// \p CallerAssigner specifies the target's handling of the
431  /// argument types for the caller.
432  bool resultsCompatible(CallLoweringInfo &Info, MachineFunction &MF,
433  SmallVectorImpl<ArgInfo> &InArgs,
434  ValueAssigner &CalleeAssigner,
435  ValueAssigner &CallerAssigner) const;
436 
437 public:
438  CallLowering(const TargetLowering *TLI) : TLI(TLI) {}
439  virtual ~CallLowering() = default;
440 
441  /// \return true if the target is capable of handling swifterror values that
442  /// have been promoted to a specified register. The extended versions of
443  /// lowerReturn and lowerCall should be implemented.
444  virtual bool supportSwiftError() const {
445  return false;
446  }
447 
448  /// Load the returned value from the stack into virtual registers in \p VRegs.
449  /// It uses the frame index \p FI and the start offset from \p DemoteReg.
450  /// The loaded data size will be determined from \p RetTy.
451  void insertSRetLoads(MachineIRBuilder &MIRBuilder, Type *RetTy,
452  ArrayRef<Register> VRegs, Register DemoteReg,
453  int FI) const;
454 
455  /// Store the return value given by \p VRegs into stack starting at the offset
456  /// specified in \p DemoteReg.
457  void insertSRetStores(MachineIRBuilder &MIRBuilder, Type *RetTy,
458  ArrayRef<Register> VRegs, Register DemoteReg) const;
459 
460  /// Insert the hidden sret ArgInfo to the beginning of \p SplitArgs.
461  /// This function should be called from the target specific
462  /// lowerFormalArguments when \p F requires the sret demotion.
464  SmallVectorImpl<ArgInfo> &SplitArgs,
465  Register &DemoteReg, MachineRegisterInfo &MRI,
466  const DataLayout &DL) const;
467 
468  /// For the call-base described by \p CB, insert the hidden sret ArgInfo to
469  /// the OrigArgs field of \p Info.
471  const CallBase &CB,
472  CallLoweringInfo &Info) const;
473 
474  /// \return True if the return type described by \p Outs can be returned
475  /// without performing sret demotion.
477  CCAssignFn *Fn) const;
478 
479  /// Get the type and the ArgFlags for the split components of \p RetTy as
480  /// returned by \c ComputeValueVTs.
481  void getReturnInfo(CallingConv::ID CallConv, Type *RetTy, AttributeList Attrs,
483  const DataLayout &DL) const;
484 
485  /// Toplevel function to check the return type based on the target calling
486  /// convention. \return True if the return value of \p MF can be returned
487  /// without performing sret demotion.
489 
490  /// This hook must be implemented to check whether the return values
491  /// described by \p Outs can fit into the return registers. If false
492  /// is returned, an sret-demotion is performed.
493  virtual bool canLowerReturn(MachineFunction &MF, CallingConv::ID CallConv,
495  bool IsVarArg) const {
496  return true;
497  }
498 
499  /// This hook must be implemented to lower outgoing return values, described
500  /// by \p Val, into the specified virtual registers \p VRegs.
501  /// This hook is used by GlobalISel.
502  ///
503  /// \p FLI is required for sret demotion.
504  ///
505  /// \p SwiftErrorVReg is non-zero if the function has a swifterror parameter
506  /// that needs to be implicitly returned.
507  ///
508  /// \return True if the lowering succeeds, false otherwise.
509  virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
511  Register SwiftErrorVReg) const {
512  if (!supportSwiftError()) {
513  assert(SwiftErrorVReg == 0 && "attempt to use unsupported swifterror");
514  return lowerReturn(MIRBuilder, Val, VRegs, FLI);
515  }
516  return false;
517  }
518 
519  /// This hook behaves as the extended lowerReturn function, but for targets
520  /// that do not support swifterror value promotion.
521  virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
522  ArrayRef<Register> VRegs,
523  FunctionLoweringInfo &FLI) const {
524  return false;
525  }
526 
527  virtual bool fallBackToDAGISel(const MachineFunction &MF) const {
528  return false;
529  }
530 
531  /// This hook must be implemented to lower the incoming (formal)
532  /// arguments, described by \p VRegs, for GlobalISel. Each argument
533  /// must end up in the related virtual registers described by \p VRegs.
534  /// In other words, the first argument should end up in \c VRegs[0],
535  /// the second in \c VRegs[1], and so on. For each argument, there will be one
536  /// register for each non-aggregate type, as returned by \c computeValueLLTs.
537  /// \p MIRBuilder is set to the proper insertion for the argument
538  /// lowering. \p FLI is required for sret demotion.
539  ///
540  /// \return True if the lowering succeeded, false otherwise.
541  virtual bool lowerFormalArguments(MachineIRBuilder &MIRBuilder,
542  const Function &F,
544  FunctionLoweringInfo &FLI) const {
545  return false;
546  }
547 
548  /// This hook must be implemented to lower the given call instruction,
549  /// including argument and return value marshalling.
550  ///
551  ///
552  /// \return true if the lowering succeeded, false otherwise.
553  virtual bool lowerCall(MachineIRBuilder &MIRBuilder,
554  CallLoweringInfo &Info) const {
555  return false;
556  }
557 
558  /// Lower the given call instruction, including argument and return value
559  /// marshalling.
560  ///
561  /// \p CI is the call/invoke instruction.
562  ///
563  /// \p ResRegs are the registers where the call's return value should be
564  /// stored (or 0 if there is no return value). There will be one register for
565  /// each non-aggregate type, as returned by \c computeValueLLTs.
566  ///
567  /// \p ArgRegs is a list of lists of virtual registers containing each
568  /// argument that needs to be passed (argument \c i should be placed in \c
569  /// ArgRegs[i]). For each argument, there will be one register for each
570  /// non-aggregate type, as returned by \c computeValueLLTs.
571  ///
572  /// \p SwiftErrorVReg is non-zero if the call has a swifterror inout
573  /// parameter, and contains the vreg that the swifterror should be copied into
574  /// after the call.
575  ///
576  /// \p GetCalleeReg is a callback to materialize a register for the callee if
577  /// the target determines it cannot jump to the destination based purely on \p
578  /// CI. This might be because \p CI is indirect, or because of the limited
579  /// range of an immediate jump.
580  ///
581  /// \return true if the lowering succeeded, false otherwise.
582  bool lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &Call,
583  ArrayRef<Register> ResRegs,
584  ArrayRef<ArrayRef<Register>> ArgRegs, Register SwiftErrorVReg,
585  std::function<unsigned()> GetCalleeReg) const;
586 
587  /// For targets which want to use big-endian can enable it with
588  /// enableBigEndian() hook
589  virtual bool enableBigEndian() const { return false; }
590 
591  /// For targets which support the "returned" parameter attribute, returns
592  /// true if the given type is a valid one to use with "returned".
593  virtual bool isTypeIsValidForThisReturn(EVT Ty) const { return false; }
594 };
595 
596 } // end namespace llvm
597 
598 #endif // LLVM_CODEGEN_GLOBALISEL_CALLLOWERING_H
llvm::CallLowering::ValueAssigner
Argument handling is mostly uniform between the four places that make these decisions: function forma...
Definition: CallLowering.h:161
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::CallLowering::CallLoweringInfo::CanLowerReturn
bool CanLowerReturn
True if the function's return value can be lowered to registers.
Definition: CallLowering.h:140
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::CallLowering::ValueHandler::~ValueHandler
virtual ~ValueHandler()=default
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::CallLowering::CallLoweringInfo::IsMustTailCall
bool IsMustTailCall
True if the call must be tail call optimized.
Definition: CallLowering.h:126
llvm::CCState
CCState - This class holds information needed while lowering arguments and return values.
Definition: CallingConvLower.h:189
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:50
llvm::Function
Definition: Function.h:60
llvm::CallLowering::IncomingValueHandler::assignValueToReg
void assignValueToReg(Register ValVReg, Register PhysReg, CCValAssign VA) override
Provides a default implementation for argument handling.
Definition: CallLowering.cpp:1226
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1181
llvm::CallLowering::ValueHandler::extendRegister
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.
Definition: CallLowering.cpp:1134
llvm::CallLowering::CallLoweringInfo::LoweredTailCall
bool LoweredTailCall
True if the call was lowered as a tail call.
Definition: CallLowering.h:134
ErrorHandling.h
llvm::CallLowering::CallLoweringInfo::SwiftErrorVReg
Register SwiftErrorVReg
Valid if the call has a swifterror inout parameter, and contains the vreg that the swifterror should ...
Definition: CallLowering.h:118
llvm::CallLowering::ValueHandler
Definition: CallLowering.h:229
llvm::CallLowering::ValueHandler::assignValueToAddress
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
llvm::CallLowering::lowerReturn
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:521
llvm::CallLowering::insertSRetOutgoingArgument
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.
Definition: CallLowering.cpp:915
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1835
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::CallLowering::OutgoingValueHandler
Base class for ValueHandlers used for arguments passed to a function call, or for return values.
Definition: CallLowering.h:333
llvm::AttributeList
Definition: Attributes.h:425
llvm::CallLowering::CallLoweringInfo::CFIType
const ConstantInt * CFIType
Expected type identifier for indirect calls with a CFI check.
Definition: CallLowering.h:149
llvm::sys::path::end
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:235
llvm::sys::path::begin
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:226
llvm::CallLowering::supportSwiftError
virtual bool supportSwiftError() const
Definition: CallLowering.h:444
llvm::CallingConv::C
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
llvm::CallLowering::splitToValueTypes
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.
Definition: CallLowering.cpp:250
llvm::CallLowering::CallLoweringInfo::DemoteRegister
Register DemoteRegister
VReg to hold the hidden sret parameter.
Definition: CallLowering.h:143
llvm::CallLowering::BaseArgInfo
Definition: CallLowering.h:49
llvm::CallLowering::ArgInfo::ArgInfo
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
F
#define F(x, y, z)
Definition: MD5.cpp:55
MachineValueType.h
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:187
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::CallLowering::getTLI
const TargetLowering * getTLI() const
Getter for generic TargetLowering class.
Definition: CallLowering.h:340
llvm::CallLowering::resultsCompatible
bool resultsCompatible(CallLoweringInfo &Info, MachineFunction &MF, SmallVectorImpl< ArgInfo > &InArgs, ValueAssigner &CalleeAssigner, ValueAssigner &CallerAssigner) const
Definition: CallLowering.cpp:1034
llvm::CCValAssign
CCValAssign - Represent assignment of one arg/retval to a location.
Definition: CallingConvLower.h:31
llvm::CallLowering::checkReturnTypeForCallConv
bool checkReturnTypeForCallConv(MachineFunction &MF) const
Toplevel function to check the return type based on the target calling convention.
Definition: CallLowering.cpp:971
llvm::CallLowering::IncomingValueHandler::IncomingValueHandler
IncomingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:319
llvm::MachineOperand::CreateImm
static MachineOperand CreateImm(int64_t Val)
Definition: MachineOperand.h:782
llvm::CallLowering::ValueAssigner::AssignFn
CCAssignFn * AssignFn
Assignment function to use for a general call.
Definition: CallLowering.h:196
llvm::CallLowering::ValueHandler::assignValueToReg
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 ...
llvm::CallLowering::ArgInfo
Definition: CallLowering.h:62
llvm::EVT
Extended Value Type.
Definition: ValueTypes.h:34
llvm::CallLowering::BaseArgInfo::BaseArgInfo
BaseArgInfo(Type *Ty, ArrayRef< ISD::ArgFlagsTy > Flags=ArrayRef< ISD::ArgFlagsTy >(), bool IsFixed=true)
Definition: CallLowering.h:54
llvm::TargetLowering
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Definition: TargetLowering.h:3446
llvm::CallLowering::lowerFormalArguments
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:541
llvm::CallLowering::lowerReturn
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:509
llvm::CallLowering::ValueHandler::getStackValueStoreType
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.
Definition: CallLowering.cpp:1088
llvm::CallLowering::CallLoweringInfo::DemoteStackIndex
int DemoteStackIndex
The stack index for sret demotion.
Definition: CallLowering.h:146
llvm::CallLowering::CallLoweringInfo::CB
const CallBase * CB
Original IR callsite corresponding to this call, if available.
Definition: CallLowering.h:121
false
Definition: StackSlotColoring.cpp:141
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:48
llvm::CallLowering::OutgoingValueAssigner
Definition: CallLowering.h:223
llvm::CallLowering::determineAssignments
bool determineAssignments(ValueAssigner &Assigner, SmallVectorImpl< ArgInfo > &Args, CCState &CCInfo) const
Analyze the argument list in Args, using Assigner to populate CCInfo.
Definition: CallLowering.cpp:587
llvm::CallLowering::ValueHandler::assignCustomValue
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
llvm::CallLowering::IncomingValueHandler
Base class for ValueHandlers used for arguments coming into the current function, or for return value...
Definition: CallLowering.h:318
llvm::CallLowering::ValueAssigner::~ValueAssigner
virtual ~ValueAssigner()=default
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::None
const NoneType None
Definition: None.h:24
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
Type.h
llvm::CallLowering::BaseArgInfo::BaseArgInfo
BaseArgInfo()
Definition: CallLowering.h:59
LowLevelTypeImpl.h
llvm::CallLowering::ArgInfo::OrigRegs
SmallVector< Register, 2 > OrigRegs
Definition: CallLowering.h:67
llvm::CallLowering::ValueAssigner::isIncomingArgumentHandler
bool isIncomingArgumentHandler() const
Returns true if the handler is dealing with incoming arguments, i.e.
Definition: CallLowering.h:177
llvm::CCAssignFn
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.
Definition: CallingConvLower.h:175
llvm::CallLowering::isTypeIsValidForThisReturn
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:593
llvm::CallLowering::ArgInfo::NoArgIndex
static const unsigned NoArgIndex
Sentinel value for implicit machine-level input arguments.
Definition: CallLowering.h:79
llvm::CCValAssign::LocInfo
LocInfo
Definition: CallingConvLower.h:33
llvm::CallLowering::OutgoingValueHandler::OutgoingValueHandler
OutgoingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:334
llvm::MachineIRBuilder
Helper class to build MachineInstr.
Definition: MachineIRBuilder.h:221
TargetCallingConv.h
uint64_t
llvm::CallLowering::checkReturn
bool checkReturn(CCState &CCInfo, SmallVectorImpl< BaseArgInfo > &Outs, CCAssignFn *Fn) const
Definition: CallLowering.cpp:937
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:78
llvm::MachinePointerInfo
This class contains a discriminated union of information about pointers in memory operands,...
Definition: MachineMemOperand.h:39
ArrayRef.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::CallLowering::getAttributesForReturn
ISD::ArgFlagsTy getAttributesForReturn(const CallBase &Call) const
Definition: CallLowering.cpp:74
llvm::FunctionLoweringInfo
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
Definition: FunctionLoweringInfo.h:52
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::Type::isVoidTy
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:31
llvm::MDNode
Metadata node.
Definition: Metadata.h:944
llvm::CallLowering::CallLoweringInfo::KnownCallees
MDNode * KnownCallees
Definition: CallLowering.h:123
llvm::CallLowering::ValueAssigner::getAssignFn
CCAssignFn * getAssignFn(bool IsVarArg) const
Select the appropriate assignment function depending on whether this is a variadic call.
Definition: CallLowering.h:208
llvm::CallLowering::addArgFlagsFromAttributes
void addArgFlagsFromAttributes(ISD::ArgFlagsTy &Flags, const AttributeList &Attrs, unsigned OpIdx) const
Adds flags to Flags based off of the attributes in Attrs.
Definition: CallLowering.cpp:82
llvm::MachineFunction
Definition: MachineFunction.h:257
getType
static M68kRelType getType(unsigned Kind, MCSymbolRefExpr::VariantKind &Modifier, bool &IsPCRel)
Definition: M68kELFObjectWriter.cpp:48
llvm::CCState::isVarArg
bool isVarArg() const
Definition: CallingConvLower.h:258
llvm::CallLowering::ValueHandler::copyArgumentMemory
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.
Definition: CallLowering.cpp:1111
llvm::CallLowering::ValueHandler::IsIncomingArgumentHandler
const bool IsIncomingArgumentHandler
Definition: CallLowering.h:232
llvm::CallLowering::enableBigEndian
virtual bool enableBigEndian() const
For targets which want to use big-endian can enable it with enableBigEndian() hook.
Definition: CallLowering.h:589
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::CallLowering::ValueHandler::getStackAddress
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.
llvm::CallLowering::~CallLowering
virtual ~CallLowering()=default
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::CallLowering::insertSRetLoads
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.
Definition: CallLowering.cpp:832
llvm::CallLowering::CallLoweringInfo::IsVarArg
bool IsVarArg
True if the call is to a vararg function.
Definition: CallLowering.h:137
uint32_t
llvm::CallLowering::getTLI
const XXXTargetLowering * getTLI() const
Getter for target specific TargetLowering class.
Definition: CallLowering.h:346
llvm::StackOffset
StackOffset is a class to represent an offset with 2 dimensions, named fixed and scalable,...
Definition: TypeSize.h:134
llvm::CallLowering::IncomingValueAssigner::IncomingValueAssigner
IncomingValueAssigner(CCAssignFn *AssignFn_, CCAssignFn *AssignFnVarArg_=nullptr)
Definition: CallLowering.h:218
llvm::ISD::ArgFlagsTy
Definition: TargetCallingConv.h:27
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::ArgInfo
Helper struct shared between Function Specialization and SCCP Solver.
Definition: SCCPSolver.h:47
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::CallLowering::insertSRetIncomingArgument
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.
Definition: CallLowering.cpp:893
llvm::CallLowering::getAttributesForArgIdx
ISD::ArgFlagsTy getAttributesForArgIdx(const CallBase &Call, unsigned ArgIdx) const
Definition: CallLowering.cpp:64
CallingConv.h
llvm::CallLowering::canLowerReturn
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:493
llvm::CallLowering::insertSRetStores
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.
Definition: CallLowering.cpp:862
CallingConvLower.h
llvm::CallLowering::ValueHandler::MRI
MachineRegisterInfo & MRI
Definition: CallLowering.h:231
llvm::CallLowering::CallLoweringInfo::CallConv
CallingConv::ID CallConv
Calling convention to be used for the call.
Definition: CallLowering.h:104
llvm::Type::isEmptyTy
bool isEmptyTy() const
Return true if this type is empty, that is, it has no elements or all of its elements are empty.
Definition: Type.cpp:147
llvm::CallLowering::handleAssignments
bool handleAssignments(ValueHandler &Handler, SmallVectorImpl< ArgInfo > &Args, CCState &CCState, SmallVectorImpl< CCValAssign > &ArgLocs, MachineIRBuilder &MIRBuilder, ArrayRef< Register > ThisReturnRegs=None) const
Use Handler to insert code to handle the argument/return values represented by Args.
Definition: CallLowering.cpp:648
llvm::CallLowering::IncomingValueAssigner
Definition: CallLowering.h:217
llvm::CallLowering::ArgInfo::Regs
SmallVector< Register, 4 > Regs
Definition: CallLowering.h:63
llvm::CallLowering::BaseArgInfo::Ty
Type * Ty
Definition: CallLowering.h:50
llvm::CCState::getNextStackOffset
unsigned getNextStackOffset() const
getNextStackOffset - Return the next stack offset such that all stack slots satisfy their alignment r...
Definition: CallingConvLower.h:262
llvm::CallLowering::CallLoweringInfo
Definition: CallLowering.h:102
llvm::CallLowering::ValueAssigner::AssignFnVarArg
CCAssignFn * AssignFnVarArg
Assignment function to use for a variadic call.
Definition: CallLowering.h:200
llvm::CallLowering::fallBackToDAGISel
virtual bool fallBackToDAGISel(const MachineFunction &MF) const
Definition: CallLowering.h:527
llvm::CallLowering::IncomingValueHandler::buildExtensionHint
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 ...
Definition: CallLowering.cpp:1184
llvm::CallLowering::CallLowering
CallLowering(const TargetLowering *TLI)
Definition: CallLowering.h:438
llvm::CallLowering::ValueHandler::MIRBuilder
MachineIRBuilder & MIRBuilder
Definition: CallLowering.h:230
llvm::CallLowering::ValueAssigner::ValueAssigner
ValueAssigner(bool IsIncoming, CCAssignFn *AssignFn_, CCAssignFn *AssignFnVarArg_=nullptr)
Definition: CallLowering.h:162
SmallVector.h
llvm::CallLowering::ValueHandler::ValueHandler
ValueHandler(bool IsIncoming, MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI)
Definition: CallLowering.h:234
llvm::CallLowering::ArgInfo::ArgInfo
ArgInfo(ArrayRef< Register > Regs, const Value &OrigValue, unsigned OrigIndex, ArrayRef< ISD::ArgFlagsTy > Flags=ArrayRef< ISD::ArgFlagsTy >(), bool IsFixed=true)
Definition: CallLowering.h:94
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
llvm::CallLowering::getReturnInfo
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.
Definition: CallLowering.cpp:948
MachineOperand.h
llvm::CallLowering::CallLoweringInfo::OrigRet
ArgInfo OrigRet
Descriptor for the return type of the function.
Definition: CallLowering.h:111
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::CallLowering::BaseArgInfo::IsFixed
bool IsFixed
Definition: CallLowering.h:52
llvm::CallLowering::ArgInfo::OrigValue
const Value * OrigValue
Optionally track the original IR value for the argument.
Definition: CallLowering.h:73
llvm::CallLowering::ValueAssigner::assignArg
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
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:394
llvm::CallLowering::CallLoweringInfo::IsTailCall
bool IsTailCall
True if the call passes all target-independent checks for tail call optimization.
Definition: CallLowering.h:130
llvm::SI::KernelInputOffsets::Offsets
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:1326
llvm::CallLowering::ArgInfo::OrigArgIndex
unsigned OrigArgIndex
Index original Function's argument.
Definition: CallLowering.h:76
llvm::CallLowering::CallLoweringInfo::OrigArgs
SmallVector< ArgInfo, 32 > OrigArgs
List of descriptors of the arguments passed to the function.
Definition: CallLowering.h:114
llvm::CallLowering::parametersInCSRMatch
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...
Definition: CallLowering.cpp:982
Value.h
llvm::CallLowering
Definition: CallLowering.h:44
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::CallLowering::ValueHandler::isIncomingArgumentHandler
bool isIncomingArgumentHandler() const
Returns true if the handler is dealing with incoming arguments, i.e.
Definition: CallLowering.h:243
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::CallLowering::ArgInfo::ArgInfo
ArgInfo()=default
llvm::CallLowering::OutgoingValueAssigner::OutgoingValueAssigner
OutgoingValueAssigner(CCAssignFn *AssignFn_, CCAssignFn *AssignFnVarArg_=nullptr)
Definition: CallLowering.h:224
llvm::CallLowering::determineAndHandleAssignments
bool determineAndHandleAssignments(ValueHandler &Handler, ValueAssigner &Assigner, SmallVectorImpl< ArgInfo > &Args, MachineIRBuilder &MIRBuilder, CallingConv::ID CallConv, bool IsVarArg, ArrayRef< Register > ThisReturnRegs=None) const
Invoke ValueAssigner::assignArg on each of the given Args and then use Handler to move them to the as...
Definition: CallLowering.cpp:562
llvm::CallLowering::ValueHandler::assignValueToAddress
virtual void assignValueToAddress(Register ValVReg, Register Addr, LLT MemTy, MachinePointerInfo &MPO, CCValAssign &VA)=0
The specified value has been assigned to a stack location.
llvm::CallLowering::BaseArgInfo::Flags
SmallVector< ISD::ArgFlagsTy, 4 > Flags
Definition: CallLowering.h:51
llvm::CallLowering::CallLoweringInfo::Callee
MachineOperand Callee
Destination of the call.
Definition: CallLowering.h:108
llvm::LLT
Definition: LowLevelTypeImpl.h:39
llvm::CallLowering::lowerCall
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:553
llvm::CallLowering::setArgFlags
void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL, const FuncInfoTy &FuncInfo) const
Definition: CallLowering.cpp:192