LLVM  10.0.0svn
CallingConvLower.cpp
Go to the documentation of this file.
1 //===-- CallingConvLower.cpp - Calling Conventions ------------------------===//
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 // This file implements the CCState class, used for lowering and implementing
10 // calling conventions.
11 //
12 //===----------------------------------------------------------------------===//
13 
20 #include "llvm/IR/DataLayout.h"
21 #include "llvm/Support/Debug.h"
25 #include <algorithm>
26 
27 using namespace llvm;
28 
31  : CallingConv(CC), IsVarArg(isVarArg), MF(mf),
32  TRI(*MF.getSubtarget().getRegisterInfo()), Locs(locs), Context(C) {
33  // No stack is used.
34  StackOffset = 0;
35 
37  UsedRegs.resize((TRI.getNumRegs()+31)/32);
38 }
39 
40 /// Allocate space on the stack large enough to pass an argument by value.
41 /// The size and alignment information of the argument is encoded in
42 /// its parameter attribute.
43 void CCState::HandleByVal(unsigned ValNo, MVT ValVT, MVT LocVT,
44  CCValAssign::LocInfo LocInfo, int MinSize,
45  int MinAlignment, ISD::ArgFlagsTy ArgFlags) {
46  llvm::Align MinAlign(MinAlignment);
47  llvm::Align Align(ArgFlags.getByValAlign());
48  unsigned Size = ArgFlags.getByValSize();
49  if (MinSize > (int)Size)
50  Size = MinSize;
51  if (MinAlign > Align)
52  Align = MinAlign;
54  MF.getSubtarget().getTargetLowering()->HandleByVal(this, Size, Align.value());
55  Size = unsigned(alignTo(Size, MinAlign));
56  unsigned Offset = AllocateStack(Size, Align.value());
57  addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
58 }
59 
60 /// Mark a register and all of its aliases as allocated.
61 void CCState::MarkAllocated(unsigned Reg) {
62  for (MCRegAliasIterator AI(Reg, &TRI, true); AI.isValid(); ++AI)
63  UsedRegs[*AI/32] |= 1 << (*AI&31);
64 }
65 
66 bool CCState::IsShadowAllocatedReg(unsigned Reg) const {
67  if (!isAllocated(Reg))
68  return false;
69 
70  for (auto const &ValAssign : Locs) {
71  if (ValAssign.isRegLoc()) {
72  for (MCRegAliasIterator AI(ValAssign.getLocReg(), &TRI, true);
73  AI.isValid(); ++AI) {
74  if (*AI == Reg)
75  return false;
76  }
77  }
78  }
79  return true;
80 }
81 
82 /// Analyze an array of argument values,
83 /// incorporating info about the formals into this state.
84 void
86  CCAssignFn Fn) {
87  unsigned NumArgs = Ins.size();
88 
89  for (unsigned i = 0; i != NumArgs; ++i) {
90  MVT ArgVT = Ins[i].VT;
91  ISD::ArgFlagsTy ArgFlags = Ins[i].Flags;
92  if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
93 #ifndef NDEBUG
94  dbgs() << "Formal argument #" << i << " has unhandled type "
95  << EVT(ArgVT).getEVTString() << '\n';
96 #endif
97  llvm_unreachable(nullptr);
98  }
99  }
100 }
101 
102 /// Analyze the return values of a function, returning true if the return can
103 /// be performed without sret-demotion and false otherwise.
105  CCAssignFn Fn) {
106  // Determine which register each value should be copied into.
107  for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
108  MVT VT = Outs[i].VT;
109  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
110  if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this))
111  return false;
112  }
113  return true;
114 }
115 
116 /// Analyze the returned values of a return,
117 /// incorporating info about the result values into this state.
119  CCAssignFn Fn) {
120  // Determine which register each value should be copied into.
121  for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
122  MVT VT = Outs[i].VT;
123  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
124  if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this)) {
125 #ifndef NDEBUG
126  dbgs() << "Return operand #" << i << " has unhandled type "
127  << EVT(VT).getEVTString() << '\n';
128 #endif
129  llvm_unreachable(nullptr);
130  }
131  }
132 }
133 
134 /// Analyze the outgoing arguments to a call,
135 /// incorporating info about the passed values into this state.
137  CCAssignFn Fn) {
138  unsigned NumOps = Outs.size();
139  for (unsigned i = 0; i != NumOps; ++i) {
140  MVT ArgVT = Outs[i].VT;
141  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
142  if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
143 #ifndef NDEBUG
144  dbgs() << "Call operand #" << i << " has unhandled type "
145  << EVT(ArgVT).getEVTString() << '\n';
146 #endif
147  llvm_unreachable(nullptr);
148  }
149  }
150 }
151 
152 /// Same as above except it takes vectors of types and argument flags.
155  CCAssignFn Fn) {
156  unsigned NumOps = ArgVTs.size();
157  for (unsigned i = 0; i != NumOps; ++i) {
158  MVT ArgVT = ArgVTs[i];
159  ISD::ArgFlagsTy ArgFlags = Flags[i];
160  if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
161 #ifndef NDEBUG
162  dbgs() << "Call operand #" << i << " has unhandled type "
163  << EVT(ArgVT).getEVTString() << '\n';
164 #endif
165  llvm_unreachable(nullptr);
166  }
167  }
168 }
169 
170 /// Analyze the return values of a call, incorporating info about the passed
171 /// values into this state.
173  CCAssignFn Fn) {
174  for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
175  MVT VT = Ins[i].VT;
176  ISD::ArgFlagsTy Flags = Ins[i].Flags;
177  if (Fn(i, VT, VT, CCValAssign::Full, Flags, *this)) {
178 #ifndef NDEBUG
179  dbgs() << "Call result #" << i << " has unhandled type "
180  << EVT(VT).getEVTString() << '\n';
181 #endif
182  llvm_unreachable(nullptr);
183  }
184  }
185 }
186 
187 /// Same as above except it's specialized for calls that produce a single value.
189  if (Fn(0, VT, VT, CCValAssign::Full, ISD::ArgFlagsTy(), *this)) {
190 #ifndef NDEBUG
191  dbgs() << "Call result has unhandled type "
192  << EVT(VT).getEVTString() << '\n';
193 #endif
194  llvm_unreachable(nullptr);
195  }
196 }
197 
199  if (VT.isVector())
200  return true; // Assume -msse-regparm might be in effect.
201  if (!VT.isInteger())
202  return false;
204  return true;
205  return false;
206 }
207 
209  MVT VT, CCAssignFn Fn) {
210  unsigned SavedStackOffset = StackOffset;
211  llvm::Align SavedMaxStackArgAlign = MaxStackArgAlign;
212  unsigned NumLocs = Locs.size();
213 
214  // Set the 'inreg' flag if it is used for this calling convention.
215  ISD::ArgFlagsTy Flags;
216  if (isValueTypeInRegForCC(CallingConv, VT))
217  Flags.setInReg();
218 
219  // Allocate something of this value type repeatedly until we get assigned a
220  // location in memory.
221  bool HaveRegParm = true;
222  while (HaveRegParm) {
223  if (Fn(0, VT, VT, CCValAssign::Full, Flags, *this)) {
224 #ifndef NDEBUG
225  dbgs() << "Call has unhandled type " << EVT(VT).getEVTString()
226  << " while computing remaining regparms\n";
227 #endif
228  llvm_unreachable(nullptr);
229  }
230  HaveRegParm = Locs.back().isRegLoc();
231  }
232 
233  // Copy all the registers from the value locations we added.
234  assert(NumLocs < Locs.size() && "CC assignment failed to add location");
235  for (unsigned I = NumLocs, E = Locs.size(); I != E; ++I)
236  if (Locs[I].isRegLoc())
237  Regs.push_back(MCPhysReg(Locs[I].getLocReg()));
238 
239  // Clear the assigned values and stack memory. We leave the registers marked
240  // as allocated so that future queries don't return the same registers, i.e.
241  // when i64 and f64 are both passed in GPRs.
242  StackOffset = SavedStackOffset;
243  MaxStackArgAlign = SavedMaxStackArgAlign;
244  Locs.resize(NumLocs);
245 }
246 
248  SmallVectorImpl<ForwardedRegister> &Forwards, ArrayRef<MVT> RegParmTypes,
249  CCAssignFn Fn) {
250  // Oftentimes calling conventions will not user register parameters for
251  // variadic functions, so we need to assume we're not variadic so that we get
252  // all the registers that might be used in a non-variadic call.
253  SaveAndRestore<bool> SavedVarArg(IsVarArg, false);
254  SaveAndRestore<bool> SavedMustTail(AnalyzingMustTailForwardedRegs, true);
255 
256  for (MVT RegVT : RegParmTypes) {
257  SmallVector<MCPhysReg, 8> RemainingRegs;
258  getRemainingRegParmsForType(RemainingRegs, RegVT, Fn);
259  const TargetLowering *TL = MF.getSubtarget().getTargetLowering();
260  const TargetRegisterClass *RC = TL->getRegClassFor(RegVT);
261  for (MCPhysReg PReg : RemainingRegs) {
262  unsigned VReg = MF.addLiveIn(PReg, RC);
263  Forwards.push_back(ForwardedRegister(VReg, PReg, RegVT));
264  }
265  }
266 }
267 
269  CallingConv::ID CallerCC, MachineFunction &MF,
270  LLVMContext &C,
272  CCAssignFn CalleeFn, CCAssignFn CallerFn) {
273  if (CalleeCC == CallerCC)
274  return true;
276  CCState CCInfo1(CalleeCC, false, MF, RVLocs1, C);
277  CCInfo1.AnalyzeCallResult(Ins, CalleeFn);
278 
280  CCState CCInfo2(CallerCC, false, MF, RVLocs2, C);
281  CCInfo2.AnalyzeCallResult(Ins, CallerFn);
282 
283  if (RVLocs1.size() != RVLocs2.size())
284  return false;
285  for (unsigned I = 0, E = RVLocs1.size(); I != E; ++I) {
286  const CCValAssign &Loc1 = RVLocs1[I];
287  const CCValAssign &Loc2 = RVLocs2[I];
288  if (Loc1.getLocInfo() != Loc2.getLocInfo())
289  return false;
290  bool RegLoc1 = Loc1.isRegLoc();
291  if (RegLoc1 != Loc2.isRegLoc())
292  return false;
293  if (RegLoc1) {
294  if (Loc1.getLocReg() != Loc2.getLocReg())
295  return false;
296  } else {
297  if (Loc1.getLocMemOffset() != Loc2.getLocMemOffset())
298  return false;
299  }
300  }
301  return true;
302 }
uint64_t CallInst * C
void AnalyzeCallResult(const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn Fn)
AnalyzeCallResult - Analyze the return values of a call, incorporating info about the passed values i...
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
bool isInteger() const
Return true if this is an integer or a vector integer type.
StackOffset is a wrapper around scalable and non-scalable offsets and is used in several functions su...
LLVMContext & Context
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Register getLocReg() const
Describes a register that needs to be forwarded from the prologue to a musttail call.
bool isVector() const
Return true if this is a vector value type.
bool isAllocated(unsigned Reg) const
isAllocated - Return true if the specified register (or an alias) is allocated.
void push_back(const T &Elt)
Definition: SmallVector.h:211
unsigned addLiveIn(unsigned PReg, const TargetRegisterClass *RC)
addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...
void AnalyzeFormalArguments(const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn Fn)
AnalyzeFormalArguments - Analyze an array of argument values, incorporating info about the formals in...
unsigned Reg
virtual const TargetLowering * getTargetLowering() const
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...
virtual void HandleByVal(CCState *, unsigned &, unsigned) const
Target-specific cleanup for formal ByVal parameters.
unsigned const TargetRegisterInfo * TRI
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
void addLoc(const CCValAssign &V)
static bool isValueTypeInRegForCC(CallingConv::ID CC, MVT VT)
LocInfo getLocInfo() const
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
virtual const TargetRegisterClass * getRegClassFor(MVT VT, bool isDivergent=false) const
Return the register class that should be used for the specified value type.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
void ensureMaxAlignment(llvm::Align Align)
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:75
unsigned getByValSize() const
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition: MCRegister.h:19
constexpr uint64_t MinAlign(uint64_t A, uint64_t B)
A and B are either alignments or offsets.
Definition: MathExtras.h:614
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
Machine Value Type.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
X86_FastCall - &#39;fast&#39; analog of X86_StdCall.
Definition: CallingConv.h:91
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
MCRegAliasIterator enumerates all registers aliasing Reg.
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
Definition: CallingConv.h:157
std::string getEVTString() const
This function returns value type as a string, e.g. "i32".
Definition: ValueTypes.cpp:114
static bool resultsCompatible(CallingConv::ID CalleeCC, CallingConv::ID CallerCC, MachineFunction &MF, LLVMContext &C, const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn CalleeFn, CCAssignFn CallerFn)
Returns true if the results of the two calling conventions are compatible.
Extended Value Type.
Definition: ValueTypes.h:33
size_t size() const
Definition: SmallVector.h:52
void HandleByVal(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, int MinSize, int MinAlign, ISD::ArgFlagsTy ArgFlags)
Allocate space on the stack large enough to pass an argument by value.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
void getRemainingRegParmsForType(SmallVectorImpl< MCPhysReg > &Regs, MVT VT, CCAssignFn Fn)
Compute the remaining unused register parameters that would be used for the given value type...
CCState - This class holds information needed while lowering arguments and return values...
CCValAssign - Represent assignment of one arg/retval to a location.
CCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF, SmallVectorImpl< CCValAssign > &locs, LLVMContext &C)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
unsigned getByValAlign() const
void AnalyzeCallOperands(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)
AnalyzeCallOperands - Analyze the outgoing arguments to a call, incorporating info about the passed v...
A utility class that uses RAII to save and restore the value of a variable.
void analyzeMustTailForwardedRegisters(SmallVectorImpl< ForwardedRegister > &Forwards, ArrayRef< MVT > RegParmTypes, CCAssignFn Fn)
Compute the set of registers that need to be preserved and forwarded to any musttail calls...
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:126
bool CheckReturn(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)
CheckReturn - Analyze the return values of a function, returning true if the return can be performed ...
unsigned AllocateStack(unsigned Size, unsigned Alignment)
AllocateStack - Allocate a chunk of stack space with the specified size and alignment.
unsigned getLocMemOffset() const
#define I(x, y, z)
Definition: MD5.cpp:58
void AnalyzeReturn(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)
AnalyzeReturn - Analyze the returned values of a return, incorporating info about the result values i...
uint32_t Size
Definition: Profile.cpp:46
static CCValAssign getMem(unsigned ValNo, MVT ValVT, unsigned Offset, MVT LocVT, LocInfo HTP)
bool isRegLoc() const
void clearByValRegsInfo()
bool IsShadowAllocatedReg(unsigned Reg) const
A shadow allocated register is a register that was allocated but wasn&#39;t added to the location list (L...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file provides utility classes that use RAII to save and restore values.
This file describes how to lower LLVM code to machine code.
void resize(size_type N)
Definition: SmallVector.h:344