1 //===----- CGCXXABI.cpp - Interface to C++ ABIs ---------------------------===//
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 #include "CGCXXABI.h"
16 
17 using namespace clang;
18 using namespace CodeGen;
19 
20 CGCXXABI::~CGCXXABI() { }
21 
22 void CGCXXABI::ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S) {
23   DiagnosticsEngine &Diags = CGF.CGM.getDiags();
24   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
25                                           "cannot yet compile %0 in this ABI");
26   Diags.Report(CGF.getContext().getFullLoc(CGF.CurCodeDecl->getLocation()),
27                DiagID)
28     << S;
29 }
30 
31 bool CGCXXABI::canCopyArgument(const CXXRecordDecl *RD) const {
32   // If RD has a non-trivial move or copy constructor, we cannot copy the
33   // argument.
34   if (RD->hasNonTrivialCopyConstructor() || RD->hasNonTrivialMoveConstructor())
35     return false;
36 
37   // If RD has a non-trivial destructor, we cannot copy the argument.
38   if (RD->hasNonTrivialDestructor())
39     return false;
40 
41   // We can only copy the argument if there exists at least one trivial,
42   // non-deleted copy or move constructor.
43   // FIXME: This assumes that all lazily declared copy and move constructors are
44   // not deleted.  This assumption might not be true in some corner cases.
45   bool CopyDeleted = false;
46   bool MoveDeleted = false;
47   for (const CXXConstructorDecl *CD : RD->ctors()) {
48     if (CD->isCopyConstructor() || CD->isMoveConstructor()) {
49       assert(CD->isTrivial());
50       // We had at least one undeleted trivial copy or move ctor.  Return
51       // directly.
52       if (!CD->isDeleted())
53         return true;
54       if (CD->isCopyConstructor())
55         CopyDeleted = true;
56       else
57         MoveDeleted = true;
58     }
59   }
60 
61   // If all trivial copy and move constructors are deleted, we cannot copy the
62   // argument.
63   return !(CopyDeleted && MoveDeleted);
64 }
65 
66 llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
67   return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
68 }
69 
70 llvm::Type *
71 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
72   return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
73 }
74 
75 llvm::Value *CGCXXABI::EmitLoadOfMemberFunctionPointer(
76     CodeGenFunction &CGF, const Expr *E, llvm::Value *&This,
77     llvm::Value *MemPtr, const MemberPointerType *MPT) {
78   ErrorUnsupportedABI(CGF, "calls through member pointers");
79 
80   const FunctionProtoType *FPT =
81     MPT->getPointeeType()->getAs<FunctionProtoType>();
82   const CXXRecordDecl *RD =
83     cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
84   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
85                               CGM.getTypes().arrangeCXXMethodType(RD, FPT));
86   return llvm::Constant::getNullValue(FTy->getPointerTo());
87 }
88 
89 llvm::Value *
90 CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
91                                        llvm::Value *Base, llvm::Value *MemPtr,
92                                        const MemberPointerType *MPT) {
93   ErrorUnsupportedABI(CGF, "loads of member pointers");
94   llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())->getPointerTo();
95   return llvm::Constant::getNullValue(Ty);
96 }
97 
98 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
99                                                    const CastExpr *E,
100                                                    llvm::Value *Src) {
101   ErrorUnsupportedABI(CGF, "member function pointer conversions");
102   return GetBogusMemberPointer(E->getType());
103 }
104 
105 llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
106                                                       llvm::Constant *Src) {
107   return GetBogusMemberPointer(E->getType());
108 }
109 
110 llvm::Value *
111 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
112                                       llvm::Value *L,
113                                       llvm::Value *R,
114                                       const MemberPointerType *MPT,
115                                       bool Inequality) {
116   ErrorUnsupportedABI(CGF, "member function pointer comparison");
117   return CGF.Builder.getFalse();
118 }
119 
120 llvm::Value *
121 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
122                                      llvm::Value *MemPtr,
123                                      const MemberPointerType *MPT) {
124   ErrorUnsupportedABI(CGF, "member function pointer null testing");
125   return CGF.Builder.getFalse();
126 }
127 
128 llvm::Constant *
129 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
130   return GetBogusMemberPointer(QualType(MPT, 0));
131 }
132 
133 llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
134   return GetBogusMemberPointer(CGM.getContext().getMemberPointerType(
135       MD->getType(), MD->getParent()->getTypeForDecl()));
136 }
137 
138 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
139                                                 CharUnits offset) {
140   return GetBogusMemberPointer(QualType(MPT, 0));
141 }
142 
143 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
144   return GetBogusMemberPointer(MPT);
145 }
146 
147 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
148   // Fake answer.
149   return true;
150 }
151 
152 void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList &params) {
153   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
154 
155   // FIXME: I'm not entirely sure I like using a fake decl just for code
156   // generation. Maybe we can come up with a better way?
157   ImplicitParamDecl *ThisDecl
158     = ImplicitParamDecl::Create(CGM.getContext(), nullptr, MD->getLocation(),
159                                 &CGM.getContext().Idents.get("this"),
160                                 MD->getThisType(CGM.getContext()));
161   params.push_back(ThisDecl);
162   getThisDecl(CGF) = ThisDecl;
163 }
164 
165 void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
166   /// Initialize the 'this' slot.
167   assert(getThisDecl(CGF) && "no 'this' variable for function");
168   getThisValue(CGF)
169     = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
170                              "this");
171 }
172 
173 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
174                                    RValue RV, QualType ResultType) {
175   CGF.EmitReturnOfRValue(RV, ResultType);
176 }
177 
178 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
179   if (!requiresArrayCookie(expr))
180     return CharUnits::Zero();
181   return getArrayCookieSizeImpl(expr->getAllocatedType());
182 }
183 
184 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
185   // BOGUS
186   return CharUnits::Zero();
187 }
188 
189 llvm::Value *CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
190                                              llvm::Value *NewPtr,
191                                              llvm::Value *NumElements,
192                                              const CXXNewExpr *expr,
193                                              QualType ElementType) {
194   // Should never be called.
195   ErrorUnsupportedABI(CGF, "array cookie initialization");
196   return nullptr;
197 }
198 
199 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
200                                    QualType elementType) {
201   // If the class's usual deallocation function takes two arguments,
202   // it needs a cookie.
203   if (expr->doesUsualArrayDeleteWantSize())
204     return true;
205 
206   return elementType.isDestructedType();
207 }
208 
209 bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
210   // If the class's usual deallocation function takes two arguments,
211   // it needs a cookie.
212   if (expr->doesUsualArrayDeleteWantSize())
213     return true;
214 
215   return expr->getAllocatedType().isDestructedType();
216 }
217 
218 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *ptr,
219                                const CXXDeleteExpr *expr, QualType eltTy,
220                                llvm::Value *&numElements,
221                                llvm::Value *&allocPtr, CharUnits &cookieSize) {
222   // Derive a char* in the same address space as the pointer.
223   unsigned AS = ptr->getType()->getPointerAddressSpace();
224   llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS);
225   ptr = CGF.Builder.CreateBitCast(ptr, charPtrTy);
226 
227   // If we don't need an array cookie, bail out early.
228   if (!requiresArrayCookie(expr, eltTy)) {
229     allocPtr = ptr;
230     numElements = nullptr;
231     cookieSize = CharUnits::Zero();
232     return;
233   }
234 
235   cookieSize = getArrayCookieSizeImpl(eltTy);
236   allocPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ptr,
237                                                     -cookieSize.getQuantity());
238   numElements = readArrayCookieImpl(CGF, allocPtr, cookieSize);
239 }
240 
241 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
242                                            llvm::Value *ptr,
243                                            CharUnits cookieSize) {
244   ErrorUnsupportedABI(CGF, "reading a new[] cookie");
245   return llvm::ConstantInt::get(CGF.SizeTy, 0);
246 }
247 
248 /// Returns the adjustment, in bytes, required for the given
249 /// member-pointer operation.  Returns null if no adjustment is
250 /// required.
251 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
252   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
253          E->getCastKind() == CK_BaseToDerivedMemberPointer);
254 
255   QualType derivedType;
256   if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
257     derivedType = E->getSubExpr()->getType();
258   else
259     derivedType = E->getType();
260 
261   const CXXRecordDecl *derivedClass =
262     derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
263 
264   return CGM.GetNonVirtualBaseClassOffset(derivedClass,
265                                           E->path_begin(),
266                                           E->path_end());
267 }
268 
269 CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) {
270   // TODO: Store base specifiers in APValue member pointer paths so we can
271   // easily reuse CGM.GetNonVirtualBaseClassOffset().
272   const ValueDecl *MPD = MP.getMemberPointerDecl();
273   CharUnits ThisAdjustment = CharUnits::Zero();
274   ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
275   bool DerivedMember = MP.isMemberPointerToDerivedMember();
276   const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
277   for (unsigned I = 0, N = Path.size(); I != N; ++I) {
278     const CXXRecordDecl *Base = RD;
279     const CXXRecordDecl *Derived = Path[I];
280     if (DerivedMember)
281       std::swap(Base, Derived);
282     ThisAdjustment +=
283       getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
284     RD = Path[I];
285   }
286   if (DerivedMember)
287     ThisAdjustment = -ThisAdjustment;
288   return ThisAdjustment;
289 }
290 
291 llvm::BasicBlock *
292 CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
293                                         const CXXRecordDecl *RD) {
294   if (CGM.getTarget().getCXXABI().hasConstructorVariants())
295     llvm_unreachable("shouldn't be called in this ABI");
296 
297   ErrorUnsupportedABI(CGF, "complete object detection in ctor");
298   return nullptr;
299 }
300 
301 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
302   return false;
303 }
304 
305 llvm::CallInst *
306 CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
307                                               llvm::Value *Exn) {
308   // Just call std::terminate and ignore the violating exception.
309   return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
310 }
311