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 llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
32 return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
36 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
37 return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
40 llvm::Value *CGCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
43 const MemberPointerType *MPT) {
44 ErrorUnsupportedABI(CGF, "calls through member pointers");
46 const FunctionProtoType *FPT =
47 MPT->getPointeeType()->getAs<FunctionProtoType>();
48 const CXXRecordDecl *RD =
49 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
50 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
51 CGM.getTypes().arrangeCXXMethodType(RD, FPT));
52 return llvm::Constant::getNullValue(FTy->getPointerTo());
55 llvm::Value *CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF,
58 const MemberPointerType *MPT) {
59 ErrorUnsupportedABI(CGF, "loads of member pointers");
60 llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())->getPointerTo();
61 return llvm::Constant::getNullValue(Ty);
64 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
67 ErrorUnsupportedABI(CGF, "member function pointer conversions");
68 return GetBogusMemberPointer(E->getType());
71 llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
72 llvm::Constant *Src) {
73 return GetBogusMemberPointer(E->getType());
77 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
80 const MemberPointerType *MPT,
82 ErrorUnsupportedABI(CGF, "member function pointer comparison");
83 return CGF.Builder.getFalse();
87 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
89 const MemberPointerType *MPT) {
90 ErrorUnsupportedABI(CGF, "member function pointer null testing");
91 return CGF.Builder.getFalse();
95 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
96 return GetBogusMemberPointer(QualType(MPT, 0));
99 llvm::Constant *CGCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
100 return GetBogusMemberPointer(
101 CGM.getContext().getMemberPointerType(MD->getType(),
102 MD->getParent()->getTypeForDecl()));
105 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
107 return GetBogusMemberPointer(QualType(MPT, 0));
110 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
111 return GetBogusMemberPointer(MPT);
114 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
119 void CGCXXABI::BuildThisParam(CodeGenFunction &CGF, FunctionArgList ¶ms) {
120 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
122 // FIXME: I'm not entirely sure I like using a fake decl just for code
123 // generation. Maybe we can come up with a better way?
124 ImplicitParamDecl *ThisDecl
125 = ImplicitParamDecl::Create(CGM.getContext(), 0, MD->getLocation(),
126 &CGM.getContext().Idents.get("this"),
127 MD->getThisType(CGM.getContext()));
128 params.push_back(ThisDecl);
129 getThisDecl(CGF) = ThisDecl;
132 void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
133 /// Initialize the 'this' slot.
134 assert(getThisDecl(CGF) && "no 'this' variable for function");
136 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
140 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
141 RValue RV, QualType ResultType) {
142 CGF.EmitReturnOfRValue(RV, ResultType);
145 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
146 if (!requiresArrayCookie(expr))
147 return CharUnits::Zero();
148 return getArrayCookieSizeImpl(expr->getAllocatedType());
151 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
153 return CharUnits::Zero();
156 llvm::Value *CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
158 llvm::Value *NumElements,
159 const CXXNewExpr *expr,
160 QualType ElementType) {
161 // Should never be called.
162 ErrorUnsupportedABI(CGF, "array cookie initialization");
166 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
167 QualType elementType) {
168 // If the class's usual deallocation function takes two arguments,
169 // it needs a cookie.
170 if (expr->doesUsualArrayDeleteWantSize())
173 return elementType.isDestructedType();
176 bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
177 // If the class's usual deallocation function takes two arguments,
178 // it needs a cookie.
179 if (expr->doesUsualArrayDeleteWantSize())
182 return expr->getAllocatedType().isDestructedType();
185 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *ptr,
186 const CXXDeleteExpr *expr, QualType eltTy,
187 llvm::Value *&numElements,
188 llvm::Value *&allocPtr, CharUnits &cookieSize) {
189 // Derive a char* in the same address space as the pointer.
190 unsigned AS = ptr->getType()->getPointerAddressSpace();
191 llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS);
192 ptr = CGF.Builder.CreateBitCast(ptr, charPtrTy);
194 // If we don't need an array cookie, bail out early.
195 if (!requiresArrayCookie(expr, eltTy)) {
198 cookieSize = CharUnits::Zero();
202 cookieSize = getArrayCookieSizeImpl(eltTy);
203 allocPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ptr,
204 -cookieSize.getQuantity());
205 numElements = readArrayCookieImpl(CGF, allocPtr, cookieSize);
208 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
210 CharUnits cookieSize) {
211 ErrorUnsupportedABI(CGF, "reading a new[] cookie");
212 return llvm::ConstantInt::get(CGF.SizeTy, 0);
215 void CGCXXABI::registerGlobalDtor(CodeGenFunction &CGF,
217 llvm::Constant *dtor,
218 llvm::Constant *addr) {
220 CGM.ErrorUnsupported(&D, "non-trivial TLS destruction");
222 // The default behavior is to use atexit.
223 CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
226 /// Returns the adjustment, in bytes, required for the given
227 /// member-pointer operation. Returns null if no adjustment is
229 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
230 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
231 E->getCastKind() == CK_BaseToDerivedMemberPointer);
233 QualType derivedType;
234 if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
235 derivedType = E->getSubExpr()->getType();
237 derivedType = E->getType();
239 const CXXRecordDecl *derivedClass =
240 derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
242 return CGM.GetNonVirtualBaseClassOffset(derivedClass,
247 CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) {
248 // TODO: Store base specifiers in APValue member pointer paths so we can
249 // easily reuse CGM.GetNonVirtualBaseClassOffset().
250 const ValueDecl *MPD = MP.getMemberPointerDecl();
251 CharUnits ThisAdjustment = CharUnits::Zero();
252 ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
253 bool DerivedMember = MP.isMemberPointerToDerivedMember();
254 const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
255 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
256 const CXXRecordDecl *Base = RD;
257 const CXXRecordDecl *Derived = Path[I];
259 std::swap(Base, Derived);
261 getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
265 ThisAdjustment = -ThisAdjustment;
266 return ThisAdjustment;
270 CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
271 const CXXRecordDecl *RD) {
272 if (CGM.getTarget().getCXXABI().hasConstructorVariants())
273 llvm_unreachable("shouldn't be called in this ABI");
275 ErrorUnsupportedABI(CGF, "complete object detection in ctor");
279 void CGCXXABI::EmitThreadLocalInitFuncs(
280 llvm::ArrayRef<std::pair<const VarDecl *, llvm::GlobalVariable *> > Decls,
281 llvm::Function *InitFunc) {
284 LValue CGCXXABI::EmitThreadLocalDeclRefExpr(CodeGenFunction &CGF,
285 const DeclRefExpr *DRE) {
286 ErrorUnsupportedABI(CGF, "odr-use of thread_local global");
290 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {