blob: aba5d755d5c49e420f1d062c9b11c2617a1a568d [file] [log] [blame]
Anders Carlsson4992eaf2010-11-28 17:46:52 +00001//===----- CGCXXABI.cpp - Interface to C++ ABIs -----------------*- C++ -*-===//
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
17using namespace clang;
Anders Carlssonee7cde22010-11-28 17:49:03 +000018using namespace CodeGen;
Anders Carlsson4992eaf2010-11-28 17:46:52 +000019
Anders Carlsson1af610f2010-11-28 17:50:09 +000020CGCXXABI::~CGCXXABI() { }
Anders Carlssonee7cde22010-11-28 17:49:03 +000021
22static void ErrorUnsupportedABI(CodeGenFunction &CGF,
Chris Lattner5f9e2722011-07-23 10:55:15 +000023 StringRef S) {
David Blaikied6471f72011-09-25 23:23:43 +000024 DiagnosticsEngine &Diags = CGF.CGM.getDiags();
25 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
Timur Iskhodzhanovc56b5522012-06-29 01:14:21 +000026 "cannot yet compile %0 in this ABI");
Anders Carlssonee7cde22010-11-28 17:49:03 +000027 Diags.Report(CGF.getContext().getFullLoc(CGF.CurCodeDecl->getLocation()),
28 DiagID)
29 << S;
30}
31
32static llvm::Constant *GetBogusMemberPointer(CodeGenModule &CGM,
33 QualType T) {
34 return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
35}
36
Chris Lattner9cbe4f02011-07-09 17:41:47 +000037llvm::Type *
Anders Carlssonee7cde22010-11-28 17:49:03 +000038CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
39 return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
40}
41
42llvm::Value *CGCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
43 llvm::Value *&This,
44 llvm::Value *MemPtr,
45 const MemberPointerType *MPT) {
46 ErrorUnsupportedABI(CGF, "calls through member pointers");
47
48 const FunctionProtoType *FPT =
49 MPT->getPointeeType()->getAs<FunctionProtoType>();
50 const CXXRecordDecl *RD =
51 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
John McCallde5d3c72012-02-17 03:33:10 +000052 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
53 CGM.getTypes().arrangeCXXMethodType(RD, FPT));
Anders Carlssonee7cde22010-11-28 17:49:03 +000054 return llvm::Constant::getNullValue(FTy->getPointerTo());
55}
56
57llvm::Value *CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF,
58 llvm::Value *Base,
59 llvm::Value *MemPtr,
60 const MemberPointerType *MPT) {
61 ErrorUnsupportedABI(CGF, "loads of member pointers");
Chris Lattner2acc6e32011-07-18 04:24:23 +000062 llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())->getPointerTo();
Anders Carlssonee7cde22010-11-28 17:49:03 +000063 return llvm::Constant::getNullValue(Ty);
64}
65
66llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
67 const CastExpr *E,
68 llvm::Value *Src) {
69 ErrorUnsupportedABI(CGF, "member function pointer conversions");
70 return GetBogusMemberPointer(CGM, E->getType());
71}
72
John McCall4d4e5c12012-02-15 01:22:51 +000073llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
74 llvm::Constant *Src) {
75 return GetBogusMemberPointer(CGM, E->getType());
76}
77
Anders Carlssonee7cde22010-11-28 17:49:03 +000078llvm::Value *
79CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
80 llvm::Value *L,
81 llvm::Value *R,
82 const MemberPointerType *MPT,
83 bool Inequality) {
84 ErrorUnsupportedABI(CGF, "member function pointer comparison");
85 return CGF.Builder.getFalse();
86}
87
88llvm::Value *
89CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
90 llvm::Value *MemPtr,
91 const MemberPointerType *MPT) {
92 ErrorUnsupportedABI(CGF, "member function pointer null testing");
93 return CGF.Builder.getFalse();
94}
95
96llvm::Constant *
Anders Carlssonee7cde22010-11-28 17:49:03 +000097CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
98 return GetBogusMemberPointer(CGM, QualType(MPT, 0));
99}
100
John McCall755d8492011-04-12 00:42:48 +0000101llvm::Constant *CGCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
Anders Carlssonee7cde22010-11-28 17:49:03 +0000102 return GetBogusMemberPointer(CGM,
103 CGM.getContext().getMemberPointerType(MD->getType(),
104 MD->getParent()->getTypeForDecl()));
105}
106
John McCall5808ce42011-02-03 08:15:49 +0000107llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
108 CharUnits offset) {
109 return GetBogusMemberPointer(CGM, QualType(MPT, 0));
Anders Carlssonee7cde22010-11-28 17:49:03 +0000110}
111
Richard Smith2d6a5672012-01-14 04:30:29 +0000112llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
113 return GetBogusMemberPointer(CGM, MPT);
114}
115
Anders Carlssonee7cde22010-11-28 17:49:03 +0000116bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
117 // Fake answer.
118 return true;
119}
120
John McCalld26bc762011-03-09 04:27:21 +0000121void CGCXXABI::BuildThisParam(CodeGenFunction &CGF, FunctionArgList &params) {
Anders Carlssonee7cde22010-11-28 17:49:03 +0000122 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
123
124 // FIXME: I'm not entirely sure I like using a fake decl just for code
125 // generation. Maybe we can come up with a better way?
126 ImplicitParamDecl *ThisDecl
127 = ImplicitParamDecl::Create(CGM.getContext(), 0, MD->getLocation(),
128 &CGM.getContext().Idents.get("this"),
129 MD->getThisType(CGM.getContext()));
John McCalld26bc762011-03-09 04:27:21 +0000130 params.push_back(ThisDecl);
Anders Carlssonee7cde22010-11-28 17:49:03 +0000131 getThisDecl(CGF) = ThisDecl;
132}
133
134void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
135 /// Initialize the 'this' slot.
136 assert(getThisDecl(CGF) && "no 'this' variable for function");
137 getThisValue(CGF)
138 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
139 "this");
140}
141
142void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
143 RValue RV, QualType ResultType) {
144 CGF.EmitReturnOfRValue(RV, ResultType);
145}
146
John McCall6ec278d2011-01-27 09:37:56 +0000147CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
John McCalle2b45e22012-05-01 05:23:51 +0000148 if (!requiresArrayCookie(expr))
149 return CharUnits::Zero();
150 return getArrayCookieSizeImpl(expr->getAllocatedType());
151}
152
153CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
154 // BOGUS
Anders Carlssonee7cde22010-11-28 17:49:03 +0000155 return CharUnits::Zero();
156}
157
158llvm::Value *CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
159 llvm::Value *NewPtr,
160 llvm::Value *NumElements,
John McCall6ec278d2011-01-27 09:37:56 +0000161 const CXXNewExpr *expr,
Anders Carlssonee7cde22010-11-28 17:49:03 +0000162 QualType ElementType) {
163 // Should never be called.
164 ErrorUnsupportedABI(CGF, "array cookie initialization");
165 return 0;
166}
167
John McCalle2b45e22012-05-01 05:23:51 +0000168bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
169 QualType elementType) {
170 // If the class's usual deallocation function takes two arguments,
171 // it needs a cookie.
172 if (expr->doesUsualArrayDeleteWantSize())
173 return true;
Anders Carlssonee7cde22010-11-28 17:49:03 +0000174
John McCalle2b45e22012-05-01 05:23:51 +0000175 return elementType.isDestructedType();
176}
177
178bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
179 // If the class's usual deallocation function takes two arguments,
180 // it needs a cookie.
181 if (expr->doesUsualArrayDeleteWantSize())
182 return true;
183
184 return expr->getAllocatedType().isDestructedType();
185}
186
187void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *ptr,
188 const CXXDeleteExpr *expr, QualType eltTy,
189 llvm::Value *&numElements,
190 llvm::Value *&allocPtr, CharUnits &cookieSize) {
191 // Derive a char* in the same address space as the pointer.
192 unsigned AS = cast<llvm::PointerType>(ptr->getType())->getAddressSpace();
193 llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS);
194 ptr = CGF.Builder.CreateBitCast(ptr, charPtrTy);
195
196 // If we don't need an array cookie, bail out early.
197 if (!requiresArrayCookie(expr, eltTy)) {
198 allocPtr = ptr;
199 numElements = 0;
200 cookieSize = CharUnits::Zero();
201 return;
202 }
203
204 cookieSize = getArrayCookieSizeImpl(eltTy);
205 allocPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ptr,
206 -cookieSize.getQuantity());
207 numElements = readArrayCookieImpl(CGF, allocPtr, cookieSize);
208}
209
210llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
211 llvm::Value *ptr,
212 CharUnits cookieSize) {
213 ErrorUnsupportedABI(CGF, "reading a new[] cookie");
214 return llvm::ConstantInt::get(CGF.SizeTy, 0);
Anders Carlssonee7cde22010-11-28 17:49:03 +0000215}
216
217void CGCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
218 const VarDecl &D,
Chandler Carruth0f30a122012-03-30 19:44:53 +0000219 llvm::GlobalVariable *GV,
Richard Smith7ca48502012-02-13 22:16:19 +0000220 bool PerformInit) {
Anders Carlssonee7cde22010-11-28 17:49:03 +0000221 ErrorUnsupportedABI(CGF, "static local variable initialization");
222}
John McCall4d4e5c12012-02-15 01:22:51 +0000223
John McCall20bb1752012-05-01 06:13:13 +0000224void CGCXXABI::registerGlobalDtor(CodeGenFunction &CGF,
225 llvm::Constant *dtor,
226 llvm::Constant *addr) {
227 // The default behavior is to use atexit.
228 CGF.registerGlobalDtorWithAtExit(dtor, addr);
229}
230
John McCall4d4e5c12012-02-15 01:22:51 +0000231/// Returns the adjustment, in bytes, required for the given
232/// member-pointer operation. Returns null if no adjustment is
233/// required.
234llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
235 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
236 E->getCastKind() == CK_BaseToDerivedMemberPointer);
237
238 QualType derivedType;
239 if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
240 derivedType = E->getSubExpr()->getType();
241 else
242 derivedType = E->getType();
243
244 const CXXRecordDecl *derivedClass =
245 derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
246
247 return CGM.GetNonVirtualBaseClassOffset(derivedClass,
248 E->path_begin(),
249 E->path_end());
250}