1//===--- 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//
10// This provides C++ code generation targeting the Microsoft Visual C++ ABI.
11// 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"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclCXX.h"
21
22using namespace clang;
23using namespace CodeGen;
24
25namespace {
26
27class MicrosoftCXXABI : public CGCXXABI {
28public:
29  MicrosoftCXXABI(CodeGenModule &CGM) : CGCXXABI(CGM) {}
30
31  bool isReturnTypeIndirect(const CXXRecordDecl *RD) const {
32    // Structures that are not C++03 PODs are always indirect.
33    return !RD->isPOD();
34  }
35
36  RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const {
37    if (RD->hasNonTrivialCopyConstructor())
38      return RAA_DirectInMemory;
39    return RAA_Default;
40  }
41
42  StringRef GetPureVirtualCallName() { return "_purecall"; }
43  // No known support for deleted functions in MSVC yet, so this choice is
44  // arbitrary.
45  StringRef GetDeletedVirtualCallName() { return "_purecall"; }
46
47  llvm::Value *adjustToCompleteObject(CodeGenFunction &CGF,
48                                      llvm::Value *ptr,
49                                      QualType type);
50
51  void BuildConstructorSignature(const CXXConstructorDecl *Ctor,
52                                 CXXCtorType Type,
53                                 CanQualType &ResTy,
54                                 SmallVectorImpl<CanQualType> &ArgTys);
55
56  llvm::BasicBlock *EmitCtorCompleteObjectHandler(CodeGenFunction &CGF);
57
58  void BuildDestructorSignature(const CXXDestructorDecl *Ctor,
59                                CXXDtorType Type,
60                                CanQualType &ResTy,
61                                SmallVectorImpl<CanQualType> &ArgTys);
62
63  void BuildInstanceFunctionParams(CodeGenFunction &CGF,
64                                   QualType &ResTy,
65                                   FunctionArgList &Params);
66
67  void EmitInstanceFunctionProlog(CodeGenFunction &CGF);
68
69  llvm::Value *EmitConstructorCall(CodeGenFunction &CGF,
70                           const CXXConstructorDecl *D,
71                           CXXCtorType Type, bool ForVirtualBase,
72                           bool Delegating,
73                           llvm::Value *This,
74                           CallExpr::const_arg_iterator ArgBeg,
75                           CallExpr::const_arg_iterator ArgEnd);
76
77  RValue EmitVirtualDestructorCall(CodeGenFunction &CGF,
78                                   const CXXDestructorDecl *Dtor,
79                                   CXXDtorType DtorType,
80                                   SourceLocation CallLoc,
81                                   ReturnValueSlot ReturnValue,
82                                   llvm::Value *This);
83
84  void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
85                       llvm::GlobalVariable *DeclPtr,
86                       bool PerformInit);
87
88  // ==== Notes on array cookies =========
89  //
90  // MSVC seems to only use cookies when the class has a destructor; a
91  // two-argument usual array deallocation function isn't sufficient.
92  //
93  // For example, this code prints "100" and "1":
94  //   struct A {
95  //     char x;
96  //     void *operator new[](size_t sz) {
97  //       printf("%u\n", sz);
98  //       return malloc(sz);
99  //     }
100  //     void operator delete[](void *p, size_t sz) {
101  //       printf("%u\n", sz);
102  //       free(p);
103  //     }
104  //   };
105  //   int main() {
106  //     A *p = new A[100];
107  //     delete[] p;
108  //   }
109  // Whereas it prints "104" and "104" if you give A a destructor.
110
111  bool requiresArrayCookie(const CXXDeleteExpr *expr, QualType elementType);
112  bool requiresArrayCookie(const CXXNewExpr *expr);
113  CharUnits getArrayCookieSizeImpl(QualType type);
114  llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
115                                     llvm::Value *NewPtr,
116                                     llvm::Value *NumElements,
117                                     const CXXNewExpr *expr,
118                                     QualType ElementType);
119  llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
120                                   llvm::Value *allocPtr,
121                                   CharUnits cookieSize);
122  static bool needThisReturn(GlobalDecl GD);
123
124private:
125  llvm::Constant *getZeroInt() {
126    return llvm::ConstantInt::get(CGM.IntTy, 0);
127  }
128
129  llvm::Constant *getAllOnesInt() {
130    return  llvm::Constant::getAllOnesValue(CGM.IntTy);
131  }
132
133  void
134  GetNullMemberPointerFields(const MemberPointerType *MPT,
135                             llvm::SmallVectorImpl<llvm::Constant *> &fields);
136
137  llvm::Value *AdjustVirtualBase(CodeGenFunction &CGF, const CXXRecordDecl *RD,
138                                 llvm::Value *Base,
139                                 llvm::Value *VirtualBaseAdjustmentOffset,
140                                 llvm::Value *VBPtrOffset /* optional */);
141
142  /// \brief Emits a full member pointer with the fields common to data and
143  /// function member pointers.
144  llvm::Constant *EmitFullMemberPointer(llvm::Constant *FirstField,
145                                        bool IsMemberFunction,
146                                        const CXXRecordDecl *RD);
147
148public:
149  virtual llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT);
150
151  virtual bool isZeroInitializable(const MemberPointerType *MPT);
152
153  virtual llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);
154
155  virtual llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
156                                                CharUnits offset);
157  virtual llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD);
158  virtual llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT);
159
160  virtual llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
161                                                   llvm::Value *L,
162                                                   llvm::Value *R,
163                                                   const MemberPointerType *MPT,
164                                                   bool Inequality);
165
166  virtual llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
167                                                  llvm::Value *MemPtr,
168                                                  const MemberPointerType *MPT);
169
170  virtual llvm::Value *EmitMemberDataPointerAddress(CodeGenFunction &CGF,
171                                                    llvm::Value *Base,
172                                                    llvm::Value *MemPtr,
173                                                  const MemberPointerType *MPT);
174
175  virtual llvm::Value *
176  EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
177                                  llvm::Value *&This,
178                                  llvm::Value *MemPtr,
179                                  const MemberPointerType *MPT);
180
181};
182
183}
184
185llvm::Value *MicrosoftCXXABI::adjustToCompleteObject(CodeGenFunction &CGF,
186                                                     llvm::Value *ptr,
187                                                     QualType type) {
188  // FIXME: implement
189  return ptr;
190}
191
192bool MicrosoftCXXABI::needThisReturn(GlobalDecl GD) {
193  const CXXMethodDecl* MD = cast<CXXMethodDecl>(GD.getDecl());
194  return isa<CXXConstructorDecl>(MD);
195}
196
197void MicrosoftCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor,
198                                 CXXCtorType Type,
199                                 CanQualType &ResTy,
200                                 SmallVectorImpl<CanQualType> &ArgTys) {
201  // 'this' is already in place
202
203  // Ctor returns this ptr
204  ResTy = ArgTys[0];
205
206  const CXXRecordDecl *Class = Ctor->getParent();
207  if (Class->getNumVBases()) {
208    // Constructors of classes with virtual bases take an implicit parameter.
209    ArgTys.push_back(CGM.getContext().IntTy);
210  }
211}
212
213llvm::BasicBlock *MicrosoftCXXABI::EmitCtorCompleteObjectHandler(
214                                                         CodeGenFunction &CGF) {
215  llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
216  assert(IsMostDerivedClass &&
217         "ctor for a class with virtual bases must have an implicit parameter");
218  llvm::Value *IsCompleteObject
219    = CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
220
221  llvm::BasicBlock *CallVbaseCtorsBB = CGF.createBasicBlock("ctor.init_vbases");
222  llvm::BasicBlock *SkipVbaseCtorsBB = CGF.createBasicBlock("ctor.skip_vbases");
223  CGF.Builder.CreateCondBr(IsCompleteObject,
224                           CallVbaseCtorsBB, SkipVbaseCtorsBB);
225
226  CGF.EmitBlock(CallVbaseCtorsBB);
227  // FIXME: emit vbtables somewhere around here.
228
229  // CGF will put the base ctor calls in this basic block for us later.
230
231  return SkipVbaseCtorsBB;
232}
233
234void MicrosoftCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor,
235                                               CXXDtorType Type,
236                                               CanQualType &ResTy,
237                                        SmallVectorImpl<CanQualType> &ArgTys) {
238  // 'this' is already in place
239  // TODO: 'for base' flag
240
241  if (Type == Dtor_Deleting) {
242    // The scalar deleting destructor takes an implicit bool parameter.
243    ArgTys.push_back(CGM.getContext().BoolTy);
244  }
245}
246
247static bool IsDeletingDtor(GlobalDecl GD) {
248  const CXXMethodDecl* MD = cast<CXXMethodDecl>(GD.getDecl());
249  if (isa<CXXDestructorDecl>(MD)) {
250    return GD.getDtorType() == Dtor_Deleting;
251  }
252  return false;
253}
254
255void MicrosoftCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF,
256                                                  QualType &ResTy,
257                                                  FunctionArgList &Params) {
258  BuildThisParam(CGF, Params);
259  if (needThisReturn(CGF.CurGD)) {
260    ResTy = Params[0]->getType();
261  }
262
263  ASTContext &Context = getContext();
264  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
265  if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
266    ImplicitParamDecl *IsMostDerived
267      = ImplicitParamDecl::Create(Context, 0,
268                                  CGF.CurGD.getDecl()->getLocation(),
269                                  &Context.Idents.get("is_most_derived"),
270                                  Context.IntTy);
271    Params.push_back(IsMostDerived);
272    getStructorImplicitParamDecl(CGF) = IsMostDerived;
273  } else if (IsDeletingDtor(CGF.CurGD)) {
274    ImplicitParamDecl *ShouldDelete
275      = ImplicitParamDecl::Create(Context, 0,
276                                  CGF.CurGD.getDecl()->getLocation(),
277                                  &Context.Idents.get("should_call_delete"),
278                                  Context.BoolTy);
279    Params.push_back(ShouldDelete);
280    getStructorImplicitParamDecl(CGF) = ShouldDelete;
281  }
282}
283
284void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
285  EmitThisParam(CGF);
286  if (needThisReturn(CGF.CurGD)) {
287    CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
288  }
289
290  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
291  if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
292    assert(getStructorImplicitParamDecl(CGF) &&
293           "no implicit parameter for a constructor with virtual bases?");
294    getStructorImplicitParamValue(CGF)
295      = CGF.Builder.CreateLoad(
296          CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
297          "is_most_derived");
298  }
299
300  if (IsDeletingDtor(CGF.CurGD)) {
301    assert(getStructorImplicitParamDecl(CGF) &&
302           "no implicit parameter for a deleting destructor?");
303    getStructorImplicitParamValue(CGF)
304      = CGF.Builder.CreateLoad(
305          CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
306          "should_call_delete");
307  }
308}
309
310llvm::Value *MicrosoftCXXABI::EmitConstructorCall(CodeGenFunction &CGF,
311                                          const CXXConstructorDecl *D,
312                                          CXXCtorType Type, bool ForVirtualBase,
313                                          bool Delegating,
314                                          llvm::Value *This,
315                                          CallExpr::const_arg_iterator ArgBeg,
316                                          CallExpr::const_arg_iterator ArgEnd) {
317  assert(Type == Ctor_Complete || Type == Ctor_Base);
318  llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Ctor_Complete);
319
320  llvm::Value *ImplicitParam = 0;
321  QualType ImplicitParamTy;
322  if (D->getParent()->getNumVBases()) {
323    ImplicitParam = llvm::ConstantInt::get(CGM.Int32Ty, Type == Ctor_Complete);
324    ImplicitParamTy = getContext().IntTy;
325  }
326
327  // FIXME: Provide a source location here.
328  CGF.EmitCXXMemberCall(D, SourceLocation(), Callee, ReturnValueSlot(), This,
329                        ImplicitParam, ImplicitParamTy,
330                        ArgBeg, ArgEnd);
331  return Callee;
332}
333
334RValue MicrosoftCXXABI::EmitVirtualDestructorCall(CodeGenFunction &CGF,
335                                                  const CXXDestructorDecl *Dtor,
336                                                  CXXDtorType DtorType,
337                                                  SourceLocation CallLoc,
338                                                  ReturnValueSlot ReturnValue,
339                                                  llvm::Value *This) {
340  assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
341
342  // We have only one destructor in the vftable but can get both behaviors
343  // by passing an implicit bool parameter.
344  const CGFunctionInfo *FInfo
345      = &CGM.getTypes().arrangeCXXDestructor(Dtor, Dtor_Deleting);
346  llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
347  llvm::Value *Callee = CGF.BuildVirtualCall(Dtor, Dtor_Deleting, This, Ty);
348
349  ASTContext &Context = CGF.getContext();
350  llvm::Value *ImplicitParam
351    = llvm::ConstantInt::get(llvm::IntegerType::getInt1Ty(CGF.getLLVMContext()),
352                             DtorType == Dtor_Deleting);
353
354  return CGF.EmitCXXMemberCall(Dtor, CallLoc, Callee, ReturnValue, This,
355                               ImplicitParam, Context.BoolTy, 0, 0);
356}
357
358bool MicrosoftCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
359                                   QualType elementType) {
360  // Microsoft seems to completely ignore the possibility of a
361  // two-argument usual deallocation function.
362  return elementType.isDestructedType();
363}
364
365bool MicrosoftCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
366  // Microsoft seems to completely ignore the possibility of a
367  // two-argument usual deallocation function.
368  return expr->getAllocatedType().isDestructedType();
369}
370
371CharUnits MicrosoftCXXABI::getArrayCookieSizeImpl(QualType type) {
372  // The array cookie is always a size_t; we then pad that out to the
373  // alignment of the element type.
374  ASTContext &Ctx = getContext();
375  return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()),
376                  Ctx.getTypeAlignInChars(type));
377}
378
379llvm::Value *MicrosoftCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
380                                                  llvm::Value *allocPtr,
381                                                  CharUnits cookieSize) {
382  unsigned AS = allocPtr->getType()->getPointerAddressSpace();
383  llvm::Value *numElementsPtr =
384    CGF.Builder.CreateBitCast(allocPtr, CGF.SizeTy->getPointerTo(AS));
385  return CGF.Builder.CreateLoad(numElementsPtr);
386}
387
388llvm::Value* MicrosoftCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
389                                                    llvm::Value *newPtr,
390                                                    llvm::Value *numElements,
391                                                    const CXXNewExpr *expr,
392                                                    QualType elementType) {
393  assert(requiresArrayCookie(expr));
394
395  // The size of the cookie.
396  CharUnits cookieSize = getArrayCookieSizeImpl(elementType);
397
398  // Compute an offset to the cookie.
399  llvm::Value *cookiePtr = newPtr;
400
401  // Write the number of elements into the appropriate slot.
402  unsigned AS = newPtr->getType()->getPointerAddressSpace();
403  llvm::Value *numElementsPtr
404    = CGF.Builder.CreateBitCast(cookiePtr, CGF.SizeTy->getPointerTo(AS));
405  CGF.Builder.CreateStore(numElements, numElementsPtr);
406
407  // Finally, compute a pointer to the actual data buffer by skipping
408  // over the cookie completely.
409  return CGF.Builder.CreateConstInBoundsGEP1_64(newPtr,
410                                                cookieSize.getQuantity());
411}
412
413void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
414                                      llvm::GlobalVariable *DeclPtr,
415                                      bool PerformInit) {
416  // FIXME: this code was only tested for global initialization.
417  // Not sure whether we want thread-safe static local variables as VS
418  // doesn't make them thread-safe.
419
420  if (D.getTLSKind())
421    CGM.ErrorUnsupported(&D, "dynamic TLS initialization");
422
423  // Emit the initializer and add a global destructor if appropriate.
424  CGF.EmitCXXGlobalVarDeclInit(D, DeclPtr, PerformInit);
425}
426
427// Member pointer helpers.
428static bool hasVBPtrOffsetField(MSInheritanceModel Inheritance) {
429  return Inheritance == MSIM_Unspecified;
430}
431
432static bool hasOnlyOneField(MSInheritanceModel Inheritance) {
433  return Inheritance <= MSIM_SinglePolymorphic;
434}
435
436// Only member pointers to functions need a this adjustment, since it can be
437// combined with the field offset for data pointers.
438static bool hasNonVirtualBaseAdjustmentField(bool IsMemberFunction,
439                                             MSInheritanceModel Inheritance) {
440  return (IsMemberFunction && Inheritance >= MSIM_Multiple);
441}
442
443static bool hasVirtualBaseAdjustmentField(MSInheritanceModel Inheritance) {
444  return Inheritance >= MSIM_Virtual;
445}
446
447// Use zero for the field offset of a null data member pointer if we can
448// guarantee that zero is not a valid field offset, or if the member pointer has
449// multiple fields.  Polymorphic classes have a vfptr at offset zero, so we can
450// use zero for null.  If there are multiple fields, we can use zero even if it
451// is a valid field offset because null-ness testing will check the other
452// fields.
453static bool nullFieldOffsetIsZero(MSInheritanceModel Inheritance) {
454  return Inheritance != MSIM_Multiple && Inheritance != MSIM_Single;
455}
456
457bool MicrosoftCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
458  // Null-ness for function memptrs only depends on the first field, which is
459  // the function pointer.  The rest don't matter, so we can zero initialize.
460  if (MPT->isMemberFunctionPointer())
461    return true;
462
463  // The virtual base adjustment field is always -1 for null, so if we have one
464  // we can't zero initialize.  The field offset is sometimes also -1 if 0 is a
465  // valid field offset.
466  const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
467  MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
468  return (!hasVirtualBaseAdjustmentField(Inheritance) &&
469          nullFieldOffsetIsZero(Inheritance));
470}
471
472llvm::Type *
473MicrosoftCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
474  const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
475  MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
476  llvm::SmallVector<llvm::Type *, 4> fields;
477  if (MPT->isMemberFunctionPointer())
478    fields.push_back(CGM.VoidPtrTy);  // FunctionPointerOrVirtualThunk
479  else
480    fields.push_back(CGM.IntTy);  // FieldOffset
481
482  if (hasNonVirtualBaseAdjustmentField(MPT->isMemberFunctionPointer(),
483                                       Inheritance))
484    fields.push_back(CGM.IntTy);
485  if (hasVBPtrOffsetField(Inheritance))
486    fields.push_back(CGM.IntTy);
487  if (hasVirtualBaseAdjustmentField(Inheritance))
488    fields.push_back(CGM.IntTy);  // VirtualBaseAdjustmentOffset
489
490  if (fields.size() == 1)
491    return fields[0];
492  return llvm::StructType::get(CGM.getLLVMContext(), fields);
493}
494
495void MicrosoftCXXABI::
496GetNullMemberPointerFields(const MemberPointerType *MPT,
497                           llvm::SmallVectorImpl<llvm::Constant *> &fields) {
498  assert(fields.empty());
499  const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
500  MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
501  if (MPT->isMemberFunctionPointer()) {
502    // FunctionPointerOrVirtualThunk
503    fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy));
504  } else {
505    if (nullFieldOffsetIsZero(Inheritance))
506      fields.push_back(getZeroInt());  // FieldOffset
507    else
508      fields.push_back(getAllOnesInt());  // FieldOffset
509  }
510
511  if (hasNonVirtualBaseAdjustmentField(MPT->isMemberFunctionPointer(),
512                                       Inheritance))
513    fields.push_back(getZeroInt());
514  if (hasVBPtrOffsetField(Inheritance))
515    fields.push_back(getZeroInt());
516  if (hasVirtualBaseAdjustmentField(Inheritance))
517    fields.push_back(getAllOnesInt());
518}
519
520llvm::Constant *
521MicrosoftCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
522  llvm::SmallVector<llvm::Constant *, 4> fields;
523  GetNullMemberPointerFields(MPT, fields);
524  if (fields.size() == 1)
525    return fields[0];
526  llvm::Constant *Res = llvm::ConstantStruct::getAnon(fields);
527  assert(Res->getType() == ConvertMemberPointerType(MPT));
528  return Res;
529}
530
531llvm::Constant *
532MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField,
533                                       bool IsMemberFunction,
534                                       const CXXRecordDecl *RD)
535{
536  MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
537
538  // Single inheritance class member pointer are represented as scalars instead
539  // of aggregates.
540  if (hasOnlyOneField(Inheritance))
541    return FirstField;
542
543  llvm::SmallVector<llvm::Constant *, 4> fields;
544  fields.push_back(FirstField);
545
546  if (hasNonVirtualBaseAdjustmentField(IsMemberFunction, Inheritance))
547    fields.push_back(getZeroInt());
548
549  if (hasVBPtrOffsetField(Inheritance)) {
550    int64_t VBPtrOffset =
551      getContext().getASTRecordLayout(RD).getVBPtrOffset().getQuantity();
552    if (VBPtrOffset == -1)
553      VBPtrOffset = 0;
554    fields.push_back(llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset));
555  }
556
557  // The rest of the fields are adjusted by conversions to a more derived class.
558  if (hasVirtualBaseAdjustmentField(Inheritance))
559    fields.push_back(getZeroInt());
560
561  return llvm::ConstantStruct::getAnon(fields);
562}
563
564llvm::Constant *
565MicrosoftCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
566                                       CharUnits offset) {
567  const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
568  llvm::Constant *FirstField =
569    llvm::ConstantInt::get(CGM.IntTy, offset.getQuantity());
570  return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/false, RD);
571}
572
573llvm::Constant *
574MicrosoftCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
575  assert(MD->isInstance() && "Member function must not be static!");
576  MD = MD->getCanonicalDecl();
577  const CXXRecordDecl *RD = MD->getParent();
578  CodeGenTypes &Types = CGM.getTypes();
579
580  llvm::Constant *FirstField;
581  if (MD->isVirtual()) {
582    // FIXME: We have to instantiate a thunk that loads the vftable and jumps to
583    // the right offset.
584    FirstField = llvm::Constant::getNullValue(CGM.VoidPtrTy);
585  } else {
586    const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
587    llvm::Type *Ty;
588    // Check whether the function has a computable LLVM signature.
589    if (Types.isFuncTypeConvertible(FPT)) {
590      // The function has a computable LLVM signature; use the correct type.
591      Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
592    } else {
593      // Use an arbitrary non-function type to tell GetAddrOfFunction that the
594      // function type is incomplete.
595      Ty = CGM.PtrDiffTy;
596    }
597    FirstField = CGM.GetAddrOfFunction(MD, Ty);
598    FirstField = llvm::ConstantExpr::getBitCast(FirstField, CGM.VoidPtrTy);
599  }
600
601  // The rest of the fields are common with data member pointers.
602  return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/true, RD);
603}
604
605llvm::Constant *
606MicrosoftCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
607  // FIXME PR15875: Implement member pointer conversions for Constants.
608  const CXXRecordDecl *RD = MPT->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
609  return EmitFullMemberPointer(llvm::Constant::getNullValue(CGM.VoidPtrTy),
610                               /*IsMemberFunction=*/true, RD);
611}
612
613/// Member pointers are the same if they're either bitwise identical *or* both
614/// null.  Null-ness for function members is determined by the first field,
615/// while for data member pointers we must compare all fields.
616llvm::Value *
617MicrosoftCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
618                                             llvm::Value *L,
619                                             llvm::Value *R,
620                                             const MemberPointerType *MPT,
621                                             bool Inequality) {
622  CGBuilderTy &Builder = CGF.Builder;
623
624  // Handle != comparisons by switching the sense of all boolean operations.
625  llvm::ICmpInst::Predicate Eq;
626  llvm::Instruction::BinaryOps And, Or;
627  if (Inequality) {
628    Eq = llvm::ICmpInst::ICMP_NE;
629    And = llvm::Instruction::Or;
630    Or = llvm::Instruction::And;
631  } else {
632    Eq = llvm::ICmpInst::ICMP_EQ;
633    And = llvm::Instruction::And;
634    Or = llvm::Instruction::Or;
635  }
636
637  // If this is a single field member pointer (single inheritance), this is a
638  // single icmp.
639  const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
640  MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
641  if (hasOnlyOneField(Inheritance))
642    return Builder.CreateICmp(Eq, L, R);
643
644  // Compare the first field.
645  llvm::Value *L0 = Builder.CreateExtractValue(L, 0, "lhs.0");
646  llvm::Value *R0 = Builder.CreateExtractValue(R, 0, "rhs.0");
647  llvm::Value *Cmp0 = Builder.CreateICmp(Eq, L0, R0, "memptr.cmp.first");
648
649  // Compare everything other than the first field.
650  llvm::Value *Res = 0;
651  llvm::StructType *LType = cast<llvm::StructType>(L->getType());
652  for (unsigned I = 1, E = LType->getNumElements(); I != E; ++I) {
653    llvm::Value *LF = Builder.CreateExtractValue(L, I);
654    llvm::Value *RF = Builder.CreateExtractValue(R, I);
655    llvm::Value *Cmp = Builder.CreateICmp(Eq, LF, RF, "memptr.cmp.rest");
656    if (Res)
657      Res = Builder.CreateBinOp(And, Res, Cmp);
658    else
659      Res = Cmp;
660  }
661
662  // Check if the first field is 0 if this is a function pointer.
663  if (MPT->isMemberFunctionPointer()) {
664    // (l1 == r1 && ...) || l0 == 0
665    llvm::Value *Zero = llvm::Constant::getNullValue(L0->getType());
666    llvm::Value *IsZero = Builder.CreateICmp(Eq, L0, Zero, "memptr.cmp.iszero");
667    Res = Builder.CreateBinOp(Or, Res, IsZero);
668  }
669
670  // Combine the comparison of the first field, which must always be true for
671  // this comparison to succeeed.
672  return Builder.CreateBinOp(And, Res, Cmp0, "memptr.cmp");
673}
674
675llvm::Value *
676MicrosoftCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
677                                            llvm::Value *MemPtr,
678                                            const MemberPointerType *MPT) {
679  CGBuilderTy &Builder = CGF.Builder;
680  llvm::SmallVector<llvm::Constant *, 4> fields;
681  // We only need one field for member functions.
682  if (MPT->isMemberFunctionPointer())
683    fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy));
684  else
685    GetNullMemberPointerFields(MPT, fields);
686  assert(!fields.empty());
687  llvm::Value *FirstField = MemPtr;
688  if (MemPtr->getType()->isStructTy())
689    FirstField = Builder.CreateExtractValue(MemPtr, 0);
690  llvm::Value *Res = Builder.CreateICmpNE(FirstField, fields[0], "memptr.cmp0");
691
692  // For function member pointers, we only need to test the function pointer
693  // field.  The other fields if any can be garbage.
694  if (MPT->isMemberFunctionPointer())
695    return Res;
696
697  // Otherwise, emit a series of compares and combine the results.
698  for (int I = 1, E = fields.size(); I < E; ++I) {
699    llvm::Value *Field = Builder.CreateExtractValue(MemPtr, I);
700    llvm::Value *Next = Builder.CreateICmpNE(Field, fields[I], "memptr.cmp");
701    Res = Builder.CreateAnd(Res, Next, "memptr.tobool");
702  }
703  return Res;
704}
705
706// Returns an adjusted base cast to i8*, since we do more address arithmetic on
707// it.
708llvm::Value *
709MicrosoftCXXABI::AdjustVirtualBase(CodeGenFunction &CGF,
710                                   const CXXRecordDecl *RD, llvm::Value *Base,
711                                   llvm::Value *VirtualBaseAdjustmentOffset,
712                                   llvm::Value *VBPtrOffset) {
713  CGBuilderTy &Builder = CGF.Builder;
714  Base = Builder.CreateBitCast(Base, CGM.Int8PtrTy);
715  llvm::BasicBlock *OriginalBB = 0;
716  llvm::BasicBlock *SkipAdjustBB = 0;
717  llvm::BasicBlock *VBaseAdjustBB = 0;
718
719  // In the unspecified inheritance model, there might not be a vbtable at all,
720  // in which case we need to skip the virtual base lookup.  If there is a
721  // vbtable, the first entry is a no-op entry that gives back the original
722  // base, so look for a virtual base adjustment offset of zero.
723  if (VBPtrOffset) {
724    OriginalBB = Builder.GetInsertBlock();
725    VBaseAdjustBB = CGF.createBasicBlock("memptr.vadjust");
726    SkipAdjustBB = CGF.createBasicBlock("memptr.skip_vadjust");
727    llvm::Value *IsVirtual =
728      Builder.CreateICmpNE(VirtualBaseAdjustmentOffset, getZeroInt(),
729                           "memptr.is_vbase");
730    Builder.CreateCondBr(IsVirtual, VBaseAdjustBB, SkipAdjustBB);
731    CGF.EmitBlock(VBaseAdjustBB);
732  }
733
734  // If we weren't given a dynamic vbptr offset, RD should be complete and we'll
735  // know the vbptr offset.
736  if (!VBPtrOffset) {
737    CharUnits offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();
738    VBPtrOffset = llvm::ConstantInt::get(CGM.IntTy, offs.getQuantity());
739  }
740  // Load the vbtable pointer from the vbtable offset in the instance.
741  llvm::Value *VBPtr =
742    Builder.CreateInBoundsGEP(Base, VBPtrOffset, "memptr.vbptr");
743  llvm::Value *VBTable =
744    Builder.CreateBitCast(VBPtr, CGM.Int8PtrTy->getPointerTo(0));
745  VBTable = Builder.CreateLoad(VBTable, "memptr.vbtable");
746  // Load an i32 offset from the vb-table.
747  llvm::Value *VBaseOffs =
748    Builder.CreateInBoundsGEP(VBTable, VirtualBaseAdjustmentOffset);
749  VBaseOffs = Builder.CreateBitCast(VBaseOffs, CGM.Int32Ty->getPointerTo(0));
750  VBaseOffs = Builder.CreateLoad(VBaseOffs, "memptr.vbase_offs");
751  // Add it to VBPtr.  GEP will sign extend the i32 value for us.
752  llvm::Value *AdjustedBase = Builder.CreateInBoundsGEP(VBPtr, VBaseOffs);
753
754  // Merge control flow with the case where we didn't have to adjust.
755  if (VBaseAdjustBB) {
756    Builder.CreateBr(SkipAdjustBB);
757    CGF.EmitBlock(SkipAdjustBB);
758    llvm::PHINode *Phi = Builder.CreatePHI(CGM.Int8PtrTy, 2, "memptr.base");
759    Phi->addIncoming(Base, OriginalBB);
760    Phi->addIncoming(AdjustedBase, VBaseAdjustBB);
761    return Phi;
762  }
763  return AdjustedBase;
764}
765
766llvm::Value *
767MicrosoftCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF,
768                                              llvm::Value *Base,
769                                              llvm::Value *MemPtr,
770                                              const MemberPointerType *MPT) {
771  assert(MPT->isMemberDataPointer());
772  unsigned AS = Base->getType()->getPointerAddressSpace();
773  llvm::Type *PType =
774      CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS);
775  CGBuilderTy &Builder = CGF.Builder;
776  const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
777  MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
778
779  // Extract the fields we need, regardless of model.  We'll apply them if we
780  // have them.
781  llvm::Value *FieldOffset = MemPtr;
782  llvm::Value *VirtualBaseAdjustmentOffset = 0;
783  llvm::Value *VBPtrOffset = 0;
784  if (MemPtr->getType()->isStructTy()) {
785    // We need to extract values.
786    unsigned I = 0;
787    FieldOffset = Builder.CreateExtractValue(MemPtr, I++);
788    if (hasVBPtrOffsetField(Inheritance))
789      VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
790    if (hasVirtualBaseAdjustmentField(Inheritance))
791      VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
792  }
793
794  if (VirtualBaseAdjustmentOffset) {
795    Base = AdjustVirtualBase(CGF, RD, Base, VirtualBaseAdjustmentOffset,
796                             VBPtrOffset);
797  }
798  llvm::Value *Addr =
799    Builder.CreateInBoundsGEP(Base, FieldOffset, "memptr.offset");
800
801  // Cast the address to the appropriate pointer type, adopting the address
802  // space of the base pointer.
803  return Builder.CreateBitCast(Addr, PType);
804}
805
806llvm::Value *
807MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
808                                                 llvm::Value *&This,
809                                                 llvm::Value *MemPtr,
810                                                 const MemberPointerType *MPT) {
811  assert(MPT->isMemberFunctionPointer());
812  const FunctionProtoType *FPT =
813    MPT->getPointeeType()->castAs<FunctionProtoType>();
814  const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
815  llvm::FunctionType *FTy =
816    CGM.getTypes().GetFunctionType(
817      CGM.getTypes().arrangeCXXMethodType(RD, FPT));
818  CGBuilderTy &Builder = CGF.Builder;
819
820  MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
821
822  // Extract the fields we need, regardless of model.  We'll apply them if we
823  // have them.
824  llvm::Value *FunctionPointer = MemPtr;
825  llvm::Value *NonVirtualBaseAdjustment = NULL;
826  llvm::Value *VirtualBaseAdjustmentOffset = NULL;
827  llvm::Value *VBPtrOffset = NULL;
828  if (MemPtr->getType()->isStructTy()) {
829    // We need to extract values.
830    unsigned I = 0;
831    FunctionPointer = Builder.CreateExtractValue(MemPtr, I++);
832    if (hasNonVirtualBaseAdjustmentField(MPT, Inheritance))
833      NonVirtualBaseAdjustment = Builder.CreateExtractValue(MemPtr, I++);
834    if (hasVBPtrOffsetField(Inheritance))
835      VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
836    if (hasVirtualBaseAdjustmentField(Inheritance))
837      VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
838  }
839
840  if (VirtualBaseAdjustmentOffset) {
841    This = AdjustVirtualBase(CGF, RD, This, VirtualBaseAdjustmentOffset,
842                             VBPtrOffset);
843  }
844
845  if (NonVirtualBaseAdjustment) {
846    // Apply the adjustment and cast back to the original struct type.
847    llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
848    Ptr = Builder.CreateInBoundsGEP(Ptr, NonVirtualBaseAdjustment);
849    This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
850  }
851
852  return Builder.CreateBitCast(FunctionPointer, FTy->getPointerTo());
853}
854
855CGCXXABI *clang::CodeGen::CreateMicrosoftCXXABI(CodeGenModule &CGM) {
856  return new MicrosoftCXXABI(CGM);
857}
858
859