1 //===----- CGCXXABI.cpp - Interface to C++ ABIs ---------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This provides an abstract class for C++ code generation. Concrete subclasses
11 // of this implement code generation for specific C++ ABIs.
13 //===----------------------------------------------------------------------===//
16 #include "CGCleanup.h"
18 using namespace clang;
19 using namespace CodeGen;
21 CGCXXABI::~CGCXXABI() { }
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()),
32 bool CGCXXABI::canCopyArgument(const CXXRecordDecl *RD) const {
33 // If RD has a non-trivial move or copy constructor, we cannot copy the
35 if (RD->hasNonTrivialCopyConstructor() || RD->hasNonTrivialMoveConstructor())
38 // If RD has a non-trivial destructor, we cannot copy the argument.
39 if (RD->hasNonTrivialDestructor())
42 // We can only copy the argument if there exists at least one trivial,
43 // non-deleted copy or move constructor.
44 // FIXME: This assumes that all lazily declared copy and move constructors are
45 // not deleted. This assumption might not be true in some corner cases.
46 bool CopyDeleted = false;
47 bool MoveDeleted = false;
48 for (const CXXConstructorDecl *CD : RD->ctors()) {
49 if (CD->isCopyConstructor() || CD->isMoveConstructor()) {
50 assert(CD->isTrivial());
51 // We had at least one undeleted trivial copy or move ctor. Return
55 if (CD->isCopyConstructor())
62 // If all trivial copy and move constructors are deleted, we cannot copy the
64 return !(CopyDeleted && MoveDeleted);
67 llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
68 return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
72 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
73 return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
76 llvm::Value *CGCXXABI::EmitLoadOfMemberFunctionPointer(
77 CodeGenFunction &CGF, const Expr *E, Address This,
78 llvm::Value *&ThisPtrForCall,
79 llvm::Value *MemPtr, const MemberPointerType *MPT) {
80 ErrorUnsupportedABI(CGF, "calls through member pointers");
82 ThisPtrForCall = This.getPointer();
83 const FunctionProtoType *FPT =
84 MPT->getPointeeType()->getAs<FunctionProtoType>();
85 const CXXRecordDecl *RD =
86 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
87 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
88 CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
89 return llvm::Constant::getNullValue(FTy->getPointerTo());
93 CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
94 Address Base, llvm::Value *MemPtr,
95 const MemberPointerType *MPT) {
96 ErrorUnsupportedABI(CGF, "loads of member pointers");
97 llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())
98 ->getPointerTo(Base.getAddressSpace());
99 return llvm::Constant::getNullValue(Ty);
102 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
105 ErrorUnsupportedABI(CGF, "member function pointer conversions");
106 return GetBogusMemberPointer(E->getType());
109 llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
110 llvm::Constant *Src) {
111 return GetBogusMemberPointer(E->getType());
115 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
118 const MemberPointerType *MPT,
120 ErrorUnsupportedABI(CGF, "member function pointer comparison");
121 return CGF.Builder.getFalse();
125 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
127 const MemberPointerType *MPT) {
128 ErrorUnsupportedABI(CGF, "member function pointer null testing");
129 return CGF.Builder.getFalse();
133 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
134 return GetBogusMemberPointer(QualType(MPT, 0));
137 llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
138 return GetBogusMemberPointer(CGM.getContext().getMemberPointerType(
139 MD->getType(), MD->getParent()->getTypeForDecl()));
142 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
144 return GetBogusMemberPointer(QualType(MPT, 0));
147 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
148 return GetBogusMemberPointer(MPT);
151 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
156 void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList ¶ms) {
157 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
159 // FIXME: I'm not entirely sure I like using a fake decl just for code
160 // generation. Maybe we can come up with a better way?
161 ImplicitParamDecl *ThisDecl
162 = ImplicitParamDecl::Create(CGM.getContext(), nullptr, MD->getLocation(),
163 &CGM.getContext().Idents.get("this"),
164 MD->getThisType(CGM.getContext()));
165 params.push_back(ThisDecl);
166 CGF.CXXABIThisDecl = ThisDecl;
168 // Compute the presumed alignment of 'this', which basically comes
169 // down to whether we know it's a complete object or not.
170 auto &Layout = CGF.getContext().getASTRecordLayout(MD->getParent());
171 if (MD->getParent()->getNumVBases() == 0 || // avoid vcall in common case
172 MD->getParent()->hasAttr<FinalAttr>() ||
173 !isThisCompleteObject(CGF.CurGD)) {
174 CGF.CXXABIThisAlignment = Layout.getAlignment();
176 CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
180 void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
181 /// Initialize the 'this' slot.
182 assert(getThisDecl(CGF) && "no 'this' variable for function");
184 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
188 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
189 RValue RV, QualType ResultType) {
190 CGF.EmitReturnOfRValue(RV, ResultType);
193 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
194 if (!requiresArrayCookie(expr))
195 return CharUnits::Zero();
196 return getArrayCookieSizeImpl(expr->getAllocatedType());
199 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
201 return CharUnits::Zero();
204 Address CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
206 llvm::Value *NumElements,
207 const CXXNewExpr *expr,
208 QualType ElementType) {
209 // Should never be called.
210 ErrorUnsupportedABI(CGF, "array cookie initialization");
211 return Address::invalid();
214 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
215 QualType elementType) {
216 // If the class's usual deallocation function takes two arguments,
217 // it needs a cookie.
218 if (expr->doesUsualArrayDeleteWantSize())
221 return elementType.isDestructedType();
224 bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
225 // If the class's usual deallocation function takes two arguments,
226 // it needs a cookie.
227 if (expr->doesUsualArrayDeleteWantSize())
230 return expr->getAllocatedType().isDestructedType();
233 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, Address ptr,
234 const CXXDeleteExpr *expr, QualType eltTy,
235 llvm::Value *&numElements,
236 llvm::Value *&allocPtr, CharUnits &cookieSize) {
237 // Derive a char* in the same address space as the pointer.
238 ptr = CGF.Builder.CreateElementBitCast(ptr, CGF.Int8Ty);
240 // If we don't need an array cookie, bail out early.
241 if (!requiresArrayCookie(expr, eltTy)) {
242 allocPtr = ptr.getPointer();
243 numElements = nullptr;
244 cookieSize = CharUnits::Zero();
248 cookieSize = getArrayCookieSizeImpl(eltTy);
250 CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize);
251 allocPtr = allocAddr.getPointer();
252 numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize);
255 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
257 CharUnits cookieSize) {
258 ErrorUnsupportedABI(CGF, "reading a new[] cookie");
259 return llvm::ConstantInt::get(CGF.SizeTy, 0);
262 /// Returns the adjustment, in bytes, required for the given
263 /// member-pointer operation. Returns null if no adjustment is
265 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
266 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
267 E->getCastKind() == CK_BaseToDerivedMemberPointer);
269 QualType derivedType;
270 if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
271 derivedType = E->getSubExpr()->getType();
273 derivedType = E->getType();
275 const CXXRecordDecl *derivedClass =
276 derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
278 return CGM.GetNonVirtualBaseClassOffset(derivedClass,
283 CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) {
284 // TODO: Store base specifiers in APValue member pointer paths so we can
285 // easily reuse CGM.GetNonVirtualBaseClassOffset().
286 const ValueDecl *MPD = MP.getMemberPointerDecl();
287 CharUnits ThisAdjustment = CharUnits::Zero();
288 ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
289 bool DerivedMember = MP.isMemberPointerToDerivedMember();
290 const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
291 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
292 const CXXRecordDecl *Base = RD;
293 const CXXRecordDecl *Derived = Path[I];
295 std::swap(Base, Derived);
297 getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
301 ThisAdjustment = -ThisAdjustment;
302 return ThisAdjustment;
306 CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
307 const CXXRecordDecl *RD) {
308 if (CGM.getTarget().getCXXABI().hasConstructorVariants())
309 llvm_unreachable("shouldn't be called in this ABI");
311 ErrorUnsupportedABI(CGF, "complete object detection in ctor");
315 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
320 CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
322 // Just call std::terminate and ignore the violating exception.
323 return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
326 CatchTypeInfo CGCXXABI::getCatchAllTypeInfo() {
327 return CatchTypeInfo{nullptr, 0};
330 std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
331 return std::vector<CharUnits>();