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 // We can only copy the argument if there exists at least one trivial,
34 // non-deleted copy or move constructor.
35 return RD->canPassInRegisters();
38 llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
39 return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
43 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
44 return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
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");
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);
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);
74 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
77 ErrorUnsupportedABI(CGF, "member function pointer conversions");
78 return GetBogusMemberPointer(E->getType());
81 llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
82 llvm::Constant *Src) {
83 return GetBogusMemberPointer(E->getType());
87 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
90 const MemberPointerType *MPT,
92 ErrorUnsupportedABI(CGF, "member function pointer comparison");
93 return CGF.Builder.getFalse();
97 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
99 const MemberPointerType *MPT) {
100 ErrorUnsupportedABI(CGF, "member function pointer null testing");
101 return CGF.Builder.getFalse();
105 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
106 return GetBogusMemberPointer(QualType(MPT, 0));
109 llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
110 return GetBogusMemberPointer(CGM.getContext().getMemberPointerType(
111 MD->getType(), MD->getParent()->getTypeForDecl()));
114 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
116 return GetBogusMemberPointer(QualType(MPT, 0));
119 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
120 return GetBogusMemberPointer(MPT);
123 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
128 void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList ¶ms) {
129 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
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;
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();
148 CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
152 llvm::Value *CGCXXABI::loadIncomingCXXThis(CodeGenFunction &CGF) {
153 return CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
157 void CGCXXABI::setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr) {
158 /// Initialize the 'this' slot.
159 assert(getThisDecl(CGF) && "no 'this' variable for function");
160 CGF.CXXABIThisValue = ThisPtr;
163 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
164 RValue RV, QualType ResultType) {
165 CGF.EmitReturnOfRValue(RV, ResultType);
168 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
169 if (!requiresArrayCookie(expr))
170 return CharUnits::Zero();
171 return getArrayCookieSizeImpl(expr->getAllocatedType());
174 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
176 return CharUnits::Zero();
179 Address CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
181 llvm::Value *NumElements,
182 const CXXNewExpr *expr,
183 QualType ElementType) {
184 // Should never be called.
185 ErrorUnsupportedABI(CGF, "array cookie initialization");
186 return Address::invalid();
189 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
190 QualType elementType) {
191 // If the class's usual deallocation function takes two arguments,
192 // it needs a cookie.
193 if (expr->doesUsualArrayDeleteWantSize())
196 return elementType.isDestructedType();
199 bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
200 // If the class's usual deallocation function takes two arguments,
201 // it needs a cookie.
202 if (expr->doesUsualArrayDeleteWantSize())
205 return expr->getAllocatedType().isDestructedType();
208 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, Address ptr,
209 const CXXDeleteExpr *expr, QualType eltTy,
210 llvm::Value *&numElements,
211 llvm::Value *&allocPtr, CharUnits &cookieSize) {
212 // Derive a char* in the same address space as the pointer.
213 ptr = CGF.Builder.CreateElementBitCast(ptr, CGF.Int8Ty);
215 // If we don't need an array cookie, bail out early.
216 if (!requiresArrayCookie(expr, eltTy)) {
217 allocPtr = ptr.getPointer();
218 numElements = nullptr;
219 cookieSize = CharUnits::Zero();
223 cookieSize = getArrayCookieSizeImpl(eltTy);
225 CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize);
226 allocPtr = allocAddr.getPointer();
227 numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize);
230 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
232 CharUnits cookieSize) {
233 ErrorUnsupportedABI(CGF, "reading a new[] cookie");
234 return llvm::ConstantInt::get(CGF.SizeTy, 0);
237 /// Returns the adjustment, in bytes, required for the given
238 /// member-pointer operation. Returns null if no adjustment is
240 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
241 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
242 E->getCastKind() == CK_BaseToDerivedMemberPointer);
244 QualType derivedType;
245 if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
246 derivedType = E->getSubExpr()->getType();
248 derivedType = E->getType();
250 const CXXRecordDecl *derivedClass =
251 derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
253 return CGM.GetNonVirtualBaseClassOffset(derivedClass,
258 CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) {
259 // TODO: Store base specifiers in APValue member pointer paths so we can
260 // easily reuse CGM.GetNonVirtualBaseClassOffset().
261 const ValueDecl *MPD = MP.getMemberPointerDecl();
262 CharUnits ThisAdjustment = CharUnits::Zero();
263 ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
264 bool DerivedMember = MP.isMemberPointerToDerivedMember();
265 const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
266 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
267 const CXXRecordDecl *Base = RD;
268 const CXXRecordDecl *Derived = Path[I];
270 std::swap(Base, Derived);
272 getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
276 ThisAdjustment = -ThisAdjustment;
277 return ThisAdjustment;
281 CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
282 const CXXRecordDecl *RD) {
283 if (CGM.getTarget().getCXXABI().hasConstructorVariants())
284 llvm_unreachable("shouldn't be called in this ABI");
286 ErrorUnsupportedABI(CGF, "complete object detection in ctor");
290 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
295 CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
297 // Just call std::terminate and ignore the violating exception.
298 return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
301 CatchTypeInfo CGCXXABI::getCatchAllTypeInfo() {
302 return CatchTypeInfo{nullptr, 0};
305 std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
306 return std::vector<CharUnits>();