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 //===----------------------------------------------------------------------===//
17 using namespace clang;
18 using namespace CodeGen;
20 CGCXXABI::~CGCXXABI() { }
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()),
31 bool CGCXXABI::canCopyArgument(const CXXRecordDecl *RD) const {
32 // If RD has a non-trivial move or copy constructor, we cannot copy the
34 if (RD->hasNonTrivialCopyConstructor() || RD->hasNonTrivialMoveConstructor())
37 // If RD has a non-trivial destructor, we cannot copy the argument.
38 if (RD->hasNonTrivialDestructor())
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
54 if (CD->isCopyConstructor())
61 // If all trivial copy and move constructors are deleted, we cannot copy the
63 return !(CopyDeleted && MoveDeleted);
66 llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
67 return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
71 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
72 return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
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");
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());
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);
98 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
101 ErrorUnsupportedABI(CGF, "member function pointer conversions");
102 return GetBogusMemberPointer(E->getType());
105 llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
106 llvm::Constant *Src) {
107 return GetBogusMemberPointer(E->getType());
111 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
114 const MemberPointerType *MPT,
116 ErrorUnsupportedABI(CGF, "member function pointer comparison");
117 return CGF.Builder.getFalse();
121 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
123 const MemberPointerType *MPT) {
124 ErrorUnsupportedABI(CGF, "member function pointer null testing");
125 return CGF.Builder.getFalse();
129 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
130 return GetBogusMemberPointer(QualType(MPT, 0));
133 llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
134 return GetBogusMemberPointer(CGM.getContext().getMemberPointerType(
135 MD->getType(), MD->getParent()->getTypeForDecl()));
138 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
140 return GetBogusMemberPointer(QualType(MPT, 0));
143 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
144 return GetBogusMemberPointer(MPT);
147 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
152 void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList ¶ms) {
153 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
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;
165 void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
166 /// Initialize the 'this' slot.
167 assert(getThisDecl(CGF) && "no 'this' variable for function");
169 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
173 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
174 RValue RV, QualType ResultType) {
175 CGF.EmitReturnOfRValue(RV, ResultType);
178 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
179 if (!requiresArrayCookie(expr))
180 return CharUnits::Zero();
181 return getArrayCookieSizeImpl(expr->getAllocatedType());
184 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
186 return CharUnits::Zero();
189 llvm::Value *CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
191 llvm::Value *NumElements,
192 const CXXNewExpr *expr,
193 QualType ElementType) {
194 // Should never be called.
195 ErrorUnsupportedABI(CGF, "array cookie initialization");
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())
206 return elementType.isDestructedType();
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())
215 return expr->getAllocatedType().isDestructedType();
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);
227 // If we don't need an array cookie, bail out early.
228 if (!requiresArrayCookie(expr, eltTy)) {
230 numElements = nullptr;
231 cookieSize = CharUnits::Zero();
235 cookieSize = getArrayCookieSizeImpl(eltTy);
236 allocPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ptr,
237 -cookieSize.getQuantity());
238 numElements = readArrayCookieImpl(CGF, allocPtr, cookieSize);
241 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
243 CharUnits cookieSize) {
244 ErrorUnsupportedABI(CGF, "reading a new[] cookie");
245 return llvm::ConstantInt::get(CGF.SizeTy, 0);
248 /// Returns the adjustment, in bytes, required for the given
249 /// member-pointer operation. Returns null if no adjustment is
251 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
252 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
253 E->getCastKind() == CK_BaseToDerivedMemberPointer);
255 QualType derivedType;
256 if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
257 derivedType = E->getSubExpr()->getType();
259 derivedType = E->getType();
261 const CXXRecordDecl *derivedClass =
262 derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
264 return CGM.GetNonVirtualBaseClassOffset(derivedClass,
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];
281 std::swap(Base, Derived);
283 getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
287 ThisAdjustment = -ThisAdjustment;
288 return ThisAdjustment;
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");
297 ErrorUnsupportedABI(CGF, "complete object detection in ctor");
301 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
306 CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
308 // Just call std::terminate and ignore the violating exception.
309 return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());