CGCXXABI.h revision 1e7fe751466ea82665fd21e9162fd7cc9c5f412d 
1//===----- CGCXXABI.h - Interface to C++ ABIs -------------------*- C++ -*-===//
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// This provides an abstract class for C++ code generation. Concrete subclasses
11// of this implement code generation for specific C++ ABIs.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef CLANG_CODEGEN_CXXABI_H
16#define CLANG_CODEGEN_CXXABI_H
17
18#include "CodeGenFunction.h"
19
20namespace llvm {
21  class Constant;
22  class Type;
23  class Value;
24
25  template <class T> class SmallVectorImpl;
26}
27
28namespace clang {
29  class CastExpr;
30  class CXXConstructorDecl;
31  class CXXDestructorDecl;
32  class CXXMethodDecl;
33  class CXXRecordDecl;
34  class FieldDecl;
35
36namespace CodeGen {
37  class CodeGenFunction;
38  class CodeGenModule;
39  class MangleContext;
40
41/// Implements C++ ABI-specific code generation functions.
42class CGCXXABI {
43protected:
44  CodeGenModule &CGM;
45
46  CGCXXABI(CodeGenModule &CGM) : CGM(CGM) {}
47
48protected:
49  ImplicitParamDecl *&getThisDecl(CodeGenFunction &CGF) {
50    return CGF.CXXThisDecl;
51  }
52  llvm::Value *&getThisValue(CodeGenFunction &CGF) {
53    return CGF.CXXThisValue;
54  }
55
56  ImplicitParamDecl *&getVTTDecl(CodeGenFunction &CGF) {
57    return CGF.CXXVTTDecl;
58  }
59  llvm::Value *&getVTTValue(CodeGenFunction &CGF) {
60    return CGF.CXXVTTValue;
61  }
62
63  /// Build a parameter variable suitable for 'this'.
64  void BuildThisParam(CodeGenFunction &CGF, FunctionArgList &Params);
65
66  /// Perform prolog initialization of the parameter variable suitable
67  /// for 'this' emitted by BuildThisParam.
68  void EmitThisParam(CodeGenFunction &CGF);
69
70  ASTContext &getContext() const { return CGM.getContext(); }
71
72public:
73
74  virtual ~CGCXXABI();
75
76  /// Gets the mangle context.
77  virtual MangleContext &getMangleContext() = 0;
78
79  /// Find the LLVM type used to represent the given member pointer
80  /// type.
81  virtual const llvm::Type *
82  ConvertMemberPointerType(const MemberPointerType *MPT);
83
84  /// Load a member function from an object and a member function
85  /// pointer.  Apply the this-adjustment and set 'This' to the
86  /// adjusted value.
87  virtual llvm::Value *
88  EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
89                                  llvm::Value *&This,
90                                  llvm::Value *MemPtr,
91                                  const MemberPointerType *MPT);
92
93  /// Calculate an l-value from an object and a data member pointer.
94  virtual llvm::Value *EmitMemberDataPointerAddress(CodeGenFunction &CGF,
95                                                    llvm::Value *Base,
96                                                    llvm::Value *MemPtr,
97                                            const MemberPointerType *MPT);
98
99  /// Perform a derived-to-base or base-to-derived member pointer
100  /// conversion.
101  virtual llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
102                                                   const CastExpr *E,
103                                                   llvm::Value *Src);
104
105  /// Perform a derived-to-base or base-to-derived member pointer
106  /// conversion on a constant member pointer.
107  virtual llvm::Constant *EmitMemberPointerConversion(llvm::Constant *C,
108                                                      const CastExpr *E);
109
110  /// Return true if the given member pointer can be zero-initialized
111  /// (in the C++ sense) with an LLVM zeroinitializer.
112  virtual bool isZeroInitializable(const MemberPointerType *MPT);
113
114  /// Create a null member pointer of the given type.
115  virtual llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);
116
117  /// Create a member pointer for the given method.
118  virtual llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD);
119
120  /// Create a member pointer for the given field.
121  virtual llvm::Constant *EmitMemberPointer(const FieldDecl *FD);
122
123  /// Emit a comparison between two member pointers.  Returns an i1.
124  virtual llvm::Value *
125  EmitMemberPointerComparison(CodeGenFunction &CGF,
126                              llvm::Value *L,
127                              llvm::Value *R,
128                              const MemberPointerType *MPT,
129                              bool Inequality);
130
131  /// Determine if a member pointer is non-null.  Returns an i1.
132  virtual llvm::Value *
133  EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
134                             llvm::Value *MemPtr,
135                             const MemberPointerType *MPT);
136
137  /// Build the signature of the given constructor variant by adding
138  /// any required parameters.  For convenience, ResTy has been
139  /// initialized to 'void', and ArgTys has been initialized with the
140  /// type of 'this' (although this may be changed by the ABI) and
141  /// will have the formal parameters added to it afterwards.
142  ///
143  /// If there are ever any ABIs where the implicit parameters are
144  /// intermixed with the formal parameters, we can address those
145  /// then.
146  virtual void BuildConstructorSignature(const CXXConstructorDecl *Ctor,
147                                         CXXCtorType T,
148                                         CanQualType &ResTy,
149                               llvm::SmallVectorImpl<CanQualType> &ArgTys) = 0;
150
151  /// Build the signature of the given destructor variant by adding
152  /// any required parameters.  For convenience, ResTy has been
153  /// initialized to 'void' and ArgTys has been initialized with the
154  /// type of 'this' (although this may be changed by the ABI).
155  virtual void BuildDestructorSignature(const CXXDestructorDecl *Dtor,
156                                        CXXDtorType T,
157                                        CanQualType &ResTy,
158                               llvm::SmallVectorImpl<CanQualType> &ArgTys) = 0;
159
160  /// Build the ABI-specific portion of the parameter list for a
161  /// function.  This generally involves a 'this' parameter and
162  /// possibly some extra data for constructors and destructors.
163  ///
164  /// ABIs may also choose to override the return type, which has been
165  /// initialized with the formal return type of the function.
166  virtual void BuildInstanceFunctionParams(CodeGenFunction &CGF,
167                                           QualType &ResTy,
168                                           FunctionArgList &Params) = 0;
169
170  /// Emit the ABI-specific prolog for the function.
171  virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF) = 0;
172
173  virtual void EmitReturnFromThunk(CodeGenFunction &CGF,
174                                   RValue RV, QualType ResultType);
175
176  /**************************** Array cookies ******************************/
177
178  /// Returns the extra size required in order to store the array
179  /// cookie for the given type.  May return 0 to indicate that no
180  /// array cookie is required.
181  ///
182  /// Several cases are filtered out before this method is called:
183  ///   - non-array allocations never need a cookie
184  ///   - calls to ::operator new(size_t, void*) never need a cookie
185  ///
186  /// \param ElementType - the allocated type of the expression,
187  ///   i.e. the pointee type of the expression result type
188  virtual CharUnits GetArrayCookieSize(QualType ElementType);
189
190  /// Initialize the array cookie for the given allocation.
191  ///
192  /// \param NewPtr - a char* which is the presumed-non-null
193  ///   return value of the allocation function
194  /// \param NumElements - the computed number of elements,
195  ///   potentially collapsed from the multidimensional array case
196  /// \param ElementType - the base element allocated type,
197  ///   i.e. the allocated type after stripping all array types
198  virtual llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
199                                             llvm::Value *NewPtr,
200                                             llvm::Value *NumElements,
201                                             QualType ElementType);
202
203  /// Reads the array cookie associated with the given pointer,
204  /// if it has one.
205  ///
206  /// \param Ptr - a pointer to the first element in the array
207  /// \param ElementType - the base element type of elements of the array
208  /// \param NumElements - an out parameter which will be initialized
209  ///   with the number of elements allocated, or zero if there is no
210  ///   cookie
211  /// \param AllocPtr - an out parameter which will be initialized
212  ///   with a char* pointing to the address returned by the allocation
213  ///   function
214  /// \param CookieSize - an out parameter which will be initialized
215  ///   with the size of the cookie, or zero if there is no cookie
216  virtual void ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *Ptr,
217                               QualType ElementType, llvm::Value *&NumElements,
218                               llvm::Value *&AllocPtr, CharUnits &CookieSize);
219
220};
221
222/// Creates an instance of a C++ ABI class.
223CGCXXABI *CreateARMCXXABI(CodeGenModule &CGM);
224CGCXXABI *CreateItaniumCXXABI(CodeGenModule &CGM);
225CGCXXABI *CreateMicrosoftCXXABI(CodeGenModule &CGM);
226
227}
228}
229
230#endif
231