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 
22 using namespace clang;
23 using namespace CodeGen;
24 
25 namespace {
26 
27 class MicrosoftCXXABI : public CGCXXABI {
28 public:
29   MicrosoftCXXABI(CodeGenModule &CGM) : CGCXXABI(CGM) {}
30 
31   StringRef GetPureVirtualCallName() { return "_purecall"; }
32   // No known support for deleted functions in MSVC yet, so this choice is
33   // arbitrary.
34   StringRef GetDeletedVirtualCallName() { return "_purecall"; }
35 
36   llvm::Value *adjustToCompleteObject(CodeGenFunction &CGF,
37                                       llvm::Value *ptr,
38                                       QualType type);
39 
40   void BuildConstructorSignature(const CXXConstructorDecl *Ctor,
41                                  CXXCtorType Type,
42                                  CanQualType &ResTy,
43                                  SmallVectorImpl<CanQualType> &ArgTys);
44 
45   void BuildDestructorSignature(const CXXDestructorDecl *Ctor,
46                                 CXXDtorType Type,
47                                 CanQualType &ResTy,
48                                 SmallVectorImpl<CanQualType> &ArgTys) {
49     // 'this' is already in place
50     // TODO: 'for base' flag
51   }
52 
53   void BuildInstanceFunctionParams(CodeGenFunction &CGF,
54                                    QualType &ResTy,
55                                    FunctionArgList &Params);
56 
57   void EmitInstanceFunctionProlog(CodeGenFunction &CGF);
58 
59   void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
60                        llvm::GlobalVariable *DeclPtr,
61                        bool PerformInit);
62 
63   void EmitVTables(const CXXRecordDecl *Class);
64 
65 
66   // ==== Notes on array cookies =========
67   //
68   // MSVC seems to only use cookies when the class has a destructor; a
69   // two-argument usual array deallocation function isn't sufficient.
70   //
71   // For example, this code prints "100" and "1":
72   //   struct A {
73   //     char x;
74   //     void *operator new[](size_t sz) {
75   //       printf("%u\n", sz);
76   //       return malloc(sz);
77   //     }
78   //     void operator delete[](void *p, size_t sz) {
79   //       printf("%u\n", sz);
80   //       free(p);
81   //     }
82   //   };
83   //   int main() {
84   //     A *p = new A[100];
85   //     delete[] p;
86   //   }
87   // Whereas it prints "104" and "104" if you give A a destructor.
88 
89   bool requiresArrayCookie(const CXXDeleteExpr *expr, QualType elementType);
90   bool requiresArrayCookie(const CXXNewExpr *expr);
91   CharUnits getArrayCookieSizeImpl(QualType type);
92   llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
93                                      llvm::Value *NewPtr,
94                                      llvm::Value *NumElements,
95                                      const CXXNewExpr *expr,
96                                      QualType ElementType);
97   llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
98                                    llvm::Value *allocPtr,
99                                    CharUnits cookieSize);
100   static bool needThisReturn(GlobalDecl GD);
101 };
102 
103 }
104 
105 llvm::Value *MicrosoftCXXABI::adjustToCompleteObject(CodeGenFunction &CGF,
106                                                      llvm::Value *ptr,
107                                                      QualType type) {
108   // FIXME: implement
109   return ptr;
110 }
111 
112 bool MicrosoftCXXABI::needThisReturn(GlobalDecl GD) {
113   const CXXMethodDecl* MD = cast<CXXMethodDecl>(GD.getDecl());
114   return isa<CXXConstructorDecl>(MD);
115 }
116 
117 void MicrosoftCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor,
118                                  CXXCtorType Type,
119                                  CanQualType &ResTy,
120                                  SmallVectorImpl<CanQualType> &ArgTys) {
121   // 'this' is already in place
122   // TODO: 'for base' flag
123   // Ctor returns this ptr
124   ResTy = ArgTys[0];
125 }
126 
127 void MicrosoftCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF,
128                                                   QualType &ResTy,
129                                                   FunctionArgList &Params) {
130   BuildThisParam(CGF, Params);
131   if (needThisReturn(CGF.CurGD)) {
132     ResTy = Params[0]->getType();
133   }
134 }
135 
136 void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
137   EmitThisParam(CGF);
138   if (needThisReturn(CGF.CurGD)) {
139     CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
140   }
141 }
142 
143 bool MicrosoftCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
144                                    QualType elementType) {
145   // Microsoft seems to completely ignore the possibility of a
146   // two-argument usual deallocation function.
147   return elementType.isDestructedType();
148 }
149 
150 bool MicrosoftCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
151   // Microsoft seems to completely ignore the possibility of a
152   // two-argument usual deallocation function.
153   return expr->getAllocatedType().isDestructedType();
154 }
155 
156 CharUnits MicrosoftCXXABI::getArrayCookieSizeImpl(QualType type) {
157   // The array cookie is always a size_t; we then pad that out to the
158   // alignment of the element type.
159   ASTContext &Ctx = getContext();
160   return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()),
161                   Ctx.getTypeAlignInChars(type));
162 }
163 
164 llvm::Value *MicrosoftCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
165                                                   llvm::Value *allocPtr,
166                                                   CharUnits cookieSize) {
167   unsigned AS = allocPtr->getType()->getPointerAddressSpace();
168   llvm::Value *numElementsPtr =
169     CGF.Builder.CreateBitCast(allocPtr, CGF.SizeTy->getPointerTo(AS));
170   return CGF.Builder.CreateLoad(numElementsPtr);
171 }
172 
173 llvm::Value* MicrosoftCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
174                                                     llvm::Value *newPtr,
175                                                     llvm::Value *numElements,
176                                                     const CXXNewExpr *expr,
177                                                     QualType elementType) {
178   assert(requiresArrayCookie(expr));
179 
180   // The size of the cookie.
181   CharUnits cookieSize = getArrayCookieSizeImpl(elementType);
182 
183   // Compute an offset to the cookie.
184   llvm::Value *cookiePtr = newPtr;
185 
186   // Write the number of elements into the appropriate slot.
187   unsigned AS = newPtr->getType()->getPointerAddressSpace();
188   llvm::Value *numElementsPtr
189     = CGF.Builder.CreateBitCast(cookiePtr, CGF.SizeTy->getPointerTo(AS));
190   CGF.Builder.CreateStore(numElements, numElementsPtr);
191 
192   // Finally, compute a pointer to the actual data buffer by skipping
193   // over the cookie completely.
194   return CGF.Builder.CreateConstInBoundsGEP1_64(newPtr,
195                                                 cookieSize.getQuantity());
196 }
197 
198 void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
199                                       llvm::GlobalVariable *DeclPtr,
200                                       bool PerformInit) {
201   // FIXME: this code was only tested for global initialization.
202   // Not sure whether we want thread-safe static local variables as VS
203   // doesn't make them thread-safe.
204 
205   // Emit the initializer and add a global destructor if appropriate.
206   CGF.EmitCXXGlobalVarDeclInit(D, DeclPtr, PerformInit);
207 }
208 
209 void MicrosoftCXXABI::EmitVTables(const CXXRecordDecl *Class) {
210   // FIXME: implement
211 }
212 
213 CGCXXABI *clang::CodeGen::CreateMicrosoftCXXABI(CodeGenModule &CGM) {
214   return new MicrosoftCXXABI(CGM);
215 }
216 
217