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  report_fatal_error("unable to allocate function argument #" + Twine(i));
94  }
95 }
96 
97 /// Analyze the return values of a function, returning true if the return can
98 /// be performed without sret-demotion and false otherwise.
100  CCAssignFn Fn) {
101  // Determine which register each value should be copied into.
102  for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
103  MVT VT = Outs[i].VT;
104  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
105  if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this))
106  return false;
107  }
108  return true;
109 }
110 
111 /// Analyze the returned values of a return,
112 /// incorporating info about the result values into this state.
114  CCAssignFn Fn) {
115  // Determine which register each value should be copied into.
116  for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
117  MVT VT = Outs[i].VT;
118  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
119  if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this))
120  report_fatal_error("unable to allocate function return #" + Twine(i));
121  }
122 }
123 
124 /// Analyze the outgoing arguments to a call,
125 /// incorporating info about the passed values into this state.
127  CCAssignFn Fn) {
128  unsigned NumOps = Outs.size();
129  for (unsigned i = 0; i != NumOps; ++i) {
130  MVT ArgVT = Outs[i].VT;
131  ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
132  if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
133 #ifndef NDEBUG
134  dbgs() << "Call operand #" << i << " has unhandled type "
135  << EVT(ArgVT).getEVTString() << '\n';
136 #endif
137  llvm_unreachable(nullptr);
138  }
139  }
140 }
141 
142 /// Same as above except it takes vectors of types and argument flags.
145  CCAssignFn Fn) {
146  unsigned NumOps = ArgVTs.size();
147  for (unsigned i = 0; i != NumOps; ++i) {
148  MVT ArgVT = ArgVTs[i];
149  ISD::ArgFlagsTy ArgFlags = Flags[i];
150  if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
151 #ifndef NDEBUG
152  dbgs() << "Call operand #" << i << " has unhandled type "
153  << EVT(ArgVT).getEVTString() << '\n';
154 #endif
155  llvm_unreachable(nullptr);
156  }
157  }
158 }
159 
160 /// Analyze the return values of a call, incorporating info about the passed
161 /// values into this state.
163  CCAssignFn Fn) {
164  for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
165  MVT VT = Ins[i].VT;
166  ISD::ArgFlagsTy Flags = Ins[i].Flags;
167  if (Fn(i, VT, VT, CCValAssign::Full, Flags, *this)) {
168 #ifndef NDEBUG
169  dbgs() << "Call result #" << i << " has unhandled type "
170  << EVT(VT).getEVTString() << '\n';
171 #endif
172  llvm_unreachable(nullptr);
173  }
174  }
175 }
176 
177 /// Same as above except it's specialized for calls that produce a single value.
179  if (Fn(0, VT, VT, CCValAssign::Full, ISD::ArgFlagsTy(), *this)) {
180 #ifndef NDEBUG
181  dbgs() << "Call result has unhandled type "
182  << EVT(VT).getEVTString() << '\n';
183 #endif
184  llvm_unreachable(nullptr);
185  }
186 }
187 
189  if (VT.isVector())
190  return true; // Assume -msse-regparm might be in effect.
191  if (!VT.isInteger())
192  return false;
194  return true;
195  return false;
196 }
197 
199  MVT VT, CCAssignFn Fn) {
200  unsigned SavedStackOffset = StackOffset;
201  llvm::Align SavedMaxStackArgAlign = MaxStackArgAlign;
202  unsigned NumLocs = Locs.size();
203 
204  // Set the 'inreg' flag if it is used for this calling convention.
205  ISD::ArgFlagsTy Flags;
206  if (isValueTypeInRegForCC(CallingConv, VT))
207  Flags.setInReg();
208 
209  // Allocate something of this value type repeatedly until we get assigned a
210  // location in memory.
211  bool HaveRegParm = true;
212  while (HaveRegParm) {
213  if (Fn(0, VT, VT, CCValAssign::Full, Flags, *this)) {
214 #ifndef NDEBUG
215  dbgs() << "Call has unhandled type " << EVT(VT).getEVTString()
216  << " while computing remaining regparms\n";
217 #endif
218  llvm_unreachable(nullptr);
219  }
220  HaveRegParm = Locs.back().isRegLoc();
221  }
222 
223  // Copy all the registers from the value locations we added.
224  assert(NumLocs < Locs.size() && "CC assignment failed to add location");
225  for (unsigned I = NumLocs, E = Locs.size(); I != E; ++I)
226  if (Locs[I].isRegLoc())
227  Regs.push_back(MCPhysReg(Locs[I].getLocReg()));
228 
229  // Clear the assigned values and stack memory. We leave the registers marked
230  // as allocated so that future queries don't return the same registers, i.e.
231  // when i64 and f64 are both passed in GPRs.
232  StackOffset = SavedStackOffset;
233  MaxStackArgAlign = SavedMaxStackArgAlign;
234  Locs.resize(NumLocs);
235 }
236 
238  SmallVectorImpl<ForwardedRegister> &Forwards, ArrayRef<MVT> RegParmTypes,
239  CCAssignFn Fn) {
240  // Oftentimes calling conventions will not user register parameters for
241  // variadic functions, so we need to assume we're not variadic so that we get
242  // all the registers that might be used in a non-variadic call.
243  SaveAndRestore<bool> SavedVarArg(IsVarArg, false);
244  SaveAndRestore<bool> SavedMustTail(AnalyzingMustTailForwardedRegs, true);
245 
246  for (MVT RegVT : RegParmTypes) {
247  SmallVector<MCPhysReg, 8> RemainingRegs;
248  getRemainingRegParmsForType(RemainingRegs, RegVT, Fn);
249  const TargetLowering *TL = MF.getSubtarget().getTargetLowering();
250  const TargetRegisterClass *RC = TL->getRegClassFor(RegVT);
251  for (MCPhysReg PReg : RemainingRegs) {
252  unsigned VReg = MF.addLiveIn(PReg, RC);
253  Forwards.push_back(ForwardedRegister(VReg, PReg, RegVT));
254  }
255  }
256 }
257 
259  CallingConv::ID CallerCC, MachineFunction &MF,
260  LLVMContext &C,
262  CCAssignFn CalleeFn, CCAssignFn CallerFn) {
263  if (CalleeCC == CallerCC)
264  return true;
266  CCState CCInfo1(CalleeCC, false, MF, RVLocs1, C);
267  CCInfo1.AnalyzeCallResult(Ins, CalleeFn);
268 
270  CCState CCInfo2(CallerCC, false, MF, RVLocs2, C);
271  CCInfo2.AnalyzeCallResult(Ins, CallerFn);
272 
273  if (RVLocs1.size() != RVLocs2.size())
274  return false;
275  for (unsigned I = 0, E = RVLocs1.size(); I != E; ++I) {
276  const CCValAssign &Loc1 = RVLocs1[I];
277  const CCValAssign &Loc2 = RVLocs2[I];
278  if (Loc1.getLocInfo() != Loc2.getLocInfo())
279  return false;
280  bool RegLoc1 = Loc1.isRegLoc();
281  if (RegLoc1 != Loc2.isRegLoc())
282  return false;
283  if (RegLoc1) {
284  if (Loc1.getLocReg() != Loc2.getLocReg())
285  return false;
286  } else {
287  if (Loc1.getLocMemOffset() != Loc2.getLocMemOffset())
288  return false;
289  }
290  }
291  return true;
292 }
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:91
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
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:157
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
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
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
MCRegAliasIterator enumerates all registers aliasing Reg.
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