MicrosoftCXXABI.cpp revision a3609b0c7685346308ed2c8022f94949bbfe7cdf 
1//===------- MicrosoftCXXABI.cpp - AST support for the Microsoft C++ ABI --===//
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++ AST support targeting the Microsoft Visual C++
11// ABI.
12//
13//===----------------------------------------------------------------------===//
14
15#include "CXXABI.h"
16#include "clang/AST/Attr.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/RecordLayout.h"
20#include "clang/AST/Type.h"
21#include "clang/Basic/TargetInfo.h"
22
23using namespace clang;
24
25namespace {
26class MicrosoftCXXABI : public CXXABI {
27  ASTContext &Context;
28public:
29  MicrosoftCXXABI(ASTContext &Ctx) : Context(Ctx) { }
30
31  std::pair<uint64_t, unsigned>
32  getMemberPointerWidthAndAlign(const MemberPointerType *MPT) const;
33
34  CallingConv getDefaultMethodCallConv(bool isVariadic) const {
35    if (!isVariadic &&
36        Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
37      return CC_X86ThisCall;
38    return CC_C;
39  }
40
41  bool isNearlyEmpty(const CXXRecordDecl *RD) const {
42    // FIXME: Audit the corners
43    if (!RD->isDynamicClass())
44      return false;
45
46    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
47
48    // In the Microsoft ABI, classes can have one or two vtable pointers.
49    CharUnits PointerSize =
50      Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
51    return Layout.getNonVirtualSize() == PointerSize ||
52      Layout.getNonVirtualSize() == PointerSize * 2;
53  }
54};
55}
56
57// getNumBases() seems to only give us the number of direct bases, and not the
58// total.  This function tells us if we inherit from anybody that uses MI, or if
59// we have a non-primary base class, which uses the multiple inheritance model.
60static bool usesMultipleInheritanceModel(const CXXRecordDecl *RD) {
61  while (RD->getNumBases() > 0) {
62    if (RD->getNumBases() > 1)
63      return true;
64    assert(RD->getNumBases() == 1);
65    const CXXRecordDecl *Base =
66        RD->bases_begin()->getType()->getAsCXXRecordDecl();
67    if (RD->isPolymorphic() && !Base->isPolymorphic())
68      return true;
69    RD = Base;
70  }
71  return false;
72}
73
74static MSInheritanceModel MSInheritanceAttrToModel(attr::Kind Kind) {
75  switch (Kind) {
76  default: llvm_unreachable("expected MS inheritance attribute");
77  case attr::SingleInheritance:      return MSIM_Single;
78  case attr::MultipleInheritance:    return MSIM_Multiple;
79  case attr::VirtualInheritance:     return MSIM_Virtual;
80  case attr::UnspecifiedInheritance: return MSIM_Unspecified;
81  }
82}
83
84MSInheritanceModel CXXRecordDecl::getMSInheritanceModel() const {
85  if (Attr *IA = this->getAttr<MSInheritanceAttr>())
86    return MSInheritanceAttrToModel(IA->getKind());
87  // If there was no explicit attribute, the record must be defined already, and
88  // we can figure out the inheritance model from its other properties.
89  if (this->getNumVBases() > 0)
90    return MSIM_Virtual;
91  if (usesMultipleInheritanceModel(this))
92    return this->isPolymorphic() ? MSIM_MultiplePolymorphic : MSIM_Multiple;
93  return this->isPolymorphic() ? MSIM_SinglePolymorphic : MSIM_Single;
94}
95
96// Returns the number of pointer and integer slots used to represent a member
97// pointer in the MS C++ ABI.
98//
99// Member function pointers have the following general form;  however, fields
100// are dropped as permitted (under the MSVC interpretation) by the inheritance
101// model of the actual class.
102//
103//   struct {
104//     // A pointer to the member function to call.  If the member function is
105//     // virtual, this will be a thunk that forwards to the appropriate vftable
106//     // slot.
107//     void *FunctionPointerOrVirtualThunk;
108//
109//     // An offset to add to the address of the vbtable pointer after (possibly)
110//     // selecting the virtual base but before resolving and calling the function.
111//     // Only needed if the class has any virtual bases or bases at a non-zero
112//     // offset.
113//     int NonVirtualBaseAdjustment;
114//
115//     // An offset within the vb-table that selects the virtual base containing
116//     // the member.  Loading from this offset produces a new offset that is
117//     // added to the address of the vb-table pointer to produce the base.
118//     int VirtualBaseAdjustmentOffset;
119//
120//     // The offset of the vb-table pointer within the object.  Only needed for
121//     // incomplete types.
122//     int VBPtrOffset;
123//   };
124static std::pair<unsigned, unsigned>
125getMSMemberPointerSlots(const MemberPointerType *MPT) {
126  const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
127  MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
128  unsigned Ptrs;
129  unsigned Ints = 0;
130  if (MPT->isMemberFunctionPointer()) {
131    // Member function pointers are a struct of a function pointer followed by a
132    // variable number of ints depending on the inheritance model used.  The
133    // function pointer is a real function if it is non-virtual and a vftable
134    // slot thunk if it is virtual.  The ints select the object base passed for
135    // the 'this' pointer.
136    Ptrs = 1;  // First slot is always a function pointer.
137    switch (Inheritance) {
138    case MSIM_Unspecified: ++Ints;  // VBTableOffset
139    case MSIM_Virtual:     ++Ints;  // VirtualBaseAdjustmentOffset
140    case MSIM_MultiplePolymorphic:
141    case MSIM_Multiple:    ++Ints;  // NonVirtualBaseAdjustment
142    case MSIM_SinglePolymorphic:
143    case MSIM_Single:      break;   // Nothing
144    }
145  } else {
146    // Data pointers are an aggregate of ints.  The first int is an offset
147    // followed by vbtable-related offsets.
148    Ptrs = 0;
149    switch (Inheritance) {
150    case MSIM_Unspecified: ++Ints;  // VBTableOffset
151    case MSIM_Virtual:     ++Ints;  // VirtualBaseAdjustmentOffset
152    case MSIM_MultiplePolymorphic:
153    case MSIM_Multiple:             // Nothing
154    case MSIM_SinglePolymorphic:
155    case MSIM_Single:      ++Ints;  // Field offset
156    }
157  }
158  return std::make_pair(Ptrs, Ints);
159}
160
161std::pair<uint64_t, unsigned> MicrosoftCXXABI::getMemberPointerWidthAndAlign(
162    const MemberPointerType *MPT) const {
163  const TargetInfo &Target = Context.getTargetInfo();
164  assert(Target.getTriple().getArch() == llvm::Triple::x86 ||
165         Target.getTriple().getArch() == llvm::Triple::x86_64);
166  unsigned Ptrs, Ints;
167  llvm::tie(Ptrs, Ints) = getMSMemberPointerSlots(MPT);
168  // The nominal struct is laid out with pointers followed by ints and aligned
169  // to a pointer width if any are present and an int width otherwise.
170  unsigned PtrSize = Target.getPointerWidth(0);
171  unsigned IntSize = Target.getIntWidth();
172  uint64_t Width = Ptrs * PtrSize + Ints * IntSize;
173  unsigned Align = Ptrs > 0 ? Target.getPointerAlign(0) : Target.getIntAlign();
174  Width = llvm::RoundUpToAlignment(Width, Align);
175  return std::make_pair(Width, Align);
176}
177
178CXXABI *clang::CreateMicrosoftCXXABI(ASTContext &Ctx) {
179  return new MicrosoftCXXABI(Ctx);
180}
181
182