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  Align MinAlign(MinAlignment);
47  Align Alignment(ArgFlags.getByValAlign());
48  unsigned Size = ArgFlags.getByValSize();
49  if (MinSize > (int)Size)
50  Size = MinSize;
51  if (MinAlign > Alignment)
52  Alignment = MinAlign;
53  ensureMaxAlignment(Alignment);
54  MF.getSubtarget().getTargetLowering()->HandleByVal(this, Size,
55  Alignment.value());
56  Size = unsigned(alignTo(Size, MinAlign));
57  unsigned Offset = AllocateStack(Size, Alignment.value());
58  addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
59 }
60 
61 /// Mark a register and all of its aliases as allocated.
62 void CCState::MarkAllocated(unsigned Reg) {
63  for (MCRegAliasIterator AI(Reg, &TRI, true); AI.isValid(); ++AI)
64  UsedRegs[*AI/32] |= 1 << (*AI&31);
65 }
66 
67 bool CCState::IsShadowAllocatedReg(unsigned Reg) const {
68  if (!isAllocated(Reg))
69  return false;
70 
71  for (auto const &ValAssign : Locs) {
72  if (ValAssign.isRegLoc()) {
73  for (MCRegAliasIterator AI(ValAssign.getLocReg(), &TRI, true);
74  AI.isValid(); ++AI) {
75  if (*AI == Reg)
76  return false;
77  }
78  }
79  }
80  return true;
81 }
82 
83 /// Analyze an array of argument values,
84 /// incorporating info about the formals into this state.
85 void
87  CCAssignFn Fn) {
88  unsigned NumArgs = Ins.size();
89 
90  for (unsigned i = 0; i != NumArgs; ++i) {
91  MVT ArgVT = Ins[i].VT;
92  ISD::ArgFlagsTy ArgFlags = Ins[i].Flags;
93  if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this))
94  report_fatal_error("unable to allocate function argument #" + Twine(i));
95  }
96 }
97 
98 /// Analyze the return values of a function, returning true if the return can
99 /// be performed without sret-demotion and false otherwise.
101  CCAssignFn Fn) {
102  // Determine which register each value should be copied into.
103  for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
104  MVT VT = Outs[i].VT;
105  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
106  if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this))
107  return false;
108  }
109  return true;
110 }
111 
112 /// Analyze the returned values of a return,
113 /// incorporating info about the result values into this state.
115  CCAssignFn Fn) {
116  // Determine which register each value should be copied into.
117  for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
118  MVT VT = Outs[i].VT;
119  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
120  if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this))
121  report_fatal_error("unable to allocate function return #" + Twine(i));
122  }
123 }
124 
125 /// Analyze the outgoing arguments to a call,
126 /// incorporating info about the passed values into this state.
128  CCAssignFn Fn) {
129  unsigned NumOps = Outs.size();
130  for (unsigned i = 0; i != NumOps; ++i) {
131  MVT ArgVT = Outs[i].VT;
132  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
133  if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
134 #ifndef NDEBUG
135  dbgs() << "Call operand #" << i << " has unhandled type "
136  << EVT(ArgVT).getEVTString() << '\n';
137 #endif
138  llvm_unreachable(nullptr);
139  }
140  }
141 }
142 
143 /// Same as above except it takes vectors of types and argument flags.
146  CCAssignFn Fn) {
147  unsigned NumOps = ArgVTs.size();
148  for (unsigned i = 0; i != NumOps; ++i) {
149  MVT ArgVT = ArgVTs[i];
150  ISD::ArgFlagsTy ArgFlags = Flags[i];
151  if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
152 #ifndef NDEBUG
153  dbgs() << "Call operand #" << i << " has unhandled type "
154  << EVT(ArgVT).getEVTString() << '\n';
155 #endif
156  llvm_unreachable(nullptr);
157  }
158  }
159 }
160 
161 /// Analyze the return values of a call, incorporating info about the passed
162 /// values into this state.
164  CCAssignFn Fn) {
165  for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
166  MVT VT = Ins[i].VT;
167  ISD::ArgFlagsTy Flags = Ins[i].Flags;
168  if (Fn(i, VT, VT, CCValAssign::Full, Flags, *this)) {
169 #ifndef NDEBUG
170  dbgs() << "Call result #" << i << " has unhandled type "
171  << EVT(VT).getEVTString() << '\n';
172 #endif
173  llvm_unreachable(nullptr);
174  }
175  }
176 }
177 
178 /// Same as above except it's specialized for calls that produce a single value.
180  if (Fn(0, VT, VT, CCValAssign::Full, ISD::ArgFlagsTy(), *this)) {
181 #ifndef NDEBUG
182  dbgs() << "Call result has unhandled type "
183  << EVT(VT).getEVTString() << '\n';
184 #endif
185  llvm_unreachable(nullptr);
186  }
187 }
188 
190  if (VT.isVector())
191  return true; // Assume -msse-regparm might be in effect.
192  if (!VT.isInteger())
193  return false;
195  return true;
196  return false;
197 }
198 
200  MVT VT, CCAssignFn Fn) {
201  unsigned SavedStackOffset = StackOffset;
202  Align SavedMaxStackArgAlign = MaxStackArgAlign;
203  unsigned NumLocs = Locs.size();
204 
205  // Set the 'inreg' flag if it is used for this calling convention.
206  ISD::ArgFlagsTy Flags;
207  if (isValueTypeInRegForCC(CallingConv, VT))
208  Flags.setInReg();
209 
210  // Allocate something of this value type repeatedly until we get assigned a
211  // location in memory.
212  bool HaveRegParm = true;
213  while (HaveRegParm) {
214  if (Fn(0, VT, VT, CCValAssign::Full, Flags, *this)) {
215 #ifndef NDEBUG
216  dbgs() << "Call has unhandled type " << EVT(VT).getEVTString()
217  << " while computing remaining regparms\n";
218 #endif
219  llvm_unreachable(nullptr);
220  }
221  HaveRegParm = Locs.back().isRegLoc();
222  }
223 
224  // Copy all the registers from the value locations we added.
225  assert(NumLocs < Locs.size() && "CC assignment failed to add location");
226  for (unsigned I = NumLocs, E = Locs.size(); I != E; ++I)
227  if (Locs[I].isRegLoc())
228  Regs.push_back(MCPhysReg(Locs[I].getLocReg()));
229 
230  // Clear the assigned values and stack memory. We leave the registers marked
231  // as allocated so that future queries don't return the same registers, i.e.
232  // when i64 and f64 are both passed in GPRs.
233  StackOffset = SavedStackOffset;
234  MaxStackArgAlign = SavedMaxStackArgAlign;
235  Locs.resize(NumLocs);
236 }
237 
239  SmallVectorImpl<ForwardedRegister> &Forwards, ArrayRef<MVT> RegParmTypes,
240  CCAssignFn Fn) {
241  // Oftentimes calling conventions will not user register parameters for
242  // variadic functions, so we need to assume we're not variadic so that we get
243  // all the registers that might be used in a non-variadic call.
244  SaveAndRestore<bool> SavedVarArg(IsVarArg, false);
245  SaveAndRestore<bool> SavedMustTail(AnalyzingMustTailForwardedRegs, true);
246 
247  for (MVT RegVT : RegParmTypes) {
248  SmallVector<MCPhysReg, 8> RemainingRegs;
249  getRemainingRegParmsForType(RemainingRegs, RegVT, Fn);
250  const TargetLowering *TL = MF.getSubtarget().getTargetLowering();
251  const TargetRegisterClass *RC = TL->getRegClassFor(RegVT);
252  for (MCPhysReg PReg : RemainingRegs) {
253  unsigned VReg = MF.addLiveIn(PReg, RC);
254  Forwards.push_back(ForwardedRegister(VReg, PReg, RegVT));
255  }
256  }
257 }
258 
260  CallingConv::ID CallerCC, MachineFunction &MF,
261  LLVMContext &C,
263  CCAssignFn CalleeFn, CCAssignFn CallerFn) {
264  if (CalleeCC == CallerCC)
265  return true;
267  CCState CCInfo1(CalleeCC, false, MF, RVLocs1, C);
268  CCInfo1.AnalyzeCallResult(Ins, CalleeFn);
269 
271  CCState CCInfo2(CallerCC, false, MF, RVLocs2, C);
272  CCInfo2.AnalyzeCallResult(Ins, CallerFn);
273 
274  if (RVLocs1.size() != RVLocs2.size())
275  return false;
276  for (unsigned I = 0, E = RVLocs1.size(); I != E; ++I) {
277  const CCValAssign &Loc1 = RVLocs1[I];
278  const CCValAssign &Loc2 = RVLocs2[I];
279  if (Loc1.getLocInfo() != Loc2.getLocInfo())
280  return false;
281  bool RegLoc1 = Loc1.isRegLoc();
282  if (RegLoc1 != Loc2.isRegLoc())
283  return false;
284  if (RegLoc1) {
285  if (Loc1.getLocReg() != Loc2.getLocReg())
286  return false;
287  } else {
288  if (Loc1.getLocMemOffset() != Loc2.getLocMemOffset())
289  return false;
290  }
291  }
292  return true;
293 }
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...
X86_FastCall - &#39;fast&#39; analog of X86_StdCall.
Definition: CallingConv.h:96
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
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
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
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
Definition: CallingConv.h:162
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
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
void ensureMaxAlignment(Align Alignment)
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
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:651
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
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
MCRegAliasIterator enumerates all registers aliasing Reg.
constexpr double e
Definition: MathExtras.h:57
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:133
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