clang  3.7.0
CGFunctionInfo.h
Go to the documentation of this file.
1 //==-- CGFunctionInfo.h - Representation of function argument/return types -==//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Defines CGFunctionInfo and associated types used in representing the
11 // LLVM source types and ABI-coerced types for function arguments and
12 // return values.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
17 #define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
18 
20 #include "clang/AST/Type.h"
21 #include "llvm/ADT/FoldingSet.h"
22 #include <cassert>
23 
24 namespace llvm {
25  class Type;
26  class StructType;
27 }
28 
29 namespace clang {
30 class Decl;
31 
32 namespace CodeGen {
33 
34 /// ABIArgInfo - Helper class to encapsulate information about how a
35 /// specific C type should be passed to or returned from a function.
36 class ABIArgInfo {
37 public:
38  enum Kind : uint8_t {
39  /// Direct - Pass the argument directly using the normal converted LLVM
40  /// type, or by coercing to another specified type stored in
41  /// 'CoerceToType'). If an offset is specified (in UIntData), then the
42  /// argument passed is offset by some number of bytes in the memory
43  /// representation. A dummy argument is emitted before the real argument
44  /// if the specified type stored in "PaddingType" is not zero.
46 
47  /// Extend - Valid only for integer argument types. Same as 'direct'
48  /// but also emit a zero/sign extension attribute.
50 
51  /// Indirect - Pass the argument indirectly via a hidden pointer
52  /// with the specified alignment (0 indicates default alignment).
54 
55  /// Ignore - Ignore the argument (treat as void). Useful for void and
56  /// empty structs.
58 
59  /// Expand - Only valid for aggregate argument types. The structure should
60  /// be expanded into consecutive arguments for its constituent fields.
61  /// Currently expand is only allowed on structures whose fields
62  /// are all scalar types or are themselves expandable types.
64 
65  /// InAlloca - Pass the argument directly using the LLVM inalloca attribute.
66  /// This is similar to indirect with byval, except it only applies to
67  /// arguments stored in memory and forbids any implicit copies. When
68  /// applied to a return type, it means the value is returned indirectly via
69  /// an implicit sret parameter stored in the argument struct.
73  };
74 
75 private:
76  llvm::Type *TypeData; // isDirect() || isExtend()
77  llvm::Type *PaddingType;
78  union {
79  unsigned DirectOffset; // isDirect() || isExtend()
80  unsigned IndirectAlign; // isIndirect()
81  unsigned AllocaFieldIndex; // isInAlloca()
82  };
83  Kind TheKind;
84  bool PaddingInReg : 1;
85  bool InAllocaSRet : 1; // isInAlloca()
86  bool IndirectByVal : 1; // isIndirect()
87  bool IndirectRealign : 1; // isIndirect()
88  bool SRetAfterThis : 1; // isIndirect()
89  bool InReg : 1; // isDirect() || isExtend() || isIndirect()
90  bool CanBeFlattened: 1; // isDirect()
91 
92  ABIArgInfo(Kind K)
93  : PaddingType(nullptr), TheKind(K), PaddingInReg(false), InReg(false) {}
94 
95 public:
97  : TypeData(nullptr), PaddingType(nullptr), DirectOffset(0),
98  TheKind(Direct), PaddingInReg(false), InReg(false) {}
99 
100  static ABIArgInfo getDirect(llvm::Type *T = nullptr, unsigned Offset = 0,
101  llvm::Type *Padding = nullptr,
102  bool CanBeFlattened = true) {
103  auto AI = ABIArgInfo(Direct);
104  AI.setCoerceToType(T);
105  AI.setDirectOffset(Offset);
106  AI.setPaddingType(Padding);
107  AI.setCanBeFlattened(CanBeFlattened);
108  return AI;
109  }
110  static ABIArgInfo getDirectInReg(llvm::Type *T = nullptr) {
111  auto AI = getDirect(T);
112  AI.setInReg(true);
113  return AI;
114  }
115  static ABIArgInfo getExtend(llvm::Type *T = nullptr) {
116  auto AI = ABIArgInfo(Extend);
117  AI.setCoerceToType(T);
118  AI.setDirectOffset(0);
119  return AI;
120  }
121  static ABIArgInfo getExtendInReg(llvm::Type *T = nullptr) {
122  auto AI = getExtend(T);
123  AI.setInReg(true);
124  return AI;
125  }
127  return ABIArgInfo(Ignore);
128  }
129  static ABIArgInfo getIndirect(unsigned Alignment, bool ByVal = true,
130  bool Realign = false,
131  llvm::Type *Padding = nullptr) {
132  auto AI = ABIArgInfo(Indirect);
133  AI.setIndirectAlign(Alignment);
134  AI.setIndirectByVal(ByVal);
135  AI.setIndirectRealign(Realign);
136  AI.setSRetAfterThis(false);
137  AI.setPaddingType(Padding);
138  return AI;
139  }
140  static ABIArgInfo getIndirectInReg(unsigned Alignment, bool ByVal = true,
141  bool Realign = false) {
142  auto AI = getIndirect(Alignment, ByVal, Realign);
143  AI.setInReg(true);
144  return AI;
145  }
146  static ABIArgInfo getInAlloca(unsigned FieldIndex) {
147  auto AI = ABIArgInfo(InAlloca);
148  AI.setInAllocaFieldIndex(FieldIndex);
149  return AI;
150  }
152  return ABIArgInfo(Expand);
153  }
154  static ABIArgInfo getExpandWithPadding(bool PaddingInReg,
155  llvm::Type *Padding) {
156  auto AI = getExpand();
157  AI.setPaddingInReg(PaddingInReg);
158  AI.setPaddingType(Padding);
159  return AI;
160  }
161 
162  Kind getKind() const { return TheKind; }
163  bool isDirect() const { return TheKind == Direct; }
164  bool isInAlloca() const { return TheKind == InAlloca; }
165  bool isExtend() const { return TheKind == Extend; }
166  bool isIgnore() const { return TheKind == Ignore; }
167  bool isIndirect() const { return TheKind == Indirect; }
168  bool isExpand() const { return TheKind == Expand; }
169 
170  bool canHaveCoerceToType() const { return isDirect() || isExtend(); }
171 
172  // Direct/Extend accessors
173  unsigned getDirectOffset() const {
174  assert((isDirect() || isExtend()) && "Not a direct or extend kind");
175  return DirectOffset;
176  }
177  void setDirectOffset(unsigned Offset) {
178  assert((isDirect() || isExtend()) && "Not a direct or extend kind");
180  }
181 
182  llvm::Type *getPaddingType() const { return PaddingType; }
183 
184  void setPaddingType(llvm::Type *T) { PaddingType = T; }
185 
186  bool getPaddingInReg() const {
187  return PaddingInReg;
188  }
189  void setPaddingInReg(bool PIR) {
190  PaddingInReg = PIR;
191  }
192 
193  llvm::Type *getCoerceToType() const {
194  assert(canHaveCoerceToType() && "Invalid kind!");
195  return TypeData;
196  }
197 
198  void setCoerceToType(llvm::Type *T) {
199  assert(canHaveCoerceToType() && "Invalid kind!");
200  TypeData = T;
201  }
202 
203  bool getInReg() const {
204  assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
205  return InReg;
206  }
207 
208  void setInReg(bool IR) {
209  assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
210  InReg = IR;
211  }
212 
213  // Indirect accessors
214  unsigned getIndirectAlign() const {
215  assert(isIndirect() && "Invalid kind!");
216  return IndirectAlign;
217  }
218  void setIndirectAlign(unsigned IA) {
219  assert(isIndirect() && "Invalid kind!");
220  IndirectAlign = IA;
221  }
222 
223  bool getIndirectByVal() const {
224  assert(isIndirect() && "Invalid kind!");
225  return IndirectByVal;
226  }
227  void setIndirectByVal(unsigned IBV) {
228  assert(isIndirect() && "Invalid kind!");
229  IndirectByVal = IBV;
230  }
231 
232  bool getIndirectRealign() const {
233  assert(isIndirect() && "Invalid kind!");
234  return IndirectRealign;
235  }
236  void setIndirectRealign(bool IR) {
237  assert(isIndirect() && "Invalid kind!");
238  IndirectRealign = IR;
239  }
240 
241  bool isSRetAfterThis() const {
242  assert(isIndirect() && "Invalid kind!");
243  return SRetAfterThis;
244  }
245  void setSRetAfterThis(bool AfterThis) {
246  assert(isIndirect() && "Invalid kind!");
247  SRetAfterThis = AfterThis;
248  }
249 
250  unsigned getInAllocaFieldIndex() const {
251  assert(isInAlloca() && "Invalid kind!");
252  return AllocaFieldIndex;
253  }
254  void setInAllocaFieldIndex(unsigned FieldIndex) {
255  assert(isInAlloca() && "Invalid kind!");
256  AllocaFieldIndex = FieldIndex;
257  }
258 
259  /// \brief Return true if this field of an inalloca struct should be returned
260  /// to implement a struct return calling convention.
261  bool getInAllocaSRet() const {
262  assert(isInAlloca() && "Invalid kind!");
263  return InAllocaSRet;
264  }
265 
266  void setInAllocaSRet(bool SRet) {
267  assert(isInAlloca() && "Invalid kind!");
268  InAllocaSRet = SRet;
269  }
270 
271  bool getCanBeFlattened() const {
272  assert(isDirect() && "Invalid kind!");
273  return CanBeFlattened;
274  }
275 
276  void setCanBeFlattened(bool Flatten) {
277  assert(isDirect() && "Invalid kind!");
278  CanBeFlattened = Flatten;
279  }
280 
281  void dump() const;
282 };
283 
284 /// A class for recording the number of arguments that a function
285 /// signature requires.
287  /// The number of required arguments, or ~0 if the signature does
288  /// not permit optional arguments.
289  unsigned NumRequired;
290 public:
291  enum All_t { All };
292 
293  RequiredArgs(All_t _) : NumRequired(~0U) {}
294  explicit RequiredArgs(unsigned n) : NumRequired(n) {
295  assert(n != ~0U);
296  }
297 
298  /// Compute the arguments required by the given formal prototype,
299  /// given that there may be some additional, non-formal arguments
300  /// in play.
302  unsigned additional) {
303  if (!prototype->isVariadic()) return All;
304  return RequiredArgs(prototype->getNumParams() + additional);
305  }
306 
307  static RequiredArgs forPrototype(const FunctionProtoType *prototype) {
308  return forPrototypePlus(prototype, 0);
309  }
310 
312  return forPrototype(prototype.getTypePtr());
313  }
314 
316  unsigned additional) {
317  return forPrototypePlus(prototype.getTypePtr(), additional);
318  }
319 
320  bool allowsOptionalArgs() const { return NumRequired != ~0U; }
321  unsigned getNumRequiredArgs() const {
322  assert(allowsOptionalArgs());
323  return NumRequired;
324  }
325 
326  unsigned getOpaqueData() const { return NumRequired; }
327  static RequiredArgs getFromOpaqueData(unsigned value) {
328  if (value == ~0U) return All;
329  return RequiredArgs(value);
330  }
331 };
332 
333 /// CGFunctionInfo - Class to encapsulate the information about a
334 /// function definition.
335 class CGFunctionInfo : public llvm::FoldingSetNode {
336  struct ArgInfo {
338  ABIArgInfo info;
339  };
340 
341  /// The LLVM::CallingConv to use for this function (as specified by the
342  /// user).
343  unsigned CallingConvention : 8;
344 
345  /// The LLVM::CallingConv to actually use for this function, which may
346  /// depend on the ABI.
347  unsigned EffectiveCallingConvention : 8;
348 
349  /// The clang::CallingConv that this was originally created with.
350  unsigned ASTCallingConvention : 8;
351 
352  /// Whether this is an instance method.
353  unsigned InstanceMethod : 1;
354 
355  /// Whether this is a chain call.
356  unsigned ChainCall : 1;
357 
358  /// Whether this function is noreturn.
359  unsigned NoReturn : 1;
360 
361  /// Whether this function is returns-retained.
362  unsigned ReturnsRetained : 1;
363 
364  /// How many arguments to pass inreg.
365  unsigned HasRegParm : 1;
366  unsigned RegParm : 3;
367 
368  RequiredArgs Required;
369 
370  /// The struct representing all arguments passed in memory. Only used when
371  /// passing non-trivial types with inalloca. Not part of the profile.
372  llvm::StructType *ArgStruct;
373 
374  unsigned NumArgs;
375  ArgInfo *getArgsBuffer() {
376  return reinterpret_cast<ArgInfo*>(this+1);
377  }
378  const ArgInfo *getArgsBuffer() const {
379  return reinterpret_cast<const ArgInfo*>(this + 1);
380  }
381 
382  CGFunctionInfo() : Required(RequiredArgs::All) {}
383 
384 public:
385  static CGFunctionInfo *create(unsigned llvmCC,
386  bool instanceMethod,
387  bool chainCall,
388  const FunctionType::ExtInfo &extInfo,
389  CanQualType resultType,
390  ArrayRef<CanQualType> argTypes,
391  RequiredArgs required);
392 
393  typedef const ArgInfo *const_arg_iterator;
394  typedef ArgInfo *arg_iterator;
395 
396  typedef llvm::iterator_range<arg_iterator> arg_range;
397  typedef llvm::iterator_range<const_arg_iterator> arg_const_range;
398 
401  return arg_const_range(arg_begin(), arg_end());
402  }
403 
404  const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
405  const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + NumArgs; }
406  arg_iterator arg_begin() { return getArgsBuffer() + 1; }
407  arg_iterator arg_end() { return getArgsBuffer() + 1 + NumArgs; }
408 
409  unsigned arg_size() const { return NumArgs; }
410 
411  bool isVariadic() const { return Required.allowsOptionalArgs(); }
412  RequiredArgs getRequiredArgs() const { return Required; }
413  unsigned getNumRequiredArgs() const {
415  }
416 
417  bool isInstanceMethod() const { return InstanceMethod; }
418 
419  bool isChainCall() const { return ChainCall; }
420 
421  bool isNoReturn() const { return NoReturn; }
422 
423  /// In ARC, whether this function retains its return value. This
424  /// is not always reliable for call sites.
425  bool isReturnsRetained() const { return ReturnsRetained; }
426 
427  /// getASTCallingConvention() - Return the AST-specified calling
428  /// convention.
430  return CallingConv(ASTCallingConvention);
431  }
432 
433  /// getCallingConvention - Return the user specified calling
434  /// convention, which has been translated into an LLVM CC.
435  unsigned getCallingConvention() const { return CallingConvention; }
436 
437  /// getEffectiveCallingConvention - Return the actual calling convention to
438  /// use, which may depend on the ABI.
439  unsigned getEffectiveCallingConvention() const {
440  return EffectiveCallingConvention;
441  }
443  EffectiveCallingConvention = Value;
444  }
445 
446  bool getHasRegParm() const { return HasRegParm; }
447  unsigned getRegParm() const { return RegParm; }
448 
454  }
455 
456  CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
457 
458  ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
459  const ABIArgInfo &getReturnInfo() const { return getArgsBuffer()[0].info; }
460 
461  /// \brief Return true if this function uses inalloca arguments.
462  bool usesInAlloca() const { return ArgStruct; }
463 
464  /// \brief Get the struct type used to represent all the arguments in memory.
465  llvm::StructType *getArgStruct() const { return ArgStruct; }
466  void setArgStruct(llvm::StructType *Ty) { ArgStruct = Ty; }
467 
468  void Profile(llvm::FoldingSetNodeID &ID) {
469  ID.AddInteger(getASTCallingConvention());
470  ID.AddBoolean(InstanceMethod);
471  ID.AddBoolean(ChainCall);
472  ID.AddBoolean(NoReturn);
473  ID.AddBoolean(ReturnsRetained);
474  ID.AddBoolean(HasRegParm);
475  ID.AddInteger(RegParm);
476  ID.AddInteger(Required.getOpaqueData());
477  getReturnType().Profile(ID);
478  for (const auto &I : arguments())
479  I.type.Profile(ID);
480  }
481  static void Profile(llvm::FoldingSetNodeID &ID,
482  bool InstanceMethod,
483  bool ChainCall,
484  const FunctionType::ExtInfo &info,
485  RequiredArgs required,
486  CanQualType resultType,
487  ArrayRef<CanQualType> argTypes) {
488  ID.AddInteger(info.getCC());
489  ID.AddBoolean(InstanceMethod);
490  ID.AddBoolean(ChainCall);
491  ID.AddBoolean(info.getNoReturn());
492  ID.AddBoolean(info.getProducesResult());
493  ID.AddBoolean(info.getHasRegParm());
494  ID.AddInteger(info.getRegParm());
495  ID.AddInteger(required.getOpaqueData());
496  resultType.Profile(ID);
498  i = argTypes.begin(), e = argTypes.end(); i != e; ++i) {
499  i->Profile(ID);
500  }
501  }
502 };
503 
504 } // end namespace CodeGen
505 } // end namespace clang
506 
507 #endif
void setIndirectByVal(unsigned IBV)
bool isVariadic() const
Definition: Type.h:3228
void setEffectiveCallingConvention(unsigned Value)
void setSRetAfterThis(bool AfterThis)
static ABIArgInfo getExtend(llvm::Type *T=nullptr)
CanQualType getReturnType() const
unsigned getInAllocaFieldIndex() const
static RequiredArgs getFromOpaqueData(unsigned value)
static ABIArgInfo getIndirect(unsigned Alignment, bool ByVal=true, bool Realign=false, llvm::Type *Padding=nullptr)
static CGFunctionInfo * create(unsigned llvmCC, bool instanceMethod, bool chainCall, const FunctionType::ExtInfo &extInfo, CanQualType resultType, ArrayRef< CanQualType > argTypes, RequiredArgs required)
Definition: CGCall.cpp:535
void setCanBeFlattened(bool Flatten)
void setCoerceToType(llvm::Type *T)
static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod, bool ChainCall, const FunctionType::ExtInfo &info, RequiredArgs required, CanQualType resultType, ArrayRef< CanQualType > argTypes)
static ABIArgInfo getIgnore()
unsigned getNumParams() const
Definition: Type.h:3133
void setDirectOffset(unsigned Offset)
const_arg_iterator arg_end() const
static ABIArgInfo getIndirectInReg(unsigned Alignment, bool ByVal=true, bool Realign=false)
static ABIArgInfo getExtendInReg(llvm::Type *T=nullptr)
bool getInAllocaSRet() const
Return true if this field of an inalloca struct should be returned to implement a struct return calli...
void setPaddingInReg(bool PIR)
llvm::StructType * getArgStruct() const
Get the struct type used to represent all the arguments in memory.
llvm::Type * getCoerceToType() const
unsigned getRegParm() const
Definition: Type.h:2891
unsigned getEffectiveCallingConvention() const
unsigned getIndirectAlign() const
static ABIArgInfo getDirect(llvm::Type *T=nullptr, unsigned Offset=0, llvm::Type *Padding=nullptr, bool CanBeFlattened=true)
void setInAllocaFieldIndex(unsigned FieldIndex)
static ABIArgInfo getExpandWithPadding(bool PaddingInReg, llvm::Type *Padding)
uint32_t Offset
Definition: CacheTokens.cpp:43
void setArgStruct(llvm::StructType *Ty)
unsigned getCallingConvention() const
llvm::iterator_range< const_arg_iterator > arg_const_range
static ABIArgInfo getExpand()
static RequiredArgs forPrototype(CanQual< FunctionProtoType > prototype)
unsigned getOpaqueData() const
unsigned getNumRequiredArgs() const
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
bool usesInAlloca() const
Return true if this function uses inalloca arguments.
bool getNoReturn() const
Definition: Type.h:2888
void setPaddingType(llvm::Type *T)
void Profile(llvm::FoldingSetNodeID &ID)
void Profile(llvm::FoldingSetNodeID &ID) const
llvm::Type * getPaddingType() const
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:204
CallingConv getASTCallingConvention() const
unsigned getNumRequiredArgs() const
#define false
Definition: stdbool.h:33
Kind
FunctionType::ExtInfo getExtInfo() const
RequiredArgs getRequiredArgs() const
llvm::iterator_range< arg_iterator > arg_range
const ABIArgInfo & getReturnInfo() const
bool canHaveCoerceToType() const
unsigned getDirectOffset() const
static ABIArgInfo getDirectInReg(llvm::Type *T=nullptr)
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
bool getProducesResult() const
Definition: Type.h:2889
CallingConv getCC() const
Definition: Type.h:2897
static RequiredArgs forPrototype(const FunctionProtoType *prototype)
static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)
static ABIArgInfo getInAlloca(unsigned FieldIndex)
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:70
const_arg_iterator arg_begin() const
bool getHasRegParm() const
Definition: Type.h:2890
arg_const_range arguments() const
static RequiredArgs forPrototypePlus(CanQual< FunctionProtoType > prototype, unsigned additional)
bool getIndirectRealign() const
void setIndirectAlign(unsigned IA)
void setInAllocaSRet(bool SRet)
void setIndirectRealign(bool IR)