blob: e6eca28b29f55779bf238af5e8375fc7bf16d2b3 [file] [log] [blame]
Charles Davisc3926642010-06-09 23:25:41 +00001//===--- MicrosoftCXXABI.cpp - Emit LLVM Code from ASTs for a Module ------===//
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//
Chris Lattnerfc8f0e12011-04-15 05:22:18 +000010// This provides C++ code generation targeting the Microsoft Visual C++ ABI.
Charles Davisc3926642010-06-09 23:25:41 +000011// The class in this file generates structures that follow the Microsoft
12// Visual C++ ABI, which is actually not very well documented at all outside
13// of Microsoft.
14//
15//===----------------------------------------------------------------------===//
16
17#include "CGCXXABI.h"
18#include "CodeGenModule.h"
Charles Davisc3926642010-06-09 23:25:41 +000019#include "clang/AST/Decl.h"
20#include "clang/AST/DeclCXX.h"
Charles Davisc3926642010-06-09 23:25:41 +000021
22using namespace clang;
23using namespace CodeGen;
24
25namespace {
26
Charles Davis071cc7d2010-08-16 03:33:14 +000027class MicrosoftCXXABI : public CGCXXABI {
Charles Davisc3926642010-06-09 23:25:41 +000028public:
Peter Collingbourne14110472011-01-13 18:57:25 +000029 MicrosoftCXXABI(CodeGenModule &CGM) : CGCXXABI(CGM) {}
John McCall4c40d982010-08-31 07:33:07 +000030
Stephen Lind4c0cd02013-06-18 17:00:49 +000031 bool HasThisReturn(GlobalDecl GD) const;
32
Timur Iskhodzhanoved23bdf2013-04-17 12:54:10 +000033 bool isReturnTypeIndirect(const CXXRecordDecl *RD) const {
34 // Structures that are not C++03 PODs are always indirect.
35 return !RD->isPOD();
36 }
37
38 RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const {
39 if (RD->hasNonTrivialCopyConstructor())
40 return RAA_DirectInMemory;
41 return RAA_Default;
42 }
43
Joao Matos285baac2012-07-17 17:10:11 +000044 StringRef GetPureVirtualCallName() { return "_purecall"; }
David Blaikie2eb9a952012-10-16 22:56:05 +000045 // No known support for deleted functions in MSVC yet, so this choice is
46 // arbitrary.
47 StringRef GetDeletedVirtualCallName() { return "_purecall"; }
Joao Matos285baac2012-07-17 17:10:11 +000048
John McCallecd03b42012-09-25 10:10:39 +000049 llvm::Value *adjustToCompleteObject(CodeGenFunction &CGF,
50 llvm::Value *ptr,
51 QualType type);
52
Reid Klecknerb0f533e2013-05-29 18:02:47 +000053 llvm::Value *GetVirtualBaseClassOffset(CodeGenFunction &CGF,
54 llvm::Value *This,
55 const CXXRecordDecl *ClassDecl,
56 const CXXRecordDecl *BaseClassDecl);
57
John McCall4c40d982010-08-31 07:33:07 +000058 void BuildConstructorSignature(const CXXConstructorDecl *Ctor,
59 CXXCtorType Type,
60 CanQualType &ResTy,
John McCallbd315742012-09-25 08:00:39 +000061 SmallVectorImpl<CanQualType> &ArgTys);
John McCall4c40d982010-08-31 07:33:07 +000062
Timur Iskhodzhanov1d4fff52013-02-27 13:46:31 +000063 llvm::BasicBlock *EmitCtorCompleteObjectHandler(CodeGenFunction &CGF);
64
John McCall4c40d982010-08-31 07:33:07 +000065 void BuildDestructorSignature(const CXXDestructorDecl *Ctor,
66 CXXDtorType Type,
67 CanQualType &ResTy,
Timur Iskhodzhanov59660c22013-02-13 08:37:51 +000068 SmallVectorImpl<CanQualType> &ArgTys);
John McCall4c40d982010-08-31 07:33:07 +000069
70 void BuildInstanceFunctionParams(CodeGenFunction &CGF,
71 QualType &ResTy,
John McCallbd315742012-09-25 08:00:39 +000072 FunctionArgList &Params);
John McCall4c40d982010-08-31 07:33:07 +000073
John McCallbd315742012-09-25 08:00:39 +000074 void EmitInstanceFunctionProlog(CodeGenFunction &CGF);
John McCallfd708262011-01-27 02:46:02 +000075
Stephen Lind4c0cd02013-06-18 17:00:49 +000076 RValue EmitConstructorCall(CodeGenFunction &CGF,
77 const CXXConstructorDecl *D,
78 CXXCtorType Type,
79 bool ForVirtualBase, bool Delegating,
80 ReturnValueSlot ReturnValue,
81 llvm::Value *This,
82 CallExpr::const_arg_iterator ArgBeg,
83 CallExpr::const_arg_iterator ArgEnd);
Timur Iskhodzhanov1d4fff52013-02-27 13:46:31 +000084
Timur Iskhodzhanov0f9827f2013-02-15 14:45:22 +000085 RValue EmitVirtualDestructorCall(CodeGenFunction &CGF,
86 const CXXDestructorDecl *Dtor,
87 CXXDtorType DtorType,
88 SourceLocation CallLoc,
89 ReturnValueSlot ReturnValue,
90 llvm::Value *This);
91
John McCall20bb1752012-05-01 06:13:13 +000092 void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
93 llvm::GlobalVariable *DeclPtr,
94 bool PerformInit);
95
John McCallfd708262011-01-27 02:46:02 +000096 // ==== Notes on array cookies =========
97 //
98 // MSVC seems to only use cookies when the class has a destructor; a
99 // two-argument usual array deallocation function isn't sufficient.
100 //
101 // For example, this code prints "100" and "1":
102 // struct A {
103 // char x;
104 // void *operator new[](size_t sz) {
105 // printf("%u\n", sz);
106 // return malloc(sz);
107 // }
108 // void operator delete[](void *p, size_t sz) {
109 // printf("%u\n", sz);
110 // free(p);
111 // }
112 // };
113 // int main() {
114 // A *p = new A[100];
115 // delete[] p;
116 // }
117 // Whereas it prints "104" and "104" if you give A a destructor.
John McCalle2b45e22012-05-01 05:23:51 +0000118
119 bool requiresArrayCookie(const CXXDeleteExpr *expr, QualType elementType);
120 bool requiresArrayCookie(const CXXNewExpr *expr);
121 CharUnits getArrayCookieSizeImpl(QualType type);
122 llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
123 llvm::Value *NewPtr,
124 llvm::Value *NumElements,
125 const CXXNewExpr *expr,
126 QualType ElementType);
127 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
128 llvm::Value *allocPtr,
129 CharUnits cookieSize);
Reid Klecknera8a0f762013-03-22 19:02:54 +0000130
131private:
Reid Klecknera3609b02013-04-11 18:13:19 +0000132 llvm::Constant *getZeroInt() {
133 return llvm::ConstantInt::get(CGM.IntTy, 0);
Reid Klecknera8a0f762013-03-22 19:02:54 +0000134 }
135
Reid Klecknera3609b02013-04-11 18:13:19 +0000136 llvm::Constant *getAllOnesInt() {
137 return llvm::Constant::getAllOnesValue(CGM.IntTy);
Reid Klecknera8a0f762013-03-22 19:02:54 +0000138 }
139
Reid Klecknerf6327302013-05-09 21:01:17 +0000140 llvm::Constant *getConstantOrZeroInt(llvm::Constant *C) {
141 return C ? C : getZeroInt();
142 }
143
144 llvm::Value *getValueOrZeroInt(llvm::Value *C) {
145 return C ? C : getZeroInt();
146 }
147
Reid Klecknera3609b02013-04-11 18:13:19 +0000148 void
149 GetNullMemberPointerFields(const MemberPointerType *MPT,
150 llvm::SmallVectorImpl<llvm::Constant *> &fields);
151
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000152 /// \brief Finds the offset from the base of RD to the vbptr it uses, even if
153 /// it is reusing a vbptr from a non-virtual base. RD must have morally
154 /// virtual bases.
155 CharUnits GetVBPtrOffsetFromBases(const CXXRecordDecl *RD);
156
157 /// \brief Shared code for virtual base adjustment. Returns the offset from
158 /// the vbptr to the virtual base. Optionally returns the address of the
159 /// vbptr itself.
160 llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
161 llvm::Value *Base,
162 llvm::Value *VBPtrOffset,
163 llvm::Value *VBTableOffset,
164 llvm::Value **VBPtr = 0);
165
166 /// \brief Performs a full virtual base adjustment. Used to dereference
167 /// pointers to members of virtual bases.
Reid Klecknera3609b02013-04-11 18:13:19 +0000168 llvm::Value *AdjustVirtualBase(CodeGenFunction &CGF, const CXXRecordDecl *RD,
169 llvm::Value *Base,
170 llvm::Value *VirtualBaseAdjustmentOffset,
171 llvm::Value *VBPtrOffset /* optional */);
172
Reid Kleckner79e02912013-05-03 01:15:11 +0000173 /// \brief Emits a full member pointer with the fields common to data and
174 /// function member pointers.
175 llvm::Constant *EmitFullMemberPointer(llvm::Constant *FirstField,
176 bool IsMemberFunction,
Reid Klecknerf6327302013-05-09 21:01:17 +0000177 const CXXRecordDecl *RD,
178 CharUnits NonVirtualBaseAdjustment);
179
180 llvm::Constant *BuildMemberPointer(const CXXRecordDecl *RD,
181 const CXXMethodDecl *MD,
182 CharUnits NonVirtualBaseAdjustment);
183
184 bool MemberPointerConstantIsNull(const MemberPointerType *MPT,
185 llvm::Constant *MP);
Reid Kleckner79e02912013-05-03 01:15:11 +0000186
Reid Klecknera8a0f762013-03-22 19:02:54 +0000187public:
Reid Klecknera3609b02013-04-11 18:13:19 +0000188 virtual llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT);
189
190 virtual bool isZeroInitializable(const MemberPointerType *MPT);
191
Reid Klecknera8a0f762013-03-22 19:02:54 +0000192 virtual llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);
193
194 virtual llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
195 CharUnits offset);
Reid Kleckner79e02912013-05-03 01:15:11 +0000196 virtual llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD);
197 virtual llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT);
Reid Klecknera8a0f762013-03-22 19:02:54 +0000198
Reid Kleckner3d2f0002013-04-30 20:15:14 +0000199 virtual llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
200 llvm::Value *L,
201 llvm::Value *R,
202 const MemberPointerType *MPT,
203 bool Inequality);
204
Reid Klecknera8a0f762013-03-22 19:02:54 +0000205 virtual llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
206 llvm::Value *MemPtr,
207 const MemberPointerType *MPT);
208
209 virtual llvm::Value *EmitMemberDataPointerAddress(CodeGenFunction &CGF,
210 llvm::Value *Base,
211 llvm::Value *MemPtr,
212 const MemberPointerType *MPT);
213
Reid Klecknerf6327302013-05-09 21:01:17 +0000214 virtual llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
215 const CastExpr *E,
216 llvm::Value *Src);
217
218 virtual llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
219 llvm::Constant *Src);
220
Reid Klecknera3609b02013-04-11 18:13:19 +0000221 virtual llvm::Value *
222 EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
223 llvm::Value *&This,
224 llvm::Value *MemPtr,
225 const MemberPointerType *MPT);
226
Charles Davisc3926642010-06-09 23:25:41 +0000227};
228
229}
230
John McCallecd03b42012-09-25 10:10:39 +0000231llvm::Value *MicrosoftCXXABI::adjustToCompleteObject(CodeGenFunction &CGF,
232 llvm::Value *ptr,
233 QualType type) {
234 // FIXME: implement
235 return ptr;
236}
237
Reid Kleckner8c474322013-06-04 21:32:29 +0000238/// \brief Finds the first non-virtual base of RD that has virtual bases. If RD
239/// doesn't have a vbptr, it will reuse the vbptr of the returned class.
240static const CXXRecordDecl *FindFirstNVBaseWithVBases(const CXXRecordDecl *RD) {
241 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
242 E = RD->bases_end(); I != E; ++I) {
243 const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl();
244 if (!I->isVirtual() && Base->getNumVBases() > 0)
245 return Base;
246 }
247 llvm_unreachable("RD must have an nv base with vbases");
248}
249
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000250CharUnits MicrosoftCXXABI::GetVBPtrOffsetFromBases(const CXXRecordDecl *RD) {
251 assert(RD->getNumVBases());
252 CharUnits Total = CharUnits::Zero();
253 while (RD) {
254 const ASTRecordLayout &RDLayout = getContext().getASTRecordLayout(RD);
255 CharUnits VBPtrOffset = RDLayout.getVBPtrOffset();
256 // -1 is the sentinel for no vbptr.
257 if (VBPtrOffset != CharUnits::fromQuantity(-1)) {
258 Total += VBPtrOffset;
259 break;
260 }
Reid Kleckner8c474322013-06-04 21:32:29 +0000261 RD = FindFirstNVBaseWithVBases(RD);
262 Total += RDLayout.getBaseClassOffset(RD);
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000263 }
264 return Total;
265}
266
Reid Kleckner8c474322013-06-04 21:32:29 +0000267/// \brief Computes the index of BaseClassDecl in the vbtable of ClassDecl.
268/// BaseClassDecl must be a morally virtual base of ClassDecl. The vbtable is
269/// an array of i32 offsets. The first entry is a self entry, and the rest are
270/// offsets from the vbptr to virtual bases. The bases are ordered the same way
271/// our vbases are ordered: as they appear in a left-to-right depth-first search
272/// of the hierarchy.
273static unsigned GetVBTableIndex(const CXXRecordDecl *ClassDecl,
274 const CXXRecordDecl *BaseClassDecl) {
275 unsigned VBTableIndex = 1; // Start with one to skip the self entry.
276 for (CXXRecordDecl::base_class_const_iterator I = ClassDecl->vbases_begin(),
277 E = ClassDecl->vbases_end(); I != E; ++I) {
278 if (I->getType()->getAsCXXRecordDecl() == BaseClassDecl)
279 return VBTableIndex;
280 VBTableIndex++;
281 }
282 llvm_unreachable("BaseClassDecl must be a vbase of ClassDecl");
283}
284
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000285llvm::Value *
286MicrosoftCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
287 llvm::Value *This,
288 const CXXRecordDecl *ClassDecl,
289 const CXXRecordDecl *BaseClassDecl) {
290 int64_t VBPtrChars = GetVBPtrOffsetFromBases(ClassDecl).getQuantity();
291 llvm::Value *VBPtrOffset = llvm::ConstantInt::get(CGM.PtrDiffTy, VBPtrChars);
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000292 CharUnits IntSize = getContext().getTypeSizeInChars(getContext().IntTy);
Reid Kleckner8c474322013-06-04 21:32:29 +0000293 CharUnits VBTableChars = IntSize * GetVBTableIndex(ClassDecl, BaseClassDecl);
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000294 llvm::Value *VBTableOffset =
295 llvm::ConstantInt::get(CGM.IntTy, VBTableChars.getQuantity());
296
297 llvm::Value *VBPtrToNewBase =
298 GetVBaseOffsetFromVBPtr(CGF, This, VBTableOffset, VBPtrOffset);
299 VBPtrToNewBase =
300 CGF.Builder.CreateSExtOrBitCast(VBPtrToNewBase, CGM.PtrDiffTy);
301 return CGF.Builder.CreateNSWAdd(VBPtrOffset, VBPtrToNewBase);
302}
303
Stephen Lind4c0cd02013-06-18 17:00:49 +0000304bool MicrosoftCXXABI::HasThisReturn(GlobalDecl GD) const {
305 return isa<CXXConstructorDecl>(GD.getDecl());
John McCallbd315742012-09-25 08:00:39 +0000306}
307
308void MicrosoftCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor,
309 CXXCtorType Type,
310 CanQualType &ResTy,
311 SmallVectorImpl<CanQualType> &ArgTys) {
Stephen Lind4c0cd02013-06-18 17:00:49 +0000312 // 'this' parameter and 'this' return are already in place
Timur Iskhodzhanov1d4fff52013-02-27 13:46:31 +0000313
314 const CXXRecordDecl *Class = Ctor->getParent();
315 if (Class->getNumVBases()) {
316 // Constructors of classes with virtual bases take an implicit parameter.
317 ArgTys.push_back(CGM.getContext().IntTy);
318 }
319}
320
321llvm::BasicBlock *MicrosoftCXXABI::EmitCtorCompleteObjectHandler(
322 CodeGenFunction &CGF) {
323 llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
324 assert(IsMostDerivedClass &&
325 "ctor for a class with virtual bases must have an implicit parameter");
326 llvm::Value *IsCompleteObject
327 = CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
328
329 llvm::BasicBlock *CallVbaseCtorsBB = CGF.createBasicBlock("ctor.init_vbases");
330 llvm::BasicBlock *SkipVbaseCtorsBB = CGF.createBasicBlock("ctor.skip_vbases");
331 CGF.Builder.CreateCondBr(IsCompleteObject,
332 CallVbaseCtorsBB, SkipVbaseCtorsBB);
333
334 CGF.EmitBlock(CallVbaseCtorsBB);
335 // FIXME: emit vbtables somewhere around here.
336
337 // CGF will put the base ctor calls in this basic block for us later.
338
339 return SkipVbaseCtorsBB;
John McCallbd315742012-09-25 08:00:39 +0000340}
341
Timur Iskhodzhanov59660c22013-02-13 08:37:51 +0000342void MicrosoftCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor,
343 CXXDtorType Type,
344 CanQualType &ResTy,
345 SmallVectorImpl<CanQualType> &ArgTys) {
346 // 'this' is already in place
Stephen Lind4c0cd02013-06-18 17:00:49 +0000347
Timur Iskhodzhanov59660c22013-02-13 08:37:51 +0000348 // TODO: 'for base' flag
349
350 if (Type == Dtor_Deleting) {
351 // The scalar deleting destructor takes an implicit bool parameter.
352 ArgTys.push_back(CGM.getContext().BoolTy);
353 }
354}
355
356static bool IsDeletingDtor(GlobalDecl GD) {
357 const CXXMethodDecl* MD = cast<CXXMethodDecl>(GD.getDecl());
358 if (isa<CXXDestructorDecl>(MD)) {
359 return GD.getDtorType() == Dtor_Deleting;
360 }
361 return false;
362}
363
John McCallbd315742012-09-25 08:00:39 +0000364void MicrosoftCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF,
365 QualType &ResTy,
366 FunctionArgList &Params) {
367 BuildThisParam(CGF, Params);
Timur Iskhodzhanov59660c22013-02-13 08:37:51 +0000368
Timur Iskhodzhanov1d4fff52013-02-27 13:46:31 +0000369 ASTContext &Context = getContext();
370 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
371 if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
372 ImplicitParamDecl *IsMostDerived
373 = ImplicitParamDecl::Create(Context, 0,
374 CGF.CurGD.getDecl()->getLocation(),
375 &Context.Idents.get("is_most_derived"),
376 Context.IntTy);
377 Params.push_back(IsMostDerived);
378 getStructorImplicitParamDecl(CGF) = IsMostDerived;
379 } else if (IsDeletingDtor(CGF.CurGD)) {
Timur Iskhodzhanov59660c22013-02-13 08:37:51 +0000380 ImplicitParamDecl *ShouldDelete
381 = ImplicitParamDecl::Create(Context, 0,
382 CGF.CurGD.getDecl()->getLocation(),
383 &Context.Idents.get("should_call_delete"),
384 Context.BoolTy);
385 Params.push_back(ShouldDelete);
386 getStructorImplicitParamDecl(CGF) = ShouldDelete;
387 }
John McCallbd315742012-09-25 08:00:39 +0000388}
389
390void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
391 EmitThisParam(CGF);
Stephen Lind4c0cd02013-06-18 17:00:49 +0000392
393 /// If this is a function that the ABI specifies returns 'this', initialize
394 /// the return slot to 'this' at the start of the function.
395 ///
396 /// Unlike the setting of return types, this is done within the ABI
397 /// implementation instead of by clients of CGCXXABI because:
398 /// 1) getThisValue is currently protected
399 /// 2) in theory, an ABI could implement 'this' returns some other way;
400 /// HasThisReturn only specifies a contract, not the implementation
401 if (HasThisReturn(CGF.CurGD))
John McCallbd315742012-09-25 08:00:39 +0000402 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
Timur Iskhodzhanov1d4fff52013-02-27 13:46:31 +0000403
404 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
405 if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
406 assert(getStructorImplicitParamDecl(CGF) &&
407 "no implicit parameter for a constructor with virtual bases?");
408 getStructorImplicitParamValue(CGF)
409 = CGF.Builder.CreateLoad(
410 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
411 "is_most_derived");
412 }
413
Timur Iskhodzhanov59660c22013-02-13 08:37:51 +0000414 if (IsDeletingDtor(CGF.CurGD)) {
415 assert(getStructorImplicitParamDecl(CGF) &&
416 "no implicit parameter for a deleting destructor?");
417 getStructorImplicitParamValue(CGF)
418 = CGF.Builder.CreateLoad(
419 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
420 "should_call_delete");
421 }
John McCallbd315742012-09-25 08:00:39 +0000422}
423
Stephen Lind4c0cd02013-06-18 17:00:49 +0000424RValue MicrosoftCXXABI::EmitConstructorCall(CodeGenFunction &CGF,
425 const CXXConstructorDecl *D,
426 CXXCtorType Type,
427 bool ForVirtualBase,
428 bool Delegating,
429 ReturnValueSlot ReturnValue,
430 llvm::Value *This,
Timur Iskhodzhanov1d4fff52013-02-27 13:46:31 +0000431 CallExpr::const_arg_iterator ArgBeg,
432 CallExpr::const_arg_iterator ArgEnd) {
433 assert(Type == Ctor_Complete || Type == Ctor_Base);
434 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Ctor_Complete);
435
436 llvm::Value *ImplicitParam = 0;
437 QualType ImplicitParamTy;
438 if (D->getParent()->getNumVBases()) {
439 ImplicitParam = llvm::ConstantInt::get(CGM.Int32Ty, Type == Ctor_Complete);
440 ImplicitParamTy = getContext().IntTy;
441 }
442
443 // FIXME: Provide a source location here.
Stephen Lind4c0cd02013-06-18 17:00:49 +0000444 return CGF.EmitCXXMemberCall(D, SourceLocation(), Callee, ReturnValue,
445 This, ImplicitParam, ImplicitParamTy,
446 ArgBeg, ArgEnd);
Timur Iskhodzhanov1d4fff52013-02-27 13:46:31 +0000447}
448
Timur Iskhodzhanov0f9827f2013-02-15 14:45:22 +0000449RValue MicrosoftCXXABI::EmitVirtualDestructorCall(CodeGenFunction &CGF,
450 const CXXDestructorDecl *Dtor,
451 CXXDtorType DtorType,
452 SourceLocation CallLoc,
453 ReturnValueSlot ReturnValue,
454 llvm::Value *This) {
455 assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
456
457 // We have only one destructor in the vftable but can get both behaviors
458 // by passing an implicit bool parameter.
459 const CGFunctionInfo *FInfo
460 = &CGM.getTypes().arrangeCXXDestructor(Dtor, Dtor_Deleting);
461 llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
462 llvm::Value *Callee = CGF.BuildVirtualCall(Dtor, Dtor_Deleting, This, Ty);
463
464 ASTContext &Context = CGF.getContext();
465 llvm::Value *ImplicitParam
466 = llvm::ConstantInt::get(llvm::IntegerType::getInt1Ty(CGF.getLLVMContext()),
467 DtorType == Dtor_Deleting);
468
469 return CGF.EmitCXXMemberCall(Dtor, CallLoc, Callee, ReturnValue, This,
470 ImplicitParam, Context.BoolTy, 0, 0);
471}
472
John McCalle2b45e22012-05-01 05:23:51 +0000473bool MicrosoftCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
474 QualType elementType) {
475 // Microsoft seems to completely ignore the possibility of a
476 // two-argument usual deallocation function.
477 return elementType.isDestructedType();
478}
479
480bool MicrosoftCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
481 // Microsoft seems to completely ignore the possibility of a
482 // two-argument usual deallocation function.
483 return expr->getAllocatedType().isDestructedType();
484}
485
486CharUnits MicrosoftCXXABI::getArrayCookieSizeImpl(QualType type) {
487 // The array cookie is always a size_t; we then pad that out to the
488 // alignment of the element type.
489 ASTContext &Ctx = getContext();
490 return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()),
491 Ctx.getTypeAlignInChars(type));
492}
493
494llvm::Value *MicrosoftCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
495 llvm::Value *allocPtr,
496 CharUnits cookieSize) {
Micah Villmow956a5a12012-10-25 15:39:14 +0000497 unsigned AS = allocPtr->getType()->getPointerAddressSpace();
John McCalle2b45e22012-05-01 05:23:51 +0000498 llvm::Value *numElementsPtr =
499 CGF.Builder.CreateBitCast(allocPtr, CGF.SizeTy->getPointerTo(AS));
500 return CGF.Builder.CreateLoad(numElementsPtr);
501}
502
503llvm::Value* MicrosoftCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
504 llvm::Value *newPtr,
505 llvm::Value *numElements,
506 const CXXNewExpr *expr,
507 QualType elementType) {
508 assert(requiresArrayCookie(expr));
509
510 // The size of the cookie.
511 CharUnits cookieSize = getArrayCookieSizeImpl(elementType);
512
513 // Compute an offset to the cookie.
514 llvm::Value *cookiePtr = newPtr;
515
516 // Write the number of elements into the appropriate slot.
Micah Villmow956a5a12012-10-25 15:39:14 +0000517 unsigned AS = newPtr->getType()->getPointerAddressSpace();
John McCalle2b45e22012-05-01 05:23:51 +0000518 llvm::Value *numElementsPtr
519 = CGF.Builder.CreateBitCast(cookiePtr, CGF.SizeTy->getPointerTo(AS));
520 CGF.Builder.CreateStore(numElements, numElementsPtr);
521
522 // Finally, compute a pointer to the actual data buffer by skipping
523 // over the cookie completely.
524 return CGF.Builder.CreateConstInBoundsGEP1_64(newPtr,
525 cookieSize.getQuantity());
526}
527
John McCall20bb1752012-05-01 06:13:13 +0000528void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
529 llvm::GlobalVariable *DeclPtr,
530 bool PerformInit) {
531 // FIXME: this code was only tested for global initialization.
532 // Not sure whether we want thread-safe static local variables as VS
533 // doesn't make them thread-safe.
534
Richard Smith04e51762013-04-14 23:01:42 +0000535 if (D.getTLSKind())
536 CGM.ErrorUnsupported(&D, "dynamic TLS initialization");
537
John McCall20bb1752012-05-01 06:13:13 +0000538 // Emit the initializer and add a global destructor if appropriate.
539 CGF.EmitCXXGlobalVarDeclInit(D, DeclPtr, PerformInit);
540}
541
Reid Klecknera3609b02013-04-11 18:13:19 +0000542// Member pointer helpers.
543static bool hasVBPtrOffsetField(MSInheritanceModel Inheritance) {
544 return Inheritance == MSIM_Unspecified;
Reid Klecknera8a0f762013-03-22 19:02:54 +0000545}
546
Reid Klecknerf6327302013-05-09 21:01:17 +0000547static bool hasOnlyOneField(bool IsMemberFunction,
548 MSInheritanceModel Inheritance) {
549 return Inheritance <= MSIM_SinglePolymorphic ||
550 (!IsMemberFunction && Inheritance <= MSIM_MultiplePolymorphic);
Reid Kleckner3d2f0002013-04-30 20:15:14 +0000551}
552
Reid Klecknera3609b02013-04-11 18:13:19 +0000553// Only member pointers to functions need a this adjustment, since it can be
554// combined with the field offset for data pointers.
Reid Kleckner79e02912013-05-03 01:15:11 +0000555static bool hasNonVirtualBaseAdjustmentField(bool IsMemberFunction,
Reid Klecknera3609b02013-04-11 18:13:19 +0000556 MSInheritanceModel Inheritance) {
Reid Kleckner79e02912013-05-03 01:15:11 +0000557 return (IsMemberFunction && Inheritance >= MSIM_Multiple);
Reid Klecknera3609b02013-04-11 18:13:19 +0000558}
559
560static bool hasVirtualBaseAdjustmentField(MSInheritanceModel Inheritance) {
561 return Inheritance >= MSIM_Virtual;
562}
563
564// Use zero for the field offset of a null data member pointer if we can
565// guarantee that zero is not a valid field offset, or if the member pointer has
566// multiple fields. Polymorphic classes have a vfptr at offset zero, so we can
567// use zero for null. If there are multiple fields, we can use zero even if it
568// is a valid field offset because null-ness testing will check the other
569// fields.
570static bool nullFieldOffsetIsZero(MSInheritanceModel Inheritance) {
571 return Inheritance != MSIM_Multiple && Inheritance != MSIM_Single;
572}
573
574bool MicrosoftCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
575 // Null-ness for function memptrs only depends on the first field, which is
576 // the function pointer. The rest don't matter, so we can zero initialize.
577 if (MPT->isMemberFunctionPointer())
578 return true;
579
580 // The virtual base adjustment field is always -1 for null, so if we have one
581 // we can't zero initialize. The field offset is sometimes also -1 if 0 is a
582 // valid field offset.
583 const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
584 MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
585 return (!hasVirtualBaseAdjustmentField(Inheritance) &&
586 nullFieldOffsetIsZero(Inheritance));
587}
588
589llvm::Type *
590MicrosoftCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
591 const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
592 MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
593 llvm::SmallVector<llvm::Type *, 4> fields;
594 if (MPT->isMemberFunctionPointer())
595 fields.push_back(CGM.VoidPtrTy); // FunctionPointerOrVirtualThunk
596 else
597 fields.push_back(CGM.IntTy); // FieldOffset
598
Reid Kleckner79e02912013-05-03 01:15:11 +0000599 if (hasNonVirtualBaseAdjustmentField(MPT->isMemberFunctionPointer(),
600 Inheritance))
Reid Klecknera3609b02013-04-11 18:13:19 +0000601 fields.push_back(CGM.IntTy);
Reid Kleckner79e02912013-05-03 01:15:11 +0000602 if (hasVBPtrOffsetField(Inheritance))
Reid Klecknera3609b02013-04-11 18:13:19 +0000603 fields.push_back(CGM.IntTy);
604 if (hasVirtualBaseAdjustmentField(Inheritance))
605 fields.push_back(CGM.IntTy); // VirtualBaseAdjustmentOffset
606
607 if (fields.size() == 1)
608 return fields[0];
609 return llvm::StructType::get(CGM.getLLVMContext(), fields);
610}
611
612void MicrosoftCXXABI::
613GetNullMemberPointerFields(const MemberPointerType *MPT,
614 llvm::SmallVectorImpl<llvm::Constant *> &fields) {
615 assert(fields.empty());
616 const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
617 MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
618 if (MPT->isMemberFunctionPointer()) {
619 // FunctionPointerOrVirtualThunk
620 fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy));
621 } else {
622 if (nullFieldOffsetIsZero(Inheritance))
623 fields.push_back(getZeroInt()); // FieldOffset
624 else
625 fields.push_back(getAllOnesInt()); // FieldOffset
Reid Klecknera8a0f762013-03-22 19:02:54 +0000626 }
Reid Klecknera3609b02013-04-11 18:13:19 +0000627
Reid Kleckner79e02912013-05-03 01:15:11 +0000628 if (hasNonVirtualBaseAdjustmentField(MPT->isMemberFunctionPointer(),
629 Inheritance))
Reid Klecknera3609b02013-04-11 18:13:19 +0000630 fields.push_back(getZeroInt());
Reid Kleckner79e02912013-05-03 01:15:11 +0000631 if (hasVBPtrOffsetField(Inheritance))
Reid Klecknera3609b02013-04-11 18:13:19 +0000632 fields.push_back(getZeroInt());
633 if (hasVirtualBaseAdjustmentField(Inheritance))
634 fields.push_back(getAllOnesInt());
Reid Klecknera8a0f762013-03-22 19:02:54 +0000635}
636
637llvm::Constant *
638MicrosoftCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
Reid Klecknera3609b02013-04-11 18:13:19 +0000639 llvm::SmallVector<llvm::Constant *, 4> fields;
640 GetNullMemberPointerFields(MPT, fields);
641 if (fields.size() == 1)
642 return fields[0];
643 llvm::Constant *Res = llvm::ConstantStruct::getAnon(fields);
644 assert(Res->getType() == ConvertMemberPointerType(MPT));
645 return Res;
Reid Klecknera8a0f762013-03-22 19:02:54 +0000646}
647
648llvm::Constant *
Reid Kleckner79e02912013-05-03 01:15:11 +0000649MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField,
650 bool IsMemberFunction,
Reid Klecknerf6327302013-05-09 21:01:17 +0000651 const CXXRecordDecl *RD,
652 CharUnits NonVirtualBaseAdjustment)
Reid Kleckner79e02912013-05-03 01:15:11 +0000653{
Reid Klecknera3609b02013-04-11 18:13:19 +0000654 MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
Reid Kleckner79e02912013-05-03 01:15:11 +0000655
656 // Single inheritance class member pointer are represented as scalars instead
657 // of aggregates.
Reid Klecknerf6327302013-05-09 21:01:17 +0000658 if (hasOnlyOneField(IsMemberFunction, Inheritance))
Reid Kleckner79e02912013-05-03 01:15:11 +0000659 return FirstField;
660
Reid Klecknera3609b02013-04-11 18:13:19 +0000661 llvm::SmallVector<llvm::Constant *, 4> fields;
Reid Kleckner79e02912013-05-03 01:15:11 +0000662 fields.push_back(FirstField);
663
664 if (hasNonVirtualBaseAdjustmentField(IsMemberFunction, Inheritance))
Reid Klecknerf6327302013-05-09 21:01:17 +0000665 fields.push_back(llvm::ConstantInt::get(
666 CGM.IntTy, NonVirtualBaseAdjustment.getQuantity()));
Reid Kleckner79e02912013-05-03 01:15:11 +0000667
Reid Klecknera3609b02013-04-11 18:13:19 +0000668 if (hasVBPtrOffsetField(Inheritance)) {
Reid Klecknera06d5852013-06-05 15:58:29 +0000669 fields.push_back(llvm::ConstantInt::get(
670 CGM.IntTy, GetVBPtrOffsetFromBases(RD).getQuantity()));
Reid Klecknera3609b02013-04-11 18:13:19 +0000671 }
Reid Kleckner79e02912013-05-03 01:15:11 +0000672
673 // The rest of the fields are adjusted by conversions to a more derived class.
Reid Klecknera3609b02013-04-11 18:13:19 +0000674 if (hasVirtualBaseAdjustmentField(Inheritance))
675 fields.push_back(getZeroInt());
Reid Kleckner79e02912013-05-03 01:15:11 +0000676
Reid Klecknera3609b02013-04-11 18:13:19 +0000677 return llvm::ConstantStruct::getAnon(fields);
Reid Klecknera8a0f762013-03-22 19:02:54 +0000678}
679
Reid Kleckner79e02912013-05-03 01:15:11 +0000680llvm::Constant *
681MicrosoftCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
682 CharUnits offset) {
683 const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
684 llvm::Constant *FirstField =
685 llvm::ConstantInt::get(CGM.IntTy, offset.getQuantity());
Reid Klecknerf6327302013-05-09 21:01:17 +0000686 return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/false, RD,
687 CharUnits::Zero());
688}
689
690llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
691 return BuildMemberPointer(MD->getParent(), MD, CharUnits::Zero());
692}
693
694llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const APValue &MP,
695 QualType MPType) {
696 const MemberPointerType *MPT = MPType->castAs<MemberPointerType>();
697 const ValueDecl *MPD = MP.getMemberPointerDecl();
698 if (!MPD)
699 return EmitNullMemberPointer(MPT);
700
701 CharUnits ThisAdjustment = getMemberPointerPathAdjustment(MP);
702
703 // FIXME PR15713: Support virtual inheritance paths.
704
705 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD))
706 return BuildMemberPointer(MPT->getClass()->getAsCXXRecordDecl(),
707 MD, ThisAdjustment);
708
709 CharUnits FieldOffset =
710 getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD));
711 return EmitMemberDataPointer(MPT, ThisAdjustment + FieldOffset);
Reid Kleckner79e02912013-05-03 01:15:11 +0000712}
713
714llvm::Constant *
Reid Klecknerf6327302013-05-09 21:01:17 +0000715MicrosoftCXXABI::BuildMemberPointer(const CXXRecordDecl *RD,
716 const CXXMethodDecl *MD,
717 CharUnits NonVirtualBaseAdjustment) {
Reid Kleckner79e02912013-05-03 01:15:11 +0000718 assert(MD->isInstance() && "Member function must not be static!");
719 MD = MD->getCanonicalDecl();
Reid Kleckner79e02912013-05-03 01:15:11 +0000720 CodeGenTypes &Types = CGM.getTypes();
721
722 llvm::Constant *FirstField;
723 if (MD->isVirtual()) {
724 // FIXME: We have to instantiate a thunk that loads the vftable and jumps to
725 // the right offset.
726 FirstField = llvm::Constant::getNullValue(CGM.VoidPtrTy);
727 } else {
728 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
729 llvm::Type *Ty;
730 // Check whether the function has a computable LLVM signature.
731 if (Types.isFuncTypeConvertible(FPT)) {
732 // The function has a computable LLVM signature; use the correct type.
733 Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
734 } else {
735 // Use an arbitrary non-function type to tell GetAddrOfFunction that the
736 // function type is incomplete.
737 Ty = CGM.PtrDiffTy;
738 }
739 FirstField = CGM.GetAddrOfFunction(MD, Ty);
740 FirstField = llvm::ConstantExpr::getBitCast(FirstField, CGM.VoidPtrTy);
741 }
742
743 // The rest of the fields are common with data member pointers.
Reid Klecknerf6327302013-05-09 21:01:17 +0000744 return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/true, RD,
745 NonVirtualBaseAdjustment);
Reid Kleckner79e02912013-05-03 01:15:11 +0000746}
747
Reid Kleckner3d2f0002013-04-30 20:15:14 +0000748/// Member pointers are the same if they're either bitwise identical *or* both
749/// null. Null-ness for function members is determined by the first field,
750/// while for data member pointers we must compare all fields.
751llvm::Value *
752MicrosoftCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
753 llvm::Value *L,
754 llvm::Value *R,
755 const MemberPointerType *MPT,
756 bool Inequality) {
757 CGBuilderTy &Builder = CGF.Builder;
758
759 // Handle != comparisons by switching the sense of all boolean operations.
760 llvm::ICmpInst::Predicate Eq;
761 llvm::Instruction::BinaryOps And, Or;
762 if (Inequality) {
763 Eq = llvm::ICmpInst::ICMP_NE;
764 And = llvm::Instruction::Or;
765 Or = llvm::Instruction::And;
766 } else {
767 Eq = llvm::ICmpInst::ICMP_EQ;
768 And = llvm::Instruction::And;
769 Or = llvm::Instruction::Or;
770 }
771
772 // If this is a single field member pointer (single inheritance), this is a
773 // single icmp.
774 const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
775 MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
Reid Klecknerf6327302013-05-09 21:01:17 +0000776 if (hasOnlyOneField(MPT->isMemberFunctionPointer(), Inheritance))
Reid Kleckner3d2f0002013-04-30 20:15:14 +0000777 return Builder.CreateICmp(Eq, L, R);
778
779 // Compare the first field.
780 llvm::Value *L0 = Builder.CreateExtractValue(L, 0, "lhs.0");
781 llvm::Value *R0 = Builder.CreateExtractValue(R, 0, "rhs.0");
782 llvm::Value *Cmp0 = Builder.CreateICmp(Eq, L0, R0, "memptr.cmp.first");
783
784 // Compare everything other than the first field.
785 llvm::Value *Res = 0;
786 llvm::StructType *LType = cast<llvm::StructType>(L->getType());
787 for (unsigned I = 1, E = LType->getNumElements(); I != E; ++I) {
788 llvm::Value *LF = Builder.CreateExtractValue(L, I);
789 llvm::Value *RF = Builder.CreateExtractValue(R, I);
790 llvm::Value *Cmp = Builder.CreateICmp(Eq, LF, RF, "memptr.cmp.rest");
791 if (Res)
792 Res = Builder.CreateBinOp(And, Res, Cmp);
793 else
794 Res = Cmp;
795 }
796
797 // Check if the first field is 0 if this is a function pointer.
798 if (MPT->isMemberFunctionPointer()) {
799 // (l1 == r1 && ...) || l0 == 0
800 llvm::Value *Zero = llvm::Constant::getNullValue(L0->getType());
801 llvm::Value *IsZero = Builder.CreateICmp(Eq, L0, Zero, "memptr.cmp.iszero");
802 Res = Builder.CreateBinOp(Or, Res, IsZero);
803 }
804
805 // Combine the comparison of the first field, which must always be true for
806 // this comparison to succeeed.
807 return Builder.CreateBinOp(And, Res, Cmp0, "memptr.cmp");
808}
809
Reid Klecknera8a0f762013-03-22 19:02:54 +0000810llvm::Value *
811MicrosoftCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
812 llvm::Value *MemPtr,
813 const MemberPointerType *MPT) {
814 CGBuilderTy &Builder = CGF.Builder;
Reid Klecknera3609b02013-04-11 18:13:19 +0000815 llvm::SmallVector<llvm::Constant *, 4> fields;
816 // We only need one field for member functions.
817 if (MPT->isMemberFunctionPointer())
818 fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy));
819 else
820 GetNullMemberPointerFields(MPT, fields);
821 assert(!fields.empty());
822 llvm::Value *FirstField = MemPtr;
823 if (MemPtr->getType()->isStructTy())
824 FirstField = Builder.CreateExtractValue(MemPtr, 0);
825 llvm::Value *Res = Builder.CreateICmpNE(FirstField, fields[0], "memptr.cmp0");
Reid Klecknera8a0f762013-03-22 19:02:54 +0000826
Reid Klecknera3609b02013-04-11 18:13:19 +0000827 // For function member pointers, we only need to test the function pointer
828 // field. The other fields if any can be garbage.
829 if (MPT->isMemberFunctionPointer())
830 return Res;
831
832 // Otherwise, emit a series of compares and combine the results.
833 for (int I = 1, E = fields.size(); I < E; ++I) {
834 llvm::Value *Field = Builder.CreateExtractValue(MemPtr, I);
835 llvm::Value *Next = Builder.CreateICmpNE(Field, fields[I], "memptr.cmp");
836 Res = Builder.CreateAnd(Res, Next, "memptr.tobool");
837 }
838 return Res;
839}
840
Reid Klecknerf6327302013-05-09 21:01:17 +0000841bool MicrosoftCXXABI::MemberPointerConstantIsNull(const MemberPointerType *MPT,
842 llvm::Constant *Val) {
843 // Function pointers are null if the pointer in the first field is null.
844 if (MPT->isMemberFunctionPointer()) {
845 llvm::Constant *FirstField = Val->getType()->isStructTy() ?
846 Val->getAggregateElement(0U) : Val;
847 return FirstField->isNullValue();
848 }
849
850 // If it's not a function pointer and it's zero initializable, we can easily
851 // check zero.
852 if (isZeroInitializable(MPT) && Val->isNullValue())
853 return true;
854
855 // Otherwise, break down all the fields for comparison. Hopefully these
856 // little Constants are reused, while a big null struct might not be.
857 llvm::SmallVector<llvm::Constant *, 4> Fields;
858 GetNullMemberPointerFields(MPT, Fields);
859 if (Fields.size() == 1) {
860 assert(Val->getType()->isIntegerTy());
861 return Val == Fields[0];
862 }
863
864 unsigned I, E;
865 for (I = 0, E = Fields.size(); I != E; ++I) {
866 if (Val->getAggregateElement(I) != Fields[I])
867 break;
868 }
869 return I == E;
870}
871
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000872llvm::Value *
873MicrosoftCXXABI::GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
874 llvm::Value *This,
875 llvm::Value *VBTableOffset,
876 llvm::Value *VBPtrOffset,
877 llvm::Value **VBPtrOut) {
878 CGBuilderTy &Builder = CGF.Builder;
879 // Load the vbtable pointer from the vbptr in the instance.
880 This = Builder.CreateBitCast(This, CGM.Int8PtrTy);
881 llvm::Value *VBPtr =
882 Builder.CreateInBoundsGEP(This, VBPtrOffset, "vbptr");
883 if (VBPtrOut) *VBPtrOut = VBPtr;
884 VBPtr = Builder.CreateBitCast(VBPtr, CGM.Int8PtrTy->getPointerTo(0));
885 llvm::Value *VBTable = Builder.CreateLoad(VBPtr, "vbtable");
886
887 // Load an i32 offset from the vb-table.
888 llvm::Value *VBaseOffs = Builder.CreateInBoundsGEP(VBTable, VBTableOffset);
889 VBaseOffs = Builder.CreateBitCast(VBaseOffs, CGM.Int32Ty->getPointerTo(0));
890 return Builder.CreateLoad(VBaseOffs, "vbase_offs");
891}
892
Reid Klecknera3609b02013-04-11 18:13:19 +0000893// Returns an adjusted base cast to i8*, since we do more address arithmetic on
894// it.
895llvm::Value *
896MicrosoftCXXABI::AdjustVirtualBase(CodeGenFunction &CGF,
897 const CXXRecordDecl *RD, llvm::Value *Base,
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000898 llvm::Value *VBTableOffset,
Reid Klecknera3609b02013-04-11 18:13:19 +0000899 llvm::Value *VBPtrOffset) {
900 CGBuilderTy &Builder = CGF.Builder;
901 Base = Builder.CreateBitCast(Base, CGM.Int8PtrTy);
902 llvm::BasicBlock *OriginalBB = 0;
903 llvm::BasicBlock *SkipAdjustBB = 0;
904 llvm::BasicBlock *VBaseAdjustBB = 0;
905
906 // In the unspecified inheritance model, there might not be a vbtable at all,
907 // in which case we need to skip the virtual base lookup. If there is a
908 // vbtable, the first entry is a no-op entry that gives back the original
909 // base, so look for a virtual base adjustment offset of zero.
910 if (VBPtrOffset) {
911 OriginalBB = Builder.GetInsertBlock();
912 VBaseAdjustBB = CGF.createBasicBlock("memptr.vadjust");
913 SkipAdjustBB = CGF.createBasicBlock("memptr.skip_vadjust");
914 llvm::Value *IsVirtual =
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000915 Builder.CreateICmpNE(VBTableOffset, getZeroInt(),
Reid Klecknera3609b02013-04-11 18:13:19 +0000916 "memptr.is_vbase");
917 Builder.CreateCondBr(IsVirtual, VBaseAdjustBB, SkipAdjustBB);
918 CGF.EmitBlock(VBaseAdjustBB);
Reid Klecknera8a0f762013-03-22 19:02:54 +0000919 }
920
Reid Klecknera3609b02013-04-11 18:13:19 +0000921 // If we weren't given a dynamic vbptr offset, RD should be complete and we'll
922 // know the vbptr offset.
923 if (!VBPtrOffset) {
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000924 CharUnits offs = CharUnits::Zero();
925 if (RD->getNumVBases()) {
926 offs = GetVBPtrOffsetFromBases(RD);
927 }
Reid Klecknera3609b02013-04-11 18:13:19 +0000928 VBPtrOffset = llvm::ConstantInt::get(CGM.IntTy, offs.getQuantity());
929 }
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000930 llvm::Value *VBPtr = 0;
Reid Klecknera3609b02013-04-11 18:13:19 +0000931 llvm::Value *VBaseOffs =
Reid Klecknerb0f533e2013-05-29 18:02:47 +0000932 GetVBaseOffsetFromVBPtr(CGF, Base, VBTableOffset, VBPtrOffset, &VBPtr);
Reid Klecknera3609b02013-04-11 18:13:19 +0000933 llvm::Value *AdjustedBase = Builder.CreateInBoundsGEP(VBPtr, VBaseOffs);
934
935 // Merge control flow with the case where we didn't have to adjust.
936 if (VBaseAdjustBB) {
937 Builder.CreateBr(SkipAdjustBB);
938 CGF.EmitBlock(SkipAdjustBB);
939 llvm::PHINode *Phi = Builder.CreatePHI(CGM.Int8PtrTy, 2, "memptr.base");
940 Phi->addIncoming(Base, OriginalBB);
941 Phi->addIncoming(AdjustedBase, VBaseAdjustBB);
942 return Phi;
943 }
944 return AdjustedBase;
Reid Klecknera8a0f762013-03-22 19:02:54 +0000945}
946
947llvm::Value *
948MicrosoftCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF,
949 llvm::Value *Base,
950 llvm::Value *MemPtr,
951 const MemberPointerType *MPT) {
Reid Klecknera3609b02013-04-11 18:13:19 +0000952 assert(MPT->isMemberDataPointer());
Reid Klecknera8a0f762013-03-22 19:02:54 +0000953 unsigned AS = Base->getType()->getPointerAddressSpace();
954 llvm::Type *PType =
955 CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS);
956 CGBuilderTy &Builder = CGF.Builder;
Reid Klecknera3609b02013-04-11 18:13:19 +0000957 const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
958 MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
Reid Klecknera8a0f762013-03-22 19:02:54 +0000959
Reid Klecknera3609b02013-04-11 18:13:19 +0000960 // Extract the fields we need, regardless of model. We'll apply them if we
961 // have them.
962 llvm::Value *FieldOffset = MemPtr;
963 llvm::Value *VirtualBaseAdjustmentOffset = 0;
964 llvm::Value *VBPtrOffset = 0;
965 if (MemPtr->getType()->isStructTy()) {
966 // We need to extract values.
967 unsigned I = 0;
968 FieldOffset = Builder.CreateExtractValue(MemPtr, I++);
969 if (hasVBPtrOffsetField(Inheritance))
970 VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
971 if (hasVirtualBaseAdjustmentField(Inheritance))
972 VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
Reid Klecknera8a0f762013-03-22 19:02:54 +0000973 }
974
Reid Klecknera3609b02013-04-11 18:13:19 +0000975 if (VirtualBaseAdjustmentOffset) {
976 Base = AdjustVirtualBase(CGF, RD, Base, VirtualBaseAdjustmentOffset,
977 VBPtrOffset);
Reid Klecknera8a0f762013-03-22 19:02:54 +0000978 }
Reid Klecknera3609b02013-04-11 18:13:19 +0000979 llvm::Value *Addr =
980 Builder.CreateInBoundsGEP(Base, FieldOffset, "memptr.offset");
Reid Klecknera8a0f762013-03-22 19:02:54 +0000981
982 // Cast the address to the appropriate pointer type, adopting the address
983 // space of the base pointer.
984 return Builder.CreateBitCast(Addr, PType);
985}
986
Reid Klecknerf6327302013-05-09 21:01:17 +0000987static MSInheritanceModel
988getInheritanceFromMemptr(const MemberPointerType *MPT) {
989 return MPT->getClass()->getAsCXXRecordDecl()->getMSInheritanceModel();
990}
991
992llvm::Value *
993MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
994 const CastExpr *E,
995 llvm::Value *Src) {
996 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
997 E->getCastKind() == CK_BaseToDerivedMemberPointer ||
998 E->getCastKind() == CK_ReinterpretMemberPointer);
999
1000 // Use constant emission if we can.
1001 if (isa<llvm::Constant>(Src))
1002 return EmitMemberPointerConversion(E, cast<llvm::Constant>(Src));
1003
1004 // We may be adding or dropping fields from the member pointer, so we need
1005 // both types and the inheritance models of both records.
1006 const MemberPointerType *SrcTy =
1007 E->getSubExpr()->getType()->castAs<MemberPointerType>();
1008 const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>();
1009 MSInheritanceModel SrcInheritance = getInheritanceFromMemptr(SrcTy);
1010 MSInheritanceModel DstInheritance = getInheritanceFromMemptr(DstTy);
1011 bool IsFunc = SrcTy->isMemberFunctionPointer();
1012
1013 // If the classes use the same null representation, reinterpret_cast is a nop.
1014 bool IsReinterpret = E->getCastKind() == CK_ReinterpretMemberPointer;
1015 if (IsReinterpret && (IsFunc ||
1016 nullFieldOffsetIsZero(SrcInheritance) ==
1017 nullFieldOffsetIsZero(DstInheritance)))
1018 return Src;
1019
1020 CGBuilderTy &Builder = CGF.Builder;
1021
1022 // Branch past the conversion if Src is null.
1023 llvm::Value *IsNotNull = EmitMemberPointerIsNotNull(CGF, Src, SrcTy);
1024 llvm::Constant *DstNull = EmitNullMemberPointer(DstTy);
1025
1026 // C++ 5.2.10p9: The null member pointer value is converted to the null member
1027 // pointer value of the destination type.
1028 if (IsReinterpret) {
1029 // For reinterpret casts, sema ensures that src and dst are both functions
1030 // or data and have the same size, which means the LLVM types should match.
1031 assert(Src->getType() == DstNull->getType());
1032 return Builder.CreateSelect(IsNotNull, Src, DstNull);
1033 }
1034
1035 llvm::BasicBlock *OriginalBB = Builder.GetInsertBlock();
1036 llvm::BasicBlock *ConvertBB = CGF.createBasicBlock("memptr.convert");
1037 llvm::BasicBlock *ContinueBB = CGF.createBasicBlock("memptr.converted");
1038 Builder.CreateCondBr(IsNotNull, ConvertBB, ContinueBB);
1039 CGF.EmitBlock(ConvertBB);
1040
1041 // Decompose src.
1042 llvm::Value *FirstField = Src;
1043 llvm::Value *NonVirtualBaseAdjustment = 0;
1044 llvm::Value *VirtualBaseAdjustmentOffset = 0;
1045 llvm::Value *VBPtrOffset = 0;
1046 if (!hasOnlyOneField(IsFunc, SrcInheritance)) {
1047 // We need to extract values.
1048 unsigned I = 0;
1049 FirstField = Builder.CreateExtractValue(Src, I++);
1050 if (hasNonVirtualBaseAdjustmentField(IsFunc, SrcInheritance))
1051 NonVirtualBaseAdjustment = Builder.CreateExtractValue(Src, I++);
1052 if (hasVBPtrOffsetField(SrcInheritance))
1053 VBPtrOffset = Builder.CreateExtractValue(Src, I++);
1054 if (hasVirtualBaseAdjustmentField(SrcInheritance))
1055 VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(Src, I++);
1056 }
1057
1058 // For data pointers, we adjust the field offset directly. For functions, we
1059 // have a separate field.
1060 llvm::Constant *Adj = getMemberPointerAdjustment(E);
1061 if (Adj) {
1062 Adj = llvm::ConstantExpr::getTruncOrBitCast(Adj, CGM.IntTy);
1063 llvm::Value *&NVAdjustField = IsFunc ? NonVirtualBaseAdjustment : FirstField;
1064 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
1065 if (!NVAdjustField) // If this field didn't exist in src, it's zero.
1066 NVAdjustField = getZeroInt();
1067 if (isDerivedToBase)
1068 NVAdjustField = Builder.CreateNSWSub(NVAdjustField, Adj, "adj");
1069 else
1070 NVAdjustField = Builder.CreateNSWAdd(NVAdjustField, Adj, "adj");
1071 }
1072
1073 // FIXME PR15713: Support conversions through virtually derived classes.
1074
1075 // Recompose dst from the null struct and the adjusted fields from src.
1076 llvm::Value *Dst;
1077 if (hasOnlyOneField(IsFunc, DstInheritance)) {
1078 Dst = FirstField;
1079 } else {
1080 Dst = llvm::UndefValue::get(DstNull->getType());
1081 unsigned Idx = 0;
1082 Dst = Builder.CreateInsertValue(Dst, FirstField, Idx++);
1083 if (hasNonVirtualBaseAdjustmentField(IsFunc, DstInheritance))
1084 Dst = Builder.CreateInsertValue(
1085 Dst, getValueOrZeroInt(NonVirtualBaseAdjustment), Idx++);
1086 if (hasVBPtrOffsetField(DstInheritance))
1087 Dst = Builder.CreateInsertValue(
1088 Dst, getValueOrZeroInt(VBPtrOffset), Idx++);
1089 if (hasVirtualBaseAdjustmentField(DstInheritance))
1090 Dst = Builder.CreateInsertValue(
1091 Dst, getValueOrZeroInt(VirtualBaseAdjustmentOffset), Idx++);
1092 }
1093 Builder.CreateBr(ContinueBB);
1094
1095 // In the continuation, choose between DstNull and Dst.
1096 CGF.EmitBlock(ContinueBB);
1097 llvm::PHINode *Phi = Builder.CreatePHI(DstNull->getType(), 2, "memptr.converted");
1098 Phi->addIncoming(DstNull, OriginalBB);
1099 Phi->addIncoming(Dst, ConvertBB);
1100 return Phi;
1101}
1102
1103llvm::Constant *
1104MicrosoftCXXABI::EmitMemberPointerConversion(const CastExpr *E,
1105 llvm::Constant *Src) {
1106 const MemberPointerType *SrcTy =
1107 E->getSubExpr()->getType()->castAs<MemberPointerType>();
1108 const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>();
1109
1110 // If src is null, emit a new null for dst. We can't return src because dst
1111 // might have a new representation.
1112 if (MemberPointerConstantIsNull(SrcTy, Src))
1113 return EmitNullMemberPointer(DstTy);
1114
1115 // We don't need to do anything for reinterpret_casts of non-null member
1116 // pointers. We should only get here when the two type representations have
1117 // the same size.
1118 if (E->getCastKind() == CK_ReinterpretMemberPointer)
1119 return Src;
1120
1121 MSInheritanceModel SrcInheritance = getInheritanceFromMemptr(SrcTy);
1122 MSInheritanceModel DstInheritance = getInheritanceFromMemptr(DstTy);
1123
1124 // Decompose src.
1125 llvm::Constant *FirstField = Src;
1126 llvm::Constant *NonVirtualBaseAdjustment = 0;
1127 llvm::Constant *VirtualBaseAdjustmentOffset = 0;
1128 llvm::Constant *VBPtrOffset = 0;
1129 bool IsFunc = SrcTy->isMemberFunctionPointer();
1130 if (!hasOnlyOneField(IsFunc, SrcInheritance)) {
1131 // We need to extract values.
1132 unsigned I = 0;
1133 FirstField = Src->getAggregateElement(I++);
1134 if (hasNonVirtualBaseAdjustmentField(IsFunc, SrcInheritance))
1135 NonVirtualBaseAdjustment = Src->getAggregateElement(I++);
1136 if (hasVBPtrOffsetField(SrcInheritance))
1137 VBPtrOffset = Src->getAggregateElement(I++);
1138 if (hasVirtualBaseAdjustmentField(SrcInheritance))
1139 VirtualBaseAdjustmentOffset = Src->getAggregateElement(I++);
1140 }
1141
1142 // For data pointers, we adjust the field offset directly. For functions, we
1143 // have a separate field.
1144 llvm::Constant *Adj = getMemberPointerAdjustment(E);
1145 if (Adj) {
1146 Adj = llvm::ConstantExpr::getTruncOrBitCast(Adj, CGM.IntTy);
1147 llvm::Constant *&NVAdjustField =
1148 IsFunc ? NonVirtualBaseAdjustment : FirstField;
1149 bool IsDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
1150 if (!NVAdjustField) // If this field didn't exist in src, it's zero.
1151 NVAdjustField = getZeroInt();
1152 if (IsDerivedToBase)
1153 NVAdjustField = llvm::ConstantExpr::getNSWSub(NVAdjustField, Adj);
1154 else
1155 NVAdjustField = llvm::ConstantExpr::getNSWAdd(NVAdjustField, Adj);
1156 }
1157
1158 // FIXME PR15713: Support conversions through virtually derived classes.
1159
1160 // Recompose dst from the null struct and the adjusted fields from src.
1161 if (hasOnlyOneField(IsFunc, DstInheritance))
1162 return FirstField;
1163
1164 llvm::SmallVector<llvm::Constant *, 4> Fields;
1165 Fields.push_back(FirstField);
1166 if (hasNonVirtualBaseAdjustmentField(IsFunc, DstInheritance))
1167 Fields.push_back(getConstantOrZeroInt(NonVirtualBaseAdjustment));
1168 if (hasVBPtrOffsetField(DstInheritance))
1169 Fields.push_back(getConstantOrZeroInt(VBPtrOffset));
1170 if (hasVirtualBaseAdjustmentField(DstInheritance))
1171 Fields.push_back(getConstantOrZeroInt(VirtualBaseAdjustmentOffset));
1172 return llvm::ConstantStruct::getAnon(Fields);
1173}
1174
Reid Klecknera3609b02013-04-11 18:13:19 +00001175llvm::Value *
1176MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
1177 llvm::Value *&This,
1178 llvm::Value *MemPtr,
1179 const MemberPointerType *MPT) {
1180 assert(MPT->isMemberFunctionPointer());
1181 const FunctionProtoType *FPT =
1182 MPT->getPointeeType()->castAs<FunctionProtoType>();
1183 const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
1184 llvm::FunctionType *FTy =
1185 CGM.getTypes().GetFunctionType(
1186 CGM.getTypes().arrangeCXXMethodType(RD, FPT));
1187 CGBuilderTy &Builder = CGF.Builder;
1188
1189 MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
1190
1191 // Extract the fields we need, regardless of model. We'll apply them if we
1192 // have them.
1193 llvm::Value *FunctionPointer = MemPtr;
1194 llvm::Value *NonVirtualBaseAdjustment = NULL;
1195 llvm::Value *VirtualBaseAdjustmentOffset = NULL;
1196 llvm::Value *VBPtrOffset = NULL;
1197 if (MemPtr->getType()->isStructTy()) {
1198 // We need to extract values.
1199 unsigned I = 0;
1200 FunctionPointer = Builder.CreateExtractValue(MemPtr, I++);
Reid Klecknera3609b02013-04-11 18:13:19 +00001201 if (hasNonVirtualBaseAdjustmentField(MPT, Inheritance))
1202 NonVirtualBaseAdjustment = Builder.CreateExtractValue(MemPtr, I++);
Reid Kleckner79e02912013-05-03 01:15:11 +00001203 if (hasVBPtrOffsetField(Inheritance))
1204 VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
Reid Klecknera3609b02013-04-11 18:13:19 +00001205 if (hasVirtualBaseAdjustmentField(Inheritance))
1206 VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
1207 }
1208
1209 if (VirtualBaseAdjustmentOffset) {
1210 This = AdjustVirtualBase(CGF, RD, This, VirtualBaseAdjustmentOffset,
1211 VBPtrOffset);
1212 }
1213
1214 if (NonVirtualBaseAdjustment) {
1215 // Apply the adjustment and cast back to the original struct type.
1216 llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
1217 Ptr = Builder.CreateInBoundsGEP(Ptr, NonVirtualBaseAdjustment);
1218 This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
1219 }
1220
1221 return Builder.CreateBitCast(FunctionPointer, FTy->getPointerTo());
1222}
1223
Charles Davis071cc7d2010-08-16 03:33:14 +00001224CGCXXABI *clang::CodeGen::CreateMicrosoftCXXABI(CodeGenModule &CGM) {
Charles Davisc3926642010-06-09 23:25:41 +00001225 return new MicrosoftCXXABI(CGM);
1226}
1227