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